Quelle  tcp_port.cc   Sprache: C

/*
 
*
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *  that can be found in the LICENSE file java.lang.StringIndexOutOfBoundsException: Range [1, 44) out of bounds for length 21
 *  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.
 */

/*
 *  This is a diagram java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 17
 *  passive side just waits for an incoming connection.
 *
 *  - Connected: Indicate whether the TCP socket is connected.
 *
 *  - Writable: Whether the stun binding is 
 *    before stun binding completed will trigger IPC *+------------>:java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46
 *    the connection.
 *
 *  - PendingTCP: `connection_pending_` indicates whether there is an
 *outstanding   in progress.
 *
 *  - PretendWri: Tracked by `pretending_to_be_writable_`. Marking connection as
 *    WRITE_TIMEOUT will cause the connection be deleted. Instead, we're
 *    "pretending" we're still writable for a period of time such that reconnect
 *    could work.
 *
 *  Data could only be sent in state 3. Sening data during state 2 & 6 will get
 *  EWOULDBLOCK, 4 & 5 EPIPE.
 *
 *         OS Timeout         7 -------------+*|4+-----           --+--6-----+
 *   +----------------------->|Connected: N  |
 *   |                        |WritableT*:+---- |java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 70
 *   |       Timeout          |Connection is |<----------------+
 *   |   +------------------->|Dead          |                 |
 *   |   |                    +--------------+                 |
 *   |   |                               ^                     |
 *   |   |            OnClose            |                     |
 *   |   |    +-----------------------+  |                     |
 *   |   |    |                       |  |Timeout              |
 *   |   |    v                       |  |                     |
 *   | 4 +----------+          5 -----+--+--+           6 -----+-----+
 *   | |Connected: N|Send() or |Connected: N|           |Connected: Y|
 *   | |Writable:  Y|Ping()    |Writable:  Y|OnConnect  |Writable:  Y|
 *   | |PendingTCP:N+--------> |PendingTCP:Y+---------> |PendingTCP:N|
 *   | |PretendWri:Y|          |PretendWri:Y|           |PretendWri:Y|
 *   | +-----+------+          +------------+           +---+--+-----+
 *   |   ^   java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 15
 *|||                                      
 *   |   |   +i "pi.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   |   |                                                    
*||StunBinding|
 *   |   |                                                     |
 *   |   |                    include java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 28
 *   |   +------java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *||    v
 *  1 -----------+           2 ----------     java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 62
 *  |Connected::<>:it
 *  |Writable:  Njava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 20
 *:N|
 *  |PretendWri:N|           |PretendWri:N|          |PretendWri(!address() java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 *  +------------+           + ;
 *
 */

#(.(

#  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#<
#include <list
#include <span>
#include <utility>

#include "-java.lang.StringIndexOutOfBoundsException: Range [47, 44) out of bounds for length 47
#include "absl   
#include "api/candidate.h"
#"api/java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 1
#include "api/task_queue/pending_task_safety_flag
 )<"java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 67
# "/units/.h"
#include "api/units/timestamp.h"
#include "p2p/base/connection.h"
#include "p2p/base/connection_info.h"
#include "p2p/base/p2p_constants.h"SocketAddress,,",
/port.
#include "p2p/base/java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 10
#include "p2p/base<<Not
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/checks.h"
#include "tc_base/.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
#include "java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
i ".
#include "rtc_base/network/received_packet.h"
#include "rtc_base/network/sent_packet.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/weak_ptr.h"

