Add a Transport::TCP class for tcp-based communication.

src/transport/BUILD.gn

@@ -36,6 +36,8 @@ static_library("transport") {
     "SecureSession.h",
     "SecureSessionMgr.cpp",
     "SecureSessionMgr.h",
+    "TCP.cpp",
+    "TCP.h",
     "Tuple.h",
     "UDP.cpp",
     "UDP.h",

src/transport/Base.h

@@ -61,6 +61,8 @@ class Base : public ReferenceCounted<Base>
     /**
      * @brief Send a message to the specified target.
      *
+     * On connection-oriented transports, sending a message implies connecting to the target first.
+     *
      * @details
      *   This method calls <tt>chip::System::PacketBuffer::Free</tt> on
      *   behalf of the caller regardless of the return status.
@@ -72,7 +74,12 @@ class Base : public ReferenceCounted<Base>
      *
      * Generally it is expected that a transport can send to any peer from which it receives a message.
      */
-    virtual bool CanSendToPeer(const Transport::PeerAddress & address) = 0;
+    virtual bool CanSendToPeer(const PeerAddress & address) = 0;
+
+    /**
+     * Handle disconnection from the specified peer if currently connected to it.
+     */
+    virtual void Disconnect(const PeerAddress & address) {}
 
 protected:
     /**
@@ -85,13 +92,19 @@ class Base : public ReferenceCounted<Base>
         {
             OnMessageReceived(header, source, buffer, mMessageReceivedArgument);
         }
+        else
+        {
+            System::PacketBuffer::Free(buffer);
+        }
     }
 
     /**
      * This function is the application callback that is invoked when a message is received over a
      * Chip connection.
      *
      * @param[in]    msgBuf        A pointer to the PacketBuffer object holding the message.
+     *
+     * Callback *MUST* free msgBuf as a result of handling.
      */
     typedef void (*MessageReceiveHandler)(const MessageHeader & header, const PeerAddress & source, System::PacketBuffer * msgBuf,
                                           void * param);

src/transport/PeerAddress.h

@@ -48,7 +48,7 @@ enum class Type
     kUndefined,
     kUdp,
     kBle,
-    // More constants to be added later, such as TCP
+    kTcp,
 };
 
 /**
@@ -57,6 +57,7 @@ enum class Type
 class PeerAddress
 {
 public:
+    PeerAddress() : mIPAddress(Inet::IPAddress::Any), mTransportType(Type::kUndefined), mInterface(INET_NULL_INTERFACEID) {}
     PeerAddress(const Inet::IPAddress & addr, Type type) : mIPAddress(addr), mTransportType(type), mInterface(INET_NULL_INTERFACEID)
     {}
     PeerAddress(Type type) : mTransportType(type) {}
@@ -96,11 +97,14 @@ class PeerAddress
 
     bool IsInitialized() const { return mTransportType != Type::kUndefined; }
 
-    bool operator==(const PeerAddress & other)
+    bool operator==(const PeerAddress & other) const
     {
-        return (mTransportType == other.mTransportType) && (mIPAddress == other.mIPAddress) && (mPort == other.mPort);
+        return (mTransportType == other.mTransportType) && (mIPAddress == other.mIPAddress) && (mPort == other.mPort) &&
+            (mInterface == other.mInterface);
     }
 
+    bool operator!=(const PeerAddress & other) const { return !(*this == other); }
+
     /// Maximum size of an Inet address ToString format, that can hold both IPV6 and IPV4 addresses.
 #ifdef INET6_ADDRSTRLEN
     static constexpr size_t kInetMaxAddrLen = INET6_ADDRSTRLEN;
@@ -129,6 +133,14 @@ class PeerAddress
             mIPAddress.ToString(ip_addr, sizeof(ip_addr));
             snprintf(buf, bufSize, "UDP:%s:%d", ip_addr, mPort);
             break;
+        case Type::kTcp:
+            mIPAddress.ToString(ip_addr, sizeof(ip_addr));
+            snprintf(buf, bufSize, "TCP:%s:%d", ip_addr, mPort);
+            break;
+        case Type::kBle:
+            // Note that BLE does not currently use any specific address.
+            snprintf(buf, bufSize, "BLE");
+            break;
         default:
             snprintf(buf, bufSize, "ERROR");
             break;
@@ -146,12 +158,14 @@ class PeerAddress
     {
         return UDP(addr).SetPort(port).SetInterface(interface);
     }
+    static PeerAddress TCP(const Inet::IPAddress & addr) { return PeerAddress(addr, Type::kTcp); }
+    static PeerAddress TCP(const Inet::IPAddress & addr, uint16_t port) { return TCP(addr).SetPort(port); }
 
 private:
     Inet::IPAddress mIPAddress;
     Type mTransportType;
-    uint16_t mPort = CHIP_PORT; ///< Relevant for UDP data sending.
-    Inet::InterfaceId mInterface;
+    uint16_t mPort               = CHIP_PORT; ///< Relevant for UDP data sending.
+    Inet::InterfaceId mInterface = INET_NULL_INTERFACEID;
 };
 
 } // namespace Transport

src/transport/SecureSessionMgr.cpp

@@ -304,12 +304,16 @@ void SecureSessionMgrBase::HandleConnectionExpired(const Transport::PeerConnecti
     state.GetPeerAddress().ToString(addr, sizeof(addr));
 
     ChipLogProgress(Inet, "Connection from '%s' expired", addr);
+
+    mgr->mTransport->Disconnect(state.GetPeerAddress());
 }
 
 void SecureSessionMgrBase::ExpiryTimerCallback(System::Layer * layer, void * param, System::Error error)
 {
     SecureSessionMgrBase * mgr = reinterpret_cast<SecureSessionMgrBase *>(param);
 #if CHIP_CONFIG_SESSION_REKEYING
+    // TODO(#2279): session expiration is currently disabled until rekeying is supported
+    // the #ifdef should be removed after that.
     mgr->mPeerConnections.ExpireInactiveConnections(CHIP_PEER_CONNECTION_TIMEOUT_MS);
 #endif
     mgr->ScheduleExpiryTimer(); // re-schedule the oneshot timer