美文网首页ice
各个类型candidate的搜集过程

各个类型candidate的搜集过程

作者: 古则 | 来源:发表于2017-05-24 17:11 被阅读1285次

    1、candidate的收集整体调用逻辑

    先看整体的调用逻辑,再看各个类型candidate的收集过程

    connection的建立及相关处理.jpg

    看关键的方法AllocationSequence::Init,这里会分配本地的udp端口

    bool AllocationSequence::Init() {
      if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
        udp_socket_.reset(session_->socket_factory()->CreateUdpSocket(
            rtc::SocketAddress(ip_, 0), session_->allocator()->min_port(),
            session_->allocator()->max_port()));
        if (udp_socket_) {
          udp_socket_->SignalReadPacket.connect(
              this, &AllocationSequence::OnReadPacket);
        }
        // Continuing if |udp_socket_| is NULL, as local TCP and RelayPort using TCP
        // are next available options to setup a communication channel.
      }
      return true;
    }
    
    

    这个方法一直跟下去会发现bind时的方法是

    int Win32Socket::Bind(const SocketAddress& addr) {
      ASSERT(socket_ != INVALID_SOCKET);
      if (socket_ == INVALID_SOCKET)
        return SOCKET_ERROR;
    
      sockaddr_storage saddr;
      size_t len = addr.ToSockAddrStorage(&saddr);
      int err = ::bind(socket_,
                       reinterpret_cast<sockaddr*>(&saddr),
                       static_cast<int>(len));
      UpdateLastError();
      return err;
    }
    

    其中的端口为0,也就是说要绑定的端口由操作系统随机选择

    下面来看其中关键的方法2 BasicPortAllocatorSession::DoAllocate

    //basicportallocator.cc 341L
    void BasicPortAllocatorSession::DoAllocate() {
      bool done_signal_needed = false;
      std::vector<rtc::Network*> networks;
      GetNetworks(&networks);
    
      if (networks.empty()) {
        LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
        done_signal_needed = true;
      } else {
        for (uint32_t i = 0; i < networks.size(); ++i) {
          PortConfiguration* config = NULL;
          if (configs_.size() > 0)
            config = configs_.back();
    
          uint32_t sequence_flags = flags();
          if ((sequence_flags & DISABLE_ALL_PHASES) == DISABLE_ALL_PHASES) {
            // If all the ports are disabled we should just fire the allocation
            // done event and return.
            done_signal_needed = true;
            break;
          }
    
          if (!config || config->relays.empty()) {
            // No relay ports specified in this config.
            sequence_flags |= PORTALLOCATOR_DISABLE_RELAY;
          }
    
          if (!(sequence_flags & PORTALLOCATOR_ENABLE_IPV6) &&
              networks[i]->GetBestIP().family() == AF_INET6) {
            // Skip IPv6 networks unless the flag's been set.
            continue;
          }
    
          // Disable phases that would only create ports equivalent to
          // ones that we have already made.
          DisableEquivalentPhases(networks[i], config, &sequence_flags);
    
          if ((sequence_flags & DISABLE_ALL_PHASES) == DISABLE_ALL_PHASES) {
            // New AllocationSequence would have nothing to do, so don't make it.
            continue;
          }
    
          AllocationSequence* sequence =
              new AllocationSequence(this, networks[i], config, sequence_flags);
          if (!sequence->Init()) {
            delete sequence;
            continue;
          }
          done_signal_needed = true;
          sequence->SignalPortAllocationComplete.connect(
              this, &BasicPortAllocatorSession::OnPortAllocationComplete);
          if (running_)
            sequence->Start(); //开始建立port,然后开始搜集candidate
          sequences_.push_back(sequence);
        }
      }
      if (done_signal_needed) {
        network_thread_->Post(this, MSG_SEQUENCEOBJECTS_CREATED);
      }
    }
    
    AllocationSequence::AllocationSequence(BasicPortAllocatorSession* session,
                                           rtc::Network* network,
                                           PortConfiguration* config,
                                           uint32_t flags)
        : session_(session),
          network_(network),
          ip_(network->GetBestIP()),
          config_(config),
          state_(kInit),
          flags_(flags),
          udp_socket_(),
          udp_port_(NULL),
          phase_(0) {
    }
    
    bool AllocationSequence::Init() {
      if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
        udp_socket_.reset(session_->socket_factory()->CreateUdpSocket(
            rtc::SocketAddress(ip_, 0), session_->allocator()->min_port(),
            session_->allocator()->max_port()));
        if (udp_socket_) {
          udp_socket_->SignalReadPacket.connect(
              this, &AllocationSequence::OnReadPacket);
        }
        // Continuing if |udp_socket_| is NULL, as local TCP and RelayPort using TCP
        // are next available options to setup a communication channel.
      }
      return true;
    }
    
    

    可以看出:
    (1)一个网络(比如)会建立一个AllocationSequence
    (2)AllocationSequence对应这个网络的best ip
    (3)一个AllocationSequence建立一套port(sequence->Start() 开始建立port,然后开始搜集candidate)
    (4)经过测试IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)为true,所以udp port是复用的

    2、candidate的最终合成方法

    首先看一下最终生成candidate的方法

    //port.cc 230L
    void Port::AddAddress(const rtc::SocketAddress& address,
                          const rtc::SocketAddress& base_address,
                          const rtc::SocketAddress& related_address,
                          const std::string& protocol,
                          const std::string& relay_protocol,
                          const std::string& tcptype,
                          const std::string& type,
                          uint32_t type_preference,
                          uint32_t relay_preference,
                          bool final) {
      if (protocol == TCP_PROTOCOL_NAME && type == LOCAL_PORT_TYPE) {
        ASSERT(!tcptype.empty());
      }
    
      std::string foundation =
          ComputeFoundation(type, protocol, relay_protocol, base_address);
      Candidate c(component_, protocol, address, 0U, username_fragment(), password_,
                  type, generation_, foundation, network_->id(), network_cost_);
      c.set_priority(
          c.GetPriority(type_preference, network_->preference(), relay_preference));
      c.set_relay_protocol(relay_protocol);
      c.set_tcptype(tcptype);
      c.set_network_name(network_->name());
      c.set_network_type(network_->type());
      c.set_related_address(related_address);
      candidates_.push_back(c);
      SignalCandidateReady(this, c);
    
      if (final) {
        SignalPortComplete(this);
      }
    }
    

    candidate的结构

    candidate:499412426 1 udp 2122260223 192.168.0.136 54135 typ host generation 0 ufrag KQbng0ClMLl6gk2B network-id 3
    
      //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)
    

    对应AddAddress方法跟candidate的结构,来看candidate中各个元素的计算

    foundation的计算

    // Foundation:  An arbitrary string that is the same for two candidates
    //   that have the same type, base IP address, protocol (UDP, TCP,
    //   etc.), and STUN or TURN server.  If any of these are different,
    //   then the foundation will be different.  Two candidate pairs with
    //   the same foundation pairs are likely to have similar network
    //   characteristics.  Foundations are used in the frozen algorithm.
    static std::string ComputeFoundation(const std::string& type,
                                         const std::string& protocol,
                                         const std::string& relay_protocol,
                                         const rtc::SocketAddress& base_address) {
      std::ostringstream ost;
      ost << type << base_address.ipaddr().ToString() << protocol << relay_protocol;
      return rtc::ToString<uint32_t>(rtc::ComputeCrc32(ost.str()));
    }
    

    就是将type,protocol,relay_protocol,base_address等合并在一起,计算一个Crc32校验值

    component_

     component_(ICE_CANDIDATE_COMPONENT_DEFAULT) //port的构造函数中,port.cc 145L ICE_CANDIDATE_COMPONENT_DEFAULT = 1
    
    //component_ 最初被传入的位置位于BaseChannel::SetTransport_w(channel.cc 249L 跟 258行中)
    cricket::ICE_CANDIDATE_COMPONENT_RTP  1
    cricket::ICE_CANDIDATE_COMPONENT_RTCP  2
    

    generation_

    最初设置于 P2PTransportChannel::AddAllocatorSession(P2PTransportChannel 275L)

    session->set_generation(static_cast<uint32_t>(allocator_sessions_.size()));
    

    大部分情况下为0

    network_cost_

    跟当前网络类型有关

    network_cost_ =  (network_->type() == rtc::ADAPTER_TYPE_CELLULAR) ? kMaxNetworkCost : 0;
    
    //网络类型
    enum AdapterType {
      // This enum resembles the one in Chromium net::ConnectionType.
      ADAPTER_TYPE_UNKNOWN = 0,
      ADAPTER_TYPE_ETHERNET = 1 << 0,
      ADAPTER_TYPE_WIFI = 1 << 1,
      ADAPTER_TYPE_CELLULAR = 1 << 2,
      ADAPTER_TYPE_VPN = 1 << 3,
      ADAPTER_TYPE_LOOPBACK = 1 << 4
    };
    

    priority的计算

    //candidate.h 239
    uint32_t GetPriority(uint32_t type_preference,
                           int network_adapter_preference,
                           int relay_preference) const {
        // RFC 5245 - 4.1.2.1.
        // priority = (2^24)*(type preference) +
        //            (2^8)*(local preference) +
        //            (2^0)*(256 - component ID)
    
        // |local_preference| length is 2 bytes, 0-65535 inclusive.
        // In our implemenation we will partion local_preference into
        //              0                 1
        //       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        //      |  NIC Pref     |    Addr Pref  |
        //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        // NIC Type - Type of the network adapter e.g. 3G/Wifi/Wired.
        // Addr Pref - Address preference value as per RFC 3484.
        // local preference =  (NIC Type << 8 | Addr_Pref) - relay preference.
    
        int addr_pref = IPAddressPrecedence(address_.ipaddr());
        int local_preference = ((network_adapter_preference << 8) | addr_pref) +
            relay_preference;
    
        return (type_preference << 24) |
               (local_preference << 8) |
               (256 - component_);
      }
    

    先看各个变量的具体含义
    type_preference 各个地址类型的偏好
    具体赋值是

    //port.h 83L,在各个port调用AddAddress时传参
    enum IcePriorityValue {
      // The reason we are choosing Relay preference 2 is because, we can run
      // Relay from client to server on UDP/TCP/TLS. To distinguish the transport
      // protocol, we prefer UDP over TCP over TLS.
      // For UDP ICE_TYPE_PREFERENCE_RELAY will be 2.
      // For TCP ICE_TYPE_PREFERENCE_RELAY will be 1.
      // For TLS ICE_TYPE_PREFERENCE_RELAY will be 0.
      // Check turnport.cc for setting these values.
      ICE_TYPE_PREFERENCE_RELAY = 2,
      ICE_TYPE_PREFERENCE_HOST_TCP = 90,
      ICE_TYPE_PREFERENCE_SRFLX = 100,
      ICE_TYPE_PREFERENCE_PRFLX = 110,
      ICE_TYPE_PREFERENCE_HOST = 126
    };
    

    NIC Type 网卡类型的偏好,在network.cc 335L设置,代码如下

     std::sort(networks_.begin(), networks_.end(), SortNetworks);
        // Now network interfaces are sorted, we should set the preference value
        // for each of the interfaces we are planning to use.
        // Preference order of network interfaces might have changed from previous
        // sorting due to addition of higher preference network interface.
        // Since we have already sorted the network interfaces based on our
        // requirements, we will just assign a preference value starting with 127,
        // in decreasing order.
        int pref = kHighestNetworkPreference;
        for (Network* network : networks_) {
          network->set_preference(pref);
    

    addr_pref ip类型的Preference

    //ipaddress.cc 482L
    int IPAddressPrecedence(const IPAddress& ip) {
      // Precedence values from RFC 3484-bis. Prefers native v4 over 6to4/Teredo.
      if (ip.family() == AF_INET) {
        return 30;
      } else if (ip.family() == AF_INET6) {
        if (IPIsLoopback(ip)) {
          return 60;
        } else if (IPIsULA(ip)) {
          return 50;
        } else if (IPIsV4Mapped(ip)) {
          return 30;
        } else if (IPIs6To4(ip)) {
          return 20;
        } else if (IPIsTeredo(ip)) {
          return 10;
        } else if (IPIsV4Compatibility(ip) || IPIsSiteLocal(ip) || IPIs6Bone(ip)) {
          return 1;
        } else {
          // A 'normal' IPv6 address.
          return 40;
        }
      }
      return 0;
    }
    

    relay_preference
    只在TurnPort::OnAllocateSuccess对AddAddress调用时(turnport.cc 712L)设置了值,其他的调用都为0

    从代码:

    int addr_pref = IPAddressPrecedence(address_.ipaddr());
        int local_preference = ((network_adapter_preference << 8) | addr_pref) +
            relay_preference;
    
        return (type_preference << 24) |
               (local_preference << 8) |
               (256 - component_);
    

    可以看出,优先级值的组成在比较时起的作用是:
    1.先比较ice类型,如是host,srflx还是relay之类
    2.比较网络类型,如以太网,wifi之类
    3.比较ip地址类型,如是本地回环地址之类

    搜集host跟srflx的candidate共用的方法

    stunport.cc 251L
    void UDPPort::PrepareAddress() {
      ASSERT(requests_.empty());
      if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
        OnLocalAddressReady(socket_, socket_->GetLocalAddress());
      }
    }
    
    void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
                                      const rtc::SocketAddress& address) {
      // When adapter enumeration is disabled and binding to the any address, the
      // default local address will be issued as a candidate instead if
      // |emit_local_for_anyaddress| is true. This is to allow connectivity for
      // applications which absolutely requires a HOST candidate.
      rtc::SocketAddress addr = address;
    
      // If MaybeSetDefaultLocalAddress fails, we keep the "any" IP so that at
      // least the port is listening.
      MaybeSetDefaultLocalAddress(&addr);
    
      AddAddress(addr, addr, rtc::SocketAddress(), UDP_PROTOCOL_NAME, "", "",
                 LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST, 0, false);
      MaybePrepareStunCandidate();
    }
    
    void UDPPort::MaybePrepareStunCandidate() {
      // Sending binding request to the STUN server if address is available to
      // prepare STUN candidate.
      if (!server_addresses_.empty()) {
        SendStunBindingRequests();
      } else {
        // Port is done allocating candidates.
        MaybeSetPortCompleteOrError();
      }
    }
    

    各个port的类关系如下图

    port的类图.png

    3、host

    AllocationSequence::createUDPPorts

    也就是udpport,搜集本地地址,此时MaybePrepareStunCandidate被调用时,udpport的server_addresses_为空,不会发送bindingrequest

    4、srflx

    AllocationSequence::CreateStunPorts

    stunport继承了udpport,搜集反射地址时,MaybePrepareStunCandidate被调用时,server_addresses_为stun服务器的地址,发送bindingrequest

    5、relay

    void AllocationSequence::CreateRelayPorts() {
      if (IsFlagSet(PORTALLOCATOR_DISABLE_RELAY)) {
         LOG(LS_VERBOSE) << "AllocationSequence: Relay ports disabled, skipping.";
         return;
      }
    
      // If BasicPortAllocatorSession::OnAllocate left relay ports enabled then we
      // ought to have a relay list for them here.
      ASSERT(config_ && !config_->relays.empty());
      if (!(config_ && !config_->relays.empty())) {
        LOG(LS_WARNING)
            << "AllocationSequence: No relay server configured, skipping.";
        return;
      }
    
      PortConfiguration::RelayList::const_iterator relay;
      for (relay = config_->relays.begin();
           relay != config_->relays.end(); ++relay) {
        if (relay->type == RELAY_GTURN) {
          CreateGturnPort(*relay);
        } else if (relay->type == RELAY_TURN) {
          CreateTurnPort(*relay);
        } else {
          ASSERT(false);
        }
      }
    }
    
    • 在该方法中如果turn服务器配置的是google的传统中继服务器将调用
      CreateGturnPort(*relay);
      生成relayport,此relayport的分析从略

    • 如果不是则调用CreateTurnPort(*relay);
      生成turnport
      turnport的PrepareAddress方法代码如下:

    void TurnPort::PrepareAddress() {
      if (credentials_.username.empty() ||
          credentials_.password.empty()) {
        LOG(LS_ERROR) << "Allocation can't be started without setting the"
                      << " TURN server credentials for the user.";
        OnAllocateError();
        return;
      }
    
      if (!server_address_.address.port()) {
        // We will set default TURN port, if no port is set in the address.
        server_address_.address.SetPort(TURN_DEFAULT_PORT);
      }
    
      if (server_address_.address.IsUnresolvedIP()) {
        ResolveTurnAddress(server_address_.address);
      } else {
        // If protocol family of server address doesn't match with local, return.
        if (!IsCompatibleAddress(server_address_.address)) {
          LOG(LS_ERROR) << "IP address family does not match: "
                        << "server: " << server_address_.address.family()
                        << "local: " << ip().family();
          OnAllocateError();
          return;
        }
    
        // Insert the current address to prevent redirection pingpong.
        attempted_server_addresses_.insert(server_address_.address);
        LOG_J(LS_INFO, this) << "Trying to connect to TURN server via "
                             << ProtoToString(server_address_.proto) << " @ "
                             << server_address_.address.ToSensitiveString();
        if (!CreateTurnClientSocket()) {
          LOG(LS_ERROR) << "Failed to create TURN client socket";
          OnAllocateError();
          return;
        }
        if (server_address_.proto == PROTO_UDP) {
          // If its UDP, send AllocateRequest now.
          // For TCP and TLS AllcateRequest will be sent by OnSocketConnect.
          SendRequest(new TurnAllocateRequest(this), 0);
        }
      }
    }
    

    发送TurnAllocateRequest请求,也就是allocate请求

    6、host tcptype

    tcpport的建立

    static TCPPort* Create(rtc::Thread* thread,
                             rtc::PacketSocketFactory* factory,
                             rtc::Network* network,
                             const rtc::IPAddress& ip,
                             uint16_t min_port,
                             uint16_t max_port,
                             const std::string& username,
                             const std::string& password,
                             bool allow_listen) {
        TCPPort* port = new TCPPort(thread, factory, network, ip, min_port,
                                    max_port, username, password, allow_listen);
        if (!port->Init()) {
          delete port;
          port = NULL;
        }
        return port;
      }
    
    bool TCPPort::Init() {
      if (allow_listen_) {
        // Treat failure to create or bind a TCP socket as fatal.  This
        // should never happen.
        socket_ = socket_factory()->CreateServerTcpSocket(
            rtc::SocketAddress(ip(), 0), min_port(), max_port(),
            false /* ssl */);
        if (!socket_) {
          LOG_J(LS_ERROR, this) << "TCP socket creation failed.";
          return false;
        }
        socket_->SignalNewConnection.connect(this, &TCPPort::OnNewConnection);
        socket_->SignalAddressReady.connect(this, &TCPPort::OnAddressReady);
      }
      return true;
    }
    

    在该段代码中,min_port max_port都为0,所以tcp的端口也是相同随机选择的

    相关文章

      网友评论

        本文标题:各个类型candidate的搜集过程

        本文链接:https://www.haomeiwen.com/subject/xfnnxxtx.html