text: /*
   *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
   *
   *  Use of this source code is governed by a BSD-style license
   *  that can be found in the LICENSE file in the root of the source
   *  tree. An additional intellectual property rights grant can be found
   *  in the file PATENTS.  All contributing project authors may
   *  be found in the AUTHORS file in the root of the source tree.
   */
  
  #ifndef P2P_BASE_PORT_H_
  #define P2P_BASE_PORT_H_
  
  #include <map>
  #include <memory>
  #include <set>
  #include <string>
  #include <vector>
  
  #include "absl/types/optional.h"
  #include "api/candidate.h"
  #include "api/rtc_error.h"
  #include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h"
  #include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
  #include "logging/rtc_event_log/ice_logger.h"
  #include "p2p/base/candidate_pair_interface.h"
  #include "p2p/base/p2p_constants.h"
  #include "p2p/base/packet_loss_estimator.h"
  #include "p2p/base/packet_socket_factory.h"
  #include "p2p/base/port_interface.h"
  #include "p2p/base/stun.h"
  #include "p2p/base/stun_request.h"
  #include "rtc_base/async_packet_socket.h"
  #include "rtc_base/checks.h"
  #include "rtc_base/net_helper.h"
  #include "rtc_base/network.h"
  #include "rtc_base/proxy_info.h"
  #include "rtc_base/rate_tracker.h"
  #include "rtc_base/socket_address.h"
  #include "rtc_base/system/rtc_export.h"
  #include "rtc_base/third_party/sigslot/sigslot.h"
  #include "rtc_base/thread.h"
  #include "rtc_base/weak_ptr.h"
  
  namespace cricket {
  
  class Connection;
  class ConnectionRequest;
  
  extern const char LOCAL_PORT_TYPE[];
  extern const char STUN_PORT_TYPE[];
  extern const char PRFLX_PORT_TYPE[];
  RTC_EXPORT extern const char RELAY_PORT_TYPE[];
  
  // RFC 6544, TCP candidate encoding rules.
  extern const int DISCARD_PORT;
  extern const char TCPTYPE_ACTIVE_STR[];
  extern const char TCPTYPE_PASSIVE_STR[];
  extern const char TCPTYPE_SIMOPEN_STR[];
  
  enum RelayType {
    RELAY_GTURN,  // Legacy google relay service.
    RELAY_TURN    // Standard (TURN) relay service.
  };
  
  enum IcePriorityValue {
    ICE_TYPE_PREFERENCE_RELAY_TLS = 0,
    ICE_TYPE_PREFERENCE_RELAY_TCP = 1,
    ICE_TYPE_PREFERENCE_RELAY_UDP = 2,
    ICE_TYPE_PREFERENCE_PRFLX_TCP = 80,
    ICE_TYPE_PREFERENCE_HOST_TCP = 90,
    ICE_TYPE_PREFERENCE_SRFLX = 100,
    ICE_TYPE_PREFERENCE_PRFLX = 110,
    ICE_TYPE_PREFERENCE_HOST = 126
  };
  
  // States are from RFC 5245. http://tools.ietf.org/html/rfc5245#section-5.7.4
  enum class IceCandidatePairState {
    WAITING = 0,  // Check has not been performed, Waiting pair on CL.
    IN_PROGRESS,  // Check has been sent, transaction is in progress.
    SUCCEEDED,    // Check already done, produced a successful result.
    FAILED,       // Check for this connection failed.
    // According to spec there should also be a frozen state, but nothing is ever
    // frozen because we have not implemented ICE freezing logic.
  };
  
  enum class MdnsNameRegistrationStatus {
    // IP concealment with mDNS is not enabled or the name registration process is
    // not started yet.
    kNotStarted,
    // A request to create and register an mDNS name for a local IP address of a
    // host candidate is sent to the mDNS responder.
    kInProgress,
    // The name registration is complete and the created name is returned by the
    // mDNS responder.
    kCompleted,
  };
  
  // Stats that we can return about the port of a STUN candidate.
  class StunStats {
   public:
    StunStats() = default;
    StunStats(const StunStats&) = default;
    ~StunStats() = default;
  
    StunStats& operator=(const StunStats& other) = default;
  
    int stun_binding_requests_sent = 0;
    int stun_binding_responses_received = 0;
    double stun_binding_rtt_ms_total = 0;
    double stun_binding_rtt_ms_squared_total = 0;
  };
  
  // Stats that we can return about a candidate.
  class CandidateStats {
   public:
    CandidateStats();
    explicit CandidateStats(Candidate candidate);
    CandidateStats(const CandidateStats&);
    ~CandidateStats();
  
    Candidate candidate;
    // STUN port stats if this candidate is a STUN candidate.
    absl::optional<StunStats> stun_stats;
  };
  
  typedef std::vector<CandidateStats> CandidateStatsList;
  
  // Stats that we can return about the connections for a transport channel.
  // TODO(hta): Rename to ConnectionStats
  struct ConnectionInfo {
    ConnectionInfo();
    ConnectionInfo(const ConnectionInfo&);
    ~ConnectionInfo();
  
    bool best_connection;      // Is this the best connection we have?
    bool writable;             // Has this connection received a STUN response?
    bool receiving;            // Has this connection received anything?
    bool timeout;              // Has this connection timed out?
    bool new_connection;       // Is this a newly created connection?
    size_t rtt;                // The STUN RTT for this connection.
    size_t sent_total_bytes;   // Total bytes sent on this connection.
    size_t sent_bytes_second;  // Bps over the last measurement interval.
    size_t sent_discarded_packets;  // Number of outgoing packets discarded due to
                                    // socket errors.
    size_t sent_total_packets;  // Number of total outgoing packets attempted for
                                // sending.
    size_t sent_ping_requests_total;  // Number of STUN ping request sent.
    size_t sent_ping_requests_before_first_response;  // Number of STUN ping
    // sent before receiving the first response.
    size_t sent_ping_responses;  // Number of STUN ping response sent.
  
    size_t recv_total_bytes;     // Total bytes received on this connection.
    size_t recv_bytes_second;    // Bps over the last measurement interval.
    size_t recv_ping_requests;   // Number of STUN ping request received.
    size_t recv_ping_responses;  // Number of STUN ping response received.
    Candidate local_candidate;   // The local candidate for this connection.
    Candidate remote_candidate;  // The remote candidate for this connection.
    void* key;                   // A static value that identifies this conn.
    // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-state
    IceCandidatePairState state;
    // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-priority
    uint64_t priority;
    // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-nominated
    bool nominated;
    // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-totalroundtriptime
    uint64_t total_round_trip_time_ms;
    // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-currentroundtriptime
    absl::optional<uint32_t> current_round_trip_time_ms;
  };
  
  // Information about all the candidate pairs of a channel.
  typedef std::vector<ConnectionInfo> ConnectionInfos;
  
  const char* ProtoToString(ProtocolType proto);
  bool StringToProto(const char* value, ProtocolType* proto);
  
  struct ProtocolAddress {
    rtc::SocketAddress address;
    ProtocolType proto;
  
    ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p)
        : address(a), proto(p) {}
  
    bool operator==(const ProtocolAddress& o) const {
      return address == o.address && proto == o.proto;
    }
    bool operator!=(const ProtocolAddress& o) const { return !(*this == o); }
  };
  
  typedef std::set<rtc::SocketAddress> ServerAddresses;
  
  // Represents a local communication mechanism that can be used to create
  // connections to similar mechanisms of the other client.  Subclasses of this
  // one add support for specific mechanisms like local UDP ports.
  class Port : public PortInterface,
               public rtc::MessageHandler,
               public sigslot::has_slots<> {
   public:
    // INIT: The state when a port is just created.
    // KEEP_ALIVE_UNTIL_PRUNED: A port should not be destroyed even if no
    // connection is using it.
    // PRUNED: It will be destroyed if no connection is using it for a period of
    // 30 seconds.
    enum class State { INIT, KEEP_ALIVE_UNTIL_PRUNED, PRUNED };
    Port(rtc::Thread* thread,
         const std::string& type,
         rtc::PacketSocketFactory* factory,
         rtc::Network* network,
         const std::string& username_fragment,
         const std::string& password);
    Port(rtc::Thread* thread,
         const std::string& type,
         rtc::PacketSocketFactory* factory,
         rtc::Network* network,
         uint16_t min_port,
         uint16_t max_port,
         const std::string& username_fragment,
         const std::string& password);
    ~Port() override;
  
    // Note that the port type does NOT uniquely identify different subclasses of
    // Port. Use the 2-tuple of the port type AND the protocol (GetProtocol()) to
    // uniquely identify subclasses. Whenever a new subclass of Port introduces a
    // conflit in the value of the 2-tuple, make sure that the implementation that
    // relies on this 2-tuple for RTTI is properly changed.
    const std::string& Type() const override;
    rtc::Network* Network() const override;
  
    // Methods to set/get ICE role and tiebreaker values.
    IceRole GetIceRole() const override;
    void SetIceRole(IceRole role) override;
  
    void SetIceTiebreaker(uint64_t tiebreaker) override;
    uint64_t IceTiebreaker() const override;
  
    bool SharedSocket() const override;
    void ResetSharedSocket() { shared_socket_ = false; }
  
    // Should not destroy the port even if no connection is using it. Called when
    // a port is ready to use.
    void KeepAliveUntilPruned();
    // Allows a port to be destroyed if no connection is using it.
    void Prune();
  
    // The thread on which this port performs its I/O.
    rtc::Thread* thread() { return thread_; }
  
    // The factory used to create the sockets of this port.
    rtc::PacketSocketFactory* socket_factory() const { return factory_; }
    void set_socket_factory(rtc::PacketSocketFactory* factory) {
      factory_ = factory;
    }
  
    // For debugging purposes.
    const std::string& content_name() const { return content_name_; }
    void set_content_name(const std::string& content_name) {
      content_name_ = content_name;
    }
  
    int component() const { return component_; }
    void set_component(int component) { component_ = component; }
  
    bool send_retransmit_count_attribute() const {
      return send_retransmit_count_attribute_;
    }
    void set_send_retransmit_count_attribute(bool enable) {
      send_retransmit_count_attribute_ = enable;
    }
  
    // Identifies the generation that this port was created in.
    uint32_t generation() const { return generation_; }
    void set_generation(uint32_t generation) { generation_ = generation; }
  
    const std::string username_fragment() const;
    const std::string& password() const { return password_; }
  
    // May be called when this port was initially created by a pooled
    // PortAllocatorSession, and is now being assigned to an ICE transport.
    // Updates the information for candidates as well.
    void SetIceParameters(int component,
                          const std::string& username_fragment,
                          const std::string& password);
  
    // Fired when candidates are discovered by the port. When all candidates
    // are discovered that belong to port SignalAddressReady is fired.
    sigslot::signal2<Port*, const Candidate&> SignalCandidateReady;
  
    // Provides all of the above information in one handy object.
    const std::vector<Candidate>& Candidates() const override;
  
    // SignalPortComplete is sent when port completes the task of candidates
    // allocation.
    sigslot::signal1<Port*> SignalPortComplete;
    // This signal sent when port fails to allocate candidates and this port
    // can't be used in establishing the connections. When port is in shared mode
    // and port fails to allocate one of the candidates, port shouldn't send
    // this signal as other candidates might be usefull in establishing the
    // connection.
    sigslot::signal1<Port*> SignalPortError;
  
    // Returns a map containing all of the connections of this port, keyed by the
    // remote address.
    typedef std::map<rtc::SocketAddress, Connection*> AddressMap;
    const AddressMap& connections() { return connections_; }
  
    // Returns the connection to the given address or NULL if none exists.
    Connection* GetConnection(const rtc::SocketAddress& remote_addr) override;
  
    // Called each time a connection is created.
    sigslot::signal2<Port*, Connection*> SignalConnectionCreated;
  
    // In a shared socket mode each port which shares the socket will decide
    // to accept the packet based on the |remote_addr|. Currently only UDP
    // port implemented this method.
    // TODO(mallinath) - Make it pure virtual.
    virtual bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
                                      const char* data,
                                      size_t size,
                                      const rtc::SocketAddress& remote_addr,
                                      int64_t packet_time_us);
  
    // Shall the port handle packet from this |remote_addr|.
    // This method is overridden by TurnPort.
    virtual bool CanHandleIncomingPacketsFrom(
        const rtc::SocketAddress& remote_addr) const;
  
    // Sends a response message (normal or error) to the given request.  One of
    // these methods should be called as a response to SignalUnknownAddress.
    // NOTE: You MUST call CreateConnection BEFORE SendBindingResponse.
    void SendBindingResponse(StunMessage* request,
                             const rtc::SocketAddress& addr) override;
    void SendBindingErrorResponse(StunMessage* request,
                                  const rtc::SocketAddress& addr,
                                  int error_code,
                                  const std::string& reason) override;
  
    void set_proxy(const std::string& user_agent, const rtc::ProxyInfo& proxy) {
      user_agent_ = user_agent;
      proxy_ = proxy;
    }
    const std::string& user_agent() { return user_agent_; }
    const rtc::ProxyInfo& proxy() { return proxy_; }
  
    void EnablePortPackets() override;
  
    // Called if the port has no connections and is no longer useful.
    void Destroy();
  
    void OnMessage(rtc::Message* pmsg) override;
  
    // Debugging description of this port
    std::string ToString() const override;
    uint16_t min_port() { return min_port_; }
    uint16_t max_port() { return max_port_; }
  
    // Timeout shortening function to speed up unit tests.
    void set_timeout_delay(int delay) { timeout_delay_ = delay; }
  
    // This method will return local and remote username fragements from the
    // stun username attribute if present.
    bool ParseStunUsername(const StunMessage* stun_msg,
                           std::string* local_username,
                           std::string* remote_username) const;
    void CreateStunUsername(const std::string& remote_username,
                            std::string* stun_username_attr_str) const;
  
    bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
                              IceMessage* stun_msg,
                              const std::string& remote_ufrag);
  
    // Called when a packet has been sent to the socket.
    // This is made pure virtual to notify subclasses of Port that they MUST
    // listen to AsyncPacketSocket::SignalSentPacket and then call
    // PortInterface::OnSentPacket.
    virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
                              const rtc::SentPacket& sent_packet) = 0;
  
    // Called when the socket is currently able to send.
    void OnReadyToSend();
  
    // Called when the Connection discovers a local peer reflexive candidate.
    // Returns the index of the new local candidate.
    size_t AddPrflxCandidate(const Candidate& local);
  
    int16_t network_cost() const { return network_cost_; }
  
    void GetStunStats(absl::optional<StunStats>* stats) override{};
  
   protected:
    enum { MSG_DESTROY_IF_DEAD = 0, MSG_FIRST_AVAILABLE };
  
    virtual void UpdateNetworkCost();
  
    void set_type(const std::string& type) { type_ = type; }
  
    // Deprecated. Use the AddAddress() method below with "url" instead.
    // TODO(zhihuang): Remove this after downstream applications stop using it.
    void 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 is_final);
  
    void 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,
                    const std::string& url,
                    bool is_final);
  
    void FinishAddingAddress(const Candidate& c, bool is_final);
  
    virtual void PostAddAddress(bool is_final);
  
    // Adds the given connection to the map keyed by the remote candidate address.
    // If an existing connection has the same address, the existing one will be
    // replaced and destroyed.
    void AddOrReplaceConnection(Connection* conn);
  
    // Called when a packet is received from an unknown address that is not
    // currently a connection.  If this is an authenticated STUN binding request,
    // then we will signal the client.
    void OnReadPacket(const char* data,
                      size_t size,
                      const rtc::SocketAddress& addr,
                      ProtocolType proto);
  
    // If the given data comprises a complete and correct STUN message then the
    // return value is true, otherwise false. If the message username corresponds
    // with this port's username fragment, msg will contain the parsed STUN
    // message.  Otherwise, the function may send a STUN response internally.
    // remote_username contains the remote fragment of the STUN username.
    bool GetStunMessage(const char* data,
                        size_t size,
                        const rtc::SocketAddress& addr,
                        std::unique_ptr<IceMessage>* out_msg,
                        std::string* out_username);
  
    // Checks if the address in addr is compatible with the port's ip.
    bool IsCompatibleAddress(const rtc::SocketAddress& addr);
  
    // Returns DSCP value packets generated by the port itself should use.
    virtual rtc::DiffServCodePoint StunDscpValue() const;
  
    // Extra work to be done in subclasses when a connection is destroyed.
    virtual void HandleConnectionDestroyed(Connection* conn) {}
  
    void CopyPortInformationToPacketInfo(rtc::PacketInfo* info) const;
  
    MdnsNameRegistrationStatus mdns_name_registration_status() const {
      return mdns_name_registration_status_;
    }
    void set_mdns_name_registration_status(MdnsNameRegistrationStatus status) {
      mdns_name_registration_status_ = status;
    }
  
   private:
    void Construct();
    // Called when one of our connections deletes itself.
    void OnConnectionDestroyed(Connection* conn);
  
    void OnNetworkTypeChanged(const rtc::Network* network);
  
    rtc::Thread* thread_;
    rtc::PacketSocketFactory* factory_;
    std::string type_;
    bool send_retransmit_count_attribute_;
    rtc::Network* network_;
    uint16_t min_port_;
    uint16_t max_port_;
    std::string content_name_;
    int component_;
    uint32_t generation_;
    // In order to establish a connection to this Port (so that real data can be
    // sent through), the other side must send us a STUN binding request that is
    // authenticated with this username_fragment and password.
    // PortAllocatorSession will provide these username_fragment and password.
    //
    // Note: we should always use username_fragment() instead of using
    // |ice_username_fragment_| directly. For the details see the comment on
    // username_fragment().
    std::string ice_username_fragment_;
    std::string password_;
    std::vector<Candidate> candidates_;
    AddressMap connections_;
    int timeout_delay_;
    bool enable_port_packets_;
    IceRole ice_role_;
    uint64_t tiebreaker_;
    bool shared_socket_;
    // Information to use when going through a proxy.
    std::string user_agent_;
    rtc::ProxyInfo proxy_;
  
    // A virtual cost perceived by the user, usually based on the network type
    // (WiFi. vs. Cellular). It takes precedence over the priority when
    // comparing two connections.
    int16_t network_cost_;
    State state_ = State::INIT;
    int64_t last_time_all_connections_removed_ = 0;
    MdnsNameRegistrationStatus mdns_name_registration_status_ =
        MdnsNameRegistrationStatus::kNotStarted;
  
    rtc::WeakPtrFactory<Port> weak_factory_;
  
    bool MaybeObfuscateAddress(Candidate* c,
                               const std::string& type,
                               bool is_final);
  
    friend class Connection;
  };
  
  // Represents a communication link between a port on the local client and a
  // port on the remote client.
  class Connection : public CandidatePairInterface,
                     public rtc::MessageHandler,
                     public sigslot::has_slots<> {
   public:
    struct SentPing {
      SentPing(const std::string id, int64_t sent_time, uint32_t nomination)
          : id(id), sent_time(sent_time), nomination(nomination) {}
  
      std::string id;
      int64_t sent_time;
      uint32_t nomination;
    };
  
    ~Connection() override;
  
    // A unique ID assigned when the connection is created.
    uint32_t id() { return id_; }
  
    // The local port where this connection sends and receives packets.
    Port* port() { return port_; }
    const Port* port() const { return port_; }
  
    // Implementation of virtual methods in CandidatePairInterface.
    // Returns the description of the local port
    const Candidate& local_candidate() const override;
    // Returns the description of the remote port to which we communicate.
    const Candidate& remote_candidate() const override;
  
    // Returns the pair priority.
    uint64_t priority() const;
  
    enum WriteState {
      STATE_WRITABLE = 0,          // we have received ping responses recently
      STATE_WRITE_UNRELIABLE = 1,  // we have had a few ping failures
      STATE_WRITE_INIT = 2,        // we have yet to receive a ping response
      STATE_WRITE_TIMEOUT = 3,     // we have had a large number of ping failures
    };
  
    WriteState write_state() const { return write_state_; }
    bool writable() const { return write_state_ == STATE_WRITABLE; }
    bool receiving() const { return receiving_; }
  
    // Determines whether the connection has finished connecting.  This can only
    // be false for TCP connections.
    bool connected() const { return connected_; }
    bool weak() const { return !(writable() && receiving() && connected()); }
    bool active() const { return write_state_ != STATE_WRITE_TIMEOUT; }
  
    // A connection is dead if it can be safely deleted.
    bool dead(int64_t now) const;
  
    // Estimate of the round-trip time over this connection.
    int rtt() const { return rtt_; }
  
    int unwritable_timeout() const;
    void set_unwritable_timeout(const absl::optional<int>& value_ms) {
      unwritable_timeout_ = value_ms;
    }
    int unwritable_min_checks() const;
    void set_unwritable_min_checks(const absl::optional<int>& value) {
      unwritable_min_checks_ = value;
    }
    int inactive_timeout() const;
    void set_inactive_timeout(const absl::optional<int>& value) {
      inactive_timeout_ = value;
    }
  
    // Gets the |ConnectionInfo| stats, where |best_connection| has not been
    // populated (default value false).
    ConnectionInfo stats();
  
    sigslot::signal1<Connection*> SignalStateChange;
  
    // Sent when the connection has decided that it is no longer of value.  It
    // will delete itself immediately after this call.
    sigslot::signal1<Connection*> SignalDestroyed;
  
    // The connection can send and receive packets asynchronously.  This matches
    // the interface of AsyncPacketSocket, which may use UDP or TCP under the
    // covers.
    virtual int Send(const void* data,
                     size_t size,
                     const rtc::PacketOptions& options) = 0;
  
    // Error if Send() returns < 0
    virtual int GetError() = 0;
  
    sigslot::signal4<Connection*, const char*, size_t, int64_t> SignalReadPacket;
  
    sigslot::signal1<Connection*> SignalReadyToSend;
  
    // Called when a packet is received on this connection.
    void OnReadPacket(const char* data, size_t size, int64_t packet_time_us);
  
    // Called when the socket is currently able to send.
    void OnReadyToSend();
  
    // Called when a connection is determined to be no longer useful to us.  We
    // still keep it around in case the other side wants to use it.  But we can
    // safely stop pinging on it and we can allow it to time out if the other
    // side stops using it as well.
    bool pruned() const { return pruned_; }
    void Prune();
  
    bool use_candidate_attr() const { return use_candidate_attr_; }
    void set_use_candidate_attr(bool enable);
  
    void set_nomination(uint32_t value) { nomination_ = value; }
  
    uint32_t remote_nomination() const { return remote_nomination_; }
    // One or several pairs may be nominated based on if Regular or Aggressive
    // Nomination is used. https://tools.ietf.org/html/rfc5245#section-8
    // |nominated| is defined both for the controlling or controlled agent based
    // on if a nomination has been pinged or acknowledged. The controlled agent
    // gets its |remote_nomination_| set when pinged by the controlling agent with
    // a nomination value. The controlling agent gets its |acked_nomination_| set
    // when receiving a response to a nominating ping.
    bool nominated() const { return acked_nomination_ || remote_nomination_; }
    // Public for unit tests.
    void set_remote_nomination(uint32_t remote_nomination) {
      remote_nomination_ = remote_nomination;
    }
    // Public for unit tests.
    uint32_t acked_nomination() const { return acked_nomination_; }
  
    void set_remote_ice_mode(IceMode mode) { remote_ice_mode_ = mode; }
  
    int receiving_timeout() const;
    void set_receiving_timeout(absl::optional<int> receiving_timeout_ms) {
      receiving_timeout_ = receiving_timeout_ms;
    }
  
    // Makes the connection go away.
    void Destroy();
  
    // Makes the connection go away, in a failed state.
    void FailAndDestroy();
  
    // Prunes the connection and sets its state to STATE_FAILED,
    // It will not be used or send pings although it can still receive packets.
    void FailAndPrune();
  
    // Checks that the state of this connection is up-to-date.  The argument is
    // the current time, which is compared against various timeouts.
    void UpdateState(int64_t now);
  
    // Called when this connection should try checking writability again.
    int64_t last_ping_sent() const { return last_ping_sent_; }
    void Ping(int64_t now);
    void ReceivedPingResponse(int rtt, const std::string& request_id);
    int64_t last_ping_response_received() const {
      return last_ping_response_received_;
    }
    // Used to check if any STUN ping response has been received.
    int rtt_samples() const { return rtt_samples_; }
  
    // Called whenever a valid ping is received on this connection.  This is
    // public because the connection intercepts the first ping for us.
    int64_t last_ping_received() const { return last_ping_received_; }
    void ReceivedPing();
    // Handles the binding request; sends a response if this is a valid request.
    void HandleBindingRequest(IceMessage* msg);
  
    int64_t last_data_received() const { return last_data_received_; }
  
    // Debugging description of this connection
    std::string ToDebugId() const;
    std::string ToString() const;
    std::string ToSensitiveString() const;
    // Structured description of this candidate pair.
    const webrtc::IceCandidatePairDescription& ToLogDescription();
    void set_ice_event_log(webrtc::IceEventLog* ice_event_log) {
      ice_event_log_ = ice_event_log;
    }
    // Prints pings_since_last_response_ into a string.
    void PrintPingsSinceLastResponse(std::string* pings, size_t max);
  
    bool reported() const { return reported_; }
    void set_reported(bool reported) { reported_ = reported; }
    // The following two methods are only used for logging in ToString above, and
    // this flag is set true by P2PTransportChannel for its selected candidate
    // pair.
    bool selected() const { return selected_; }
    void set_selected(bool selected) { selected_ = selected; }
  
    // This signal will be fired if this connection is nominated by the
    // controlling side.
    sigslot::signal1<Connection*> SignalNominated;
  
    // Invoked when Connection receives STUN error response with 487 code.
    void HandleRoleConflictFromPeer();
  
    IceCandidatePairState state() const { return state_; }
  
    int num_pings_sent() const { return num_pings_sent_; }
  
    IceMode remote_ice_mode() const { return remote_ice_mode_; }
  
    uint32_t ComputeNetworkCost() const;
  
    // Update the ICE password and/or generation of the remote candidate if the
    // ufrag in |params| matches the candidate's ufrag, and the
    // candidate's password and/or ufrag has not been set.
    void MaybeSetRemoteIceParametersAndGeneration(const IceParameters& params,
                                                  int generation);
  
    // If |remote_candidate_| is peer reflexive and is equivalent to
    // |new_candidate| except the type, update |remote_candidate_| to
    // |new_candidate|.
    void MaybeUpdatePeerReflexiveCandidate(const Candidate& new_candidate);
  
    // Returns the last received time of any data, stun request, or stun
    // response in milliseconds
    int64_t last_received() const;
    // Returns the last time when the connection changed its receiving state.
    int64_t receiving_unchanged_since() const {
      return receiving_unchanged_since_;
    }
  
    bool stable(int64_t now) const;
  
   protected:
    enum { MSG_DELETE = 0, MSG_FIRST_AVAILABLE };
  
    // Constructs a new connection to the given remote port.
    Connection(Port* port, size_t index, const Candidate& candidate);
  
    // Called back when StunRequestManager has a stun packet to send
    void OnSendStunPacket(const void* data, size_t size, StunRequest* req);
  
    // Callbacks from ConnectionRequest
    virtual void OnConnectionRequestResponse(ConnectionRequest* req,
                                             StunMessage* response);
    void OnConnectionRequestErrorResponse(ConnectionRequest* req,
                                          StunMessage* response);
    void OnConnectionRequestTimeout(ConnectionRequest* req);
    void OnConnectionRequestSent(ConnectionRequest* req);
  
    bool rtt_converged() const;
  
    // If the response is not received within 2 * RTT, the response is assumed to
    // be missing.
    bool missing_responses(int64_t now) const;
  
    // Changes the state and signals if necessary.
    void set_write_state(WriteState value);
    void UpdateReceiving(int64_t now);
    void set_state(IceCandidatePairState state);
    void set_connected(bool value);
  
    uint32_t nomination() const { return nomination_; }
  
    void OnMessage(rtc::Message* pmsg) override;
  
    uint32_t id_;
    Port* port_;
    size_t local_candidate_index_;
    Candidate remote_candidate_;
  
    ConnectionInfo stats_;
    rtc::RateTracker recv_rate_tracker_;
    rtc::RateTracker send_rate_tracker_;
  
   private:
    // Update the local candidate based on the mapped address attribute.
    // If the local candidate changed, fires SignalStateChange.
    void MaybeUpdateLocalCandidate(ConnectionRequest* request,
                                   StunMessage* response);
  
    void CopyCandidatesToStatsAndSanitizeIfNecessary();
  
    void LogCandidatePairConfig(webrtc::IceCandidatePairConfigType type);
    void LogCandidatePairEvent(webrtc::IceCandidatePairEventType type,
                               uint32_t transaction_id);
  
    WriteState write_state_;
    bool receiving_;
    bool connected_;
    bool pruned_;
    bool selected_ = false;
    // By default |use_candidate_attr_| flag will be true,
    // as we will be using aggressive nomination.
    // But when peer is ice-lite, this flag "must" be initialized to false and
    // turn on when connection becomes "best connection".
    bool use_candidate_attr_;
    // Used by the controlling side to indicate that this connection will be
    // selected for transmission if the peer supports ICE-renomination when this
    // value is positive. A larger-value indicates that a connection is nominated
    // later and should be selected by the controlled side with higher precedence.
    // A zero-value indicates not nominating this connection.
    uint32_t nomination_ = 0;
    // The last nomination that has been acknowledged.
    uint32_t acked_nomination_ = 0;
    // Used by the controlled side to remember the nomination value received from
    // the controlling side. When the peer does not support ICE re-nomination,
    // its value will be 1 if the connection has been nominated.
    uint32_t remote_nomination_ = 0;
  
    IceMode remote_ice_mode_;
    StunRequestManager requests_;
    int rtt_;
    int rtt_samples_ = 0;
    // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-totalroundtriptime
    uint64_t total_round_trip_time_ms_ = 0;
    // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-currentroundtriptime
    absl::optional<uint32_t> current_round_trip_time_ms_;
    int64_t last_ping_sent_;      // last time we sent a ping to the other side
    int64_t last_ping_received_;  // last time we received a ping from the other
                                  // side
    int64_t last_data_received_;
    int64_t last_ping_response_received_;
    int64_t receiving_unchanged_since_ = 0;
    std::vector<SentPing> pings_since_last_response_;
  
    PacketLossEstimator packet_loss_estimator_;
  
    absl::optional<int> unwritable_timeout_;
    absl::optional<int> unwritable_min_checks_;
    absl::optional<int> inactive_timeout_;
  
    bool reported_;
    IceCandidatePairState state_;
    // Time duration to switch from receiving to not receiving.
    absl::optional<int> receiving_timeout_;
    int64_t time_created_ms_;
    int num_pings_sent_ = 0;
  
    absl::optional<webrtc::IceCandidatePairDescription> log_description_;
    webrtc::IceEventLog* ice_event_log_ = nullptr;
  
    friend class Port;
    friend class ConnectionRequest;
  };
  
  // ProxyConnection defers all the interesting work to the port.
  class ProxyConnection : public Connection {
   public:
    ProxyConnection(Port* port, size_t index, const Candidate& remote_candidate);
  
    int Send(const void* data,
             size_t size,
             const rtc::PacketOptions& options) override;
    int GetError() override;
  
   private:
    int error_ = 0;
  };
  
  }  // namespace cricket
  
  #endif  // P2P_BASE_PORT_H_
  