Use the same draft version in SDP data channel answers as used in the offer.

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 216 matching lines @@
 typedef std::vector<SsrcGroup> SsrcGroupVec;
 
 template <class T>
 static void AddFmtpLine(const T& codec, std::string* message);
 static void BuildMediaDescription(const ContentInfo* content_info,
                                   const TransportInfo* transport_info,
                                   const MediaType media_type,
                                   const std::vector<Candidate>& candidates,
                                   bool unified_plan_sdp,
                                   std::string* message);
-static void BuildSctpContentAttributes(std::string* message, int sctp_port);
+static void BuildSctpContentAttributes(std::string* message,
+                                       int sctp_port,
+                                       bool use_sctpmap);
 static void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
                                       const MediaType media_type,
                                       bool unified_plan_sdp,
                                       std::string* message);
 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);
@@ skipping 1020 matching lines @@
          it != audio_desc->codecs().end(); ++it) {
       fmt.append(" ");
       fmt.append(rtc::ToString<int>(it->id));
     }
   } else if (media_type == cricket::MEDIA_TYPE_DATA) {
     const DataContentDescription* data_desc =
           static_cast<const DataContentDescription*>(media_desc);
     if (IsDtlsSctp(media_desc->protocol())) {
       fmt.append(" ");
 
-      for (std::vector<cricket::DataCodec>::const_iterator it =
-           data_desc->codecs().begin();
-           it != data_desc->codecs().end(); ++it) {
-        if (cricket::CodecNamesEq(it->name, cricket::kGoogleSctpDataCodecName)
-            && it->GetParam(cricket::kCodecParamPort, &sctp_port)) {
-          break;
+      if (data_desc->use_sctpmap()) {
+        for (std::vector<cricket::DataCodec>::const_iterator it =
+                 data_desc->codecs().begin();
+             it != data_desc->codecs().end(); ++it) {
+          if (cricket::CodecNamesEq(it->name,
+                                    cricket::kGoogleSctpDataCodecName) &&
+              it->GetParam(cricket::kCodecParamPort, &sctp_port)) {
+            break;
+          }
         }
+
+        fmt.append(rtc::ToString<int>(sctp_port));
+      } else {
+        fmt.append(kDefaultSctpmapProtocol);
       }
-
-      fmt.append(rtc::ToString<int>(sctp_port));
     } else {
       for (std::vector<cricket::DataCodec>::const_iterator it =
            data_desc->codecs().begin();
            it != data_desc->codecs().end(); ++it) {
         fmt.append(" ");
         fmt.append(rtc::ToString<int>(it->id));
       }
     }
   }
   // The fmt must never be empty. If no codecs are found, set the fmt attribute
@@ skipping 102 matching lines @@
 
   // RFC 3388
   // mid-attribute      = "a=mid:" identification-tag
   // identification-tag = token
   // Use the content name as the mid identification-tag.
   InitAttrLine(kAttributeMid, &os);
   os << kSdpDelimiterColon << content_info->name;
   AddLine(os.str(), message);
 
   if (IsDtlsSctp(media_desc->protocol())) {
-    BuildSctpContentAttributes(message, sctp_port);
+    const DataContentDescription* data_desc =
+        static_cast<const DataContentDescription*>(media_desc);
+    bool use_sctpmap = data_desc->use_sctpmap();
+    BuildSctpContentAttributes(message, sctp_port, use_sctpmap);
   } else if (IsRtp(media_desc->protocol())) {
     BuildRtpContentAttributes(media_desc, media_type, unified_plan_sdp,
                               message);
   }
 }
 
-void BuildSctpContentAttributes(std::string* message, int sctp_port) {
-  // draft-ietf-mmusic-sctp-sdp-04
-  // a=sctpmap:sctpmap-number  protocol  [streams]
-  // TODO(lally): switch this over to mmusic-sctp-sdp-12 (or later), with
-  // 'a=sctp-port:'
+void BuildSctpContentAttributes(std::string* message,
+                                int sctp_port,
+                                bool use_sctpmap) {
   std::ostringstream os;
-  InitAttrLine(kAttributeSctpmap, &os);
-  os << kSdpDelimiterColon << sctp_port << kSdpDelimiterSpace
-     << kDefaultSctpmapProtocol << kSdpDelimiterSpace
-     << cricket::kMaxSctpStreams;
+  if (use_sctpmap) {
+    // draft-ietf-mmusic-sctp-sdp-04
+    // a=sctpmap:sctpmap-number  protocol  [streams]
+    InitAttrLine(kAttributeSctpmap, &os);
+    os << kSdpDelimiterColon << sctp_port << kSdpDelimiterSpace
+       << kDefaultSctpmapProtocol << kSdpDelimiterSpace
+       << cricket::kMaxSctpStreams;
+  } else {
+    // draft-ietf-mmusic-sctp-sdp-23
+    // a=sctp-port:<port>
+    InitAttrLine(kAttributeSctpPort, &os);
+    os << kSdpDelimiterColon << sctp_port;
+    // TODO(zstein): emit max-message-size here
+  }
   AddLine(os.str(), message);
 }
 
 // If unified_plan_sdp is true, will use "a=msid".
 void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
                                const MediaType media_type,
                                bool unified_plan_sdp,
                                std::string* message) {
   std::ostringstream os;
   // RFC 5285
@@ skipping 847 matching lines @@
 
   // 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;
@@ skipping 40 matching lines @@
           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, &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;
+      if (data_desc && IsDtlsSctp(protocol)) {
+        int p;
+        if (rtc::FromString(fields[3], &p)) {
+          if (!AddSctpDataCodec(data_desc, p)) {
+            return false;
+          }
+        } else if (fields[3] == kDefaultSctpmapProtocol) {
+          data_desc->set_use_sctpmap(false);
+        }
       }
     } else {
       LOG(LS_WARNING) << "Unsupported media type: " << line;
       continue;
     }
     if (!content.get()) {
       // ParseContentDescription returns NULL if failed.
       return false;
     }
 
@@ skipping 844 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