Implement parsing/serialization of a=bundle-only.

webrtc/api/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 90 matching lines @@
 static const char kLineTypeTimeZone = 'z';
 static const char kLineTypeEncryptionKey = 'k';
 static const char kLineTypeMedia = 'm';
 static const char kLineTypeConnection = 'c';
 static const char kLineTypeAttributes = 'a';
 
 // Attributes
 static const char kAttributeGroup[] = "group";
 static const char kAttributeMid[] = "mid";
 static const char kAttributeMsid[] = "msid";
+static const char kAttributeBundleOnly[] = "bundle-only";
 static const char kAttributeRtcpMux[] = "rtcp-mux";
 static const char kAttributeRtcpReducedSize[] = "rtcp-rsize";
 static const char kAttributeSsrc[] = "ssrc";
 static const char kSsrcAttributeCname[] = "cname";
 static const char kAttributeExtmap[] = "extmap";
 // draft-alvestrand-mmusic-msid-01
 // a=msid-semantic: WMS
 static const char kAttributeMsidSemantics[] = "msid-semantic";
 static const char kMediaStreamSemantic[] = "WMS";
 static const char kSsrcAttributeMsid[] = "msid";
@@ skipping 147 matching lines @@
     size_t* pos, 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,
                          MediaContentDescription* media_desc,
                          TransportDescription* transport,
                          std::vector<JsepIceCandidate*>* candidates,
                          SdpParseError* error);

[pthatcher1, 2016/12/12 23:38:29]

This could really use one out parameter that is a struct instead of having 6-7.

[Taylor Brandstetter, 2016/12/13 02:13:59]

Agreed, I don't know why we can't just use a ContentInfo. I guess because you're
not able to create a ContentInfo then add it to a SessionDescription, you need
to call "AddContent(list of params)". But that doesn't make sense in the first
place. I'll clean it up eventually.

 static bool ParseSsrcAttribute(const std::string& line,
                                SsrcInfoVec* ssrc_infos,
                                SdpParseError* error);
 static bool ParseSsrcGroupAttribute(const std::string& line,
                                     SsrcGroupVec* ssrc_groups,
                                     SdpParseError* error);
 static bool ParseCryptoAttribute(const std::string& line,
                                  MediaContentDescription* media_desc,
                                  SdpParseError* error);
 static bool ParseRtpmapAttribute(const std::string& line,
@@ skipping 983 matching lines @@
         fmt.append(rtc::ToString<int>(it->id));
       }
     }
   }
   // The fmt must never be empty. If no codecs are found, set the fmt attribute
   // to 0.
   if (fmt.empty()) {
     fmt = " 0";
   }
 
-  // The port number in the m line will be updated later when associate with
+  // 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.
-  const std::string& port = content_info->rejected ?
-      kMediaPortRejected : kDummyPort;
+  //
+  // 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;
 
   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);
 
   // 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) {
+    InitAttrLine(kAttributeBundleOnly, &os);
+    AddLine(os.str(), message);
+  }
+
   // Add the a=rtcp line.
   if (IsRtp(media_desc->protocol())) {
     std::string rtcp_line = GetRtcpLine(candidates);
     if (!rtcp_line.empty()) {
       AddLine(rtcp_line, message);
     }
   }
 
   // Build the a=candidate lines. We don't include ufrag and pwd in the
   // candidates in the SDP to avoid redundancy.
@@ skipping 883 matching lines @@
 }
 
 template <class C>
 static C* ParseContentDescription(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,
                                   TransportDescription* transport,
                                   std::vector<JsepIceCandidate*>* candidates,
                                   webrtc::SdpParseError* error) {
   C* media_desc = new C();
   switch (media_type) {
     case cricket::MEDIA_TYPE_AUDIO:
       *content_name = cricket::CN_AUDIO;
       break;
     case cricket::MEDIA_TYPE_VIDEO:
       *content_name = cricket::CN_VIDEO;
       break;
     case cricket::MEDIA_TYPE_DATA:
       *content_name = cricket::CN_DATA;
       break;
     default:
       ASSERT(false);
       break;
   }
   if (!ParseContent(message, media_type, mline_index, protocol, payload_types,
-                    pos, content_name, media_desc, transport, candidates,
-                    error)) {
+                    pos, content_name, bundle_only, media_desc, transport,
+                    candidates, error)) {
     delete media_desc;
     return NULL;
   }
   // 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) {
@@ skipping 26 matching lines @@
   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 rejected = false;
