[Inet] Add TCPEndpointImpl for OpenThread (#16671)

* Add TCPEndpointImpl for OpenThread

examples/light-switch-app/efr32/args.gni

@@ -25,4 +25,3 @@ declare_args() {
 pw_log_BACKEND = "${chip_root}/src/lib/support/pw_log_chip"
 pw_assert_BACKEND = "$dir_pw_assert_log"
 chip_enable_openthread = true
-chip_system_config_use_open_thread_udp = true

examples/lighting-app/efr32/args.gni

@@ -25,4 +25,3 @@ declare_args() {
 pw_log_BACKEND = "${chip_root}/src/lib/support/pw_log_chip"
 pw_assert_BACKEND = "$dir_pw_assert_log"
 chip_enable_openthread = true
-chip_system_config_use_open_thread_udp = true

examples/lock-app/efr32/args.gni

@@ -23,6 +23,5 @@ declare_args() {
 }
 
 chip_enable_openthread = true
-chip_system_config_use_open_thread_udp = true
 pw_log_BACKEND = "${chip_root}/src/lib/support/pw_log_chip"
 pw_assert_BACKEND = "$dir_pw_assert_log"

examples/persistent-storage/qpg/args.gni

@@ -18,7 +18,7 @@ import("${chip_root}/examples/platform/qpg/args.gni")
 qpg_sdk_target = get_label_info(":sdk", "label_no_toolchain")
 chip_enable_openthread = false
 chip_openthread_ftd = false
-chip_system_config_use_open_thread_udp = false
+chip_system_config_use_open_thread_inet_endpoints = false
 
 declare_args() {
   # Disable lock tracking, since our FreeRTOS configuration does not set

examples/window-app/efr32/args.gni

@@ -26,4 +26,3 @@ declare_args() {
 pw_log_BACKEND = "${chip_root}/src/lib/support/pw_log_chip"
 pw_assert_BACKEND = "$dir_pw_assert_log"
 chip_enable_openthread = true
-chip_system_config_use_open_thread_udp = true

src/app/server/Server.cpp

@@ -150,9 +150,9 @@ CHIP_ERROR Server::Init(AppDelegate * delegate, uint16_t secureServicePort, uint
     err = mTransports.Init(UdpListenParameters(DeviceLayer::UDPEndPointManager())
                                .SetAddressType(IPAddressType::kIPv6)
                                .SetListenPort(mSecuredServicePort)
-#if CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_UDP
+#if CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
                                .SetNativeParams(chip::DeviceLayer::ThreadStackMgrImpl().OTInstance())
-#endif // CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_UDP
+#endif // CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
 
 #if INET_CONFIG_ENABLE_IPV4
                                ,

src/inet/BUILD.gn

@@ -24,7 +24,7 @@ import("${chip_root}/src/lwip/lwip.gni")
 import("${chip_root}/src/platform/device.gni")
 import("inet.gni")
 
-if (chip_system_config_use_open_thread_udp) {
+if (chip_system_config_use_open_thread_inet_endpoints) {
   import("//build_overrides/openthread.gni")
 }
 
@@ -55,13 +55,7 @@ buildconfig_header("inet_buildconfig") {
   }
 
   defines += [ "INET_TCP_END_POINT_IMPL_CONFIG_FILE=<inet/TCPEndPointImpl${chip_system_config_inet}.h>" ]
-  if (chip_system_config_use_open_thread_udp) {
-    defines += [
-      "INET_UDP_END_POINT_IMPL_CONFIG_FILE=<inet/UDPEndPointImpl_OpenThread.h>",
-    ]
-  } else {
-    defines += [ "INET_UDP_END_POINT_IMPL_CONFIG_FILE=<inet/UDPEndPointImpl${chip_system_config_inet}.h>" ]
-  }
+  defines += [ "INET_UDP_END_POINT_IMPL_CONFIG_FILE=<inet/UDPEndPointImpl${chip_system_config_inet}.h>" ]
 }
 
 source_set("inet_config_header") {
@@ -113,7 +107,7 @@ static_library("inet") {
     public_deps += [ "${chip_root}/src/lwip" ]
   }
 
-  if (chip_system_config_use_open_thread_udp) {
+  if (chip_system_config_use_open_thread_inet_endpoints) {
     if (chip_openthread_ftd) {
       public_deps +=
           [ "${chip_root}/third_party/openthread/repo:libopenthread-ftd" ]
@@ -137,20 +131,10 @@ static_library("inet") {
     sources += [
       "UDPEndPoint.cpp",
       "UDPEndPoint.h",
+      "UDPEndPointImpl${chip_system_config_inet}.cpp",
+      "UDPEndPointImpl${chip_system_config_inet}.h",
       "UDPEndPointImpl.h",
     ]
-
-    if (chip_system_config_use_open_thread_udp) {
-      sources += [
-        "UDPEndPointImpl_OpenThread.cpp",
-        "UDPEndPointImpl_OpenThread.h",
-      ]
-    } else {
-      sources += [
-        "UDPEndPointImpl${chip_system_config_inet}.cpp",
-        "UDPEndPointImpl${chip_system_config_inet}.h",
-      ]
-    }
   }
 
   if (chip_with_nlfaultinjection) {

src/inet/EndPointStateOpenThread.h

@@ -0,0 +1,49 @@
+/*
+ *
+ *    Copyright (c) 2020-2021 Project CHIP Authors
+ *    Copyright (c) 2015-2017 Nest Labs, Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *  Shared state for OpenThread implementations of TCPEndPoint and UDPEndPoint.
+ */
+
+#pragma once
+
+#include <inet/EndPointBasis.h>
+
+#include <inet/IPAddress.h>
+
+namespace chip {
+namespace Inet {
+
+/**
+ * Definitions shared by all OpenThread EndPoint classes.
+ */
+class DLL_EXPORT EndPointStateOpenThread
+{
+protected:
+    EndPointStateOpenThread() : mOpenThreadEndPointType(OpenThreadEndPointType::Unknown) {}
+
+    enum class OpenThreadEndPointType : uint8_t
+    {
+        Unknown = 0,
+        UDP     = 1,
+        TCP     = 2
+    } mOpenThreadEndPointType;
+};
+
+} // namespace Inet
+} // namespace chip

src/inet/TCPEndPointImplOpenThread.cpp

@@ -0,0 +1,96 @@
+/*
+ *
+ *    Copyright (c) 2020-2021 Project CHIP Authors
+ *    Copyright (c) 2018 Google LLC.
+ *    Copyright (c) 2013-2018 Nest Labs, Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include <inet/TCPEndPointImplOpenThread.h>
+
+#include <lib/support/CodeUtils.h>
+#include <lib/support/SafeInt.h>
+#include <lib/support/logging/CHIPLogging.h>
+
+#include <platform/OpenThread/OpenThreadUtils.h>
+
+#include <system/SystemPacketBuffer.h>
+
+namespace chip {
+namespace Inet {
+
+CHIP_ERROR TCPEndPointImplOT::GetPeerInfo(IPAddress * retAddr, uint16_t * retPort) const
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::GetLocalInfo(IPAddress * retAddr, uint16_t * retPort) const
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::GetInterfaceId(InterfaceId * retInterface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::EnableNoDelay()
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::EnableKeepAlive(uint16_t interval, uint16_t timeoutCount)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::DisableKeepAlive()
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::AckReceive(uint16_t len)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
+CHIP_ERROR TCPEndPointImplOT::BindImpl(IPAddressType addrType, const IPAddress & addr, uint16_t port, bool reuseAddr)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::ListenImpl(uint16_t backlog)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::ConnectImpl(const IPAddress & addr, uint16_t port, InterfaceId intfId)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::SendQueuedImpl(bool queueWasEmpty)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::SetUserTimeoutImpl(uint32_t userTimeoutMillis)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+CHIP_ERROR TCPEndPointImplOT::DriveSendingImpl()
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+void TCPEndPointImplOT::HandleConnectCompleteImpl()
+{
+    // Not implemented
+}
+void TCPEndPointImplOT::DoCloseImpl(CHIP_ERROR err, State oldState)
+{
+    // Not implemented
+}
+
+} // namespace Inet
+} // namespace chip

src/inet/TCPEndPointImplOpenThread.h

@@ -0,0 +1,73 @@
+/*
+ *
+ *    Copyright (c) 2020-2021 Project CHIP Authors
+ *    Copyright (c) 2018 Google LLC
+ *    Copyright (c) 2013-2017 Nest Labs, Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#pragma once
+
+#include <inet/EndPointStateOpenThread.h>
+#include <inet/TCPEndPoint.h>
+
+#include <openthread/error.h>
+#include <openthread/icmp6.h>
+#include <openthread/ip6.h>
+#include <openthread/netdata.h>
+#include <openthread/tcp.h>
+#include <openthread/thread.h>
+
+namespace chip {
+namespace Inet {
+
+class TCPEndPointImplOT : public TCPEndPoint, public EndPointStateOpenThread
+{
+public:
+    TCPEndPointImplOT(EndPointManager<TCPEndPoint> & endPointManager) :
+        TCPEndPoint(endPointManager), mBoundIntfId(InterfaceId::Null())
+    {}
+
+    // TCPEndPoint overrides.
+    CHIP_ERROR GetPeerInfo(IPAddress * retAddr, uint16_t * retPort) const override;
+    CHIP_ERROR GetLocalInfo(IPAddress * retAddr, uint16_t * retPort) const override;
+    CHIP_ERROR GetInterfaceId(InterfaceId * retInterface) override;
+    CHIP_ERROR EnableNoDelay() override;
+    CHIP_ERROR EnableKeepAlive(uint16_t interval, uint16_t timeoutCount) override;
+    CHIP_ERROR DisableKeepAlive() override;
+    CHIP_ERROR AckReceive(uint16_t len) override;
+#if INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT
+    void TCPUserTimeoutHandler() override;
+#endif // INET_CONFIG_OVERRIDE_SYSTEM_TCP_USER_TIMEOUT
+
+private:
+    // TCPEndPoint overrides.
+    CHIP_ERROR BindImpl(IPAddressType addrType, const IPAddress & addr, uint16_t port, bool reuseAddr) override;
+    CHIP_ERROR ListenImpl(uint16_t backlog) override;
+    CHIP_ERROR ConnectImpl(const IPAddress & addr, uint16_t port, InterfaceId intfId) override;
+    CHIP_ERROR SendQueuedImpl(bool queueWasEmpty) override;
+    CHIP_ERROR SetUserTimeoutImpl(uint32_t userTimeoutMillis) override;
+    CHIP_ERROR DriveSendingImpl() override;
+    void HandleConnectCompleteImpl() override;
+    void DoCloseImpl(CHIP_ERROR err, State oldState) override;
+
+    InterfaceId mBoundIntfId;
+    uint16_t mBoundPort;
+    otInstance * mOTInstance = nullptr;
+};
+
+using TCPEndPointImpl = TCPEndPointImplOT;
+
+} // namespace Inet
+} // namespace chip

src/inet/UDPEndPointImpl_OpenThread.cpp → src/inet/UDPEndPointImplOpenThread.cpp

@@ -17,7 +17,7 @@
  *    limitations under the License.
  */
 
-#include <inet/UDPEndPointImpl_OpenThread.h>
+#include <inet/UDPEndPointImplOpenThread.h>
 
 #include <lib/support/CodeUtils.h>
 #include <lib/support/SafeInt.h>

src/inet/UDPEndPointImpl_OpenThread.h → src/inet/UDPEndPointImplOpenThread.h

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include <inet/EndPointStateOpenThread.h>
 #include <inet/UDPEndPoint.h>
 
 #include <openthread/error.h>
@@ -31,7 +32,7 @@
 namespace chip {
 namespace Inet {
 
-class UDPEndPointImplOT : public UDPEndPoint
+class UDPEndPointImplOT : public UDPEndPoint, public EndPointStateOpenThread
 {
 public:
     UDPEndPointImplOT(EndPointManager<UDPEndPoint> & endPointManager) :

src/inet/inet.gni

@@ -27,7 +27,9 @@ declare_args() {
   chip_inet_config_enable_tcp_endpoint = true
 
   # Inet implementation type.
-  if (chip_system_config_use_lwip) {
+  if (chip_system_config_use_open_thread_inet_endpoints) {
+    chip_system_config_inet = "OpenThread"
+  } else if (chip_system_config_use_lwip) {
     chip_system_config_inet = "LwIP"
   } else {
     chip_system_config_inet = "Sockets"

src/platform/EFR32/args.gni

@@ -32,6 +32,9 @@ lwip_platform = "efr32"
 
 chip_inet_config_enable_ipv4 = false
 
+chip_inet_config_enable_tcp_endpoint = false
+chip_system_config_use_open_thread_inet_endpoints = true
+
 chip_build_tests = false
 
 openthread_core_config_platform_check_file =

src/platform/EFR32/wifi_args.gni

@@ -34,6 +34,7 @@ chip_device_platform = "efr32"
 chip_enable_openthread = false
 chip_inet_config_enable_ipv4 = true
 chip_inet_config_enable_dns_resolver = false
+chip_inet_config_enable_tcp_endpoint = true
 
 chip_build_tests = false
 chip_config_memory_management = "platform"

src/platform/OpenThread/GenericThreadStackManagerImpl_OpenThread_LwIP.cpp

@@ -233,14 +233,14 @@ void GenericThreadStackManagerImpl_OpenThread_LwIP<ImplClass>::UpdateThreadInter
 
 // Multicast won't work with LWIP on top of OT
 // Duplication of listeners, unecessary timers, buffer duplication, hardfault etc...
-#if CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_UDP
+#if CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
             // Refresh Multicast listening
             if (GenericThreadStackManagerImpl_OpenThread<ImplClass>::IsThreadAttachedNoLock())
             {
                 ChipLogDetail(DeviceLayer, "Thread Attached updating Multicast address");
                 Server::GetInstance().RejoinExistingMulticastGroups();
             }
-#endif // CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_UDP
+#endif // CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
         }
 
         ChipLogDetail(DeviceLayer, "LwIP Thread interface addresses %s", isInterfaceUp ? "updated" : "cleared");