Parse the connection data in SDP (c= line).

webrtc/pc/webrtcsdp.cc

 /*
  *  Copyright 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 231 matching lines @@
 static void BuildRtpMap(const MediaContentDescription* media_desc,
                         const MediaType media_type,
                         std::string* message);
 static void BuildCandidate(const std::vector<Candidate>& candidates,
                            bool include_ufrag,
                            std::string* message);
 static void BuildIceOptions(const std::vector<std::string>& transport_options,
                             std::string* message);
 static bool IsRtp(const std::string& protocol);
 static bool IsDtlsSctp(const std::string& protocol);
-static bool ParseSessionDescription(const std::string& message, size_t* pos,
+static bool ParseSessionDescription(const std::string& message,
+                                    size_t* pos,
                                     std::string* session_id,
                                     std::string* session_version,
                                     TransportDescription* session_td,
                                     RtpHeaderExtensions* session_extmaps,
+                                    rtc::SocketAddress* connection_addr,
                                     cricket::SessionDescription* desc,
                                     SdpParseError* error);
 static bool ParseGroupAttribute(const std::string& line,
                                 cricket::SessionDescription* desc,
                                 SdpParseError* error);
 static bool ParseMediaDescription(
     const std::string& message,
     const TransportDescription& session_td,
     const RtpHeaderExtensions& session_extmaps,
-    size_t* pos, cricket::SessionDescription* desc,
+    size_t* pos,
+    const rtc::SocketAddress& session_connection_addr,
+    cricket::SessionDescription* desc,
     std::vector<JsepIceCandidate*>* candidates,
     SdpParseError* error);
 static bool ParseContent(const std::string& message,
                          const MediaType media_type,
                          int mline_index,
                          const std::string& protocol,
                          const std::vector<int>& payload_types,
                          size_t* pos,
                          std::string* content_name,
                          bool* bundle_only,
@@ skipping 429 matching lines @@
     } else if (family == AF_INET6) {
       addr_type->assign(kConnectionIpv6Addrtype);
     }
     current_preference = preference;
     current_family = family;
     *port = it->address().PortAsString();
     *ip = it->address().ipaddr().ToString();
   }
 }
 
-// Update |mline|'s default destination and append a c line after it.
+// Update |mline|'s default destination.
 static void UpdateMediaDefaultDestination(
     const std::vector<Candidate>& candidates,
     const std::string& mline,
     std::string* message) {
   std::string new_lines;
   AddLine(mline, &new_lines);
   // RFC 4566
   // m=<media> <port> <proto> <fmt> ...
   std::vector<std::string> fields;
   rtc::split(mline, kSdpDelimiterSpace, &fields);
@@ skipping 11 matching lines @@
   // destination for media.  For streams based on RTP, this is done by
   // placing the IP address and port of the RTP candidate into the c and m
   // lines, respectively.
   // Update the port in the m line.
   // If this is a m-line with port equal to 0, we don't change it.
   if (fields[1] != kMediaPortRejected) {
     new_lines.replace(fields[0].size() + 1,
                       fields[1].size(),
                       rtp_port);
   }
-  // Add the c line.
-  // RFC 4566
-  // c=<nettype> <addrtype> <connection-address>
-  InitLine(kLineTypeConnection, kConnectionNettype, &os);
-  os << " " << addr_type << " " << rtp_ip;
-  AddLine(os.str(), &new_lines);

[Taylor Brandstetter, 2017/03/15 17:57:20]

We shouldn't remove this "default destination" logic, since it's required by the
ICE standard and may be needed by legacy endpoints.

Two things I can think of doing:

* Change the logic to: "If connection_address was set, use that. Otherwise, use
default destination from ICE candidates." One oddity with this is that if you
serialize a description with the address unset, then parse it, the address
becomes set. Which breaks the serialize/deserialize symmetry.
* Update the default destination in JsepSessionDescription::AddCandidate.
Assuming this works, this seems cleaner in my opinion. The tests for this in
webrtcsdp.cc would then move to jsepsessiondescription_unittest.cc.

   message->append(new_lines);
 }
 
 // Gets "a=rtcp" line if found default RTCP candidate from |candidates|.
 static std::string GetRtcpLine(const std::vector<Candidate>& candidates) {
   std::string rtcp_line, rtcp_port, rtcp_ip, addr_type;
   GetDefaultDestination(candidates, ICE_CANDIDATE_COMPONENT_RTCP,
                         &rtcp_port, &rtcp_ip, &addr_type);
   // Found default RTCP candidate.
   // RFC 5245
@@ skipping 131 matching lines @@
   return message;
 }
 
 bool SdpDeserialize(const std::string& message,
                     JsepSessionDescription* jdesc,
                     SdpParseError* error) {
   std::string session_id;
   std::string session_version;
   TransportDescription session_td("", "");
   RtpHeaderExtensions session_extmaps;
+  rtc::SocketAddress session_connection_addr;
   cricket::SessionDescription* desc = new cricket::SessionDescription();
   std::vector<JsepIceCandidate*> candidates;
   size_t current_pos = 0;
 
   // Session Description
   if (!ParseSessionDescription(message, &current_pos, &session_id,
                                &session_version, &session_td, &session_extmaps,
-                               desc, error)) {
+                               &session_connection_addr, desc, error)) {
     delete desc;
     return false;
   }
 
   // Media Description
   if (!ParseMediaDescription(message, session_td, session_extmaps, &current_pos,
-                             desc, &candidates, error)) {
+                             session_connection_addr, desc, &candidates,
+                             error)) {
     delete desc;
     for (std::vector<JsepIceCandidate*>::const_iterator
          it = candidates.begin(); it != candidates.end(); ++it) {
       delete *it;
     }
     return false;
   }
 
   jdesc->Initialize(desc, session_id, session_version);
 
@@ skipping 391 matching lines @@
 
   rtc::SSLFingerprint* fp = (transport_info) ?
       transport_info->description.identity_fingerprint.get() : NULL;
 
   // Add the m and c lines.
   InitLine(kLineTypeMedia, type, &os);
   os << " " << port << " " << media_desc->protocol() << fmt;
   std::string mline = os.str();
   UpdateMediaDefaultDestination(candidates, mline, message);
 
+  InitLine(kLineTypeConnection, kConnectionNettype, &os);
+  if (media_desc->connection_addr().family() == AF_INET) {
+    os << " "
+       << "IP4"
+       << " " << media_desc->connection_addr().ipaddr().ToString();
+  } else {
+    os << " "
+       << "IP6"
+       << " " << media_desc->connection_addr().ipaddr().ToString();
+  }
+  AddLine(os.str(), message);
+
   // RFC 4566
   // b=AS:<bandwidth>
   if (media_desc->bandwidth() >= 1000) {
     InitLine(kLineTypeSessionBandwidth, kApplicationSpecificMaximum, &os);
     os << kSdpDelimiterColon << (media_desc->bandwidth() / 1000);
     AddLine(os.str(), message);
   }
 
   // Add the a=bundle-only line.
   if (content_info->bundle_only) {
@@ skipping 552 matching lines @@
 bool IsRtp(const std::string& protocol) {
   return protocol.empty() ||
       (protocol.find(cricket::kMediaProtocolRtpPrefix) != std::string::npos);
 }
 
 bool IsDtlsSctp(const std::string& protocol) {
   // This intentionally excludes "SCTP" and "SCTP/DTLS".
   return protocol.find(cricket::kMediaProtocolDtlsSctp) != std::string::npos;
 }
 
-bool ParseSessionDescription(const std::string& message, size_t* pos,
+bool ParseConnectionData(const std::string& line,
+                         rtc::SocketAddress* addr,
+                         SdpParseError* error) {
+  // Parse the line from left to right.
+  std::string token;
+  std::string rightpart;
+  // RFC 4566
+  // c=<nettype> <addrtype> <connection-address>
+  // Skip the "c="
+  if (!rtc::tokenize_first(line, kSdpDelimiterEqual, &token, &rightpart)) {
+    return ParseFailed(line, "Failed to parse the network type.", error);
+  }
+
+  // Extract and verify the <nettype>
+  if (!rtc::tokenize_first(rightpart, kSdpDelimiterSpace, &token, &rightpart) ||
+      token != kConnectionNettype) {
+    return ParseFailed(line,
+                       "Failed to parse the connection data. The network type "
+                       "is not currently supported.",
+                       error);
+  }
+
+  // Extract the "<addrtype>" and "<connection-address>".
+  if (!rtc::tokenize_first(rightpart, kSdpDelimiterSpace, &token, &rightpart)) {
+    return ParseFailed(line, "Failed to parse the address type.", error);
+  }
+
+  // The rightpart part should be the IP address without the slash which is used
+  // for multicast.
+  if (rightpart.find('/') != std::string::npos) {
+    return ParseFailed(line,
+                       "Failed to parse the connection data. Multicast is not "
+                       "currently supported.",
+                       error);
+  }
+  addr->SetIP(rightpart);
+
+  // Verify that the addrtype matches the type of the parsed address.
+  if ((addr->family() == AF_INET && token != "IP4") ||
+      (addr->family() == AF_INET6 && token != "IP6")) {
+    addr->Clear();
+    return ParseFailed(
+        line,
+        "Failed to parse the connection data. The address type is mismatching.",
+        error);
+  }
+  return true;
+}
+
+bool ParseSessionDescription(const std::string& message,
+                             size_t* pos,
                              std::string* session_id,
                              std::string* session_version,
                              TransportDescription* session_td,
                              RtpHeaderExtensions* session_extmaps,
+                             rtc::SocketAddress* connection_addr,
                              cricket::SessionDescription* desc,
                              SdpParseError* error) {
   std::string line;
 
   desc->set_msid_supported(false);
 
   // RFC 4566
   // v=  (protocol version)
   if (!GetLineWithType(message, pos, &line, kLineTypeVersion)) {
     return ParseFailedExpectLine(message, *pos, kLineTypeVersion,
@@ skipping 37 matching lines @@
   // e=* (email address)
   GetLineWithType(message, pos, &line, kLineTypeSessionEmail);
 
   // RFC 4566
   // p=* (phone number)
   GetLineWithType(message, pos, &line, kLineTypeSessionPhone);
 
   // RFC 4566
   // c=* (connection information -- not required if included in
   //      all media)
-  GetLineWithType(message, pos, &line, kLineTypeConnection);
+  if (GetLineWithType(message, pos, &line, kLineTypeConnection)) {
+    if (!ParseConnectionData(line, connection_addr, error)) {
+      return false;
+    }
+  }
 
   // RFC 4566
   // b=* (zero or more bandwidth information lines)
   while (GetLineWithType(message, pos, &line, kLineTypeSessionBandwidth)) {
     // By pass zero or more b lines.
   }
 
   // RFC 4566
   // One or more time descriptions ("t=" and "r=" lines; see below)
   // t=  (time the session is active)
@@ skipping 283 matching lines @@
       *content_name = cricket::CN_DATA;
       break;
     default:
       RTC_NOTREACHED();
       break;
   }
   if (!ParseContent(message, media_type, mline_index, protocol, payload_types,
                     pos, content_name, bundle_only, media_desc, transport,
                     candidates, error)) {
     delete media_desc;
-    return NULL;
+    return nullptr;
   }
   // Sort the codecs according to the m-line fmt list.
   std::unordered_map<int, int> payload_type_preferences;
   // "size + 1" so that the lowest preference payload type has a preference of
   // 1, which is greater than the default (0) for payload types not in the fmt
   // list.
   int preference = static_cast<int>(payload_types.size() + 1);
   for (int pt : payload_types) {
     payload_type_preferences[pt] = preference--;
   }
   std::vector<typename C::CodecType> codecs = media_desc->codecs();
   std::sort(codecs.begin(), codecs.end(), [&payload_type_preferences](
                                               const typename C::CodecType& a,
                                               const typename C::CodecType& b) {
     return payload_type_preferences[a.id] > payload_type_preferences[b.id];
   });
   media_desc->set_codecs(codecs);
   return media_desc;
 }
 
 bool ParseMediaDescription(const std::string& message,
                            const TransportDescription& session_td,
                            const RtpHeaderExtensions& session_extmaps,
                            size_t* pos,
+                           const rtc::SocketAddress& session_connection_addr,
                            cricket::SessionDescription* desc,
                            std::vector<JsepIceCandidate*>* candidates,
                            SdpParseError* error) {
   RTC_DCHECK(desc != NULL);
   std::string line;
   int mline_index = -1;
 
   // Zero or more media descriptions
   // RFC 4566
   // m=<media> <port> <proto> <fmt>
   while (GetLineWithType(message, pos, &line, kLineTypeMedia)) {
     ++mline_index;
 
     std::vector<std::string> fields;
     rtc::split(line.substr(kLinePrefixLength),
                      kSdpDelimiterSpace, &fields);
 
     const size_t expected_min_fields = 4;
     if (fields.size() < expected_min_fields) {
       return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
     }
     bool port_rejected = false;
     // RFC 3264
     // To reject an offered stream, the port number in the corresponding stream
     // in the answer MUST be set to zero.
     if (fields[1] == kMediaPortRejected) {

[Taylor Brandstetter, 2017/03/15 17:57:20]

Something I just realized: the port on the m= line itself should probably be
copied into the connection_address for convenience. So that with the combination
of the "m=" and "c=" lines, you have a full IP/port pair.

[Zhi Huang, 2017/03/16 19:47:26]

Done.

       port_rejected = true;
     }
 
     std::string protocol = fields[2];
 
     // <fmt>
     std::vector<int> payload_types;
     if (IsRtp(protocol)) {
       for (size_t j = 3 ; j < fields.size(); ++j) {
         // TODO(wu): Remove when below bug is fixed.
@@ skipping 83 matching lines @@
         return ParseFailed("",
                            "The a=extmap MUST be either all session level or "
                            "all media level.",
                            error);
       }
       for (size_t i = 0; i < session_extmaps.size(); ++i) {
         content->AddRtpHeaderExtension(session_extmaps[i]);
       }
     }
     content->set_protocol(protocol);
+
+    // Use the session level connection address if the media level addresses are
+    // not specified.
+    if (content->connection_addr().IsNil()) {
+      content->set_connection_addr(session_connection_addr);
+    }
+
     desc->AddContent(content_name,
                      IsDtlsSctp(protocol) ? cricket::NS_JINGLE_DRAFT_SCTP
                                           : cricket::NS_JINGLE_RTP,
                      content_rejected, bundle_only, content.release());
     // Create TransportInfo with the media level "ice-pwd" and "ice-ufrag".
     TransportInfo transport_info(content_name, transport);
 
     if (!desc->AddTransportInfo(transport_info)) {
       std::ostringstream description;
       description << "Failed to AddTransportInfo with content name: "
@@ skipping 228 matching lines @@
             return ParseFailed(line, description.str(), error);
           }
           // Prevent integer overflow.
           b = std::min(b, INT_MAX / 1000);
           media_desc->set_bandwidth(b * 1000);
         }
       }
       continue;
     }
 
+    // Parse the media level connection data.
+    if (IsLineType(line, kLineTypeConnection)) {
+      rtc::SocketAddress addr;
+      if (!ParseConnectionData(line, &addr, error)) {
+        return false;
+      }
+      media_desc->set_connection_addr(addr);
+      continue;
+    }
+
     if (!IsLineType(line, kLineTypeAttributes)) {
       // TODO: Handle other lines if needed.
       LOG(LS_INFO) << "Ignored line: " << line;
       continue;
     }
 
     // Handle attributes common to SCTP and RTP.
     if (HasAttribute(line, kAttributeMid)) {
       // RFC 3388
       // mid-attribute      = "a=mid:" identification-tag
@@ skipping 553 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc