本节主要说的是发送AllocateRequest到turn服务器的过程。

STUN/TURN消息类型

image.png

发送AllocateRequest调用栈

image.png

AllocationSequence::CreateRelayPorts

h:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\p2p\client\basic_port_allocator.cc
image.png

AllocationSequence::CreateTurnPort

image.png
一般只有一个ports，所以循环一般只执行一遍。

  1. void AllocationSequence::CreateTurnPort(const RelayServerConfig& config) {
  2.     PortList::const_iterator relay_port;
  3.     for (relay_port = config.ports.begin(); relay_port != config.ports.end();
  4.          ++relay_port) {
  5.         // Skip UDP connections to relay servers if it's disallowed.
  6.         if (IsFlagSet(PORTALLOCATOR_DISABLE_UDP_RELAY) &&
  7.             relay_port->proto == PROTO_UDP) {
  8.             continue;
  9.         }
  11.         // Do not create a port if the server address family is known and does
  12.         // not match the local IP address family.
  13.         int server_ip_family = relay_port->address.ipaddr().family();
  14.         int local_ip_family = network_->GetBestIP().family();
  15.         if (server_ip_family != AF_UNSPEC && server_ip_family != local_ip_family) {
  16.             RTC_LOG(LS_INFO)
  17.                 << "Server and local address families are not compatible. "
  18.                 "Server address: "
  19.                 << relay_port->address.ipaddr().ToSensitiveString()
  20.                 << " Local address: " << network_->GetBestIP().ToSensitiveString();
  21.             continue;
  22.         }
  24.         CreateRelayPortArgs args;
  25.         args.network_thread = session_->network_thread();
  26.         args.socket_factory = session_->socket_factory();
  27.         args.network = network_;
  28.         args.username = session_->username();
  29.         args.password = session_->password();
  30.         args.server_address = &(*relay_port);
  31.         args.config = &config;
  32.         args.origin = session_->allocator()->origin();
  33.         args.turn_customizer = session_->allocator()->turn_customizer();
  35.         std::unique_ptr<cricket::Port> port;
  36.         // Shared socket mode must be enabled only for UDP based ports. Hence
  37.         // don't pass shared socket for ports which will create TCP sockets.
  38.         // TODO(mallinath) - Enable shared socket mode for TURN ports. Disabled
  39.         // due to webrtc bug https://code.google.com/p/webrtc/issues/detail?id=3537
  40.         if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) &&
  41.             relay_port->proto == PROTO_UDP && udp_socket_) {
  42.             port = session_->allocator()->relay_port_factory()->Create(
  43.                 args, udp_socket_.get());
  45.             if (!port) {
  46.                 RTC_LOG(LS_WARNING) << "Failed to create relay port with "
  47.                     << args.server_address->address.ToSensitiveString();
  48.                 continue;
  49.             }
  51.             relay_ports_.push_back(port.get());
  52.             // Listen to the port destroyed signal, to allow AllocationSequence to
  53.             // remove the entry from it's map.
  54.             port->SubscribePortDestroyed(
  55.                 [this](PortInterface* port) { OnPortDestroyed(port); });
  57.         } else {
  58.             port = session_->allocator()->relay_port_factory()->Create(
  59.                 args, session_->allocator()->min_port(),
  60.                 session_->allocator()->max_port());
  62.             if (!port) {
  64.                 RTC_LOG(LS_WARNING) << "Failed to create relay port with "
  65.                     << args.server_address->address.ToSensitiveString();
  66.                 continue;
  67.             }
  68.         }
  69.         RTC_DCHECK(port != NULL);
  70.         session_->AddAllocatedPort(port.release(), this, true);
  71.     }
  72. }

BasicPortAllocatorSession::AddAllocatedPort

image.png

  1. void BasicPortAllocatorSession::AddAllocatedPort(Port* port,
  2.                                                  AllocationSequence* seq,
  3.                                                  bool prepare_address) {
  4.   RTC_DCHECK_RUN_ON(network_thread_);
  5.   if (!port)
  6.     return;
  8.   RTC_LOG(LS_INFO) << "Adding allocated port for " << content_name();
  9.   port->set_content_name(content_name());
  10.   port->set_component(component());
  11.   port->set_generation(generation());
  12.   if (allocator_->proxy().type != rtc::PROXY_NONE)
  13.     port->set_proxy(allocator_->user_agent(), allocator_->proxy());
  14.   port->set_send_retransmit_count_attribute(
  15.       (flags() & PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE) != 0);
  17.   PortData data(port, seq);
  18.   ports_.push_back(data);
  20.   port->SignalCandidateReady.connect(
  21.       this, &BasicPortAllocatorSession::OnCandidateReady);
  22.   port->SignalCandidateError.connect(
  23.       this, &BasicPortAllocatorSession::OnCandidateError);
  24.   port->SignalPortComplete.connect(this,
  25.                                    &BasicPortAllocatorSession::OnPortComplete);
  26.   port->SubscribePortDestroyed(
  27.       [this](PortInterface* port) { OnPortDestroyed(port); });
  29.   port->SignalPortError.connect(this, &BasicPortAllocatorSession::OnPortError);
  30.   RTC_LOG(LS_INFO) << port->ToString() << ": Added port to allocator";
  32.   if (prepare_address)
  33.     port->PrepareAddress();
  34. }

TurnPort::PrepareAddress

image.png

  1. void TurnPort::PrepareAddress() {
  2.   if (credentials_.username.empty() || credentials_.password.empty()) {
  3.     RTC_LOG(LS_ERROR) << "Allocation can't be started without setting the"
  4.                          " TURN server credentials for the user.";
  5.     OnAllocateError(STUN_ERROR_UNAUTHORIZED,
  6.                     "Missing TURN server credentials.");
  7.     return;
  8.   }
  10.   if (!server_address_.address.port()) {
  11.     // We will set default TURN port, if no port is set in the address.
  12.     server_address_.address.SetPort(TURN_DEFAULT_PORT);
  13.   }
  15.   if (!AllowedTurnPort(server_address_.address.port())) {
  16.     // This can only happen after a 300 ALTERNATE SERVER, since the port can't
  17.     // be created with a disallowed port number.
  18.     RTC_LOG(LS_ERROR) << "Attempt to start allocation with disallowed port# "
  19.                       << server_address_.address.port();
  20.     OnAllocateError(STUN_ERROR_SERVER_ERROR,
  21.                     "Attempt to start allocation to a disallowed port");
  22.     return;
  23.   }
  24.   if (server_address_.address.IsUnresolvedIP()) {
  25.     ResolveTurnAddress(server_address_.address);
  26.   } else {
  27.     // If protocol family of server address doesn't match with local, return.
  28.     if (!IsCompatibleAddress(server_address_.address)) {
  29.       RTC_LOG(LS_ERROR) << "IP address family does not match. server: "
  30.                         << server_address_.address.family()
  31.                         << " local: " << Network()->GetBestIP().family();
  32.       OnAllocateError(STUN_ERROR_GLOBAL_FAILURE,
  33.                       "IP address family does not match.");
  34.       return;
  35.     }
  37.     // Insert the current address to prevent redirection pingpong.
  38.     attempted_server_addresses_.insert(server_address_.address);
  40.     RTC_LOG(LS_INFO) << ToString() << ": Trying to connect to TURN server via "
  41.                      << ProtoToString(server_address_.proto) << " @ "
  42.                      << server_address_.address.ToSensitiveString();
  43.     if (!CreateTurnClientSocket()) {
  44.       RTC_LOG(LS_ERROR) << "Failed to create TURN client socket";
  45.       OnAllocateError(SERVER_NOT_REACHABLE_ERROR,
  46.                       "Failed to create TURN client socket.");
  47.       return;
  48.     }
  49.     if (server_address_.proto == PROTO_UDP) {
  50.       // If its UDP, send AllocateRequest now.
  51.       // For TCP and TLS AllcateRequest will be sent by OnSocketConnect.
  52.       SendRequest(new TurnAllocateRequest(this), 0);
  53.     }
  54.   }
  55. }

TurnPort::ResolveTurnAddress域名解析

image.png

TurnPort::OnResolveResult

image.png

  1. void TurnPort::OnResolveResult(rtc::AsyncResolverInterface* resolver) {
  2.   RTC_DCHECK(resolver == resolver_);
  3.   // If DNS resolve is failed when trying to connect to the server using TCP,
  4.   // one of the reason could be due to DNS queries blocked by firewall.
  5.   // In such cases we will try to connect to the server with hostname, assuming
  6.   // socket layer will resolve the hostname through a HTTP proxy (if any).
  7.   if (resolver_->GetError() != 0 && (server_address_.proto == PROTO_TCP ||
  8.                                      server_address_.proto == PROTO_TLS)) {
  9.     if (!CreateTurnClientSocket()) {
  10.       OnAllocateError(SERVER_NOT_REACHABLE_ERROR,
  11.                       "TURN host lookup received error.");
  12.     }
  13.     return;
  14.   }
  16.   // Copy the original server address in |resolved_address|. For TLS based
  17.   // sockets we need hostname along with resolved address.
  18.   rtc::SocketAddress resolved_address = server_address_.address;
  19.   if (resolver_->GetError() != 0 ||
  20.       !resolver_->GetResolvedAddress(Network()->GetBestIP().family(),
  21.                                      &resolved_address)) {
  22.     RTC_LOG(LS_WARNING) << ToString() << ": TURN host lookup received error "
  23.                         << resolver_->GetError();
  24.     error_ = resolver_->GetError();
  25.     OnAllocateError(SERVER_NOT_REACHABLE_ERROR,
  26.                     "TURN host lookup received error.");
  27.     return;
  28.   }
  29.   // Signal needs both resolved and unresolved address. After signal is sent
  30.   // we can copy resolved address back into |server_address_|.
  31.   SignalResolvedServerAddress(this, server_address_.address, resolved_address);
  32.   server_address_.address = resolved_address;
  33.   PrepareAddress();
  34. }

域名解析完成后，再次回到 TurnPort::PrepareAddress

TurnPort::PrepareAddress

image.png