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.
-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);
-  if (fields.size() < 3) {
-    return;
-  }
-
-  std::ostringstream os;
-  std::string rtp_port, rtp_ip, addr_type;
-  GetDefaultDestination(candidates, ICE_CANDIDATE_COMPONENT_RTP,
-                        &rtp_port, &rtp_ip, &addr_type);
-  // Found default RTP candidate.
-  // RFC 5245
-  // The default candidates are added to the SDP as the default
-  // 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);
-  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
   // If the agent is utilizing RTCP, it MUST encode the RTCP candidate
   // using the a=rtcp attribute as defined in RFC 3605.
 
@@ skipping 128 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 378 matching lines @@
   // The port number in the m line will be updated later when associated with
   // the candidates.
   //
   // A port value of 0 indicates that the m= section is rejected.
   // RFC 3264
   // To reject an offered stream, the port number in the corresponding stream in
   // the answer MUST be set to zero.
   //
   // However, the BUNDLE draft adds a new meaning to port zero, when used along
   // with a=bundle-only.
-  const std::string& port =
-      (content_info->rejected || content_info->bundle_only) ? kMediaPortRejected
-                                                            : kDummyPort;
+  std::string port = kDummyPort;
+  if (content_info->rejected || content_info->bundle_only) {
+    port = kMediaPortRejected;
+  } else if (!media_desc->connection_address().IsNil()) {
+    port = rtc::ToString(media_desc->connection_address().port());
+  }
 
   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);
+  AddLine(os.str(), message);
+
+  InitLine(kLineTypeConnection, kConnectionNettype, &os);
+  if (media_desc->connection_address().IsNil()) {
+    os << " " << kConnectionIpv4Addrtype << " " << kDummyAddress;
+  } else if (media_desc->connection_address().family() == AF_INET) {
+    os << " " << kConnectionIpv4Addrtype << " "
+       << media_desc->connection_address().ipaddr().ToString();
+  } else {
+    os << " " << kConnectionIpv6Addrtype << " "
+       << media_desc->connection_address().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.
@@ skipping 553 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) {
       port_rejected = true;
     }
 
+    int port = 0;
+    if (!rtc::FromString<int>(fields[1], &port) || !IsValidPort(port)) {
+      return ParseFailed(line, "The port number is invalid", error);
+    }
     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.
         // https://bugzilla.mozilla.org/show_bug.cgi?id=996329
         if (fields[j].empty() && j == fields.size() - 1) {
           continue;
@@ skipping 80 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.
+    rtc::SocketAddress address;
+    address = content->connection_address().IsNil()
+                  ? session_connection_addr
+                  : content->connection_address();
+    address.SetPort(port);
+    content->set_connection_address(address);
+
     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_address(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