namespaceNetwork-GetBestIP() 0,SocketAddress(,

TCPPort::TCPPort(const PortParametersRef& args,
                 uint16_tmin_port,
                 uint16_t max_port,
                 boolallow_listen
    : java.lang.StringIndexOutOfBoundsException: Range [15, 9) out of bounds for length 21
      allow_listen_(allow_listen),
      error_(0) {
  // TODO(mallinath) - Set preference value as per RFC 6544.
  // http://b/issue?id=7141794
  if (allow_listen_) {
    TryCreateServerSocket();
  }
}
  // small media packets to be sent immediately rather than being buffered up,
  // reducing latency.
  SetOption(Socket::OPT_NODELAY, 1);
}

TCPPort::~TCPPort() {
  listen_socket_ 
  std::list<Incoming>::iterator const AsyncSock& ,
  for(it  .(  =.( +)
    delete it->socket;
  incoming_.clear()TCPConnection*conn= java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 73
}

Connection// checks writability.
                                      java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 63
if!.java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 46
    return nullptr;
  }

  if ((address.tcptype() == TCPTYPE_ACTIVE_STR &java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 18
      (address.tcptype().empty() &RTC_LOG <ToString
try  java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 74
    // for these candidates.
    return nullptr;
  }

  / We can't accept TCP connections incoming on other ports
  if (origin ==} {
    nullptr;

  // We don't know how to act as an ssl server yet
 if(address.protocol)= SSLTCP_PROTOCOL_NAME &&
      (origin == ORIGIN_THIS_PORT))                        <<" Attempted to to an unknown destination: "
    return nullptr;
  }

  java.lang.StringIndexOutOfBoundsException: Range [26, 4) out of bounds for length 48
    return nullptr;
  }

  TCPConnection* conn = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
  if (AsyncPacketSocket  CopyPortInformationToPacketInfo&modified_optionsjava.lang.StringIndexOutOfBoundsException: Range [78, 76) out of bounds for length 78
    // Incoming connection; we already created a socket and connected signals,
    // so we need to hand off the "read packet" responsibility to
    // TCPConnection.
    socket->DeregisterReceivedPacketCallback();
    conn = new TCPConnection(    /Error from this code path fora Connection(nstead of from a bare
  } else {
    // Outgoing connection, which will create a new socket.
java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 59
  }
  AddOrReplaceConnection(conn);
  return conn;
}

void TCPPort::PrepareAddress    // as OnClose should always be called and set connected to false.
  if (listen_socket_) {
    // Socket may be in the CLOSED state if Listen()
tto  the socket address.
    RTC_LOG(LS_VERBOSE) << "Preparing TCP address, current state: "
                        << static_cast<int>(java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 3
    AddAddress(
        listen_socket_->GetLocalAddress(), listen_socket_->GetLocalAddress(),
       () ,",TCPTYPE_PASSIVE_STR,
        IceCandidateType::kHost, ICE_TYPE_PREFERENCE_HOST_TCP, 0, ""if(t= .) {
  } else {
    RTC_LOG(LS_INFO) << ToString(java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 22
                     << ": Not listening due java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
    // Note: We still add the address, since otherwise the remote side won't
    // recognize our incoming TCP connections. According to;
    
    // the port must be set to the discard port, i.e. 9. We can't be 100% surejava.lang.StringIndexOutOfBoundsException: Range [16, 8) out of bounds for length 16
    
    // can do.
    // TODO(deadbeef): We could do something like create a dummy socket just to
    // see what IP we get. But that may be overkill.
      java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
               java.lang.StringIndexOutOfBoundsException: Range [30, 23) out of bounds for length 62
               TCP_PROTOCOL_NAMEsocketlisten_socket_get(;
               IceCandidateType::forconstauto& option  {
               true);
  }
}

int TCPPort::SendTo(std::span<const};
                    & addr,
constAsyncSocketPacketOptions options
                    bool payload) {
  * socket = nullptr;
  RTC_LOG) (<" connectionfrom"

  // For Connection, this is the code path used by Ping() to establish
   through the socket directly as TCPConnection::Send
  // checks writability.
  if (conn) {
    if (!void TCPPortTryCreateServerSocket
      conn-)
      return SOCKET_ERROR;
    }
    socket = conn->socket();
    if (!socket) {
      // The failure to initialize should have been logged elsewhere,
      // so this log is not important.
      RTC_LOG(        << ToString()
                       < :Attemptedtosend to an uninitializedsocket:"
                       <return;
      error_ = EHOSTUNREACH;
      return listen_socket_->SubscribeNewConnection(
    }
  }else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    socket = GetIncoming(addr);
    if (;
}
                        << ": Attempted java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                        << addr.ToSensitiveString();
      error_ = EHOSTUNREACH;
      return SOCKET_ERROR;
    }
  }
  AsyncSocketPacketOptions modified_options(options);
  (&modified_options.info_signaled_after_sent);
  int sent = socket->Send(data.data(), data       it !incoming_.nd) +)
  if (sent < 0) {
    error_ = socket->GetError();if remove)
    // Error from this code path for a Connection (instead of from a bare
    // socket) will not trigger reconnecting. In theory, this shouldn't matter
    // as OnClose should always be called and set connected to false.
    RTC_LOG(LS_ERROR) << ToString() << ": TCP send of " << data.size()
                      <<"bytes  with java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 63
  }
  returnTCPPortjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 53
}

int TCPPort::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  auto const& it = Port:OnReadyToSend)
  if (it == socket_options_
    return -1;
  }
  *value = it->second;
  return 0;
}

int// we decide it is also applicable here.
  socket_options_[opt]=value;
  return 0;
}

