blob: 43f421070806bdc439d22c524eeb3340b04daef3 [file] [log] [blame]
// Copyright 2013 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 "remoting/jingle_glue/chromium_port_allocator.h"
#include "base/bind.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "googleurl/src/gurl.h"
#include "net/http/http_status_code.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "net/url_request/url_request_context_getter.h"
#include "remoting/jingle_glue/chromium_socket_factory.h"
#include "remoting/jingle_glue/network_settings.h"
namespace remoting {
namespace {
class ChromiumPortAllocatorSession
: public cricket::HttpPortAllocatorSessionBase,
public net::URLFetcherDelegate {
public:
ChromiumPortAllocatorSession(
cricket::HttpPortAllocatorBase* allocator,
const std::string& content_name,
int component,
const std::string& ice_username_fragment,
const std::string& ice_password,
const std::vector<talk_base::SocketAddress>& stun_hosts,
const std::vector<std::string>& relay_hosts,
const std::string& relay,
const scoped_refptr<net::URLRequestContextGetter>& url_context);
virtual ~ChromiumPortAllocatorSession();
// cricket::HttpPortAllocatorBase overrides.
virtual void ConfigReady(cricket::PortConfiguration* config) OVERRIDE;
virtual void SendSessionRequest(const std::string& host, int port) OVERRIDE;
// net::URLFetcherDelegate interface.
virtual void OnURLFetchComplete(const net::URLFetcher* url_fetcher) OVERRIDE;
private:
scoped_refptr<net::URLRequestContextGetter> url_context_;
std::set<const net::URLFetcher*> url_fetchers_;
DISALLOW_COPY_AND_ASSIGN(ChromiumPortAllocatorSession);
};
ChromiumPortAllocatorSession::ChromiumPortAllocatorSession(
cricket::HttpPortAllocatorBase* allocator,
const std::string& content_name,
int component,
const std::string& ice_username_fragment,
const std::string& ice_password,
const std::vector<talk_base::SocketAddress>& stun_hosts,
const std::vector<std::string>& relay_hosts,
const std::string& relay,
const scoped_refptr<net::URLRequestContextGetter>& url_context)
: HttpPortAllocatorSessionBase(allocator,
content_name,
component,
ice_username_fragment,
ice_password,
stun_hosts,
relay_hosts,
relay,
std::string()),
url_context_(url_context) {}
ChromiumPortAllocatorSession::~ChromiumPortAllocatorSession() {
STLDeleteElements(&url_fetchers_);
}
void ChromiumPortAllocatorSession::ConfigReady(
cricket::PortConfiguration* config) {
// Filter out non-UDP relay ports, so that we don't try using TCP.
for (cricket::PortConfiguration::RelayList::iterator relay =
config->relays.begin(); relay != config->relays.end(); ++relay) {
cricket::PortList filtered_ports;
for (cricket::PortList::iterator port =
relay->ports.begin(); port != relay->ports.end(); ++port) {
if (port->proto == cricket::PROTO_UDP) {
filtered_ports.push_back(*port);
}
}
relay->ports = filtered_ports;
}
cricket::BasicPortAllocatorSession::ConfigReady(config);
}
void ChromiumPortAllocatorSession::SendSessionRequest(
const std::string& host,
int port) {
GURL url("https://" + host + ":" + base::IntToString(port) +
GetSessionRequestUrl() + "&sn=1");
scoped_ptr<net::URLFetcher> url_fetcher(
net::URLFetcher::Create(url, net::URLFetcher::GET, this));
url_fetcher->SetRequestContext(url_context_.get());
url_fetcher->AddExtraRequestHeader("X-Talk-Google-Relay-Auth: " +
relay_token());
url_fetcher->AddExtraRequestHeader("X-Google-Relay-Auth: " + relay_token());
url_fetcher->AddExtraRequestHeader("X-Stream-Type: chromoting");
url_fetcher->Start();
url_fetchers_.insert(url_fetcher.release());
}
void ChromiumPortAllocatorSession::OnURLFetchComplete(
const net::URLFetcher* source) {
int response_code = source->GetResponseCode();
std::string response;
source->GetResponseAsString(&response);
url_fetchers_.erase(source);
delete source;
if (response_code != net::HTTP_OK) {
LOG(WARNING) << "Received error when allocating relay session: "
<< response_code;
TryCreateRelaySession();
return;
}
ReceiveSessionResponse(response);
}
} // namespace
// static
scoped_ptr<ChromiumPortAllocator> ChromiumPortAllocator::Create(
const scoped_refptr<net::URLRequestContextGetter>& url_context,
const NetworkSettings& network_settings) {
scoped_ptr<talk_base::NetworkManager> network_manager(
new talk_base::BasicNetworkManager());
scoped_ptr<talk_base::PacketSocketFactory> socket_factory(
new remoting::ChromiumPacketSocketFactory());
scoped_ptr<ChromiumPortAllocator> result(
new ChromiumPortAllocator(url_context, network_manager.Pass(),
socket_factory.Pass()));
// We always use PseudoTcp to provide a reliable channel. It
// provides poor performance when combined with TCP-based transport,
// so we have to disable TCP ports.
// ENABLE_SHARED_UFRAG flag is
// specified so that the same username fragment is shared between
// all candidates for this channel.
int flags = cricket::PORTALLOCATOR_DISABLE_TCP |
cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG;
if (network_settings.nat_traversal_mode !=
NetworkSettings::NAT_TRAVERSAL_ENABLED) {
flags |= cricket::PORTALLOCATOR_DISABLE_STUN |
cricket::PORTALLOCATOR_DISABLE_RELAY;
}
result->set_flags(flags);
result->SetPortRange(network_settings.min_port,
network_settings.max_port);
return result.Pass();
}
ChromiumPortAllocator::ChromiumPortAllocator(
const scoped_refptr<net::URLRequestContextGetter>& url_context,
scoped_ptr<talk_base::NetworkManager> network_manager,
scoped_ptr<talk_base::PacketSocketFactory> socket_factory)
: HttpPortAllocatorBase(network_manager.get(),
socket_factory.get(),
std::string()),
url_context_(url_context),
network_manager_(network_manager.Pass()),
socket_factory_(socket_factory.Pass()) {}
ChromiumPortAllocator::~ChromiumPortAllocator() {
}
cricket::PortAllocatorSession* ChromiumPortAllocator::CreateSessionInternal(
const std::string& content_name,
int component,
const std::string& ice_username_fragment,
const std::string& ice_password) {
return new ChromiumPortAllocatorSession(
this, content_name, component, ice_username_fragment, ice_password,
stun_hosts(), relay_hosts(), relay_token(), url_context_);
}
} // namespace remoting