TCPConnection can never be deteted if they fail to connect

webrtc/p2p/base/tcpport.cc

 /*
  *  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.
  */
 
@@ skipping 11 matching lines @@
  *    outstanding TCP connection 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.
  *
- *                          7 -------------+
- *                          |Connected: N  |
- *         Timeout          |Writable:  N  |     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|
- *   +-----+------+          +------------+           +---+--+-----+
- *     ^   ^                                              |  |
- *     |   |                     OnClose                  |  |
- *     |   +----------------------------------------------+  |
- *     |                                                     |
- *     |                              Stun Binding Completed |
- *     |                                                     |
- *     |                    OnClose                          |
- *     +------------------------------------------------+    |
- *                                                      |    v
+ *         OS Timeout         7 -------------+
+ *   +----------------------->|Connected: N  |
+ *   |                        |Writable:  N  |     Timeout
+ *   |       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|
+ *   | +-----+------+          +------------+           +---+--+-----+
+ *   |   ^   ^                                              |  |
+ *   |   |   |                     OnClose                  |  |
+ *   |   |   +----------------------------------------------+  |
+ *   |   |                                                     |
+ *   |   |                              Stun Binding Completed |
+ *   |   |                                                     |
+ *   |   |                    OnClose                          |
+ *   |   +------------------------------------------------+    |
+ *   |                                                    |    v
  *  1 -----------+           2 -----------+Stun      3 -----------+
  *  |Connected: N|           |Connected: Y|Binding   |Connected: Y|
  *  |Writable:  N|OnConnect  |Writable:  N|Completed |Writable:  Y|
  *  |PendingTCP:Y+---------> |PendingTCP:N+--------> |PendingTCP:N|
  *  |PretendWri:N|           |PretendWri:N|          |PretendWri:N|
  *  +------------+           +------------+          +------------+
  *
  */
 
 #include "webrtc/p2p/base/tcpport.h"
@@ skipping 309 matching lines @@
   if (socket_ip == port()->ip()) {
     LOG_J(LS_VERBOSE, this) << "Connection established to "
                             << socket->GetRemoteAddress().ToSensitiveString();
     set_connected(true);
     connection_pending_ = false;
   } else {
     LOG_J(LS_WARNING, this) << "Dropping connection as TCP socket bound to IP "
                             << socket_ip.ToSensitiveString()
                             << ", different from the local candidate IP "
                             << port()->ip().ToSensitiveString();
-    socket_->Close();
+    OnClose(socket, 0);
   }
 }
 
 void TCPConnection::OnClose(rtc::AsyncPacketSocket* socket, int error) {
   ASSERT(socket == socket_);
   LOG_J(LS_INFO, this) << "Connection closed with error " << error;
 
   // Guard against the condition where IPC socket will call OnClose for every
   // packet it can't send.
   if (connected()) {
     set_connected(false);
+
+    // Prevent the connection to be destroyed.

[pthatcher1, 2015/08/25 17:58:41]

to be destroyed => from being destroyed

     pretending_to_be_writable_ = true;
 
     // 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().
     port()->thread()->PostDelayed(reconnection_timeout(), this,
                                   MSG_TCPCONNECTION_DELAYED_ONCLOSE);
+  } else if (!pretending_to_be_writable_) {
+    // 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.
+    Destroy();
   }
 }
 
 void TCPConnection::OnMessage(rtc::Message* pmsg) {
   switch (pmsg->message_id) {
     case MSG_TCPCONNECTION_DELAYED_ONCLOSE:
       // 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.
       if (pretending_to_be_writable_) {
-        set_write_state(STATE_WRITE_TIMEOUT);
+        Destroy();
       }
       break;
     default:
       Connection::OnMessage(pmsg);
   }
 }
 
 void TCPConnection::MaybeReconnect() {
   // Only reconnect for an outgoing TCPConnection when OnClose was signaled and
   // no outstanding reconnect is pending.
@@ skipping 46 matching lines @@
 void TCPConnection::ConnectSocketSignals(rtc::AsyncPacketSocket* socket) {
   if (outgoing_) {
     socket->SignalConnect.connect(this, &TCPConnection::OnConnect);
   }
   socket->SignalReadPacket.connect(this, &TCPConnection::OnReadPacket);
   socket->SignalReadyToSend.connect(this, &TCPConnection::OnReadyToSend);
   socket->SignalClose.connect(this, &TCPConnection::OnClose);
 }
 
 }  // namespace cricket