Libjingle roll 129:132.

content/renderer/p2p/port_allocator.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/p2p/port_allocator.h"
 
 #include "base/bind.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 108 matching lines @@
   LOG(ERROR) << "Relay session request failed.";
 
   // Retry the request.
   AllocateRelaySession();
 }
 
 void P2PPortAllocatorSession::GetPortConfigurations() {
   // Add an empty configuration synchronously, so a local connection
   // can be started immediately.
   ConfigReady(new cricket::PortConfiguration(
-      talk_base::SocketAddress(), "", "", ""));
+      talk_base::SocketAddress(), username(), password(), ""));
 
   ResolveStunServerAddress();
   AllocateRelaySession();
 }
 
 void P2PPortAllocatorSession::ResolveStunServerAddress() {
  if (allocator_->config_.stun_server.empty())
    return;
 
  DCHECK(!stun_address_request_);
@@ skipping 46 matching lines @@
       WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
 
   relay_session_request_.reset(
       allocator_->web_frame_->createAssociatedURLLoader(options));
   if (!relay_session_request_.get()) {
     LOG(ERROR) << "Failed to create URL loader.";
     return;
   }
 
   std::string url = "https://" + allocator_->config_.relay_server +
-      kCreateRelaySessionURL;
+      kCreateRelaySessionURL + "?username=" + username() +
+      "&password=" + password();

[Wez, 2012/04/13 02:49:49]

Are username() and password() URL-escaped, or guaranteed URL-friendly?

[Sergey Ulanov, 2012/04/13 19:50:38]

That's a good catch! PortAllocator uses Base64 alphabet to generate these values
- they may contain plus sign, which needs to be encoded. Looks like there is
similar bug in libjingle's.

 
   // Use |relay_username| parameter to identify type of client for the
   // relay session.
   //
   // TODO(sergeyu): Username is not used for legacy non-TURN relay
   // servers, so we reuse it here to identify relay client type. This
   // is currently used for Chromoting only. This code should be removed
   // once Chromoting stops using Transport API and the API is removed.
   if (!allocator_->config_.relay_username.empty()) {
     url += "?sn=" +
@@ skipping 21 matching lines @@
 }
 
 void P2PPortAllocatorSession::ParseRelayResponse() {
   std::vector<std::pair<std::string, std::string> > value_pairs;
   if (!base::SplitStringIntoKeyValuePairs(relay_session_response_, '=', '\n',
                                           &value_pairs)) {
     LOG(ERROR) << "Received invalid response from relay server";
     return;
   }
 
-  relay_username_.clear();
-  relay_password_.clear();
   relay_ip_.Clear();
   relay_udp_port_ = 0;
   relay_tcp_port_ = 0;
   relay_ssltcp_port_ = 0;
 
   for (std::vector<std::pair<std::string, std::string> >::iterator
            it = value_pairs.begin();
        it != value_pairs.end(); ++it) {
     std::string key;
     std::string value;
     TrimWhitespaceASCII(it->first, TRIM_ALL, &key);
     TrimWhitespaceASCII(it->second, TRIM_ALL, &value);
 
     if (key == "username") {
-      relay_username_ = value;
+      if (value != username()) {
+        LOG(WARNING) << "When creating relay session received "
+            " user name that was specified in the query";

[Wez, 2012/04/13 02:49:49]

I don't understand this error message.

This is the case where we've sent a request to a relay server to set up a
session, and it's responded with different username & password to the ones we
supplied it - you're now warning in that case rather than respecting the new
values.  Can you not set_username() to keep the original behaviour?

[Sergey Ulanov, 2012/04/13 19:50:38]

Right. Previously username/password were generated on the relay server. Now we
specify them when creating relay session and expect to receive the same values
in the response. This warning is just so that we can see when the server returns
values that are different from we expected.

There are no set_username() and set_password() in the base PortAllocator() and
we shouldn't be changing them because they must be fixed per channel.

[Wez, 2012/04/13 22:26:04]

In that case, should we fail this port allocator if we detect that they were
changed by the relay?

[Sergey Ulanov, 2012/04/13 22:30:28]

Done.

+      }
     } else if (key == "password") {
-      relay_password_ = value;
+      if (value != password()) {
+        LOG(WARNING) << "When creating relay session received "
+            " user name that was specified in the query";

[Wez, 2012/04/13 02:49:49]

typo: "user name" -> "password"

[Sergey Ulanov, 2012/04/13 19:50:38]

Done.

+      }
     } else if (key == "relay.ip") {
       relay_ip_.SetIP(value);
       if (relay_ip_.ip() == 0) {
         LOG(ERROR) << "Received unresolved relay server address: " << value;
         return;
       }
     } else if (key == "relay.udp_port") {
       if (!ParsePortNumber(value, &relay_udp_port_))
         return;
     } else if (key == "relay.tcp_port") {
       if (!ParsePortNumber(value, &relay_tcp_port_))
         return;
     } else if (key == "relay.ssltcp_port") {
       if (!ParsePortNumber(value, &relay_ssltcp_port_))
         return;
     }
   }
 
   AddConfig();
 }
 
 void P2PPortAllocatorSession::AddConfig() {
   cricket::PortConfiguration* config =
       new cricket::PortConfiguration(stun_server_address_,
-                                     relay_username_, relay_password_, "");
+                                     username(), password(), "");
 
   if (relay_ip_.ip() != 0) {
     cricket::PortConfiguration::PortList ports;
     if (relay_udp_port_ > 0) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_udp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_UDP));
     }
     if (relay_tcp_port_ > 0 && !allocator_->config_.disable_tcp_transport) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_tcp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_TCP));
     }
     if (relay_ssltcp_port_ > 0 && !allocator_->config_.disable_tcp_transport) {
       talk_base::SocketAddress address(relay_ip_.ip(), relay_ssltcp_port_);
       ports.push_back(cricket::ProtocolAddress(address, cricket::PROTO_SSLTCP));
     }
     if (!ports.empty())
       config->AddRelay(ports, 0.0f);
   }
   ConfigReady(config);
 }
 
 }  // namespace content