TCP ConnectToPeer() API in Transport Manager

Currently, connecting to a peer is coupled with sending a message to the
peer.
This decouples the two and creates a clear API for connecting to a peer
address. Goes along with the existing Disconnect() API.
This would be essential during activation of retained sessions by solely
connecting to the peer and associating with the retained session.

Surface Connection completion and Closure callbacks and hook them
through SessionManager(TransportMgr delegate) and CASESession.

Modify ActiveConnectionState in TCPBase to hold state for each
connection, so that it is able to handle the various control flow paths.

Author: pidarped

src/lib/core/CHIPConfig.h

@@ -1600,6 +1600,20 @@ extern const char CHIP_NON_PRODUCTION_MARKER[];
 #define CHIP_CONFIG_SYNCHRONOUS_REPORTS_ENABLED 0
 #endif
 
+/**
+ * @def CHIP_CONFIG_TCP_SUPPORT_ENABLED
+ *
+ *  @brief
+ *    Enable (1) or disable (0) support for TCP as a transport protocol for
+ *    operational communications.
+ *
+ *  When enabled, the node would advertise this support via DNS-SD advertisements to allow peers
+ *  to know and select the appropriate transport for session establishment.
+ */
+#ifndef CHIP_CONFIG_TCP_SUPPORT_ENABLED
+#define CHIP_CONFIG_TCP_SUPPORT_ENABLED (INET_CONFIG_ENABLE_TCP_ENDPOINT)
+#endif
+
 /**
  * @}
  */

src/protocols/secure_channel/CASESession.cpp

@@ -444,13 +444,18 @@ CHIP_ERROR CASESession::Init(SessionManager & sessionManager, Credentials::Certi
     ReturnErrorOnFailure(mCommissioningHash.Begin());
 
     mDelegate = delegate;
+    mSessionManager = &sessionManager;
+
     ReturnErrorOnFailure(AllocateSecureSession(sessionManager, sessionEvictionHint));
 
     mValidContext.Reset();
     mValidContext.mRequiredKeyUsages.Set(KeyUsageFlags::kDigitalSignature);
     mValidContext.mRequiredKeyPurposes.Set(KeyPurposeFlags::kServerAuth);
     mValidContext.mValidityPolicy = policy;
 
+    // Set callbacks for connection in sessionmanager
+    sessionManager.SetConnectionCallbacks(HandleConnectionComplete, HandleConnectionClosed, this);
+
     return CHIP_NO_ERROR;
 }
 
@@ -530,8 +535,24 @@ CHIP_ERROR CASESession::EstablishSession(SessionManager & sessionManager, Fabric
     ChipLogProgress(SecureChannel, "Initiating session on local FabricIndex %u from 0x" ChipLogFormatX64 " -> 0x" ChipLogFormatX64,
                     static_cast<unsigned>(mFabricIndex), ChipLogValueX64(mLocalNodeId), ChipLogValueX64(mPeerNodeId));
 
-    err = SendSigma1();
-    SuccessOrExit(err);
+
+    //TODO: Need to look into unifying this call to invoke ConnectToPeer() for
+    // all transports, including MRP.
+    // For UDP based transports, this call would short-circuit back into
+    // HandleConnectionComplete() callback.
+    // Currently, TestCASESession is organized such that it requires synchronous
+    // calls back from EstablishSession() over UDP. So, bifurcate TCP and MRP
+    // calls here, for now.
+    if (mExchangeCtxt->GetSessionHandle()->AsUnauthenticatedSession()->GetPeerAddress().GetTransportType() == Transport::Type::kTcp)
+    {
+        err = sessionManager.ConnectToPeer(mExchangeCtxt->GetSessionHandle()->AsUnauthenticatedSession()->GetPeerAddress());
+        SuccessOrExit(err);
+    }
+    else
+    {
+        err = SendSigma1();
+        SuccessOrExit(err);
+    }
 
 exit:
     if (err != CHIP_NO_ERROR)
@@ -637,6 +658,40 @@ CHIP_ERROR CASESession::RecoverInitiatorIpk()
     return CHIP_NO_ERROR;
 }
 
