TCP connection setup/management and CASESession association.

Add ConnectToPeer() API for explicit connection setup.
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.

Mark SecureSession as defunct on connection closures.

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

Associate a session with a connection object.

Associate the PeerAddress with the session early. Pass the PeerAddress
in the Find APIs. This helps check against the correct TransportType
when searching for a Sesssion in the SessionTable.

Add a `large payload` flag in EstablishSession() and Session lookup
functions to create/associate with the correct session and transport.

Have default configurations for TCP in a separate TCPConfig.h.

Refactor echo_requester.cpp and echo_responder.cpp to use the session
associated with the connection.

Handle Connection closure at ExchangeMgr and uplevel to corresponding
ExchangeContext using the corresponding session handle.

Add tests around connection establishment in TestTCP.

Author: pidarped

examples/shell/shell_common/include/Globals.h

@@ -24,7 +24,9 @@
 #include <protocols/secure_channel/MessageCounterManager.h>
 #include <transport/SessionHolder.h>
 #include <transport/SessionManager.h>
+#if INET_CONFIG_ENABLE_TCP_ENDPOINT
 #include <transport/raw/TCP.h>
+#endif // INET_CONFIG_ENABLE_TCP_ENDPOINT
 #include <transport/raw/UDP.h>
 
 #if INET_CONFIG_ENABLE_TCP_ENDPOINT

src/app/CASESessionManager.cpp

@@ -30,62 +30,57 @@ CHIP_ERROR CASESessionManager::Init(chip::System::Layer * systemLayer, const CAS
 }
 
 void CASESessionManager::FindOrEstablishSession(const ScopedNodeId & peerId, Callback::Callback<OnDeviceConnected> * onConnection,
-                                                Callback::Callback<OnDeviceConnectionFailure> * onFailure
+                                                Callback::Callback<OnDeviceConnectionFailure> * onFailure,
 #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
-                                                ,
-                                                uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry
+                                                uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry,
 #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
-)
+                                                TransportPayloadCapability transportPayloadCapability)
 {
     FindOrEstablishSessionHelper(peerId, onConnection, onFailure, nullptr
 #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
                                  ,
                                  attemptCount, onRetry
 #endif
-    );
+                                 ,
+                                 transportPayloadCapability);
 }
 
 void CASESessionManager::FindOrEstablishSession(const ScopedNodeId & peerId, Callback::Callback<OnDeviceConnected> * onConnection,
-                                                Callback::Callback<OperationalSessionSetup::OnSetupFailure> * onSetupFailure
+                                                Callback::Callback<OperationalSessionSetup::OnSetupFailure> * onSetupFailure,
 #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
-                                                ,
-                                                uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry
+                                                uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry,
 #endif
-)
+                                                TransportPayloadCapability transportPayloadCapability)
 {
-    FindOrEstablishSessionHelper(peerId, onConnection, nullptr, onSetupFailure
+    FindOrEstablishSessionHelper(peerId, onConnection, nullptr, onSetupFailure,
 #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
-                                 ,
-                                 attemptCount, onRetry
+                                 attemptCount, onRetry,
 #endif
-    );
+                                 transportPayloadCapability);
 }
 
 void CASESessionManager::FindOrEstablishSession(const ScopedNodeId & peerId, Callback::Callback<OnDeviceConnected> * onConnection,
-                                                nullptr_t
+                                                nullptr_t,
 #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
-                                                ,
-                                                uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry
+                                                uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry,
 #endif
-)
+                                                TransportPayloadCapability transportPayloadCapability)
 {
-    FindOrEstablishSessionHelper(peerId, onConnection, nullptr, nullptr
+    FindOrEstablishSessionHelper(peerId, onConnection, nullptr, nullptr,
 #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
-                                 ,
-                                 attemptCount, onRetry
+                                 attemptCount, onRetry,
 #endif
-    );
+                                 transportPayloadCapability);
 }
 
 void CASESessionManager::FindOrEstablishSessionHelper(const ScopedNodeId & peerId,
                                                       Callback::Callback<OnDeviceConnected> * onConnection,
                                                       Callback::Callback<OnDeviceConnectionFailure> * onFailure,
-                                                      Callback::Callback<OperationalSessionSetup::OnSetupFailure> * onSetupFailure
+                                                      Callback::Callback<OperationalSessionSetup::OnSetupFailure> * onSetupFailure,
 #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
-                                                      ,
-                                                      uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry
+                                                      uint8_t attemptCount, Callback::Callback<OnDeviceConnectionRetry> * onRetry,
 #endif
-)
+                                                      TransportPayloadCapability transportPayloadCapability)
 {
     ChipLogDetail(CASESessionManager, "FindOrEstablishSession: PeerId = [%d:" ChipLogFormatX64 "]", peerId.GetFabricIndex(),
                   ChipLogValueX64(peerId.GetNodeId()));
@@ -124,12 +119,12 @@ void CASESessionManager::FindOrEstablishSessionHelper(const ScopedNodeId & peerI
 
     if (onFailure != nullptr)
     {
-        session->Connect(onConnection, onFailure);
+        session->Connect(onConnection, onFailure, transportPayloadCapability);
     }
 
     if (onSetupFailure != nullptr)
     {
-        session->Connect(onConnection, onSetupFailure);
+        session->Connect(onConnection, onSetupFailure, transportPayloadCapability);
     }
 }
 
@@ -143,10 +138,11 @@ void CASESessionManager::ReleaseAllSessions()
     mConfig.sessionSetupPool->ReleaseAllSessionSetup();
 }
 
-CHIP_ERROR CASESessionManager::GetPeerAddress(const ScopedNodeId & peerId, Transport::PeerAddress & addr)
+CHIP_ERROR CASESessionManager::GetPeerAddress(const ScopedNodeId & peerId, Transport::PeerAddress & addr,
+                                              TransportPayloadCapability transportPayloadCapability)
 {
     ReturnErrorOnFailure(mConfig.sessionInitParams.Validate());
-    auto optionalSessionHandle = FindExistingSession(peerId);
+    auto optionalSessionHandle = FindExistingSession(peerId, transportPayloadCapability);
     ReturnErrorCodeIf(!optionalSessionHandle.HasValue(), CHIP_ERROR_NOT_CONNECTED);
     addr = optionalSessionHandle.Value()->AsSecureSession()->GetPeerAddress();
     return CHIP_NO_ERROR;
@@ -182,10 +178,11 @@ OperationalSessionSetup * CASESessionManager::FindExistingSessionSetup(const Sco
     return mConfig.sessionSetupPool->FindSessionSetup(peerId, forAddressUpdate);
 }
 
-Optional<SessionHandle> CASESessionManager::FindExistingSession(const ScopedNodeId & peerId) const
+Optional<SessionHandle> CASESessionManager::FindExistingSession(const ScopedNodeId & peerId,
+                                                                const TransportPayloadCapability transportPayloadCapability) const
 {
-    return mConfig.sessionInitParams.sessionManager->FindSecureSessionForNode(peerId,
-                                                                              MakeOptional(Transport::SecureSession::Type::kCASE));
+    return mConfig.sessionInitParams.sessionManager->FindSecureSessionForNode(
+        peerId, MakeOptional(Transport::SecureSession::Type::kCASE), transportPayloadCapability);
 }
 
 void CASESessionManager::ReleaseSession(OperationalSessionSetup * session)