content/renderer/p2p/port_allocator.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/p2p/port_allocator.h"
   6
   7 namespace content {
   8
   9 P2PPortAllocator::Config::Config()
  10     : disable_tcp_transport(false) {
  11 }
  12
  13 P2PPortAllocator::Config::~Config() {
  14 }
  15
  16 P2PPortAllocator::Config::RelayServerConfig::RelayServerConfig()
  17     : port(0) {
  18 }
  19
  20 P2PPortAllocator::Config::RelayServerConfig::~RelayServerConfig() {
  21 }
  22
  23 P2PPortAllocator::P2PPortAllocator(
  24     P2PSocketDispatcher* socket_dispatcher,
  25     rtc::NetworkManager* network_manager,
  26     rtc::PacketSocketFactory* socket_factory,
  27     const Config& config)
  28     : cricket::BasicPortAllocator(network_manager, socket_factory),
  29       socket_dispatcher_(socket_dispatcher),
  30       config_(config) {
  31   uint32 flags = 0;
  32   if (config_.disable_tcp_transport)
  33     flags |= cricket::PORTALLOCATOR_DISABLE_TCP;
  34   if (!config_.enable_multiple_routes)
  35     flags |= cricket::PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION;
  36   set_flags(flags);
  37   set_allow_tcp_listen(false);
  38 }
  39
  40 P2PPortAllocator::~P2PPortAllocator() {
  41 }
  42
  43 cricket::PortAllocatorSession* P2PPortAllocator::CreateSessionInternal(
  44     const std::string& content_name,
  45     int component,
  46     const std::string& ice_username_fragment,
  47     const std::string& ice_password) {
  48   return new P2PPortAllocatorSession(
  49       this, content_name, component, ice_username_fragment, ice_password);
  50 }
  51
  52 P2PPortAllocatorSession::P2PPortAllocatorSession(
  53     P2PPortAllocator* allocator,
  54     const std::string& content_name,
  55     int component,
  56     const std::string& ice_username_fragment,
  57     const std::string& ice_password)
  58     : cricket::BasicPortAllocatorSession(allocator,
  59                                          content_name,
  60                                          component,
  61                                          ice_username_fragment,
  62                                          ice_password),
  63       allocator_(allocator) {
  64 }
  65
  66 P2PPortAllocatorSession::~P2PPortAllocatorSession() {
  67 }
  68
  69 void P2PPortAllocatorSession::GetPortConfigurations() {
  70   const P2PPortAllocator::Config& config = allocator_->config_;
  71   cricket::PortConfiguration* port_config = new cricket::PortConfiguration(
  72       config.stun_servers, std::string(), std::string());
  73
  74   for (size_t i = 0; i < config.relays.size(); ++i) {
  75     cricket::RelayCredentials credentials(config.relays[i].username,
  76                                           config.relays[i].password);
  77     cricket::RelayServerConfig relay_server(cricket::RELAY_TURN);
  78     cricket::ProtocolType protocol;
  79     if (!cricket::StringToProto(config.relays[i].transport_type.c_str(),
  80                                 &protocol)) {
  81       DLOG(WARNING) << "Ignoring TURN server "
  82                     << config.relays[i].server_address << ". "
  83                     << "Reason= Incorrect "
  84                     << config.relays[i].transport_type
  85                     << " transport parameter.";
  86       continue;
  87     }
  88
  89     relay_server.ports.push_back(cricket::ProtocolAddress(
  90         rtc::SocketAddress(config.relays[i].server_address,
  91                                  config.relays[i].port),
  92         protocol,
  93         config.relays[i].secure));
  94     relay_server.credentials = credentials;
  95     port_config->AddRelay(relay_server);
  96   }
  97   ConfigReady(port_config);
  98 }
  99
 100 }  // namespace content