+void CASESession::HandleConnectionComplete(void *context, Inet::TCPEndPoint * conObj, CHIP_ERROR conErr)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    VerifyOrReturn(context != nullptr);
+    // VerifyOrReturn(peerAddr.GetTransportType() == Transport::Type::kTcp);
+
+    CASESession * caseSession = reinterpret_cast<CASESession *>(context);
+
+    // Send Sigma1 after connection is established for sessions over TCP
+    err = caseSession->SendSigma1();
+    if (err != CHIP_NO_ERROR)
+    {
+        caseSession->Clear();
+    }
+}
+
+void CASESession::HandleConnectionClosed(void *context, Inet::TCPEndPoint * conObj, CHIP_ERROR conErr)
+{
+    //CHIP_ERROR err = CHIP_NO_ERROR;
+
+    VerifyOrReturn(context != nullptr);
+    CASESession * caseSession = reinterpret_cast<CASESession *>(context);
+    if (conErr == CHIP_NO_ERROR)
+    {
+        caseSession->Clear();
+    }
+    else
+    {
+        // Connection establishment failed
+
+    }
+}
+
 CHIP_ERROR CASESession::SendSigma1()
 {
     MATTER_TRACE_SCOPE("SendSigma1", "CASESession");

src/protocols/secure_channel/CASESession.h

@@ -283,6 +283,11 @@ class DLL_EXPORT CASESession : public Messaging::UnsolicitedMessageHandler,
 
     void InvalidateIfPendingEstablishmentOnFabric(FabricIndex fabricIndex);
 
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+    static void HandleConnectionComplete(void *context, Inet::TCPEndPoint * conObj, CHIP_ERROR conErr);
+    static void HandleConnectionClosed(void *context, Inet::TCPEndPoint * conObj, CHIP_ERROR conErr);
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
+
 #if CONFIG_BUILD_FOR_HOST_UNIT_TEST
     void SetStopSigmaHandshakeAt(Optional<State> state) { mStopHandshakeAtState = state; }
 #endif // CONFIG_BUILD_FOR_HOST_UNIT_TEST
@@ -298,6 +303,7 @@ class DLL_EXPORT CASESession : public Messaging::UnsolicitedMessageHandler,
     uint8_t mIPK[kIPKSize];
 
     SessionResumptionStorage * mSessionResumptionStorage = nullptr;
+    SessionManager * mSessionManager = nullptr;
 
     FabricTable * mFabricsTable = nullptr;
     FabricIndex mFabricIndex    = kUndefinedFabricIndex;

src/transport/SessionManager.cpp

@@ -108,6 +108,13 @@ CHIP_ERROR SessionManager::Init(System::Layer * systemLayer, TransportMgrBase *
 
     mTransportMgr->SetSessionManager(this);
 
+    mTransportMgr->SetSystemLayer(systemLayer);
+
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+    mConnCompleteCb        = nullptr;
+    mConnClosedCb          = nullptr;
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
+
     return CHIP_NO_ERROR;
 }
 
@@ -582,6 +589,66 @@ void SessionManager::OnMessageReceived(const PeerAddress & peerAddress, System::
     }
 }
 
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+void SessionManager::SetConnectionCallbacks(OnConnectionCompleteCallback connCompleteCb,
+                                            OnConnectionClosedCallback connClosedCb,
+                                            void * connContext)
+{
+    mConnCompleteCb = connCompleteCb;
+    mConnClosedCb = connClosedCb;
+    mConnContext = connContext;
+}
+
+void SessionManager::HandleConnectionComplete(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr)
+{
+    if (mConnCompleteCb != nullptr)
+    {
+        ChipLogProgress(Inet, "Calling Connection Complete callback");
+        mConnCompleteCb(mConnContext, conObj, conErr);
+    }
+    else
+    {
+        ChipLogProgress(Inet, "Connection Complete callback missing");
+    }
+}
+
+void SessionManager::HandleConnectionClosed(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr)
+{
+    if (mConnClosedCb != nullptr)
+    {
+        mConnClosedCb(mConnContext, conObj, conErr);
+    }
+    else
+    {
+        ChipLogProgress(Inet, "Connection Closed callback missing");
+    }
+}
+
+CHIP_ERROR SessionManager::ConnectToPeer(const PeerAddress & peerAddress)
+{
+    if (mTransportMgr != nullptr)
+    {
+        ChipLogProgress(Inet, "Connecting to peer ");
+        return mTransportMgr->ConnectToPeer(peerAddress);
+    }
+
+    ChipLogError(Inet, "The transport manager is not initialized. Unable to connect to peer");
+
+    return CHIP_ERROR_INCORRECT_STATE;
+}
+
+CHIP_ERROR SessionManager::Disconnect(const PeerAddress & peerAddress)
+{
+    if (mTransportMgr != nullptr)
+    {
+        ChipLogProgress(Inet, "Disconnecting from peer ");
+        mTransportMgr->Disconnect(peerAddress);
+    }
+
+    return CHIP_NO_ERROR;
+}
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
+
 void SessionManager::UnauthenticatedMessageDispatch(const PacketHeader & partialPacketHeader,
                                                     const Transport::PeerAddress & peerAddress, System::PacketBufferHandle && msg)
 {

src/transport/SessionManager.h

@@ -407,6 +407,7 @@ class DLL_EXPORT SessionManager : public TransportMgrDelegate, public FabricTabl
     TransportMgrBase * GetTransportManager() const { return mTransportMgr; }
     Transport::SecureSessionTable & GetSecureSessions() { return mSecureSessions; }
 
+
     /**
      * @brief
      *   Handle received secure message. Implements TransportMgrDelegate
@@ -416,6 +417,26 @@ class DLL_EXPORT SessionManager : public TransportMgrDelegate, public FabricTabl
      */
     void OnMessageReceived(const Transport::PeerAddress & source, System::PacketBufferHandle && msgBuf) override;
 
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+    CHIP_ERROR ConnectToPeer(const Transport::PeerAddress & peerAddress);
+
+    CHIP_ERROR Disconnect(const Transport::PeerAddress & peerAddress);
+
+    void HandleConnectionComplete(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr) override;
+
+    void HandleConnectionClosed(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr) override;
+
+    // Functors for callbacks into higher layers
+    using OnConnectionCompleteCallback = void (*)(void * appContext, Inet::TCPEndPoint * conObj, CHIP_ERROR conErr);
+
+    using OnConnectionClosedCallback = void (*)(void * appContext, Inet::TCPEndPoint * conObj, CHIP_ERROR conErr);
+
+    // Set the higher layer callbacks
+    void SetConnectionCallbacks(OnConnectionCompleteCallback connCompleteCb,
+                                OnConnectionClosedCallback connClosedCb,
+                                void *connContext);
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
+
     Optional<SessionHandle> CreateUnauthenticatedSession(const Transport::PeerAddress & peerAddress,
                                                          const ReliableMessageProtocolConfig & config)
     {
@@ -477,6 +498,12 @@ class DLL_EXPORT SessionManager : public TransportMgrDelegate, public FabricTabl
     State mState; // < Initialization state of the object
     chip::Transport::GroupOutgoingCounters mGroupClientCounter;
 
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+    OnConnectionCompleteCallback mConnCompleteCb = nullptr;
+    OnConnectionClosedCallback mConnClosedCb = nullptr;
+    void * mConnContext = nullptr;
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
+
     SessionMessageDelegate * mCB = nullptr;
 
     TransportMgrBase * mTransportMgr                                   = nullptr;

src/transport/TransportMgr.h

@@ -51,6 +51,20 @@ class TransportMgrDelegate
      * @param msgBuf    the buffer containing a full CHIP message (except for the optional length field).
      */
     virtual void OnMessageReceived(const Transport::PeerAddress & source, System::PacketBufferHandle && msgBuf) = 0;
+
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+    /**
+     * @brief
+     *   Handle connection completion.
+     *
+     * @param conObj    the connection object
+     * @param conErr    the connection error on the attempt.
+     */
+    virtual void HandleConnectionComplete(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr) {};
+
+
+    virtual void HandleConnectionClosed(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr) {};
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
 };
 
 template <typename... TransportTypes>

src/transport/TransportMgrBase.cpp

@@ -20,6 +20,7 @@
 #include <platform/LockTracker.h>
 #include <transport/TransportMgr.h>
 #include <transport/raw/Base.h>
+#include <transport/raw/TCP.h>
 
 namespace chip {
 
@@ -28,10 +29,17 @@ CHIP_ERROR TransportMgrBase::SendMessage(const Transport::PeerAddress & address,
     return mTransport->SendMessage(address, std::move(msgBuf));
 }
 
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+CHIP_ERROR TransportMgrBase::ConnectToPeer(const Transport::PeerAddress & address)
+{
+    return mTransport->ConnectToPeer(address);
+}
+
 void TransportMgrBase::Disconnect(const Transport::PeerAddress & address)
 {
     mTransport->Disconnect(address);
 }
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
 
 CHIP_ERROR TransportMgrBase::Init(Transport::Base * transport)
 {
@@ -41,6 +49,7 @@ CHIP_ERROR TransportMgrBase::Init(Transport::Base * transport)
     }
     mTransport = transport;
     mTransport->SetDelegate(this);
+
     ChipLogDetail(Inet, "TransportMgr initialized");
     return CHIP_NO_ERROR;
 }
@@ -83,4 +92,41 @@ void TransportMgrBase::HandleMessageReceived(const Transport::PeerAddress & peer
     }
 }
 
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+void TransportMgrBase::HandleConnectionComplete(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr)
+{
+    if (mSessionManager != nullptr)
+    {
+        mSessionManager->HandleConnectionComplete(conObj, conErr);
+    }
+    else
+    {
+        Transport::TCPBase * tcp = reinterpret_cast<Transport::TCPBase *>(conObj->mAppState);
+
+        // Close connection here
+        if (tcp)
+        {
+            tcp->Disconnect(conObj);
+        }
+    }
+}
+
+void TransportMgrBase::HandleConnectionClosed(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr)
+{
+    if (mSessionManager != nullptr)
+    {
+        mSessionManager->HandleConnectionClosed(conObj, conErr);
+    }
+    else
+    {
+      Transport::TCPBase * tcp = reinterpret_cast<Transport::TCPBase *>(conObj->mAppState);
+      if (tcp)
+      {
+          tcp->Disconnect(conObj);
+      }
+    }
+
+}
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
+
 } // namespace chip

src/transport/TransportMgrBase.h

@@ -39,10 +39,22 @@ class TransportMgrBase : public Transport::RawTransportDelegate
 
     void Close();
 
+#if CHIP_CONFIG_TCP_SUPPORT_ENABLED
+    CHIP_ERROR ConnectToPeer(const Transport::PeerAddress & address);
+
     void Disconnect(const Transport::PeerAddress & address);
 
+    void HandleConnectionComplete(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr) override;
+
+    void HandleConnectionClosed(Inet::TCPEndPoint * conObj, CHIP_ERROR conErr) override;
+#endif // CHIP_CONFIG_TCP_SUPPORT_ENABLED
+
+    void SetSystemLayer(System::Layer * systemLayer) { mTransport->SetSystemLayer(systemLayer); }
+
     void SetSessionManager(TransportMgrDelegate * sessionManager) { mSessionManager = sessionManager; }
 
+    TransportMgrDelegate * GetSessionManager() { return mSessionManager; };
+
     CHIP_ERROR MulticastGroupJoinLeave(const Transport::PeerAddress & address, bool join);
 
     void HandleMessageReceived(const Transport::PeerAddress & peerAddress, System::PacketBufferHandle && msg) override;