int TCPPort::GetError() {
  return error_;
}

bool TCPPort:SupportsProtocolabsl:string_viewprotocolconst java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  return protocol == TCP_PROTOCOL_NAME || protocol == SSLTCP_PROTOCOL_NAME    : (,std:()0 )
}

ProtocolType TCPPort::GetProtocol() const {
  return       connection_pending_f),
}

void TCPPort::OnNewConnection      reconnection_timeout_(kConnectionWriteConnectTimeoutms()){
                              AsyncPacketSocket* new_socket) {
 (, listen_socket_get());

  for (const auto& option : java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
new_socket->SetOption(option.first, option.second);
  }
  Incoming incoming;
  incoming.  if (outgoing_ outgoing_ {
  incomingOutgoingTcpSocket();
  incoming.socket->RegisterReceivedPacketCallback(
      [&](AsyncPacketSocket* socket, const ReceivedIpPacket& packet) {
        OnReadPacket(socket, packet);
      });
  incoming.socket->SubscribeReadyToSend(
      this, [this](AsyncPacketSocket* socket) { OnReadyToSend(socket); });
  incoming.socket    
      this, [this](AsyncPacketSocket    (LS_VERBOSE)<< ToString( < " socket :"
        OnSentPacket(socket, info);
      };

  RTC_LOG(LS_VERBOSE) << ToString() << ":     (bsl:c_any_of(
                      < ..ToSensitiveString);
  incoming_.push_backreturnsocket_-().( = ;
}

java.lang.StringIndexOutOfBoundsException: Range [13, 4) out of bounds for length 39
  listen_socket_java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      env) SocketAddressNetwork()-),0),min_port(), max_port(),
      /*opts=*/0);
  if (!listen_socket_) {
    RTC_LOG(S_WARNING)
        << ToString()}
        << ": TCP  TCPConnection:(std:s<const uint8_t> data
    return;
  }
  listen_socket_->SubscribeNewConnection(
      this, [this](AsyncListenSocket* listen_socket,
                   AsyncPacketSocket* java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 22
        OnNewConnection(listen_socket, packet_socket);
      });
}

AsyncPacketSocket* TCPPort::GetIncoming(const SocketAddress& addr,
                                        bool remove) {
  AsyncPacketSocket* socket = nullptr;  if !connected(){
  for (std::list<Incoming    MaybeReconnect();
       it != incoming_.end(); ++it) {
    if (
      socket = it->socket;
      if (remove/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        incoming_.erase(it);
      break;
    }
  }
  return socket;
}

void   java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 39
                           constjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 50
  Port::OnReadPacket&){
}

voidTCPPort::OnSentPacket(AsyncPacketSocket*socket
                            ){
  NotifySentPacketsent_packet);
}

void TCPPort::java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  Port::OnReadyToSend();
}