+    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) {
-      rejected = true;
+      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.
         // https://bugzilla.mozilla.org/show_bug.cgi?id=996329
@@ skipping 11 matching lines @@
 
     // Make a temporary TransportDescription based on |session_td|.
     // Some of this gets overwritten by ParseContent.
     TransportDescription transport(
         session_td.transport_options, session_td.ice_ufrag, session_td.ice_pwd,
         session_td.ice_mode, session_td.connection_role,
         session_td.identity_fingerprint.get());
 
     std::unique_ptr<MediaContentDescription> content;
     std::string content_name;
+    bool bundle_only = false;
     if (HasAttribute(line, kMediaTypeVideo)) {
       content.reset(ParseContentDescription<VideoContentDescription>(
           message, cricket::MEDIA_TYPE_VIDEO, mline_index, protocol,
-          payload_types, pos, &content_name, &transport, candidates, error));
+          payload_types, pos, &content_name, &bundle_only, &transport,
+          candidates, error));
     } else if (HasAttribute(line, kMediaTypeAudio)) {
       content.reset(ParseContentDescription<AudioContentDescription>(
           message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
-          payload_types, pos, &content_name, &transport, candidates, error));
+          payload_types, pos, &content_name, &bundle_only, &transport,
+          candidates, error));
     } else if (HasAttribute(line, kMediaTypeData)) {
       DataContentDescription* data_desc =
           ParseContentDescription<DataContentDescription>(
               message, cricket::MEDIA_TYPE_DATA, mline_index, protocol,
-              payload_types, pos, &content_name, &transport, candidates, error);
+              payload_types, pos, &content_name, &bundle_only, &transport,
+              candidates, error);
       content.reset(data_desc);
 
       int p;
       if (data_desc && IsDtlsSctp(protocol) && rtc::FromString(fields[3], &p)) {
         if (!AddSctpDataCodec(data_desc, p))
           return false;
       }
     } else {
       LOG(LS_WARNING) << "Unsupported media type: " << line;
       continue;
     }
     if (!content.get()) {
       // ParseContentDescription returns NULL if failed.
       return false;
     }
 
+    bool content_rejected = false;
+    if (bundle_only) {
+      // A port of 0 is not interpreted as a rejected m= section when it's
+      // used along with a=bundle-only.
+      if (!port_rejected) {
+        return ParseFailed(
+            "a=bundle-only",
+            "a=bundle-only MUST only be used in combination with a 0 port.",
+            error);
+      }

[pthatcher1, 2017/01/03 17:31:01]

It looks like we need to remove this block (or comment it out) until Firefox
fixes their SDP:

https://bugzilla.mozilla.org/show_bug.cgi?id=1325991

+    } else {
+      // If not using bundle-only, interpret port 0 in the normal way; the m=
+      // section is being rejected.
+      content_rejected = port_rejected;
+    }
+
     if (IsRtp(protocol)) {
       // Set the extmap.
       if (!session_extmaps.empty() &&
           !content->rtp_header_extensions().empty()) {
         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);
     desc->AddContent(content_name,
-                     IsDtlsSctp(protocol) ? cricket::NS_JINGLE_DRAFT_SCTP :
-                                            cricket::NS_JINGLE_RTP,
-                     rejected,
-                     content.release());
+                     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: "
                   << content_name;
       return ParseFailed("", description.str(), error);
     }
   }
@@ skipping 155 matching lines @@
   audio_desc->set_codecs(codecs);
 }
 
 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,
                   MediaContentDescription* media_desc,
                   TransportDescription* transport,
                   std::vector<JsepIceCandidate*>* candidates,
                   SdpParseError* error) {
   ASSERT(media_desc != NULL);
   ASSERT(content_name != NULL);
   ASSERT(transport != NULL);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     MaybeCreateStaticPayloadAudioCodecs(
@@ skipping 62 matching lines @@
     // Handle attributes common to SCTP and RTP.
     if (HasAttribute(line, kAttributeMid)) {
       // RFC 3388
       // mid-attribute      = "a=mid:" identification-tag
       // identification-tag = token
       // Use the mid identification-tag as the content name.
       if (!GetValue(line, kAttributeMid, &mline_id, error)) {
         return false;
       }
       *content_name = mline_id;
+    } else if (HasAttribute(line, kAttributeBundleOnly)) {
+      *bundle_only = true;
     } else if (HasAttribute(line, kAttributeCandidate)) {
       Candidate candidate;
       if (!ParseCandidate(line, &candidate, error, false)) {
         return false;
       }
       candidates_orig.push_back(candidate);
     } else if (HasAttribute(line, kAttributeIceUfrag)) {
       if (!GetValue(line, kAttributeIceUfrag, &transport->ice_ufrag, error)) {
         return false;
       }
@@ skipping 541 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