Add ufrag to the ICE candidate signaling.

talk/app/webrtc/webrtcsdp.cc

 /*
  * libjingle
  * Copyright 2011 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 122 matching lines @@
 static const char kSsrcAttributeMsid[] = "msid";
 static const char kDefaultMsid[] = "default";
 static const char kSsrcAttributeMslabel[] = "mslabel";
 static const char kSSrcAttributeLabel[] = "label";
 static const char kAttributeSsrcGroup[] = "ssrc-group";
 static const char kAttributeCrypto[] = "crypto";
 static const char kAttributeCandidate[] = "candidate";
 static const char kAttributeCandidateTyp[] = "typ";
 static const char kAttributeCandidateRaddr[] = "raddr";
 static const char kAttributeCandidateRport[] = "rport";
-static const char kAttributeCandidateUsername[] = "username";
-static const char kAttributeCandidatePassword[] = "password";
+static const char kAttributeCandidateUfrag[] = "ufrag";
+static const char kAttributeCandidatePwd[] = "pwd";
 static const char kAttributeCandidateGeneration[] = "generation";
 static const char kAttributeFingerprint[] = "fingerprint";
 static const char kAttributeSetup[] = "setup";
 static const char kAttributeFmtp[] = "fmtp";
 static const char kAttributeRtpmap[] = "rtpmap";
 static const char kAttributeSctpmap[] = "sctpmap";
 static const char kAttributeRtcp[] = "rtcp";
 static const char kAttributeIceUfrag[] = "ice-ufrag";
 static const char kAttributeIcePwd[] = "ice-pwd";
 static const char kAttributeIceLite[] = "ice-lite";
@@ skipping 100 matching lines @@
                                   std::string* message);
 static void BuildSctpContentAttributes(std::string* message, int sctp_port);
 static void BuildRtpContentAttributes(
     const MediaContentDescription* media_desc,
     const MediaType media_type,
     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);
 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,
                                     std::string* session_id,
                                     std::string* session_version,
                                     TransportDescription* session_td,
                                     RtpHeaderExtensions* session_extmaps,
@@ skipping 596 matching lines @@
   return message;
 }
 
 // Serializes the passed in IceCandidateInterface to a SDP string.
 // candidate - The candidate to be serialized.
 std::string SdpSerializeCandidate(
     const IceCandidateInterface& candidate) {
   std::string message;
   std::vector<cricket::Candidate> candidates;
   candidates.push_back(candidate.candidate());
-  BuildCandidate(candidates, &message);
+  BuildCandidate(candidates, true, &message);
   // From WebRTC draft section 4.8.1.1 candidate-attribute will be
   // just candidate:<candidate> not a=candidate:<blah>CRLF
   ASSERT(message.find("a=") == 0);
   message.erase(0, 2);
   ASSERT(message.find(kLineBreak) == message.size() - 2);
   message.resize(message.size() - 2);
   return message;
 }
 
 bool SdpDeserialize(const std::string& message,
@@ skipping 173 matching lines @@
         tcptype != cricket::TCPTYPE_SIMOPEN_STR) {
       return ParseFailed(first_line, "Invalid TCP candidate type.", error);
     }
 
     if (protocol != cricket::PROTO_TCP) {
       return ParseFailed(first_line, "Invalid non-TCP candidate", error);
     }
   }
 
   // Extension
-  // Empty string as the candidate username and password.
-  // Will be updated later with the ice-ufrag and ice-pwd.
-  // TODO: Remove the username/password extension, which is currently
-  // kept for backwards compatibility.
+  // Though non-standard, we support the ICE ufrag and pwd being signaled on
+  // the candidate to avoid issues with confusing which generation a candidate
+  // belongs to when trickling multiple generations at the same time.
   std::string username;
   std::string password;
   uint32_t generation = 0;
   for (size_t i = current_position; i + 1 < fields.size(); ++i) {
     // RFC 5245
     // *(SP extension-att-name SP extension-att-value)
     if (fields[i] == kAttributeCandidateGeneration) {
       if (!GetValueFromString(first_line, fields[++i], &generation, error)) {
         return false;
       }
-    } else if (fields[i] == kAttributeCandidateUsername) {
+    } else if (fields[i] == kAttributeCandidateUfrag) {
       username = fields[++i];
-    } else if (fields[i] == kAttributeCandidatePassword) {
+    } else if (fields[i] == kAttributeCandidatePwd) {
       password = fields[++i];
     } else {
       // Skip the unknown extension.
       ++i;
     }
   }
 
   *candidate = Candidate(component_id, cricket::ProtoToString(protocol),
                          address, priority, username, password, candidate_type,
                          generation, foundation);
@@ skipping 176 matching lines @@
   }
 
   // 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.
-  BuildCandidate(candidates, message);
+  // Build the a=candidate lines. We don't include ufrag and pwd in the
+  // candidates in the SDP to avoid redundancy.
+  BuildCandidate(candidates, false, message);
 
   // Use the transport_info to build the media level ice-ufrag and ice-pwd.
   if (transport_info) {
     // RFC 5245
     // ice-pwd-att           = "ice-pwd" ":" password
     // ice-ufrag-att         = "ice-ufrag" ":" ufrag
     // ice-ufrag
     InitAttrLine(kAttributeIceUfrag, &os);
     os << kSdpDelimiterColon << transport_info->description.ice_ufrag;
     AddLine(os.str(), message);
@@ skipping 410 matching lines @@
       // [/<encodingparameters>]
       InitAttrLine(kAttributeRtpmap, &os);
       os << kSdpDelimiterColon << it->id << " "
          << it->name << "/" << it->clockrate;
       AddLine(os.str(), message);
     }
   }
 }
 
 void BuildCandidate(const std::vector<Candidate>& candidates,
+                    bool include_ufrag,
                     std::string* message) {
   std::ostringstream os;
 
   for (std::vector<Candidate>::const_iterator it = candidates.begin();
        it != candidates.end(); ++it) {
     // RFC 5245
     // a=candidate:<foundation> <component-id> <transport> <priority>
     // <connection-address> <port> typ <candidate-types>
     // [raddr <connection-address>] [rport <port>]
     // *(SP extension-att-name SP extension-att-value)
@@ skipping 29 matching lines @@
          << kAttributeCandidateRport << " "
          << it->related_address().PortAsString() << " ";
     }
 
     if (it->protocol() == cricket::TCP_PROTOCOL_NAME) {
       os << kTcpCandidateType << " " << it->tcptype() << " ";
     }
 
     // Extensions
     os << kAttributeCandidateGeneration << " " << it->generation();
+    if (include_ufrag && !it->username().empty()) {
+      os << " " << kAttributeCandidateUfrag << " " << it->username();
+    }
 
     AddLine(os.str(), message);
   }
 }
 
 void BuildIceOptions(const std::vector<std::string>& transport_options,
                      std::string* message) {
   if (!transport_options.empty()) {
     std::ostringstream os;
     InitAttrLine(kAttributeIceOption, &os);
@@ skipping 891 matching lines @@
     // only rtcp-fb.
     if (!VerifyVideoCodecs(video_desc)) {
       return ParseFailed("Failed to parse video codecs correctly.", error);
     }
   }
 
   // RFC 5245
   // Update the candidates with the media level "ice-pwd" and "ice-ufrag".
   for (Candidates::iterator it = candidates_orig.begin();
        it != candidates_orig.end(); ++it) {
-    ASSERT((*it).username().empty());
+    ASSERT((*it).username().empty() ||
+           (*it).username() == transport->ice_ufrag);
     (*it).set_username(transport->ice_ufrag);
     ASSERT((*it).password().empty());
     (*it).set_password(transport->ice_pwd);
     candidates->push_back(
         new JsepIceCandidate(mline_id, mline_index, *it));
   }
   return true;
 }
 
 bool ParseSsrcAttribute(const std::string& line, SsrcInfoVec* ssrc_infos,
@@ skipping 376 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