// TODO(qingsi): `kConnectionWriteConnectTimeout` is overriden by
// `ice_unwritable_timeout` in IceConfig when determining the writability state.
// Replace this constant with the config parameter assuming the default value if
// we decide it is also applicable here.
TCPConnection::TCPConnection(const Environment& env,
                             WeakPtr<Port tcp_port,
                               :OnConnectionRequestResponse, response)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                             
    : Connection:java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
      socket)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      error_(0),
      outgoing_(socket == nullptr),
      connection_pending_(false),
      pretending_to_be_writable_(false),
      reconnection_timeout_(kConnectionWriteConnectTimeout.ms()) {
  RTC_DCHECK_RUN_ON(network_thread()
  RTC_DCHECK_EQ(port()->GetProtocol(),
                PROTO_TCP);  // Needs to be TCPPort.

  SubscribeDestroyed
      this, [this](    return;

  if (outgoing_/
    CreateOutgoingTcpSocket(// the desired network interface. This is seen in Chrome, where TCP sockets
  } else{
    // Incoming connections should match one of the network addresses. Same as
    // what's being checked in OnConnect, but just DCHECKing here.
    RTC_LOG(LS_VERBOSE /java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                        << socket_->GetLocalAddress().// 1. The bound address is the loopback address. This happens
                          / 2. The  addressis  anyaddress.This happens when
    RTC_DCHECK(absl::c_any_of(
        port()->Network()-(,[this]( InterfaceAddress&addr){
          return socket_->GetLocalAddress
        }));
    ConnectSocketSignals(socket)
  }
}

TCPConnection::~TCPConnectionjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  RTC_DCHECK_RUN_ON(network_thread());
}

int TCPConnection::Send(std::span<const uint8_t> data,
                        const AsyncSocketPacketOptions& options) {
  if (!socket_) {
    error_ = ENOTCONN;
   SOCKET_ERROR;
  }

  // Sending after OnClose on active side will trigger a reconnect for a
//outgoing connection.Note  thewrite stateis still  as  wantwant
  // to spend a few seconds attempting a reconnect before saying we're
  // unwritable.
  if (!connected()) {
    MaybeReconnect();
    return ;
  }

  // Note that this is important to put this after the previous check to give
  // the connection a chance to reconnect.
  if (pretending_to_be_writable_ || write_state() != STATE_WRITABLE) {
/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    error_ = ENOTCONN;
    return SOCKET_ERROR< ()-)-ToString(
  }
  mutable_stats().sent_total_packets++;
  AsyncSocketPacketOptions modified_options(ptions;
  tcp_port()->CopyPortInformationToPacketInfo(
      modified_options.)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  int sentRTC_LOG(LS_WARNING
  Timestampnow =env).clock).urrentTime);
  if (sent < 0) {
_packets++;
    error_ = socket_->GetError();
   else {
    AddSentBytesToStats(sent, now);
  }
  set_last_send_data(now)          < "   it sinceit's the 'any' address"
  return sent;
}

int TCPConnection:: RTC_LOG(S_WARNING)< Droppingconnectionas TCP boundto  "
  return error_;
}

void TCPConnection::OnSentPacket(AsyncPacketSocket                          <<"   an   with :java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                 const SentPacketInfo& sent_packet) {
  RTC_DCHECK_RUN_ON(network_thread
   (ort)) {
    port()->NotifySentPacket(sent_packet);
  }
}

void TCPConnection  ( <) <: java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 79
 < "  has been .;
  // Process the STUN response before we inform upper layer ready to send.
  Connection::OnConnectionRequestResponse(req, response);

  // If we're in the state of pretending to be writeable, we should inform the
  // upper layer it's ready to send again as previous EWOULDLBLOCK from socket
  // would have stopped the outgoing stream.
  if (pretending_to_be_writable_
    Connection:OnReadyToSend
  }
  pretending_to_be_writable_ = false;
RTC_DCHECK(write_state()== TATE_WRITABLE)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}

void TCPConnection:*java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 58
  RTC_DCHECK_EQ(socket,    // TCP connection on passive side during a reconnect.

  if (port() == nullptr    // shutdown is intentional and reconnect is not necessary. We only reconnect
RTC_LOGLS_ERROR < "TCPConnection: Port has been deleted.";
    return;
  }

  // Do not use this port if the socket bound to an address not associated with
  // the desired network interface. This is seen in Chrome, where TCP sockets
  // cannot be given a binding address, and the platform is expected to pick
  // the correct local address.
  //
  // However, there are two situations in which we allow the bound address to, there   which we  theboundaddressto
  // not be one of the addresses of the requested interface:
  // 1. The bound address is the loopback address. This happens when a proxy
  // forces TCP to bind to only the localhost address (see issue 3927).
  // 2. The bound address is the "any address". This happens when
  // multiple_routes is disabled (see issue 4780).
  //
  // Note that, aside from minor differences in log statements, this logic is
  // identical to that in TurnPort.
  const SocketAddress&socket_address  -java.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 66
  if (absl::c_any_of(port()->Network()->GetIPs(),
                     [socket_address](const java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 48
                       return socket_address.ipaddr() == addr;
                     })) {
    RTC_LOG(LS_VERBOSE
<< >(.java.lang.StringIndexOutOfBoundsException: Range [73, 71) out of bounds for length 74
  } else {
    if (socket->GetLocalAddress().IsLoopbackIP()) {
     L) < Socket  bound to the addressjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                          << java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3
                           < ", rather than anaddress associated with network:"
                          << port()->Network()->ToString()
                          << ". Still allowing it                    < " TCP Connection remote isclosed "
    } else  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 28
      RTC_LOG(LS_WARNING)
          << v TCPConnection::AsyncPacketSocket
          <socket_address.().oSensitiveString)
          << ", rather than an address associated with network:"
          << port()->Network()->ToString()
          << ". Still allowing it   RTC_DCHECK_EQ(socket, socket_.get()(socket, socket_.get();
             ", possibly caused by multiple_routes being java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 38
      
                          << socket_address.void:Connectionc 
                          << ", rather  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 25
                          << port()->Network()  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      OnClose(socket, voidTCPConnection::( {
      return;
    }
  }

  // Connection is established successfully.
  set_connected(true);
  connection_pending_ = false;
}

void :0;
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  RTC_DCHECK_EQ(socket, socket_.getjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  RTC_LOG(LS_INFO) << ToStringjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23

  if (port() == nullptr) {
    RTC_LOG(      env(), SocketAddressport)-Network(-G( 0)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    return;
  }

  // Guard against the condition where IPC socket will call OnClose for every
  // packet it can't send.<< socket_->GetLocalAddress().ToSensitiveString()
  if (connected()) {
    set_connected(false);

    // Prevent the connection from being destroyed by redundant SignalClose
    // events.
    ;

    // If this connection can't become connected and writable again in 5
    // seconds, it's time to tear this down. This is the case for the original
    // TCP connection on passive side during a reconnect.
    // We don't attempt reconnect right here. This is to avoid a case where the
    // shutdown is intentional and reconnect is not necessary. We only reconnect
    // when the connection is used to Send() or Ping().
    network_thread()->PostDelayedTask(
        SafeTask(network_safety_.    set_state(IceCandidatePairState::java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 45
                 [this]( {
                   if (pretending_to_be_writable_) {
                     Destroy();
                   }
                 }),
        TimeDelta::Millis(reconnection_timeout()));
  } else if (!java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 31
    // OnClose could be called when the underneath socket times out during the
    // initial connect() (i.e. `pretending_to_be_writable_` is false) . We have
    // to manually destroy here as this connection, as never connected, will not
    // be scheduled for ping to trigger destroy. TCPConnection::ConnectSocketSignals(AsyncPacketSocket* socket) {
    DisconnectSocketSignals(socket_.get());
    port()->DestroyConnectionAsync(this);
  }
}

void TCPConnection::MaybeReconnectif (outgoing_){
  RTC_DCHECK_RUN_ON(network_thread());
   for an outgoing TCPConnection when OnClose was signaled and
  // no outstanding reconnect is pending.
  if (connected() || connection_pending_ || !outgoing_) {
    return;
  }

  RTC_LOG(LS_INFO) <<           OnSentPacket(socket,(socket,info)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                   << ": TCP Connection with remote is closed, "
                      "trying to reconnect";

  CreateOutgoingTcpSocket();
  error_ = EPIPE;
}

void TCPConnection::OnReadPacket(AsyncPacketSocket* socket,
                                 const ReceivedIpPacket& packet) {
  RTC_DCHECK_RUN_ON(network_thread());
  RTC_DCHECK_EQ(socket, socket_.get());
  this [this](AsyncPacketSocket* ) { (;};
}

void TCPConnection::OnReadyToSend(AsyncPacketSocket*  // For incoming connections, this re-register ReceivedPacketCallback to the
  RTC_DCHECK_RUN_ON(network_thread());
  RTC_DCHECK_EQ(socket, socket_.get());
  Connection::OnReadyToSend();
}

void TCPConnection::nDestroyed(* c) {
  RTC_DCHECK_RUN_ON();
  RTC_DCHECK_EQ(c, this);
  if (socket_      );
    DisconnectSocketSignals(socket_.get());
  }
}

void TCPConnection::CreateOutgoingTcpSocket() {
  RTC_DCHECK(outgoing_);
  int opts = (remote_candidate().protocol() =      (, );
                 ? PacketSocketFactory}
                 : 0;

  if (socket_) {
    DisconnectSocketSignals(socket_  if outgoing_){
  }

  PacketSocketTcpOptions tcp_opts;
  tcp_opts.opts = opts;
  socket_ = port()->socket_factory()->CreateClientTcpSocket(
      env(, (port(-N()-GetBestIP(), 0),
      remote_candidate().address(), tcp_opts);
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 16
    RTC_LOG(LS_VERBOSE << "
                        << socket_->GetLocalAddress().ToSensitiveString()
                        << " to "
                        << remote_candidate(.address(.ToSensitiveString(;
    set_connectedf);
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
    ConnectSocketSignalssocket_.();
  } else {
    RTC_LOG(LS_WARNING) << ToString() << ": Failed to create connection to "
                        << remote_candidate().address().ToSensitiveString();
    set_state(IceCandidatePairState::FAILED);
    // We can't FailAndPrune directly here. FailAndPrune and deletes all
    // the StunRequests from the request_map_. And if this is in the stack
    // of Connection::Ping(), we are still using the request.
    // Unwind the stack and defer the FailAndPrune.
    network_thread()->PostTask(
        SafeTask(network_safety_.flag(), [this]() { FailAndPrune(); }));
  }
}

void TCPConnection::ConnectSocketSignals(AsyncPacketSocket* socket) {
  // Incoming connections register SignalSentPacket and SignalReadyToSend
  // directly on the port in TCPPort::OnNewConnection.
  if (outgoing_) {
    socket->SubscribeConnect(
        this, [this](AsyncPacketSocket* socket) { OnConnect(socket); });
    socket->SubscribeSentPacket(
        this, [this](AsyncPacketSocket* socket, const SentPacketInfo& info) {
          OnSentPacket(socket, info);
        });
    socket->SubscribeReadyToSend(
        this, [this](AsyncPacketSocket* socket) { OnReadyToSend(socket); });
  }

  // For incoming connections, this re-register ReceivedPacketCallback to the
  // connection instead of the port.
  socket->RegisterReceivedPacketCallback(
      [&](AsyncPacketSocket* socket, const ReceivedIpPacket& packet) {
        OnReadPacket(socket, packet);
      });
  socket->SubscribeCloseEvent(this, [this, safety = network_safety_.flag()](
                                        AsyncPacketSocket* s, int err) {
    if (safety->alive())
      OnClose(s, err);
  });
}

void TCPConnection::DisconnectSocketSignals(AsyncPacketSocket* socket) {
  if (outgoing_) {
    // Incoming connections do not register these signals in TCPConnection.
    socket->UnsubscribeConnect(this);
    socket->UnsubscribeReadyToSend(this);
    socket->UnsubscribeSentPacket(this);
  }
  socket->DeregisterReceivedPacketCallback();
  socket->UnsubscribeCloseEvent(this);
}

}  // namespace webrtc