first submission

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/BUILD.gn

@@ -0,0 +1,50 @@
+# Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("lwip_porting.gni")
+import("//third_party/lwip/lwip.gni")
+
+config("lwip_depends") {
+  defines = [ "_BSD_SOURCE = 1" ]
+}
+
+static_library("lwip") {
+  include_dirs = [
+    "//kernel/liteos_m/kal/posix/include",
+    "//kernel/liteos_m/kernel/arch/include",
+  ]
+
+  include_dirs += LWIP_PORTING_INCLUDE_DIRS
+  include_dirs += LWIP_INCLUDE_DIRS
+
+  sources = LWIP_PORTING_FILES + LWIPNOAPPSFILES
+
+  configs += [ ":lwip_depends" ]
+
+  deps = [ "//kernel/liteos_m/kal/posix" ]
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/enhancement/src/fixme.c

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <lwip/sys.h>
+#include <lwip/etharp.h>
+#include <lwip/netifapi.h>
+#include <lwip/priv/api_msg.h>
+
+#define NETIFAPI_VAR_REF(name)      API_VAR_REF(name)
+#define NETIFAPI_VAR_DECLARE(name)  API_VAR_DECLARE(struct netifapi_msg, name)
+#define NETIFAPI_VAR_ALLOC(name)    API_VAR_ALLOC(struct netifapi_msg, MEMP_NETIFAPI_MSG, name, ERR_MEM)
+#define NETIFAPI_VAR_FREE(name)     API_VAR_FREE(MEMP_NETIFAPI_MSG, name)
+
+static struct netif *netif_find_by_name(const char *name)
+{
+    struct netif *netif = NULL;
+    LWIP_ASSERT_CORE_LOCKED();
+    if (name == NULL) {
+        return NULL;
+    }
+    NETIF_FOREACH(netif) {
+        if (strcmp("lo", name) == 0 && (netif->name[0] == 'l' && netif->name[1] == 'o')) {
+            LWIP_DEBUGF(NETIF_DEBUG, ("netif_find_by_name: found lo\n"));
+            return netif;
+        }
+
+        if (strcmp(netif->full_name, name) == 0) {
+            LWIP_DEBUGF(NETIF_DEBUG, ("netif_find_by_name: found %s\n", name));
+            return netif;
+        }
+    }
+
+    LWIP_DEBUGF(NETIF_DEBUG, ("netif_find_by_name: didn't find %s\n", name));
+    return NULL;
+}
+
+static err_t netifapi_do_find_by_name(struct tcpip_api_call_data *m)
+{
+    /* cast through void* to silence alignment warnings.
+     * We know it works because the structs have been instantiated as struct netifapi_msg */
+    struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m;
+    msg->netif = netif_find_by_name(msg->msg.ifs.name);
+    return ERR_OK;
+}
+
+struct netif *netifapi_netif_find_by_name(const char *name)
+{
+    struct netif *netif = NULL;
+    NETIFAPI_VAR_DECLARE(msg);
+    NETIFAPI_VAR_ALLOC(msg);
+    NETIFAPI_VAR_REF(msg).netif = NULL;
+#if LWIP_MPU_COMPATIBLE
+    if (strncpy_s(NETIFAPI_VAR_REF(msg).msg.ifs.name, NETIF_NAMESIZE, name, NETIF_NAMESIZE - 1)) {
+        NETIFAPI_VAR_FREE(msg);
+        return netif;
+    }
+    NETIFAPI_VAR_REF(msg).msg.ifs.name[NETIF_NAMESIZE - 1] = '\0';
+#else
+    NETIFAPI_VAR_REF(msg).msg.ifs.name = (char *)name;
+#endif /* LWIP_MPU_COMPATIBLE */
+
+    (void)tcpip_api_call(netifapi_do_find_by_name, &API_VAR_REF(msg).call);
+    netif = msg.netif;
+    NETIFAPI_VAR_FREE(msg);
+    return netif;
+}
+
+#if LWIP_IPV6
+int ip6addr_aton(const char *cp, ip6_addr_t *addr)
+{
+    const int ipv6_blocks = 8;
+    u16_t current_block_index = 0;
+    u16_t current_block_value = 0;
+    u16_t addr16[ipv6_blocks];
+    u16_t *a16 = (u16_t *)addr->addr;
+    int squash_pos = ipv6_blocks;
+    int i;
+    const char *sc = cp;
+    const char *ss = cp-1;
+
+    for (; ; sc++) {
+        if (current_block_index >= ipv6_blocks) {
+            return 0; // address too long
+        }
+        if (*sc == 0) {
+            if (sc - ss == 1) {
+                if (squash_pos != current_block_index) {
+                    return 0; // empty address or address ends with a single ':'
+                } // else address ends with one valid "::"
+            } else {
+                addr16[current_block_index++] = current_block_value;
+            }
+            break;
+        } else if (*sc == ':') {
+            if (sc - ss == 1) {
+                if (sc != cp || sc[1] != ':') {
+                    return 0; // address begins with a single ':' or contains ":::"
+                } // else address begins with one valid "::"
+            } else {
+                addr16[current_block_index++] = current_block_value;
+            }
+            if (sc[1] == ':') {
+                if (squash_pos != ipv6_blocks) {
+                    return 0; // more than one "::"
+                }
+                squash_pos = current_block_index;
+                sc++;
+            }
+            ss = sc; // ss points to the recent ':' position
+            current_block_value = 0;
+        } else if (lwip_isxdigit(*sc) && (sc - ss) < 5) { // 4 hex-digits at most
+            current_block_value = (current_block_value << 4) +
+                (*sc | ('a' - 'A')) - '0' - ('a' - '9' - 1) * (*sc >= 'A');
+#if LWIP_IPV4
+        } else if (*sc == '.' && current_block_index < ipv6_blocks - 1) {
+            ip4_addr_t ip4;
+            int ret = ip4addr_aton(ss+1, &ip4);
+            if (!ret) {
+                return 0;
+            }
+            ip4.addr = lwip_ntohl(ip4.addr);
+            addr16[current_block_index++] = (u16_t)(ip4.addr >> 16);
+            addr16[current_block_index++] = (u16_t)(ip4.addr);
+            break;
+#endif /* LWIP_IPV4 */
+        } else {
+            return 0; // unexpected char or too many digits
+        }
+    }
+
+    if (squash_pos == ipv6_blocks && current_block_index != ipv6_blocks) {
+        return 0; // address too short
+    }
+    if (squash_pos != ipv6_blocks && current_block_index == ipv6_blocks) {
+        return 0; // unexpected "::" in address
+    }
+
+    for (i = 0; i < squash_pos; ++i) {
+        a16[i] = lwip_htons(addr16[i]);
+    }
+    for (; i < ipv6_blocks - current_block_index + squash_pos; ++i) {
+        a16[i] = 0;
+    }
+    for (; i < ipv6_blocks; ++i) {
+        a16[i] = lwip_htons(addr16[i - ipv6_blocks + current_block_index]);
+    }
+
+    return 1;
+}
+#endif /* LWIP_IPV6 */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/lwip_porting.gni

@@ -0,0 +1,41 @@
+# Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+LWIP_PORTING_DIR = "//kernel/liteos_m/components/net/lwip-2.1"
+
+LWIP_PORTING_INCLUDE_DIRS = [ "$LWIP_PORTING_DIR/porting/include" ]
+
+LWIP_PORTING_FILES = [
+  "$LWIP_PORTING_DIR/porting/src/driverif.c",
+  "$LWIP_PORTING_DIR/porting/src/lwip_init.c",
+  "$LWIP_PORTING_DIR/porting/src/netdb_porting.c",
+  "$LWIP_PORTING_DIR/porting/src/sockets_porting.c",
+  "$LWIP_PORTING_DIR/porting/src/sys_arch.c",
+
+  "$LWIP_PORTING_DIR/enhancement/src/fixme.c",
+]

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/arch/cc.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_CC_H_
+#define _LWIP_PORTING_CC_H_
+
+#ifdef LITTLE_ENDIAN
+#undef LITTLE_ENDIAN
+#endif
+
+#ifdef BIG_ENDIAN
+#undef BIG_ENDIAN
+#endif
+
+#include <endian.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "securec.h"
+#include "memory_pool.h"
+
+#ifdef htons
+#define LWIP_DONT_PROVIDE_BYTEORDER_FUNCTIONS
+#endif
+
+#define SOCKLEN_T_DEFINED
+#define SA_FAMILY_T_DEFINED
+#define IN_PORT_T_DEFINED
+
+#define LWIP_TIMEVAL_PRIVATE    0
+#define LWIP_ERRNO_STDINCLUDE
+#define LWIP_SOCKET_STDINCLUDE
+
+#define LWIP_DNS_API_DEFINE_ERRORS    0
+#define LWIP_DNS_API_DEFINE_FLAGS     0
+#define LWIP_DNS_API_DECLARE_STRUCTS  0
+#define LWIP_DNS_API_DECLARE_H_ERRNO  0
+
+#ifndef __SIZEOF_POINTER__
+#define __SIZEOF_POINTER__ 4   // 32 bit system
+#endif
+
+#define LOS_TASK_STATUS_DETACHED   0x0100  // reserved
+
+#if defined(__arm__) && defined(__ARMCC_VERSION)
+    /* Keil uVision4 tools */
+    #define PACK_STRUCT_BEGIN __packed
+    #define PACK_STRUCT_STRUCT
+    #define PACK_STRUCT_END
+    #define PACK_STRUCT_FIELD(fld) fld
+    #define ALIGNED(n)  __align(n)
+#elif defined (__IAR_SYSTEMS_ICC__)
+    /* IAR Embedded Workbench tools */
+    #define PACK_STRUCT_BEGIN __packed
+    #define PACK_STRUCT_STRUCT
+    #define PACK_STRUCT_END
+    #define PACK_STRUCT_FIELD(fld) fld
+    // #error NEEDS ALIGNED
+#else
+    /* GCC tools (CodeSourcery) */
+    #define PACK_STRUCT_BEGIN
+    #define PACK_STRUCT_STRUCT __attribute__ ((__packed__))
+    #define PACK_STRUCT_END
+    #define PACK_STRUCT_FIELD(fld) fld
+    #define ALIGNED(n)  __attribute__((aligned (n)))
+#endif
+
+#define LWIP_RAND rand
+
+extern void HilogPrintf(const char *fmt, ...);
+
+#ifndef HILOG_INFO
+#define HILOG_INFO(...)
+#ifndef HILOG_MODULE_APP
+#define HILOG_MODULE_APP 0
+#endif
+#endif
+
+#ifndef HILOG_ERROR
+#define HILOG_ERROR(...)
+#endif
+
+#define LWIP_PLATFORM_DIAG(vars) HilogPrintf vars
+#define LWIP_PLATFORM_ASSERT(x) do {HILOG_ERROR(HILOG_MODULE_APP, \
+                                    "Assertion \"%s\" errno %d line %d in %s\n", \
+                                    x, errno, __LINE__, __FILE__);} while (0)
+
+#define mem_clib_malloc LWIP_MEM_ALLOC
+#define mem_clib_free LWIP_MEM_FREE
+#define mem_clib_calloc LWIP_MEM_CALLOC
+
+#define init_waitqueue_head(...)
+#define poll_check_waiters(...)
+#define IOCTL_CMD_CASE_HANDLER()
+
+#define DNS_SERVER_ADDRESS(ipaddr)        (ip4_addr_set_u32(ipaddr, ipaddr_addr("114.114.114.114")))
+#define DNS_SERVER_ADDRESS_SECONDARY(ipaddr)        (ip4_addr_set_u32(ipaddr, ipaddr_addr("114.114.115.115")))
+
+#endif /* _LWIP_PORTING_CC_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/arch/perf.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_PERF_H_
+#define _LWIP_PORTING_PERF_H_
+
+#if LWIP_PERF
+
+#define PERF_START    do { /* something to do */ } while (0)
+#define PERF_STOP(x)  do { /* something to do */ } while (0)
+
+#endif
+
+#endif /* _LWIP_PORTING_PERF_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/arch/sys_arch.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_SYS_ARCH_H_
+#define _LWIP_PORTING_SYS_ARCH_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Mutex
+ */
+typedef uint32_t sys_mutex_t;
+
+/**
+ * Semaphore
+ */
+typedef uint32_t sys_sem_t;
+
+/**
+ * MessageBox
+ */
+typedef uint32_t sys_mbox_t;
+
+/**
+ * Protector
+ */
+typedef void *sys_prot_t;
+
+/**
+ * Thread
+ */
+typedef uint32_t sys_thread_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LWIP_PORTING_SYS_ARCH_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/lwip/inet.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_INET_H_
+#define _LWIP_PORTING_INET_H_
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include_next <lwip/inet.h>
+
+#if LWIP_IPV4
+#define inet_addr_from_ip4addr(target_inaddr, source_ipaddr) \
+            ((target_inaddr)->s_addr = ip4_addr_get_u32(source_ipaddr))
+#define inet_addr_to_ip4addr(target_ipaddr, source_inaddr) \
+            (ip4_addr_set_u32(target_ipaddr, (source_inaddr)->s_addr))
+
+/* directly map this to the lwip internal functions */
+#define inet_addr(cp)                   ipaddr_addr(cp)
+#define inet_aton(cp, addr)             ip4addr_aton(cp, (ip4_addr_t*)addr)
+#define inet_ntoa(addr)                 ip4addr_ntoa((const ip4_addr_t*)&(addr))
+#define inet_ntoa_r(addr, buf, buflen)  ip4addr_ntoa_r((const ip4_addr_t*)&(addr), buf, buflen)
+#endif /* LWIP_IPV4 */
+#if LWIP_IPV6
+#define inet6_addr_from_ip6addr(target_in6addr, source_ip6addr) \
+            {(target_in6addr)->s6_addr32[0] = (source_ip6addr)->addr[0]; \
+            (target_in6addr)->s6_addr32[1] = (source_ip6addr)->addr[1]; \
+            (target_in6addr)->s6_addr32[2] = (source_ip6addr)->addr[2]; \
+            (target_in6addr)->s6_addr32[3] = (source_ip6addr)->addr[3];}
+#define inet6_addr_to_ip6addr(target_ip6addr, source_in6addr) \
+            {(target_ip6addr)->addr[0] = (source_in6addr)->s6_addr32[0]; \
+            (target_ip6addr)->addr[1] = (source_in6addr)->s6_addr32[1]; \
+            (target_ip6addr)->addr[2] = (source_in6addr)->s6_addr32[2]; \
+            (target_ip6addr)->addr[3] = (source_in6addr)->s6_addr32[3]; \
+            ip6_addr_clear_zone(target_ip6addr);}
+#endif /* LWIP_IPV6 */
+
+#endif /* _LWIP_PORTING_INET_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/lwip/lwipopts.h

@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_LWIPOPTS_H_
+#define _LWIP_PORTING_LWIPOPTS_H_
+
+// lwIP debug options, comment the ones you don't want
+#define LWIP_DEBUG 0
+#if LWIP_DEBUG
+#define ETHARP_DEBUG                    LWIP_DBG_OFF
+#define NETIF_DEBUG                     LWIP_DBG_OFF
+#define PBUF_DEBUG                      LWIP_DBG_OFF
+#define API_LIB_DEBUG                   LWIP_DBG_OFF
+#define API_MSG_DEBUG                   LWIP_DBG_OFF
+#define SOCKETS_DEBUG                   LWIP_DBG_OFF
+#define ICMP_DEBUG                      LWIP_DBG_OFF
+#define IGMP_DEBUG                      LWIP_DBG_OFF
+#define INET_DEBUG                      LWIP_DBG_OFF
+#define IP_DEBUG                        LWIP_DBG_OFF
+#define DRIVERIF_DEBUG                  LWIP_DBG_OFF
+#define IP_REASS_DEBUG                  LWIP_DBG_OFF
+#define RAW_DEBUG                       LWIP_DBG_OFF
+#define MEM_DEBUG                       LWIP_DBG_OFF
+#define MEMP_DEBUG                      LWIP_DBG_OFF
+#define SYS_DEBUG                       LWIP_DBG_OFF
+#define TIMERS_DEBUG                    LWIP_DBG_OFF
+#define TCP_DEBUG                       LWIP_DBG_OFF
+#define TCP_ERR_DEBUG                   LWIP_DBG_OFF
+#define TCP_INPUT_DEBUG                 LWIP_DBG_OFF
+#define TCP_FR_DEBUG                    LWIP_DBG_OFF
+#define TCP_RTO_DEBUG                   LWIP_DBG_OFF
+#define TCP_CWND_DEBUG                  LWIP_DBG_OFF
+#define TCP_WND_DEBUG                   LWIP_DBG_OFF
+#define TCP_OUTPUT_DEBUG                LWIP_DBG_OFF
+#define TCP_RST_DEBUG                   LWIP_DBG_OFF
+#define TCP_QLEN_DEBUG                  LWIP_DBG_OFF
+#define TCP_SACK_DEBUG                  LWIP_DBG_OFF
+#define TCP_TLP_DEBUG                   LWIP_DBG_OFF
+#define UDP_DEBUG                       LWIP_DBG_OFF
+#define TCPIP_DEBUG                     LWIP_DBG_OFF
+#define SLIP_DEBUG                      LWIP_DBG_OFF
+#define DHCP_DEBUG                      LWIP_DBG_OFF
+#define AUTOIP_DEBUG                    LWIP_DBG_OFF
+#define DNS_DEBUG                       LWIP_DBG_OFF
+#define TFTP_DEBUG                      LWIP_DBG_OFF
+#define SYS_ARCH_DEBUG                  LWIP_DBG_OFF
+#define SNTP_DEBUG                      LWIP_DBG_OFF
+#define IP6_DEBUG                       LWIP_DBG_OFF
+#define DHCP6_DEBUG                     LWIP_DBG_OFF
+#define DRV_STS_DEBUG                   LWIP_DBG_OFF
+#endif
+
+// Options only in new opt.h
+#define LWIP_SOCKET_SELECT              0
+#define LWIP_SOCKET_POLL                1
+
+// Options in old opt.h that differs from new opt.h
+#define MEM_ALIGNMENT                   __SIZEOF_POINTER__
+#define MEMP_NUM_NETDB                  8
+#define IP_REASS_MAXAGE                 3
+#define IP_SOF_BROADCAST                1
+#define IP_SOF_BROADCAST_RECV           1
+#define LWIP_MULTICAST_PING             1
+#define LWIP_RAW                        1
+#define LWIP_DHCP_AUTOIP_COOP_TRIES     64
+#define TCP_LISTEN_BACKLOG              1
+#define TCP_DEFAULT_LISTEN_BACKLOG      16
+
+#define LWIP_WND_SCALE                  1
+#define TCP_RCV_SCALE                   7
+
+#define LWIP_NETIF_HOSTNAME             1
+#define LWIP_NETIF_TX_SINGLE_PBUF       1
+#define LWIP_NETCONN_FULLDUPLEX         1 // Caution
+#define LWIP_COMPAT_SOCKETS             2
+#define LWIP_POSIX_SOCKETS_IO_NAMES     0
+#define LWIP_TCP_KEEPALIVE              1
+#define RECV_BUFSIZE_DEFAULT            65535
+#define SO_REUSE_RXTOALL                1
+
+#define LWIP_CHECKSUM_ON_COPY           1
+#define LWIP_IPV6                       1
+#define LWIP_IPV6_NUM_ADDRESSES         5
+#define LWIP_ND6_NUM_PREFIXES           10
+#define LWIP_IPV6_DHCP6                 1
+#define LWIP_IPV6_DHCP6_STATEFUL        1
+
+// Options in old lwipopts.h
+#define ARP_QUEUEING                    1
+#define DEFAULT_ACCEPTMBOX_SIZE         32
+#define DEFAULT_RAW_RECVMBOX_SIZE       128
+#define DEFAULT_TCP_RECVMBOX_SIZE       128
+#define DEFAULT_UDP_RECVMBOX_SIZE       128
+#define ETHARP_SUPPORT_STATIC_ENTRIES   1
+#define ETH_PAD_SIZE                    2
+#define IP_REASS_MAX_PBUFS              (((65535) / (IP_FRAG_MAX_MTU - 20 - 8) + 1) * MEMP_NUM_REASSDATA)
+#define LWIP_COMPAT_SOCKETS             2
+#define LWIP_DBG_MIN_LEVEL              LWIP_DBG_LEVEL_OFF
+#define LWIP_DHCP                       1
+#define LWIP_DNS                        1
+#define LWIP_ETHERNET                   1
+#define LWIP_HAVE_LOOPIF                1
+#define LWIP_IGMP                       1
+#define LWIP_NETIF_API                  1
+#define LWIP_NETIF_LINK_CALLBACK        1
+#define LWIP_NETIF_LOOPBACK             1
+#define LWIP_POSIX_SOCKETS_IO_NAMES     0
+#define LWIP_RAW                        1
+#define LWIP_SOCKET_OFFSET              FAT_MAX_OPEN_FILES
+#define LWIP_SO_RCVBUF                  1
+#define LWIP_SO_RCVTIMEO                1
+#define LWIP_SO_SNDTIMEO                1
+#define LWIP_STATS_DISPLAY              1
+#define MEM_LIBC_MALLOC                 1
+#define MEMP_NUM_ARP_QUEUE              (65535 * LWIP_CONFIG_NUM_SOCKETS / (IP_FRAG_MAX_MTU - 20 - 8))
+#define MEMP_NUM_NETBUF                 (65535 * 3 * LWIP_CONFIG_NUM_SOCKETS / (IP_FRAG_MAX_MTU - 20 - 8))
+#define MEMP_NUM_NETCONN                LWIP_CONFIG_NUM_SOCKETS
+#define MEMP_NUM_PBUF                   LWIP_CONFIG_NUM_SOCKETS*2
+#define MEMP_NUM_RAW_PCB                LWIP_CONFIG_NUM_SOCKETS
+#define MEMP_NUM_REASSDATA              (IP_REASS_MAX_MEM_SIZE / 65535)
+#define MEMP_NUM_TCPIP_MSG_API          64
+#define MEMP_NUM_TCPIP_MSG_INPKT        512
+#define MEMP_NUM_TCP_PCB                LWIP_CONFIG_NUM_SOCKETS
+#define MEMP_NUM_TCP_PCB_LISTEN         LWIP_CONFIG_NUM_SOCKETS
+#define MEMP_NUM_TCP_SEG                (((TCP_SND_BUF * 3 / 2) + TCP_WND) * LWIP_CONFIG_NUM_SOCKETS / TCP_MSS)
+#define MEMP_NUM_UDP_PCB                LWIP_CONFIG_NUM_SOCKETS
+#define MEM_SIZE                        (4*1024*1024) // (512*1024)
+#define PBUF_POOL_BUFSIZE               1550
+#define PBUF_POOL_SIZE                  64
+#define SO_REUSE                        1
+#define TCPIP_MBOX_SIZE                 512
+#define TCPIP_THREAD_PRIO               5
+#define TCPIP_THREAD_STACKSIZE          0x6000
+#define TCP_MAXRTX                      64
+#define TCP_MSS                         1400
+#define TCP_SND_BUF                     65535
+#define TCP_SND_QUEUELEN                (8 * TCP_SND_BUF) / TCP_MSS
+#define TCP_TTL                         255
+#define TCP_WND                         32768
+#define UDP_TTL                         255
+
+// Options in old lwipopts.h but kept in Defaults with new opt.h
+#define IP_FORWARD                      0
+#define LWIP_DBG_TYPES_ON               LWIP_DBG_ON
+#define LWIP_ICMP                       1
+#define LWIP_NETCONN                    1
+#define LWIP_SOCKET                     1
+#define LWIP_STATS                      1
+#define LWIP_TCP                        1
+#define LWIP_UDP                        1
+#define NO_SYS                          0
+#define TCP_QUEUE_OOSEQ                 LWIP_TCP
+
+// Change some options for lwIP 2.1.2
+#undef TCP_MAXRTX
+#define TCP_MAXRTX                      12
+
+#undef LWIP_COMPAT_SOCKETS
+#define LWIP_COMPAT_SOCKETS             0
+
+#define MEMP_NUM_SYS_TIMEOUT            (LWIP_NUM_SYS_TIMEOUT_INTERNAL + (LWIP_IPV6 * LWIP_IPV6_DHCP6))
+
+#undef DEFAULT_ACCEPTMBOX_SIZE
+#define DEFAULT_ACCEPTMBOX_SIZE         LWIP_CONFIG_NUM_SOCKETS
+
+#undef TCP_MSS
+#define TCP_MSS                         (IP_FRAG_MAX_MTU - 20 - 20)
+
+#undef IP_SOF_BROADCAST_RECV
+#define IP_SOF_BROADCAST_RECV           0
+
+/**
+ * Defines whether to enable debugging for driver module.
+ */
+#ifndef DRIVERIF_DEBUG
+#define DRIVERIF_DEBUG                  LWIP_DBG_OFF
+#endif
+
+// Options for old lwipopts.h
+#define IP_FRAG_MAX_MTU                 1500
+#define LWIP_CONFIG_NUM_SOCKETS         128
+#define IP_REASS_MAX_MEM_SIZE           (MEM_SIZE / 4)
+
+// Options for enhancement code, same for old lwipopts.h
+#define LWIP_NETIF_PROMISC              1
+#define LWIP_TFTP                       LOSCFG_NET_LWIP_SACK_TFTP
+#define LWIP_DHCPS                      1
+#define LWIP_ENABLE_NET_CAPABILITY      1
+#define LWIP_ENABLE_CAP_NET_BROADCAST   0
+
+// Options for GT
+#undef LWIP_NETIF_PROMISC
+#define LWIP_NETIF_PROMISC              0
+
+#undef LWIP_ICMP
+#define LWIP_ICMP                       0
+
+#undef LWIP_DHCP
+#define LWIP_DHCP                       0
+
+#undef LWIP_IGMP
+#define LWIP_IGMP                       0
+
+#undef LWIP_IPV6
+#define LWIP_IPV6                       0
+
+#undef LWIP_IPV6_DHCP6
+#define LWIP_IPV6_DHCP6                 0
+
+#undef TCP_SND_BUF
+#define TCP_SND_BUF                     (65535 / 3)
+
+#undef TCP_WND
+#define TCP_WND                         ((TCP_SND_BUF * 2) / 3)
+
+#undef TCP_SND_QUEUELEN
+#define TCP_SND_QUEUELEN                (2 * (TCP_SND_BUF / TCP_MSS))
+
+#undef MEMP_NUM_NETDB
+#define MEMP_NUM_NETDB                  1
+
+#undef MEMP_NUM_ARP_QUEUE
+#define MEMP_NUM_ARP_QUEUE              4
+
+#undef MEMP_NUM_NETBUF
+#define MEMP_NUM_NETBUF                 12
+
+#undef MEMP_NUM_NETCONN
+#define MEMP_NUM_NETCONN                32
+
+#undef MEMP_NUM_PBUF
+#define MEMP_NUM_PBUF                   0
+
+#undef PBUF_POOL_SIZE
+#define PBUF_POOL_SIZE                  0
+
+#undef MEMP_NUM_RAW_PCB
+#define MEMP_NUM_RAW_PCB                8
+
+#undef MEMP_NUM_REASSDATA
+#define MEMP_NUM_REASSDATA              12
+
+#undef MEMP_NUM_TCPIP_MSG_API
+#define MEMP_NUM_TCPIP_MSG_API          32
+
+#undef MEMP_NUM_TCPIP_MSG_INPKT
+#define MEMP_NUM_TCPIP_MSG_INPKT        32
+
+#undef MEMP_NUM_TCP_PCB
+#define MEMP_NUM_TCP_PCB                8
+
+#undef MEMP_NUM_TCP_PCB_LISTEN
+#define MEMP_NUM_TCP_PCB_LISTEN         4
+
+#undef MEMP_NUM_TCP_SEG
+#define MEMP_NUM_TCP_SEG                64
+
+#undef MEMP_NUM_UDP_PCB
+#define MEMP_NUM_UDP_PCB                4
+
+#undef TCPIP_THREAD_STACKSIZE
+#define TCPIP_THREAD_STACKSIZE          0x1000
+
+#undef LWIP_SOCKET_SELECT
+#define LWIP_SOCKET_SELECT              1
+
+// use PBUF_RAM instead of PBUF_POOL in udp_input
+#define USE_PBUF_RAM_UDP_INPUT          1
+
+#endif /* _LWIP_PORTING_LWIPOPTS_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/lwip/netdb.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_NETDB_H_
+#define _LWIP_PORTING_NETDB_H_
+
+#include <netdb.h>
+#include_next <lwip/netdb.h>
+
+#endif /* _LWIP_PORTING_NETDB_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/lwip/netif.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_NETIF_H_
+#define _LWIP_PORTING_NETIF_H_
+
+#include <net/if.h>
+#include <netinet/ip.h>
+
+#define netif_find netifapi_netif_find_by_name
+
+#if LWIP_DHCPS
+#define LWIP_NETIF_CLIENT_DATA_INDEX_DHCP   LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, \
+                                            LWIP_NETIF_CLIENT_DATA_INDEX_DHCPS
+#endif
+
+#define linkoutput      linkoutput; \
+                        void (*drv_send)(struct netif *netif, struct pbuf *p); \
+                        u8_t (*drv_set_hwaddr)(struct netif *netif, u8_t *addr, u8_t len); \
+                        void (*drv_config)(struct netif *netif, u32_t config_flags, u8_t setBit); \
+                        char full_name[IFNAMSIZ]; \
+                        u16_t link_layer_type
+#include_next <lwip/netif.h>
+#undef linkoutput
+#if LWIP_DHCPS
+#undef LWIP_NETIF_CLIENT_DATA_INDEX_DHCP
+#endif
+
+#include <lwip/etharp.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// redefine NETIF_NAMESIZE which was defined in netif.h
+#undef NETIF_NAMESIZE
+#define NETIF_NAMESIZE IFNAMSIZ
+
+#define LOOPBACK_IF         0
+#define ETHERNET_DRIVER_IF  1
+#define WIFI_DRIVER_IF      801
+#define BT_PROXY_IF         802
+
+err_t driverif_init(struct netif *netif);
+void driverif_input(struct netif *netif, struct pbuf *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LWIP_PORTING_NETIF_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/lwip/netifapi.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_NETIFAPI_H_
+#define _LWIP_PORTING_NETIFAPI_H_
+
+#include_next <lwip/netifapi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+err_t netifapi_dhcps_start(struct netif *netif, char *start_ip, u16_t ip_num);
+err_t netifapi_dhcps_stop(struct netif *netif);
+
+#define netifapi_dhcp_cleanup(n)          netifapi_netif_common(n, dhcp_cleanup, NULL)
+#define netifapi_dhcp_is_bound(n)         netifapi_netif_common(n, NULL, dhcp_is_bound)
+
+void netifapi_netif_rmv_ip6_address(struct netif *netif, ip_addr_t *ipaddr);
+struct netif *netifapi_netif_find_by_name(const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LWIP_PORTING_NETIFAPI_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/lwip/sockets.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_SOCKETS_H_
+#define _LWIP_PORTING_SOCKETS_H_
+
+#include <sys/socket.h>
+#include <poll.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <limits.h>
+#include <fcntl.h>
+#include_next <lwip/sockets.h>
+#include <fatfs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if FD_SETSIZE < (LWIP_SOCKET_OFFSET + MEMP_NUM_NETCONN)
+#error "external FD_SETSIZE too small for number of sockets"
+#else
+#define LWIP_SELECT_MAXNFDS FD_SETSIZE
+#endif
+
+#if IOV_MAX > 0xFFFF
+#error "IOV_MAX larger than supported by LwIP"
+#endif
+
+#if LWIP_UDP && LWIP_UDPLITE
+#define UDPLITE_SEND_CSCOV 0x01 /* sender checksum coverage */
+#define UDPLITE_RECV_CSCOV 0x02 /* minimal receiver checksum coverage */
+#endif
+
+// For BSD 4.4 socket sa_len compatibility
+#define DF_NADDR(addr)
+#define SA_LEN(addr, _)  (IP_IS_V4_VAL(addr) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6))
+#define sa_len sa_data[0] * 0 + SA_LEN(naddr, _)
+#define sin_len sin_zero[0]
+#define sin6_len sin6_addr.s6_addr[0]
+
+// for sockets.c, TCP_KEEPALIVE is not supported currently
+#define TCP_KEEPALIVE   0xFF
+#define SIN_ZERO_LEN    8
+
+int closesocket(int sockfd);
+int ioctlsocket(int s, long cmd, void *argp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LWIP_PORTING_SOCKETS_H_ */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/include/lwipopts.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __LITEOS_M_LWIPOPTS_H__
+#define __LITEOS_M_LWIPOPTS_H__
+
+// Just redirect
+#include "lwip/lwipopts.h"
+
+#endif // __LITEOS_M_LWIPOPTS_H__

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/src/driverif.c

@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <lwip/sys.h>
+#include <lwip/netif.h>
+#include <lwip/snmp.h>
+#include <lwip/etharp.h>
+#include <lwip/sockets.h>
+#include <lwip/snmp.h>
+#include <lwip/etharp.h>
+#include <lwip/ethip6.h>
+
+#define LWIP_NETIF_HOSTNAME_DEFAULT         "default"
+#define LINK_SPEED_OF_YOUR_NETIF_IN_BPS     100000000 // 100Mbps
+
+#define link_rx_drop cachehit
+#define link_rx_overrun cachehit
+
+#define LWIP_STATIC static
+
+#define NETIF_NAME_PREFIX_MAX_LENGTH 10
+#define NETIF_NAME_PREFIX_ETH "eth"
+#define NETIF_NAME_PREFIX_WIFI "wlan"
+#define NETIF_NAME_PREFIX_BT "bt"
+
+#ifndef LWIP_NETIF_IFINDEX_MAX_EX
+#define LWIP_NETIF_IFINDEX_MAX_EX 255
+#endif
+
+LWIP_STATIC void driverif_get_ifname_prefix(struct netif *netif, char *prefix, int prefixLen)
+{
+    if (prefix == NULL || netif == NULL) {
+        LWIP_ASSERT("invalid param", 0);
+        return;
+    }
+    switch (netif->link_layer_type) {
+        case ETHERNET_DRIVER_IF:
+            strcpy_s(prefix, prefixLen, NETIF_NAME_PREFIX_ETH);
+            break;
+        case WIFI_DRIVER_IF:
+            strcpy_s(prefix, prefixLen, NETIF_NAME_PREFIX_WIFI);
+            break;
+        case BT_PROXY_IF:
+            strcpy_s(prefix, prefixLen, NETIF_NAME_PREFIX_BT);
+            break;
+        default:
+            LWIP_ASSERT("invalid link_layer_type", 0);
+            break;
+    }
+}
+
+LWIP_STATIC void driverif_init_ifname(struct netif *netif)
+{
+    struct netif *tmpnetif = NULL;
+    char prefix[NETIF_NAME_PREFIX_MAX_LENGTH] = {0};
+
+    driverif_get_ifname_prefix(netif, prefix, NETIF_NAME_PREFIX_MAX_LENGTH);
+    netif->name[0] = prefix[0];
+    netif->name[1] = prefix[1];
+
+    if (netif->full_name[0] != '\0') {
+        LWIP_DEBUGF(DRIVERIF_DEBUG, ("netif already has fullname %s\n", netif->full_name));
+        return;
+    }
+    for (int i = 0; i < LWIP_NETIF_IFINDEX_MAX_EX; ++i) {
+        if (snprintf_s(netif->full_name, sizeof(netif->full_name), sizeof(netif->full_name) - 1,
+            "%s%d", prefix, i) < 0) {
+            break;
+        }
+        NETIF_FOREACH(tmpnetif) {
+            if (strcmp(tmpnetif->full_name, netif->full_name) == 0) {
+                break;
+            }
+        }
+        if (tmpnetif == NULL) {
+            LWIP_DEBUGF(DRIVERIF_DEBUG, ("set fullname success %s\n", netif->full_name));
+            return;
+        }
+    }
+    netif->full_name[0] = '\0';
+}
+
+/*
+ * This function should do the actual transmission of the packet. The packet is
+ * contained in the pbuf that is passed to the function. This pbuf
+ * might be chained.
+ *
+ * @param netif the lwip network interface structure for this driverif
+ * @param p the MAC packet to send (e.g. IP packet including MAC_addresses and type)
+ * @return ERR_OK if the packet could be sent
+ *         an err_t value if the packet couldn't be sent
+ *
+ * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
+ *       strange results. You might consider waiting for space in the DMA queue
+ *       to become availale since the stack doesn't retry to send a packet
+ *       dropped because of memory failure (except for the TCP timers).
+ */
+
+LWIP_STATIC err_t driverif_output(struct netif *netif, struct pbuf *p)
+{
+    LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_output : send packet pbuf 0x%p of length %"U16_F" through netif 0x%p\n", \
+        (void *)p, p->tot_len, (void *)netif));
+
+#if PF_PKT_SUPPORT
+    if (all_pkt_raw_pcbs != NULL) {
+        p->flags = (u16_t)(p->flags & ~(PBUF_FLAG_LLMCAST | PBUF_FLAG_LLBCAST | PBUF_FLAG_HOST));
+        p->flags |= PBUF_FLAG_OUTGOING;
+        (void)raw_pkt_input(p, netif, NULL);
+    }
+#endif
+
+#if ETH_PAD_SIZE
+    (void)pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
+#endif
+
+    netif->drv_send(netif, p);
+
+#if ETH_PAD_SIZE
+    (void)pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
+#endif
+    MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len);
+    LINK_STATS_INC(link.xmit);
+
+    return ERR_OK;
+}
+
+void driverif_input_proc(struct netif *netif, struct pbuf *p)
+{
+    u16_t ethhdr_type;
+    struct eth_hdr *ethhdr = NULL;
+    err_t ret = ERR_VAL;
+
+    ethhdr = (struct eth_hdr *)p->payload;
+    ethhdr_type = ntohs(ethhdr->type);
+
+    switch (ethhdr_type) {
+        /* IP or ARP packet? */
+        case ETHTYPE_IP:
+        case ETHTYPE_IPV6:
+        case ETHTYPE_ARP:
+#if ETHARP_SUPPORT_VLAN
+        case ETHTYPE_VLAN:
+#endif /* ETHARP_SUPPORT_VLAN */
+            LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_input : received packet of type %"U16_F"\n", ethhdr_type));
+            /* full packet send to tcpip_thread to process */
+            if (netif->input != NULL) {
+                ret = netif->input(p, netif);
+            }
+
+            if (ret != ERR_OK) {
+                LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_input: IP input error\n"));
+                (void)pbuf_free(p);
+                LINK_STATS_INC(link.drop);
+                LINK_STATS_INC(link.link_rx_drop);
+                if (ret == ERR_MEM) {
+                    MIB2_STATS_NETIF_INC(netif, ifinoverruns);
+                    LINK_STATS_INC(link.link_rx_overrun);
+                }
+            } else {
+                LINK_STATS_INC(link.recv);
+            }
+            break;
+
+        default:
+            LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_input : received packet is of unsupported type %"U16_F"\n", \
+                ethhdr_type));
+            (void)pbuf_free(p);
+            LINK_STATS_INC(link.drop);
+            LINK_STATS_INC(link.link_rx_drop);
+            break;
+    }
+}
+
+/*
+ * This function should be called by network driver to pass the input packet to LwIP.
+ * Before calling this API, driver has to keep the packet in pbuf structure. Driver has to
+ * call pbuf_alloc() with type as PBUF_RAM to create pbuf structure. Then driver
+ * has to pass the pbuf structure to this API. This will add the pbuf into the TCPIP thread.
+ * Once this packet is processed by TCPIP thread, pbuf will be freed. Driver is not required to
+ * free the pbuf.
+ *
+ * @param netif the lwip network interface structure for this driverif
+ * @param p packet in pbuf structure format
+ */
+void driverif_input(struct netif *netif, struct pbuf *p)
+{
+#if PF_PKT_SUPPORT
+#if  (DRIVERIF_DEBUG & LWIP_DBG_OFF)
+    u16_t ethhdr_type;
+    struct eth_hdr* ethhdr = NULL;
+#endif
+    err_t ret = ERR_VAL;
+#endif
+
+    LWIP_ERROR("driverif_input : invalid arguments", ((netif != NULL) && (p != NULL)), return);
+
+    LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_input : going to receive input packet. netif 0x%p, pbuf 0x%p, \
+        packet_length %"U16_F"\n", (void *)netif, (void *)p, p->tot_len));
+
+    /* points to packet payload, which starts with an Ethernet header */
+    MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len);
+    if (p->len < SIZEOF_ETH_HDR) {
+        (void)pbuf_free(p);
+        LINK_STATS_INC(link.drop);
+        LINK_STATS_INC(link.link_rx_drop);
+        return;
+    }
+
+#if PF_PKT_SUPPORT
+#if  (DRIVERIF_DEBUG & LWIP_DBG_OFF)
+    ethhdr = (struct eth_hdr *)p->payload;
+    ethhdr_type = ntohs(ethhdr->type);
+    LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_input : received packet of type %"U16_F" netif->input=%p\n", \
+        ethhdr_type, netif->input));
+#endif
+
+    /* full packet send to tcpip_thread to process */
+    if (netif->input) {
+        ret = netif->input(p, netif);
+    }
+    if (ret != ERR_OK) {
+        LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_input: IP input error\n"));
+        (void)pbuf_free(p);
+        LINK_STATS_INC(link.drop);
+        LINK_STATS_INC(link.link_rx_drop);
+        if (ret == ERR_MEM) {
+            LINK_STATS_INC(link.link_rx_overrun);
+        }
+    } else {
+        LINK_STATS_INC(link.recv);
+    }
+
+#else
+    driverif_input_proc(netif, p);
+#endif
+
+    LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_input : received packet is processed\n"));
+}
+
+/*
+ * Should be called at the beginning of the program to set up the
+ * network interface. It calls the function low_level_init() to do the
+ * actual setup of the hardware.
+ *
+ * This function should be passed as a parameter to netif_add().
+ *
+ * @param netif the lwip network interface structure for this driverif
+ * @return ERR_OK if the loopif is initialized
+ *         ERR_MEM on Allocation Failure
+ *         any other err_t on error
+ */
+err_t driverif_init(struct netif *netif)
+{
+    u16_t link_layer_type;
+
+    if (netif == NULL) {
+        return ERR_IF;
+    }
+    link_layer_type = netif->link_layer_type;
+    LWIP_ERROR("driverif_init : invalid link_layer_type in netif", \
+        ((link_layer_type == ETHERNET_DRIVER_IF) \
+        || (link_layer_type == WIFI_DRIVER_IF \
+        || link_layer_type == BT_PROXY_IF)), \
+            return ERR_IF);
+
+    LWIP_ERROR("driverif_init : netif hardware length is greater than maximum supported", \
+    (netif->hwaddr_len <= NETIF_MAX_HWADDR_LEN), return ERR_IF);
+
+    LWIP_ERROR("driverif_init : drv_send is null", (netif->drv_send != NULL), return ERR_IF);
+
+#if LWIP_NETIF_PROMISC
+    LWIP_ERROR("driverif_init : drv_config is null", (netif->drv_config != NULL), return ERR_IF);
+#endif
+
+#if LWIP_NETIF_HOSTNAME
+    /* Initialize interface hostname */
+    netif->hostname = LWIP_NETIF_HOSTNAME_DEFAULT;
+#endif /* LWIP_NETIF_HOSTNAME */
+
+    /*
+     * Initialize the snmp variables and counters inside the struct netif.
+     * The last argument should be replaced with your link speed, in units
+     * of bits per second.
+     */
+    NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
+
+    netif->output = etharp_output;
+    netif->linkoutput = driverif_output;
+
+    /* init the netif's full name */
+    driverif_init_ifname(netif);
+
+    /* maximum transfer unit */
+    netif->mtu = IP_FRAG_MAX_MTU;
+
+    /* device capabilities */
+    /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
+    netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP |
+#if DRIVER_STATUS_CHECK
+        NETIF_FLAG_DRIVER_RDY |
+#endif
+#if LWIP_IGMP
+        NETIF_FLAG_IGMP |
+#endif
+
+        /**
+        @page RFC-2710 RFC-2710
+        @par Compliant Sections
+        Section 5. Node State Transition Diagram
+        @par Behavior Description
+        MLD messages are sent for multicast addresses whose scope is 2
+        (link-local), including Solicited-Node multicast addresses.\n
+        Behavior:Stack will send MLD6 report /Done to solicited node multicast address
+        if the LWIP_MLD6_ENABLE_MLD_ON_DAD is enabled. By default, this is disabled.
+        */
+        /* Enable sending MLD report /done for solicited address during neighbour discovery */
+#if LWIP_IPV6 && LWIP_IPV6_MLD
+#if LWIP_MLD6_ENABLE_MLD_ON_DAD
+        NETIF_FLAG_MLD6 |
+#endif /* LWIP_MLD6_ENABLE_MLD_ON_DAD */
+#endif
+        NETIF_FLAG_LINK_UP;
+
+#if DRIVER_STATUS_CHECK
+    netif->waketime = -1;
+#endif /* DRIVER_STATUS_CHECK */
+    LWIP_DEBUGF(DRIVERIF_DEBUG, ("driverif_init : Initialized netif 0x%p\n", (void *)netif));
+    return ERR_OK;
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/src/lwip_init.c

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "lwip/tcpip.h"
+#include "ohos_init.h"
+void TcpIpPortingInit()
+{
+    tcpip_init(NULL, NULL);
+}
+SYSEX_SERVICE_INIT(TcpIpPortingInit);

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/src/netdb_porting.c

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip/netdb.h"
+
+#if LWIP_DNS && LWIP_SOCKET
+
+struct hostent *gethostbyname(const char *name)
+{
+    if (name == NULL) {
+        return NULL;
+    }
+    return lwip_gethostbyname(name);
+}
+
+int gethostbyname_r(const char *name, struct hostent *ret, char *buf, size_t buflen, struct hostent **result,
+    int *h_errnop)
+{
+    return lwip_gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
+}
+
+void freeaddrinfo(struct addrinfo *res)
+{
+    lwip_freeaddrinfo(res);
+}
+
+int getaddrinfo(const char *restrict nodename, const char *restrict servname, const struct addrinfo *restrict hints,
+    struct addrinfo **restrict res)
+{
+    return lwip_getaddrinfo(nodename, servname, hints, res);
+}
+
+#endif

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/src/sockets_porting.c

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip/priv/sockets_priv.h"
+#include <lwip/sockets.h>
+
+#if !LWIP_COMPAT_SOCKETS
+#if LWIP_SOCKET
+
+#define CHECK_NULL_PTR(ptr) do { if ((ptr) == NULL) { set_errno(EFAULT); return -1; } } while (0)
+
+int accept(int s, struct sockaddr *addr, socklen_t *addrlen)
+{
+    return lwip_accept(s, addr, addrlen);
+}
+
+int bind(int s, const struct sockaddr *name, socklen_t namelen)
+{
+    CHECK_NULL_PTR(name);
+    if (namelen < sizeof(*name)) {
+        set_errno(EINVAL);
+        return -1;
+    }
+    return lwip_bind(s, name, namelen);
+}
+
+int shutdown(int s, int how)
+{
+    return lwip_shutdown(s, how);
+}
+
+int getpeername(int s, struct sockaddr *name, socklen_t *namelen)
+{
+    CHECK_NULL_PTR(name);
+    CHECK_NULL_PTR(namelen);
+    return lwip_getpeername(s, name, namelen);
+}
+
+int getsockname(int s, struct sockaddr *name, socklen_t *namelen)
+{
+    CHECK_NULL_PTR(name);
+    CHECK_NULL_PTR(namelen);
+    return lwip_getsockname(s, name, namelen);
+}
+
+int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
+{
+    return lwip_getsockopt(s, level, optname, optval, optlen);
+}
+
+int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
+{
+    return lwip_setsockopt(s, level, optname, optval, optlen);
+}
+
+int closesocket(int s)
+{
+    return lwip_close(s);
+}
+
+int connect(int s, const struct sockaddr *name, socklen_t namelen)
+{
+    CHECK_NULL_PTR(name);
+    if (namelen < sizeof(*name)) {
+        set_errno(EINVAL);
+        return -1;
+    }
+    return lwip_connect(s, name, namelen);
+}
+
+int listen(int s, int backlog)
+{
+    return lwip_listen(s, backlog);
+}
+
+ssize_t recv(int s, void *mem, size_t len, int flags)
+{
+    CHECK_NULL_PTR(mem);
+    return lwip_recv(s, mem, len, flags);
+}
+
+ssize_t recvfrom(int s, void *mem, size_t len, int flags,
+                 struct sockaddr *from, socklen_t *fromlen)
+{
+    CHECK_NULL_PTR(mem);
+    return lwip_recvfrom(s, mem, len, flags, from, fromlen);
+}
+
+ssize_t recvmsg(int s, struct msghdr *message, int flags)
+{
+    CHECK_NULL_PTR(message);
+    if (message->msg_iovlen) {
+        CHECK_NULL_PTR(message->msg_iov);
+    }
+    return lwip_recvmsg(s, message, flags);
+}
+
+ssize_t send(int s, const void *dataptr, size_t size, int flags)
+{
+    CHECK_NULL_PTR(dataptr);
+    return  lwip_send(s, dataptr, size, flags);
+}
+
+ssize_t sendmsg(int s, const struct msghdr *message, int flags)
+{
+    return lwip_sendmsg(s, message, flags);
+}
+
+ssize_t sendto(int s, const void *dataptr, size_t size, int flags,
+               const struct sockaddr *to, socklen_t tolen)
+{
+    CHECK_NULL_PTR(dataptr);
+    if (to && tolen < sizeof(*to)) {
+        set_errno(EINVAL);
+        return -1;
+    }
+    return lwip_sendto(s, dataptr, size, flags, to, tolen);
+}
+
+int socket(int domain, int type, int protocol)
+{
+    return lwip_socket(domain, type, protocol);
+}
+
+const char *inet_ntop(int af, const void *src, char *dst, socklen_t size)
+{
+    return lwip_inet_ntop(af, src, dst, size);
+}
+
+int inet_pton(int af, const char *src, void *dst)
+{
+    return lwip_inet_pton(af, src, dst);
+}
+
+int ioctlsocket(int s, long cmd, void *argp)
+{
+    return lwip_ioctl(s, cmd, argp);
+}
+
+#if LWIP_SOCKET_SELECT
+int select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, struct timeval *timeout)
+{
+    return lwip_select(maxfdp1, readset, writeset, exceptset, timeout);
+}
+#endif
+
+#if LWIP_SOCKET_POLL
+int poll(struct pollfd *fds, nfds_t nfds, int timeout)
+{
+    return lwip_poll(fds, nfds, timeout);
+}
+#endif
+
+unsigned int if_nametoindex(const char *ifname)
+{
+    return lwip_if_nametoindex(ifname);
+}
+
+#endif
+#endif /* !LWIP_COMPAT_SOCKETS */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/lwip-2.1/porting/src/sys_arch.c

@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+#include <lwip/debug.h>
+#include <los_task.h>
+#include <los_tick.h>
+#include <los_queue.h>
+#include <los_sem.h>
+#include <los_mux.h>
+#include "cmsis_os2.h"
+#include <los_tick.h>
+#include <los_config.h>
+
+#ifndef LOSCFG_KERNEL_SMP
+#define LOSCFG_KERNEL_SMP 0
+#endif
+
+#if (LOSCFG_KERNEL_SMP)
+SPIN_LOCK_INIT(arch_protect_spin);
+static u32_t lwprot_thread = LOS_ERRNO_TSK_ID_INVALID;
+static int lwprot_count = 0;
+#endif /* LOSCFG_KERNEL_SMP */
+
+#define ROUND_UP_DIV(val, div) (((val) + (div) - 1) / (div))
+#define LWIP_LOG_BUF_SIZE 64
+
+/**
+ * Thread and System misc
+ */
+sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stackSize, int prio)
+{
+    UINT32 taskID = LOS_ERRNO_TSK_ID_INVALID;
+    UINT32 ret;
+    TSK_INIT_PARAM_S task = {0};
+
+    /* Create host Task */
+    task.pfnTaskEntry = (TSK_ENTRY_FUNC)thread;
+    task.uwStackSize = stackSize;
+    task.pcName = (char *)name;
+    task.usTaskPrio = prio;
+    task.uwArg = (UINTPTR)arg;
+    task.uwResved = LOS_TASK_STATUS_DETACHED;
+    ret = LOS_TaskCreate(&taskID, &task);
+    if (ret != LOS_OK) {
+        LWIP_DEBUGF(SYS_DEBUG, ("sys_thread_new: LOS_TaskCreate error %u\n", ret));
+        return -1;
+    }
+
+    return taskID;
+}
+
+void sys_init(void)
+{
+    /* set rand seed to make random sequence diff on every startup */
+    UINT32 seedlsb = (UINT32)LOS_SysCycleGet();
+    srand(seedlsb);
+}
+
+u32_t sys_now(void)
+{
+    /* Lwip docs mentioned like wraparound is not a problem in this funtion */
+    return (u32_t)osKernelGetTickCount();
+}
+
+/**
+ * Protector
+ */
+sys_prot_t sys_arch_protect(void)
+{
+#if (LOSCFG_KERNEL_SMP)
+    /* Note that we are using spinlock instead of mutex for LiteOS-SMP here:
+     * 1. spinlock is more effective for short critical region protection.
+     * 2. this function is called only in task context, not in interrupt handler.
+     *    so it's not needed to disable interrupt.
+     */
+    if (lwprot_thread != LOS_CurTaskIDGet()) {
+        /* We are locking the spinlock where it has not been locked before
+         * or is being locked by another thread */
+        LOS_SpinLock(&arch_protect_spin);
+        lwprot_thread = LOS_CurTaskIDGet();
+        lwprot_count = 1;
+    } else {
+        /* It is already locked by THIS thread */
+        lwprot_count++;
+    }
+#else
+    LOS_TaskLock();
+#endif /* LOSCFG_KERNEL_SMP */
+    return 0; /* return value is unused */
+}
+
+void sys_arch_unprotect(sys_prot_t pval)
+{
+    LWIP_UNUSED_ARG(pval);
+#if (LOSCFG_KERNEL_SMP)
+    if (lwprot_thread == LOS_CurTaskIDGet()) {
+        lwprot_count--;
+        if (lwprot_count == 0) {
+            lwprot_thread = LOS_ERRNO_TSK_ID_INVALID;
+            LOS_SpinUnlock(&arch_protect_spin);
+        }
+    }
+#else
+    LOS_TaskUnlock();
+#endif /* LOSCFG_KERNEL_SMP */
+}
+
+/**
+ * MessageBox
+ */
+err_t sys_mbox_new(sys_mbox_t *mbox, int size)
+{
+    CHAR qName[] = "lwIP";
+    UINT32 ret = LOS_QueueCreate(qName, (UINT16)size, mbox, 0, sizeof(void *));
+    switch (ret) {
+        case LOS_OK:
+            return ERR_OK;
+        case LOS_ERRNO_QUEUE_CB_UNAVAILABLE:
+        case LOS_ERRNO_QUEUE_CREATE_NO_MEMORY:
+            return ERR_MEM;
+        default:
+            break;
+    }
+    LWIP_DEBUGF(SYS_DEBUG, ("%s: LOS_QueueCreate error %u\n", __FUNCTION__, ret));
+    return ERR_ARG;
+}
+
+void sys_mbox_post(sys_mbox_t *mbox, void *msg)
+{
+    /* Caution: the second parameter is NOT &msg */
+    UINT32 ret = LOS_QueueWrite(*mbox, msg, sizeof(char *), LOS_WAIT_FOREVER);
+    if (ret != LOS_OK) {
+        LWIP_DEBUGF(SYS_DEBUG, ("%s: LOS_QueueWrite error %u\n", __FUNCTION__, ret));
+    }
+}
+
+err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
+{
+    /* Caution: the second parameter is NOT &msg */
+    UINT32 ret = LOS_QueueWrite(*mbox, msg, sizeof(char *), 0);
+    switch (ret) {
+        case LOS_OK:
+            return ERR_OK;
+        case LOS_ERRNO_QUEUE_ISFULL:
+            return ERR_MEM;
+        default:
+            break;
+    }
+    LWIP_DEBUGF(SYS_DEBUG, ("%s: LOS_QueueWrite error %u\n", __FUNCTION__, ret));
+    return ERR_ARG;
+}
+
+err_t sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg)
+{
+    return ERR_ARG;
+}
+
+u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeoutMs)
+{
+    void *ignore = 0; /* if msg==NULL, the fetched msg should be dropped */
+    UINT64 tick = ROUND_UP_DIV((UINT64)timeoutMs * LOSCFG_BASE_CORE_TICK_PER_SECOND, OS_SYS_MS_PER_SECOND);
+    UINT32 ret = LOS_QueueRead(*mbox, msg ? msg : &ignore, sizeof(void *), tick ? (UINT32)tick : LOS_WAIT_FOREVER);
+    switch (ret) {
+        case LOS_OK:
+            return ERR_OK;
+        case LOS_ERRNO_QUEUE_ISEMPTY:
+        case LOS_ERRNO_QUEUE_TIMEOUT:
+            return SYS_ARCH_TIMEOUT;
+        default:
+            break;
+    }
+    LWIP_DEBUGF(SYS_DEBUG, ("%s: LOS_QueueRead error %u\n", __FUNCTION__, ret));
+    return SYS_ARCH_TIMEOUT; /* Errors should be treated as timeout */
+}
+
+u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
+{
+    void *ignore = 0; /* if msg==NULL, the fetched msg should be dropped */
+    UINT32 ret = LOS_QueueRead(*mbox, msg ? msg : &ignore, sizeof(void *), 0);
+    switch (ret) {
+        case LOS_OK:
+            return ERR_OK;
+        case LOS_ERRNO_QUEUE_ISEMPTY:
+            return SYS_MBOX_EMPTY;
+        case LOS_ERRNO_QUEUE_TIMEOUT:
+            return SYS_ARCH_TIMEOUT;
+        default:
+            break;
+    }
+    LWIP_DEBUGF(SYS_DEBUG, ("%s: LOS_QueueRead error %u\n", __FUNCTION__, ret));
+    return SYS_MBOX_EMPTY; /* Errors should be treated as timeout */
+}
+
+void sys_mbox_free(sys_mbox_t *mbox)
+{
+    (void)LOS_QueueDelete(*mbox);
+}
+
+int sys_mbox_valid(sys_mbox_t *mbox)
+{
+    QUEUE_INFO_S queueInfo;
+    return LOS_OK == LOS_QueueInfoGet(*mbox, &queueInfo);
+}
+
+void sys_mbox_set_invalid(sys_mbox_t *mbox)
+{
+    *mbox = LOSCFG_BASE_IPC_QUEUE_LIMIT;
+}
+
+/**
+ * Semaphore
+ */
+err_t sys_sem_new(sys_sem_t *sem, u8_t count)
+{
+    UINT32 ret = LOS_SemCreate(count, sem);
+    if (ret != LOS_OK) {
+        return ERR_ARG;
+    }
+
+    return ERR_OK;
+}
+
+void sys_sem_signal(sys_sem_t *sem)
+{
+    (void)LOS_SemPost(*sem);
+}
+
+u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeoutMs)
+{
+    UINT64 tick = ROUND_UP_DIV((UINT64)timeoutMs * LOSCFG_BASE_CORE_TICK_PER_SECOND, OS_SYS_MS_PER_SECOND);
+    UINT32 ret = LOS_SemPend(*sem, tick ? (UINT32)tick : LOS_WAIT_FOREVER); // timeoutMs 0 means wait forever
+    switch (ret) {
+        case LOS_OK:
+            return ERR_OK;
+        case LOS_ERRNO_SEM_TIMEOUT:
+            return SYS_ARCH_TIMEOUT;
+        default:
+            break;
+    }
+    LWIP_DEBUGF(SYS_DEBUG, ("%s: LOS_SemPend error %u\n", __FUNCTION__, ret));
+    return SYS_ARCH_TIMEOUT; /* Errors should be treated as timeout */
+}
+
+void sys_sem_free(sys_sem_t *sem)
+{
+    (void)LOS_SemDelete(*sem);
+}
+
+int sys_sem_valid(sys_sem_t *sem)
+{
+    return *sem != LOSCFG_BASE_IPC_SEM_LIMIT;
+}
+
+void sys_sem_set_invalid(sys_sem_t *sem)
+{
+    *sem = LOSCFG_BASE_IPC_SEM_LIMIT;
+}
+
+/**
+ * Mutex
+ */
+err_t sys_mutex_new(sys_mutex_t *mutex)
+{
+    UINT32 ret = LOS_MuxCreate(mutex);
+    if (ret != LOS_OK) {
+        return ERR_ARG;
+    }
+
+    return ERR_OK;
+}
+
+void sys_mutex_lock(sys_mutex_t *mutex)
+{
+    (void)LOS_MuxPend(*mutex, LOS_WAIT_FOREVER);
+}
+
+void sys_mutex_unlock(sys_mutex_t *mutex)
+{
+    (void)LOS_MuxPost(*mutex);
+}
+
+void sys_mutex_free(sys_mutex_t *mutex)
+{
+    (void)LOS_MuxDelete(*mutex);
+}
+
+int sys_mutex_valid(sys_mutex_t *mutex)
+{
+    return *mutex != LOSCFG_BASE_IPC_MUX_LIMIT;
+}
+
+void sys_mutex_set_invalid(sys_mutex_t *mutex)
+{
+    *mutex = LOSCFG_BASE_IPC_MUX_LIMIT;
+}
+
+void HilogPrintf(const char *fmt, ...)
+{
+    if ((fmt == NULL) || (strlen(fmt) == 0)) {
+        return;
+    }
+
+    int len;
+    char buf[LWIP_LOG_BUF_SIZE] = {0};
+    va_list ap;
+    va_start(ap, fmt);
+    len = vsprintf_s(buf, sizeof(buf) - 1, fmt, ap);
+    va_end(ap);
+    if (len < 0) {
+        HILOG_INFO(HILOG_MODULE_APP, "log param invalid or buf is not enough.");
+        return;
+    }
+    HILOG_INFO(HILOG_MODULE_APP, buf);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/lwip_test.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LWIP_TEST_H
+#define LWIP_TEST_H
+
+#include "lwip/arch.h"
+#include "lwip/sockets.h"
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include "securec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int g_testCase;
+extern int g_testError;
+extern int g_testTemp;
+#define LWIP_TEST_RET_OK    0
+#define LWIP_TEST_RET_ERR   1
+
+#define LOCALHOST "127.0.0.1"
+#define STACK_IP LOCALHOST
+#define STACK_PORT 2277
+#define PEER_PORT STACK_PORT
+#define SERVER_PORT STACK_PORT
+#define CLIENT_PORT 2288
+#define PEER_IP LOCALHOST
+#define BUF_SIZE (128 * 1)
+#define IOV_LENGTH 2
+#define STACK_TEST_SIZE (0x800UL)
+
+#define ICUNIT_ASSERT_NOT_EQUAL(a, b, c)  if ((a) == (b)) { \
+                                              g_testError = (c); \
+                                              LWIP_ASSERT("lwip test", 0); \
+                                          }
+#define ICUNIT_ASSERT_EQUAL(a, b, c)      if ((a) != (b)) { \
+                                              g_testError = (c); \
+                                              LWIP_ASSERT("lwip test", 0); \
+                                          }
+
+#define LogPrintln(fmt, ...) \
+    HILOG_INFO(HILOG_MODULE_APP, fmt "%c", \
+         ##__VA_ARGS__, \
+        ('\n' == " "fmt[sizeof(" "fmt)-2]) ? '\0' : '\n') // trailing newline is auto appended
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LWIP_TEST_H */

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_001.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+
+#define TEST_CASE 110
+
+int SocketTest(void)
+{
+    LogPrintln("net_socket_test_001.c enter");
+    g_testCase = TEST_CASE;
+    int fd = socket(0, 0, 0);
+    LWIP_ASSERT("socket invalid param.", fd == -1);
+    return LWIP_TEST_RET_OK;
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_002.c

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+#define MSG "Hi, I am UDP"
+#define TEST_CASE 120
+
+static char g_buf[BUF_SIZE + 1] = { 0 };
+
+void UdpTestTask(void *p)
+{
+    (void)p;
+    LogPrintln("net_socket_test_002.c enter");
+    g_testCase = TEST_CASE;
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    int ret;
+    struct msghdr msg = { 0 };
+    struct iovec iov[IOV_LENGTH] = { 0 };
+    int recvCount = 0;
+
+    /* socket creation */
+    sfd = socket(AF_INET, SOCK_DGRAM, 0);
+    LWIP_ASSERT("socket invalid param.", sfd != -1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(STACK_PORT);
+    ret = bind(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LWIP_ASSERT("socket invalid param.", ret == 0);
+
+    /* send */
+    clnAddr.sin_family = AF_INET;
+    clnAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    clnAddr.sin_port = htons(PEER_PORT);
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), MSG);
+    ret = sendto(sfd, g_buf, strlen(MSG), 0, (struct sockaddr*)&clnAddr,
+        (socklen_t)sizeof(clnAddr));
+    LWIP_ASSERT("socket invalid param.", ret != -1);
+
+    ret = ioctlsocket(sfd, FIONREAD, &recvCount);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 1);
+    LogPrintln("udp recv count %d", recvCount);
+
+    /* recv */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    ret = recvfrom(sfd, g_buf, sizeof(g_buf), 0, (struct sockaddr*)&clnAddr,
+        &clnAddrLen);
+    LWIP_ASSERT("socket invalid param.", ret == strlen(MSG));
+
+    /* sendmsg */
+    clnAddr.sin_family = AF_INET;
+    clnAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    clnAddr.sin_port = htons(PEER_PORT);
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), MSG);
+    msg.msg_name = &clnAddr;
+    msg.msg_namelen = sizeof(clnAddr);
+    msg.msg_iov = iov;
+    msg.msg_iovlen = IOV_LENGTH;
+    iov[0].iov_base = g_buf;
+    iov[0].iov_len = strlen(MSG);
+    iov[1].iov_base = g_buf;
+    iov[1].iov_len = strlen(MSG);
+    ret = sendmsg(sfd, &msg, 0);
+    LWIP_ASSERT("socket invalid param.", ret == IOV_LENGTH * strlen(MSG));
+
+    /* recvmsg */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)memset_s(&msg, sizeof(msg), 0, sizeof(msg));
+    msg.msg_name = &clnAddr;
+    msg.msg_namelen = sizeof(clnAddr);
+    msg.msg_iov = iov;
+    msg.msg_iovlen = 1;
+    iov[0].iov_base = g_buf;
+    iov[0].iov_len = sizeof(g_buf);
+    ret = recvmsg(sfd, &msg, 0);
+    LWIP_ASSERT("socket invalid param.", ret == IOV_LENGTH * strlen(MSG));
+
+    /* close socket */
+    ret = closesocket(sfd);
+    LWIP_ASSERT("socket invalid param.", ret != -1);
+    return;
+}
+
+int UdpTest()
+{
+    int ret = sys_thread_new("udp_test", UdpTestTask, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+    return ret;
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_003.c

@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+#define SRV_MSG "Hi, I am TCP server"
+#define CLI_MSG "Hi, I am TCP client"
+#define TEST_CASE 130
+
+static char g_buf[BUF_SIZE + 1] = { 0 };
+
+static int SampleTcpServer()
+{
+    g_testCase++;
+    int sfd, lsfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    struct msghdr msg = { 0 };
+    struct iovec iov[IOV_LENGTH] = { 0 };
+    int ret;
+
+    /* tcp server */
+    lsfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create server socket inet stream: %d", lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(lsfd, -1, 1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(STACK_PORT);
+    ret = bind(lsfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("bind socket %d to %s:%d: %d", lsfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+
+    ret = listen(lsfd, 0);
+    LogPrintln("listen socket %d: %d", lsfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 3);
+
+    sfd = accept(lsfd, (struct sockaddr*)&clnAddr, &clnAddrLen);
+    LogPrintln("accept socket %d: %d <%s:%d>", lsfd, sfd, inet_ntoa(clnAddr.sin_addr), ntohs(clnAddr.sin_port));
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 4);
+
+    /* send */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), SRV_MSG);
+    ret = send(sfd, g_buf, strlen(SRV_MSG), 0);
+    LogPrintln("server send on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(SRV_MSG), 5);
+
+    /* recv */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    ret = recv(sfd, g_buf, sizeof(g_buf), 0);
+    LogPrintln("server recv on socket %d: %d", sfd, ret);
+    LogPrintln("ser:%s", g_buf);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(CLI_MSG), 6);
+
+    /* sendmsg */
+    clnAddr.sin_family = AF_INET;
+    clnAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    clnAddr.sin_port = htons(PEER_PORT);
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), SRV_MSG);
+    msg.msg_name = &clnAddr;
+    msg.msg_namelen = sizeof(clnAddr);
+    msg.msg_iov = iov;
+    msg.msg_iovlen = IOV_LENGTH;
+    iov[0].iov_base = g_buf;
+    iov[0].iov_len = strlen(SRV_MSG);
+    iov[1].iov_base = g_buf;
+    iov[1].iov_len = strlen(SRV_MSG);
+    ret = sendmsg(sfd, &msg, 0);
+    LogPrintln("sendmsg on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, IOV_LENGTH * strlen(SRV_MSG), 7);
+
+    /* recvmsg */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)memset_s(&msg, sizeof(msg), 0, sizeof(msg));
+    msg.msg_name = &clnAddr;
+    msg.msg_namelen = sizeof(clnAddr);
+    msg.msg_iov = iov;
+    msg.msg_iovlen = 1;
+    iov[0].iov_base = g_buf;
+    iov[0].iov_len = sizeof(g_buf);
+    ret = recvmsg(sfd, &msg, 0);
+    LogPrintln("recvmsg on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, IOV_LENGTH * strlen(CLI_MSG), 8);
+
+    ret = shutdown(sfd, SHUT_RDWR);
+    LogPrintln("shutdown socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 9);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 10);
+    ret = closesocket(lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 11);
+
+    return 0;
+}
+
+static int SampleTcpClient()
+{
+    g_testCase++;
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    int ret;
+    struct msghdr msg = { 0 };
+    struct iovec iov[IOV_LENGTH] = { 0 };
+    struct sockaddr addr;
+    socklen_t addrLen = sizeof(addr);
+
+    /* tcp client connection */
+    sfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create client socket inet stream: %d", sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 10);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    srvAddr.sin_port = htons(PEER_PORT);
+    ret = connect(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("connect socket %d to %s:%d: %d", sfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 11);
+
+    /* test getpeername */
+    ret = getpeername(sfd, &addr, &addrLen);
+    LogPrintln("getpeername %d %s:%d: %d", \
+        sfd, inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr), ntohs(((struct sockaddr_in*)&addr)->sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 12);
+    ICUNIT_ASSERT_EQUAL(addrLen, sizeof(struct sockaddr_in), 13);
+    ICUNIT_ASSERT_EQUAL(((struct sockaddr_in*)&addr)->sin_addr.s_addr, \
+        inet_addr(PEER_IP), 14);
+
+    /* test getsockname */
+    ret = getsockname(sfd, &addr, &addrLen);
+    LogPrintln("getsockname %d %s:%d: %d", \
+        sfd, inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr), ntohs(((struct sockaddr_in*)&addr)->sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 15);
+    ICUNIT_ASSERT_EQUAL(addrLen, sizeof(struct sockaddr_in), 16);
+    ICUNIT_ASSERT_EQUAL(((struct sockaddr_in*)&addr)->sin_addr.s_addr, \
+        inet_addr(STACK_IP), 17);
+
+    /* send */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), CLI_MSG);
+    ret = send(sfd, g_buf, strlen(CLI_MSG), 0);
+    LogPrintln("client send on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(CLI_MSG), 18);
+
+    /* recv */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    ret = recv(sfd, g_buf, sizeof(g_buf), 0);
+    LogPrintln("client recv on socket %d: %d", sfd, ret);
+    LogPrintln("cli:%s", g_buf);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(SRV_MSG), 19);
+
+    /* sendmsg */
+    clnAddr.sin_family = AF_INET;
+    clnAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    clnAddr.sin_port = htons(PEER_PORT);
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), CLI_MSG);
+    msg.msg_name = &clnAddr;
+    msg.msg_namelen = sizeof(clnAddr);
+    msg.msg_iov = iov;
+    msg.msg_iovlen = IOV_LENGTH;
+    iov[0].iov_base = g_buf;
+    iov[0].iov_len = strlen(CLI_MSG);
+    iov[1].iov_base = g_buf;
+    iov[1].iov_len = strlen(CLI_MSG);
+    ret = sendmsg(sfd, &msg, 0);
+    LogPrintln("sendmsg on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 2 * strlen(CLI_MSG), 20);
+
+    /* recvmsg */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)memset_s(&msg, sizeof(msg), 0, sizeof(msg));
+    msg.msg_name = &clnAddr;
+    msg.msg_namelen = sizeof(clnAddr);
+    msg.msg_iov = iov;
+    msg.msg_iovlen = 1;
+    iov[0].iov_base = g_buf;
+    iov[0].iov_len = sizeof(g_buf);
+    ret = recvmsg(sfd, &msg, 0);
+    LogPrintln("recvmsg on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, IOV_LENGTH * strlen(SRV_MSG), 21);
+
+    ret = shutdown(sfd, SHUT_RDWR);
+    LogPrintln("shutdown socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 22);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+    return 0;
+}
+
+static void TcpServerRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpServer();
+}
+
+static void TcpClientRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpClient();
+}
+
+void TcpTest()
+{
+    LogPrintln("net_socket_test_003.c enter");
+    g_testCase = TEST_CASE;
+    int ret;
+    ret = sys_thread_new("tcp_server", TcpServerRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+
+    ret = sys_thread_new("tcp_client", TcpClientRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 24);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_004.c

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+
+#define TEST_CASE 140
+#define OPT_TIMEOUT 1000
+
+int SockOptTest()
+{
+    LogPrintln("net_socket_test_004.c enter");
+    g_testCase = TEST_CASE;
+    int ret, error, flag;
+    struct timeval timeout;
+    socklen_t len;
+
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    ICUNIT_ASSERT_NOT_EQUAL(fd, -1, 1);
+
+    error = -1;
+    len = sizeof(error);
+    ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
+    LogPrintln("getsockopt(%d, SOL_SOCKET, SO_ERROR, &error, &len)=%d, error=%d, len=%d, errno=%d", \
+        fd, ret, error, len, errno);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+    ICUNIT_ASSERT_EQUAL(error, 0, 3);
+
+    len = sizeof(timeout);
+    ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 4);
+
+    timeout.tv_sec = OPT_TIMEOUT;
+    len = sizeof(timeout);
+    ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 5);
+
+    (void)memset_s(&timeout, len, 0, len);
+    ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 6);
+    ICUNIT_ASSERT_EQUAL(timeout.tv_sec, OPT_TIMEOUT, 7);
+
+    error = -1;
+    len = sizeof(error);
+    ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
+    LogPrintln("getsockopt(%d, SOL_SOCKET, SO_ERROR, &error, &len)=%d, error=%d, len=%d, errno=%d", \
+        fd, ret, error, len, errno);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 8);
+    ICUNIT_ASSERT_EQUAL(error, 0, 9);
+
+    flag = 1;
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
+    LogPrintln("setsockopt(TCP_NODELAY) ret=%d", ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 10);
+
+    ret = closesocket(fd);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 11);
+
+    return LWIP_TEST_RET_OK;
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_005.c

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+
+#define TEST_CASE 150
+
+int ByteOrderTest(void)
+{
+    LogPrintln("net_socket_test_005.c enter");
+#if BYTE_ORDER == LITTLE_ENDIAN
+    g_testCase = TEST_CASE + 1;
+    uint32_t hl = ntohl(0x12345678);
+    ICUNIT_ASSERT_EQUAL(hl, 0x78563412, 1);
+
+    uint32_t nl = htonl(0x12345678);
+    ICUNIT_ASSERT_EQUAL(nl, 0x78563412, 2);
+
+    uint16_t hs = ntohs(0x1234);
+    ICUNIT_ASSERT_EQUAL(hs, 0x3412, 3);
+
+    uint16_t ns = htons(0x1234);
+    ICUNIT_ASSERT_EQUAL(ns, 0x3412, 4);
+#else
+    g_testCase = TEST_CASE;
+    uint32_t hl = ntohl(0x12345678);
+    ICUNIT_ASSERT_EQUAL(hl, 0x12345678, 5);
+
+    uint32_t nl = htonl(0x12345678);
+    ICUNIT_ASSERT_EQUAL(nl, 0x12345678, 6);
+
+    uint16_t hs = ntohs(0x1234);
+    ICUNIT_ASSERT_EQUAL(hs, 0x1234, 7);
+
+    uint16_t ns = htons(0x1234);
+    ICUNIT_ASSERT_EQUAL(ns, 0x1234, 8);
+#endif
+    return LWIP_TEST_RET_OK;
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_006.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+
+#define TEST_CASE 160
+#define TEMP_BUF_SIZE 32
+int InetTest()
+{
+    LogPrintln("net_socket_test_006.c enter");
+    g_testCase = TEST_CASE;
+    struct in_addr in;
+    int ret = inet_pton(AF_INET, "300.10.10.10", &in);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 1);
+
+    ret = inet_pton(AF_INET, "10.11.12.13", &in);
+    ICUNIT_ASSERT_EQUAL(ret, 1, 2);
+#if BYTE_ORDER == LITTLE_ENDIAN
+    g_testCase++;
+    ICUNIT_ASSERT_EQUAL(in.s_addr, 0x0d0c0b0a, 3);
+#else
+    ICUNIT_ASSERT_EQUAL(in.s_addr, 0x0a0b0c0d, 4);
+#endif
+
+    const char *p = inet_ntoa(in);
+    ICUNIT_ASSERT_EQUAL(strcmp(p, "10.11.12.13"), 0, 5);
+
+    char buf[TEMP_BUF_SIZE];
+    p = inet_ntop(AF_INET, &in, buf, sizeof(buf));
+    ICUNIT_ASSERT_EQUAL(p, buf, 6);
+    ICUNIT_ASSERT_EQUAL(strcmp(p, "10.11.12.13"), 0, 7);
+
+    return LWIP_TEST_RET_OK;
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_007.c

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+static char g_buf[BUF_SIZE + 1] = { 0 };
+static char g_buf_temp[BUF_SIZE + 1] = { 0 };
+
+#define SEND_UDP_COUNT 10000  // send count
+#define TEST_CASE 170
+
+static void UdpTestMoreTask(void *p)
+{
+    (void)p;
+    LogPrintln("net_socket_test_007.c enter");
+    if (g_testCase < TEST_CASE) {
+        g_testCase = TEST_CASE;
+    } else {
+        g_testCase++;
+    }
+
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    int ret;
+    int i;
+
+    /* socket creation */
+    sfd = socket(AF_INET, SOCK_DGRAM, 0);
+    LWIP_ASSERT("socket invalid param.", sfd != -1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(STACK_PORT);
+    ret = bind(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LWIP_ASSERT("socket invalid param.", ret == 0);
+
+    /* send */
+    clnAddr.sin_family = AF_INET;
+    clnAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    clnAddr.sin_port = htons(PEER_PORT);
+    if (g_buf_temp[0] == '\0') {
+        for (i = 0; i < BUF_SIZE; i++) {
+            g_buf_temp[i] = 'U';
+        }
+        g_buf_temp[BUF_SIZE] = '\0';
+    }
+
+    LogPrintln("udp begin send");
+    for (i = 0; i < SEND_UDP_COUNT; i++) {
+        ret = memcpy_s(g_buf, sizeof(g_buf), g_buf_temp, sizeof(g_buf_temp));
+        ICUNIT_ASSERT_EQUAL(ret, EOK, 1);
+        ret = sendto(sfd, g_buf, BUF_SIZE, 0, (struct sockaddr*)&clnAddr, (socklen_t)sizeof(clnAddr));
+        LWIP_ASSERT("socket invalid param.", ret != -1);
+
+        /* recv */
+        (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+        ret = recvfrom(sfd, g_buf, sizeof(g_buf), 0, (struct sockaddr*)&clnAddr,
+            &clnAddrLen);
+        LWIP_ASSERT("socket invalid param.", ret == BUF_SIZE);
+    }
+    LogPrintln("udp end send");
+
+    /* close socket */
+    ret = closesocket(sfd);
+    LWIP_ASSERT("socket invalid param.", ret != -1);
+}
+
+void UdpTestMore()
+{
+    int ret;
+    ret = sys_thread_new("udp_more", UdpTestMoreTask, NULL,
+        STACK_TEST_SIZE * 2, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 10);
+}
+

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_008.c

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+#define SEND_TCP_COUNT 1000  // send count
+#define STACK_PORT_8 2288
+#define TEST_CASE 180
+
+static char g_serverSendBuf[BUF_SIZE + 1] = { 0 };
+static char g_clientRecvBuf[BUF_SIZE + 1] = { 0 };
+
+static void InitMsgBuf()
+{
+    int i;
+    if (g_serverSendBuf[0] != '\0') {
+        return;
+    }
+    for (i = 0; i < BUF_SIZE; i++) {
+        g_serverSendBuf[i] = 'S';
+    }
+    g_serverSendBuf[BUF_SIZE] = '\0';
+}
+
+static int SampleTcpServer()
+{
+    g_testCase++;
+    int sfd, lsfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    int ret;
+    int i;
+
+    /* tcp server */
+    lsfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create server socket inet stream: %d", lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(lsfd, -1, 1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(STACK_PORT_8);
+    ret = bind(lsfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("bind socket %d to %s:%d: %d", lsfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+
+    ret = listen(lsfd, 0);
+    LogPrintln("listen socket %d: %d", lsfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 3);
+
+    sfd = accept(lsfd, (struct sockaddr*)&clnAddr, &clnAddrLen);
+    LogPrintln("accept socket %d: %d <%s:%d>", lsfd, sfd, inet_ntoa(clnAddr.sin_addr), ntohs(clnAddr.sin_port));
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 4);
+
+    for (i = 0; i < SEND_TCP_COUNT; i++) {
+        /* send */
+        ret = send(sfd, g_serverSendBuf, BUF_SIZE, 0);
+        ICUNIT_ASSERT_EQUAL(ret, BUF_SIZE, 5);
+    }
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 7);
+    ret = closesocket(lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 8);
+    return 0;
+}
+
+static int SampleTcpClient()
+{
+    g_testCase++;
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    int ret;
+    int i;
+    struct sockaddr addr;
+    socklen_t addrLen = sizeof(addr);
+    int recvCount = 0;
+
+    /* tcp client connection */
+    sfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create client socket inet stream: %d", sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 7);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    srvAddr.sin_port = htons(STACK_PORT_8);
+    ret = connect(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("connect socket %d to %s:%d: %d", sfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 8);
+
+    /* test getpeername */
+    ret = getpeername(sfd, &addr, &addrLen);
+    LogPrintln("getpeername %d %s:%d: %d",
+        sfd, inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr), ntohs(((struct sockaddr_in*)&addr)->sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 9);
+    ICUNIT_ASSERT_EQUAL(addrLen, sizeof(struct sockaddr_in), 10);
+    ICUNIT_ASSERT_EQUAL(((struct sockaddr_in*)&addr)->sin_addr.s_addr, \
+        inet_addr(PEER_IP), 11);
+
+    /* test getsockname */
+    ret = getsockname(sfd, &addr, &addrLen);
+    LogPrintln("getsockname %d %s:%d: %d",
+        sfd, inet_ntoa(((struct sockaddr_in*)&addr)->sin_addr), ntohs(((struct sockaddr_in*)&addr)->sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 12);
+    ICUNIT_ASSERT_EQUAL(addrLen, sizeof(struct sockaddr_in), 13);
+    ICUNIT_ASSERT_EQUAL(((struct sockaddr_in*)&addr)->sin_addr.s_addr, \
+        inet_addr(STACK_IP), 14);
+
+    LogPrintln("tcp begin recv");
+    for (i = 0; i < 2 * SEND_TCP_COUNT; i++) {
+        /* recv */
+        (void)memset_s(g_clientRecvBuf, sizeof(g_clientRecvBuf), 0, sizeof(g_clientRecvBuf));
+        ret = recv(sfd, g_clientRecvBuf, BUF_SIZE, 0);
+        recvCount += ret;
+        if (recvCount >= BUF_SIZE * SEND_TCP_COUNT) {
+            LogPrintln("client recv on socket %d: %d, i = %d", sfd, recvCount, i);
+            break;
+        }
+    }
+    ICUNIT_ASSERT_EQUAL(recvCount, BUF_SIZE * SEND_TCP_COUNT, recvCount);
+    LogPrintln("tcp end recv");
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 17);
+    return 0;
+}
+
+static void TcpServerRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpServer();
+}
+
+static void TcpClientRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpClient();
+}
+
+void TcpTestMore()
+{
+    LogPrintln("net_socket_test_008.c enter");
+    if (g_testCase < TEST_CASE) {
+        g_testCase = TEST_CASE;
+    }
+
+    int ret;
+    InitMsgBuf();
+    ret = sys_thread_new("tcp_server_more", TcpServerRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 17);
+
+    ret = sys_thread_new("tcp_client_more", TcpClientRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 18);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_009.c

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+#define SRV_MSG "Hi, I am TCP server"
+#define CLI_MSG "Hi, I am TCP client"
+
+#define TEST_CASE 190
+#define STACK_PORT_9 2299
+#define TIME_OUT 10   // timeout 10s
+
+static char g_buf[BUF_SIZE + 1] = { 0 };
+
+static int SampleTcpServer()
+{
+#if LWIP_SOCKET_SELECT
+    g_testCase++;
+    int sfd, lsfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    fd_set fdsr;
+    struct timeval tv;
+    int ret;
+
+    /* tcp server */
+    lsfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create server socket inet stream: %d", lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(lsfd, -1, 1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(STACK_PORT_9);
+    ret = bind(lsfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("bind socket %d to %s:%d: %d", lsfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+
+    ret = listen(lsfd, 0);
+    LogPrintln("listen socket %d: %d", lsfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 3);
+
+    FD_ZERO(&fdsr);
+    FD_SET(lsfd, &fdsr);
+    // timeout setting
+    tv.tv_sec = TIME_OUT;
+    tv.tv_usec = 0;
+
+    ret = select(lsfd + 1, &fdsr, NULL, NULL, &tv);
+    if (ret < 0) {
+        LogPrintln("select error");
+        ICUNIT_ASSERT_EQUAL(-1, 0, 4);
+    } else if (ret == 0) {
+        LogPrintln("select timeout");
+        ICUNIT_ASSERT_EQUAL(-1, 0, 5);
+    }
+
+    sfd = accept(lsfd, (struct sockaddr*)&clnAddr, &clnAddrLen);
+    LogPrintln("accept socket %d: %d <%s:%d>", lsfd, sfd, inet_ntoa(clnAddr.sin_addr), ntohs(clnAddr.sin_port));
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 6);
+
+    /* send */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), SRV_MSG);
+    ret = send(sfd, g_buf, strlen(SRV_MSG), 0);
+    LogPrintln("server send on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(SRV_MSG), 7);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 8);
+    ret = closesocket(lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 9);
+#endif
+    return 0;
+}
+
+static int SampleTcpClient()
+{
+#if LWIP_SOCKET_SELECT
+    g_testCase++;
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    int ret;
+
+    /* tcp client connection */
+    sfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create client socket inet stream: %d", sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 10);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    srvAddr.sin_port = htons(STACK_PORT_9);
+    ret = connect(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("connect socket %d to %s:%d: %d", sfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 11);
+
+    /* recv */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    ret = recv(sfd, g_buf, sizeof(g_buf), 0);
+    LogPrintln("client recv on socket %d: %d", sfd, ret);
+    LogPrintln("cli:%s", g_buf);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(SRV_MSG), 12);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 13);
+#endif
+    return 0;
+}
+
+static void TcpServerRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpServer();
+}
+
+static void TcpClientRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpClient();
+}
+
+void TcpTestSelect()
+{
+    LogPrintln("net_socket_test_009.c enter");
+    g_testCase = TEST_CASE;
+    int ret;
+    ret = sys_thread_new("tcp_server_select", TcpServerRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+
+    ret = sys_thread_new("tcp_client_select", TcpClientRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 24);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_010.c

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+#define SRV_MSG "Hi, I am TCP server"
+#define CLI_MSG "Hi, I am TCP client"
+
+#define TEST_CASE 200
+#define STACK_PORT_10 2230
+#define POLL_OPEN_MAX 10
+#define TIME_OUT (1000 * 10) // timeout 10s
+static char g_buf[BUF_SIZE + 1] = { 0 };
+
+static int SampleTcpServer()
+{
+#if LWIP_SOCKET_POLL
+    g_testCase++;
+    int sfd, lsfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    struct pollfd client[POLL_OPEN_MAX] = {0};
+    int ret;
+
+    /* tcp server */
+    lsfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create server socket inet stream: %d", lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(lsfd, -1, 1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(STACK_PORT_10);
+    ret = bind(lsfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("bind socket %d to %s:%d: %d", lsfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+
+    ret = listen(lsfd, 0);
+    LogPrintln("listen socket %d: %d", lsfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 3);
+
+    client[0].fd = lsfd;
+    client[0].events = POLLIN;
+    ret = poll(client, 1, TIME_OUT);
+    if (ret < 0) {
+        LogPrintln("poll error");
+        ICUNIT_ASSERT_EQUAL(-1, 0, 4);
+    } else if (ret == 0) {
+        LogPrintln("poll timeout");
+        ICUNIT_ASSERT_EQUAL(-1, 0, 5);
+    }
+
+    sfd = accept(lsfd, (struct sockaddr*)&clnAddr, &clnAddrLen);
+    LogPrintln("accept socket %d: %d <%s:%d>", lsfd, sfd, inet_ntoa(clnAddr.sin_addr), ntohs(clnAddr.sin_port));
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 6);
+
+    /* recv */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    ret = recv(sfd, g_buf, sizeof(g_buf), 0);
+    LogPrintln("server recv on socket %d: %d", sfd, ret);
+    LogPrintln("ser:%s", g_buf);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(CLI_MSG), 7);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 8);
+    ret = closesocket(lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 9);
+#endif
+    return 0;
+}
+
+static int SampleTcpClient()
+{
+#if LWIP_SOCKET_POLL
+    g_testCase++;
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    int ret;
+
+    /* tcp client connection */
+    sfd = socket(AF_INET, SOCK_STREAM, 0);
+    LogPrintln("create client socket inet stream: %d", sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 10);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    srvAddr.sin_port = htons(STACK_PORT_10);
+    ret = connect(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LogPrintln("connect socket %d to %s:%d: %d", sfd, inet_ntoa(srvAddr.sin_addr), ntohs(srvAddr.sin_port), ret);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 11);
+
+    /* send */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), CLI_MSG);
+    ret = send(sfd, g_buf, strlen(CLI_MSG), 0);
+    LogPrintln("client send on socket %d: %d", sfd, ret);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(CLI_MSG), 12);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 13);
+#endif
+    return 0;
+}
+
+static void TcpServerRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpServer();
+}
+
+static void TcpClientRoutine(void *p)
+{
+    (void)p;
+    (void)SampleTcpClient();
+}
+
+void TcpTestPoll()
+{
+    LogPrintln("net_socket_test_010.c enter");
+    g_testCase = TEST_CASE;
+    int ret;
+    ret = sys_thread_new("tcp_server_poll", TcpServerRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+
+    ret = sys_thread_new("tcp_client_poll", TcpClientRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 24);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_011.c

@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include <lwip/netif.h>
+#include <lwip/netifapi.h>
+#include <lwip/pbuf.h>
+#include <lwip/ip4_addr.h>
+#include <lwip/ip4.h>
+#include <lwip/ip.h>
+#include <lwip/def.h>
+#include <lwip/udp.h>
+#include <lwip/inet_chksum.h>
+#include "lwip/prot/iana.h"
+
+#define MSG "Hi, I am testing BT netif."
+#define STACK_IP_BT "192.168.167.1"
+#define PEER_IP_BT "100.100.100.100"
+#define GATEWAY_IP_BT "192.168.167.239"
+#define NETIF_MAC "121212"
+#define PEER_MAC "454545"
+#define NETIF_NAME_BT "bt1000"
+#define TEST_CASE 210
+static char g_buf[BUF_SIZE + 1] = { 0 };
+struct netif *btProxyNf = NULL;
+
+static void ReplayArpTask();
+static void ArpPackageProc(struct netif *netif, struct pbuf *p);
+extern void driverif_input(struct netif *netif, struct pbuf *p);
+static void ReplayArpEncodeEthernet(struct netif *netif, struct pbuf *p);
+
+static void ReplayUdpEncodeEthernet(struct netif *netif, struct pbuf *p)
+{
+    int ret;
+    ret = pbuf_add_header(p, SIZEOF_ETH_HDR);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 1);
+
+    struct eth_hdr *ethhdr;
+    ethhdr = (struct eth_hdr *)p->payload;
+    ethhdr->type = lwip_htons(ETHTYPE_IP);
+    SMEMCPY(&ethhdr->dest, NETIF_MAC, ETH_HWADDR_LEN);
+    SMEMCPY(&ethhdr->src,  PEER_MAC, ETH_HWADDR_LEN);
+
+    driverif_input(netif, p);
+}
+
+static void ReplayUdpEncodeIp(struct pbuf *p, ip4_addr_t *src, ip4_addr_t *dest)
+{
+    struct ip_hdr *iphdr;
+    int ret;
+#if CHECKSUM_GEN_IP_INLINE
+    u32_t chk_sum = 0;
+#endif /* CHECKSUM_GEN_IP_INLINE */
+
+   // ip header
+    ret = pbuf_add_header(p, IP_HLEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+    iphdr = (struct ip_hdr *)p->payload;
+    IPH_TTL_SET(iphdr, UDP_TTL);
+    IPH_PROTO_SET(iphdr, IP_PROTO_UDP);
+
+#if CHECKSUM_GEN_IP_INLINE
+    chk_sum += PP_NTOHS(IP_PROTO_UDP | (ttl << 8));
+#endif /* CHECKSUM_GEN_IP_INLINE */
+
+    /* dest cannot be NULL here */
+    ip4_addr_copy(iphdr->dest, *dest);
+#if CHECKSUM_GEN_IP_INLINE
+    chk_sum += ip4_addr_get_u32(&iphdr->dest) & 0xFFFF;
+    chk_sum += ip4_addr_get_u32(&iphdr->dest) >> 16;
+#endif /* CHECKSUM_GEN_IP_INLINE */
+
+    u16_t ip_hlen = IP_HLEN;
+    IPH_VHL_SET(iphdr, 4, ip_hlen / 4);
+    IPH_TOS_SET(iphdr, 0);
+#if CHECKSUM_GEN_IP_INLINE
+    chk_sum += PP_NTOHS(tos | (iphdr->_v_hl << 8));
+#endif /* CHECKSUM_GEN_IP_INLINE */
+    IPH_LEN_SET(iphdr, lwip_htons(p->tot_len));
+#if CHECKSUM_GEN_IP_INLINE
+    chk_sum += iphdr->_len;
+#endif /* CHECKSUM_GEN_IP_INLINE */
+    IPH_OFFSET_SET(iphdr, 0);
+    IPH_ID_SET(iphdr, lwip_htons(0));
+#if CHECKSUM_GEN_IP_INLINE
+    chk_sum += iphdr->_id;
+#endif /* CHECKSUM_GEN_IP_INLINE */
+    ip4_addr_copy(iphdr->src, *src);
+
+#if CHECKSUM_GEN_IP_INLINE
+    chk_sum += ip4_addr_get_u32(&iphdr->src) & 0xFFFF;
+    chk_sum += ip4_addr_get_u32(&iphdr->src) >> 16;
+    chk_sum = (chk_sum >> 16) + (chk_sum & 0xFFFF);
+    chk_sum = (chk_sum >> 16) + chk_sum;
+    chk_sum = ~chk_sum;
+    IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) {
+        iphdr->_chksum = (u16_t)chk_sum; /* network order */
+    }
+#if LWIP_CHECKSUM_CTRL_PER_NETIF
+    else {
+        IPH_CHKSUM_SET(iphdr, 0);
+    }
+#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */
+#else /* CHECKSUM_GEN_IP_INLINE */
+    IPH_CHKSUM_SET(iphdr, 0);
+#if CHECKSUM_GEN_IP
+    IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) {
+        IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, ip_hlen));
+    }
+#endif /* CHECKSUM_GEN_IP */
+#endif /* CHECKSUM_GEN_IP_INLINE */
+
+    ReplayUdpEncodeEthernet(btProxyNf, p);
+}
+
+static void ReplayUdp(void *ptemp)
+{
+    struct udp_hdr *udphdr;
+    ip4_addr_t sipaddr, dipaddr;
+    int size = strlen(MSG);
+    int ret;
+    (void)ptemp;
+
+    LogPrintln("encode udp replay packet");
+    inet_pton(AF_INET, PEER_IP_BT, &sipaddr);
+    inet_pton(AF_INET, STACK_IP_BT, &dipaddr);
+
+    struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, size, PBUF_RAM);
+    u16_t chksum = LWIP_CHKSUM_COPY(p->payload, MSG, size);
+
+    // udp header
+    ret = pbuf_add_header(p, UDP_HLEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 1);
+    udphdr = (struct udp_hdr *)p->payload;
+    udphdr->src = lwip_htons(STACK_PORT);
+    udphdr->dest = lwip_htons(STACK_PORT);
+    udphdr->len = lwip_htons(p->tot_len);
+    /* in UDP, 0 checksum means 'no checksum' */
+    u16_t udpchksum = ip_chksum_pseudo_partial(p, IP_PROTO_UDP, p->tot_len, UDP_HLEN, &sipaddr, &dipaddr);
+    u32_t acc = udpchksum + (u16_t)~(chksum);
+    udpchksum = FOLD_U32T(acc);
+    if (udpchksum == 0x0000) {
+        udpchksum = 0xffff;
+    }
+    udphdr->chksum = udpchksum;
+    udphdr->chksum = 0;
+
+    ReplayUdpEncodeIp(p, &sipaddr, &dipaddr);
+}
+
+static void ReplayUdpTask()
+{
+    int ret;
+    ret = sys_thread_new("replay_udp", ReplayUdp, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 3);
+}
+
+static void ParsePackageIpUdp(struct netif *netif, struct pbuf *btBuf)
+{
+    // get scr_addr and dest_addr from ip head
+    const struct ip_hdr *iphdr;
+    iphdr = (const struct ip_hdr *)btBuf->payload;
+    ip4_addr_p_t ip4_addr_scr = iphdr->src;
+    ip4_addr_p_t ip4_addr_dest = iphdr->dest;
+    char buf[32];
+    int dataLen;
+
+    // get scr_port and dest port from tcp head
+    u16_t scr_port, dest_port;
+    void *data;
+    struct udp_hdr *udphdr;
+    udphdr = (struct udp_hdr *)((u8_t *)iphdr + IPH_HL_BYTES(iphdr));
+    scr_port = udphdr->src;
+    dest_port = udphdr->dest;
+    data = (void *)((u8_t *)udphdr + UDP_HLEN);
+
+    LogPrintln("======Bt netif send package======");
+    LogPrintln("netif full name %s", netif->full_name);
+    (void)inet_ntop(AF_INET, &ip4_addr_scr.addr, buf, sizeof(buf));
+    LogPrintln("package src ip %s", buf);
+    (void)inet_ntop(AF_INET, &ip4_addr_dest.addr, buf, sizeof(buf));
+    LogPrintln("package dest ip %s", buf);
+    LogPrintln("package src port %d", lwip_ntohs(scr_port));
+    LogPrintln("package dest port %d", lwip_ntohs(dest_port));
+    LogPrintln("send data %s", (char *)data);
+    dataLen = lwip_ntohs(udphdr->len) - UDP_HLEN;
+    LogPrintln("send data length %d", dataLen);
+    ICUNIT_ASSERT_EQUAL(dataLen, strlen(MSG), 4);
+    LogPrintln("=================================");
+
+    // 回应udp报文
+    ReplayUdpTask();
+}
+
+static void ParsePackageEthernet(struct netif *netif, struct pbuf *p)
+{
+    u16_t next_hdr_offset = SIZEOF_ETH_HDR;
+    // get src mac and dest mac
+    struct eth_hdr *ethhdr;
+    ethhdr = (struct eth_hdr *)p->payload;
+    u16_t type = ethhdr->type;
+
+    LogPrintln("ParsePackageEthernet type is %d", type);
+    switch (type) {
+#if LWIP_IPV4 && LWIP_ARP
+        /* IP packet? */
+        case PP_HTONS(ETHTYPE_IP): // 0x0008
+            if (!(netif->flags & NETIF_FLAG_ETHARP)) {
+                return;
+            }
+            /* skip Ethernet header (min. size checked above) */
+            if (pbuf_remove_header(p, next_hdr_offset)) {
+                return;
+            } else {
+                /* pass to IP layer */
+                ParsePackageIpUdp(netif, p);
+            }
+            break;
+
+        case PP_HTONS(ETHTYPE_ARP): // 0x0608
+            if (!(netif->flags & NETIF_FLAG_ETHARP)) {
+                return;
+            }
+            /* skip Ethernet header (min. size checked above) */
+            if (pbuf_remove_header(p, next_hdr_offset)) {
+                return;
+            } else {
+                /* pass p to ARP module */
+                LogPrintln("recv arp packet");
+                ArpPackageProc(netif, p);
+            }
+            break;
+#endif /* LWIP_IPV4 && LWIP_ARP */
+
+        default:
+            LogPrintln("type is other %d", type);
+            break;
+    }
+}
+
+static void BtProxySend(struct netif *netif, struct pbuf *p)
+{
+    if (netif == NULL || p == NULL) {
+        LogPrintln("%s : netif = NUll or p = NULL!", __func__);
+        return;
+    }
+#if ETH_PAD_SIZE
+    (void)pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
+#endif
+    ParsePackageEthernet(netif, p);
+}
+
+static struct netif *CreateBtNetIf()
+{
+    struct netif *btNetif = NULL;
+    btNetif = (struct netif *)malloc(sizeof(struct netif));
+    if (btNetif == NULL) {
+        LogPrintln("%s fail : netif malloc fail!", __func__);
+        LWIP_ASSERT("btNetif malloc fail.", 0);
+        return NULL;
+    }
+    (void)memset_s(btNetif, sizeof(struct netif), 0, sizeof(struct netif));
+    btNetif->drv_send = BtProxySend;
+    btNetif->link_layer_type = BT_PROXY_IF;
+    btNetif->hwaddr_len = ETH_HWADDR_LEN;
+    (void)memcpy_s(&btNetif->hwaddr, sizeof(btNetif->hwaddr), NETIF_MAC, ETH_HWADDR_LEN);
+    (void)memcpy_s(&btNetif->full_name, sizeof(btNetif->full_name), NETIF_NAME_BT, sizeof(NETIF_NAME_BT));
+    ip4_addr_t gw, ipaddr, netmask;
+    IP4_ADDR(&gw, 192, 168, 167, 239);
+    IP4_ADDR(&ipaddr, 192, 168, 167, 1);
+    IP4_ADDR(&netmask, 255, 255, 255, 255);
+    int ret = 0;
+    if ((ret = netifapi_netif_add(btNetif, &ipaddr, &netmask, &gw, btNetif, driverif_init, tcpip_input)) != ERR_OK) {
+        LogPrintln("%s : netifapi_netif_add fail!,ret=%d", __func__, ret);
+        LWIP_ASSERT("btNetif add fail.", 0);
+        return NULL;
+    }
+    LogPrintln("netifapi_netif_add success!");
+    netif_set_link_up(btNetif);
+    netifapi_netif_set_up(btNetif);
+    return btNetif;
+}
+
+static void UdpTestNetifTask(void *p)
+{
+    (void)p;
+    LogPrintln("net_socket_test_011.c enter");
+    g_testCase = TEST_CASE;
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    struct ifreq nif;
+    int ret;
+
+    // 注册网卡
+    btProxyNf = CreateBtNetIf();
+
+    /* socket creation */
+    sfd = socket(AF_INET, SOCK_DGRAM, 0);
+    LWIP_ASSERT("socket invalid param.", sfd != -1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP_BT);
+    srvAddr.sin_port = htons(STACK_PORT);
+    ret = bind(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    LWIP_ASSERT("socket invalid param.", ret == 0);
+
+    /* 指定网卡接口 */
+    char *inface = NETIF_NAME_BT;
+    (void)strcpy_s(nif.ifr_name, sizeof(nif.ifr_name), inface);
+    if (setsockopt(sfd, SOL_SOCKET, SO_BINDTODEVICE, (char *)&nif, sizeof(nif)) < 0) {
+        LogPrintln("set intaface fail");
+        LWIP_ASSERT("set intaface fail.", 0);
+    }
+
+    /* send */
+    clnAddr.sin_family = AF_INET;
+    clnAddr.sin_addr.s_addr = inet_addr(PEER_IP_BT);
+    clnAddr.sin_port = htons(PEER_PORT);
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    (void)strcpy_s(g_buf, sizeof(g_buf), MSG);
+    ret = sendto(sfd, g_buf, strlen(MSG), 0, (struct sockaddr*)&clnAddr,
+        (socklen_t)sizeof(clnAddr));
+    LogPrintln("client send success: %d", sfd);
+    LWIP_ASSERT("socket invalid param.", ret != -1);
+
+    /* recv */
+    (void)memset_s(g_buf, sizeof(g_buf), 0, sizeof(g_buf));
+    ret = recvfrom(sfd, g_buf, sizeof(g_buf), 0, (struct sockaddr*)&clnAddr,
+        &clnAddrLen);
+    LWIP_ASSERT("socket invalid param.", ret == strlen(MSG));
+    LogPrintln("cli recv: %s", g_buf);
+
+    /* close socket */
+    ret = closesocket(sfd);
+    LWIP_ASSERT("socket invalid param.", ret != -1);
+    return;
+}
+
+int UdpTestNetif()
+{
+    int ret = sys_thread_new("udp_test_netif", UdpTestNetifTask, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+    return ret;
+}
+
+static void ArpPackageProc(struct netif *netif, struct pbuf *p)
+{
+    struct etharp_hdr *hdr;
+    ip4_addr_t sipaddr, dipaddr;
+    hdr = (struct etharp_hdr *)p->payload;
+
+    if (hdr->opcode != PP_HTONS(ARP_REQUEST)) {
+        LogPrintln("opcode %d is not arp request", hdr->opcode);
+        return;
+    }
+
+    inet_pton(AF_INET, GATEWAY_IP_BT, &sipaddr);
+    inet_pton(AF_INET, STACK_IP_BT, &dipaddr);
+    if (memcmp(&hdr->dipaddr, &sipaddr, sizeof(ip4_addr_t)) != EOK) {
+        LogPrintln("hdr->dipaddr %u is invalid", hdr->dipaddr);
+        return;
+    }
+
+    // 回应arp报文
+    ReplayArpTask();
+}
+
+static void ReplayArpEncodeEthernet(struct netif *netif, struct pbuf *p)
+{
+    int ret;
+    ret = pbuf_add_header(p, SIZEOF_ETH_HDR);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 1);
+
+    struct eth_hdr *ethhdr;
+    ethhdr = (struct eth_hdr *)p->payload;
+    ethhdr->type = lwip_htons(ETHTYPE_ARP);
+    SMEMCPY(&ethhdr->dest, NETIF_MAC, ETH_HWADDR_LEN);
+    SMEMCPY(&ethhdr->src,  PEER_MAC, ETH_HWADDR_LEN);
+
+    driverif_input(netif, p);
+}
+
+static void ReplayArp(void *ptemp)
+{
+    struct etharp_hdr *hdr;
+    ip4_addr_t sipaddr, dipaddr;
+
+    (void)ptemp;
+    LogPrintln("encode arp replay packet");
+    inet_pton(AF_INET, GATEWAY_IP_BT, &sipaddr);
+    inet_pton(AF_INET, STACK_IP_BT, &dipaddr);
+    struct pbuf *p = pbuf_alloc(PBUF_LINK, SIZEOF_ETHARP_HDR, PBUF_RAM);
+    hdr = (struct etharp_hdr *)p->payload;
+    hdr->opcode = PP_HTONS(ARP_REPLY);
+    /* Write the ARP MAC-Addresses */
+    SMEMCPY(&hdr->shwaddr, PEER_MAC, ETH_HWADDR_LEN);
+    SMEMCPY(&hdr->dhwaddr, NETIF_MAC, ETH_HWADDR_LEN);
+    /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without
+        * structure packing. */
+    IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->sipaddr, &sipaddr);
+    IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->dipaddr, &dipaddr);
+    hdr->hwtype = PP_HTONS(LWIP_IANA_HWTYPE_ETHERNET);
+    hdr->proto = PP_HTONS(ETHTYPE_IP);
+    /* set hwlen and protolen */
+    hdr->hwlen = ETH_HWADDR_LEN;
+    hdr->protolen = sizeof(ip4_addr_t);
+
+    ReplayArpEncodeEthernet(btProxyNf, p);
+}
+
+static void ReplayArpTask()
+{
+    int ret;
+    ret = sys_thread_new("replay_arp", ReplayArp, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_012.c

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+#define SRV_MSG "Hi, I am TCP server"
+#define CLI_MSG "Hi, I am TCP client"
+#define TEST_CASE 220
+#define TEST_COUNT 100
+#define STACK_PORT_TCP_DUP_START 3000
+
+static int g_portServer = STACK_PORT_TCP_DUP_START;
+static int g_portClient = STACK_PORT_TCP_DUP_START;
+
+static char g_bufServer[BUF_SIZE + 1] = { 0 };
+static char g_bufClient[BUF_SIZE + 1] = { 0 };
+
+static int SampleTcpServer()
+{
+    int sfd, lsfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    int ret;
+
+    /* tcp server */
+    lsfd = socket(AF_INET, SOCK_STREAM, 0);
+    ICUNIT_ASSERT_NOT_EQUAL(lsfd, -1, 1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(g_portServer);
+    g_portServer++;
+    ret = bind(lsfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+
+    ret = listen(lsfd, 0);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 3);
+
+    sfd = accept(lsfd, (struct sockaddr*)&clnAddr, &clnAddrLen);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 4);
+
+    /* send */
+    (void)memset_s(g_bufServer, sizeof(g_bufServer), 0, sizeof(g_bufServer));
+    (void)strcpy_s(g_bufServer, sizeof(g_bufServer), SRV_MSG);
+    ret = send(sfd, g_bufServer, strlen(SRV_MSG), 0);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(SRV_MSG), 5);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 10);
+    ret = closesocket(lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 11);
+
+    return 0;
+}
+
+static int SampleTcpClient()
+{
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    int ret;
+
+    /* tcp client connection */
+    sfd = socket(AF_INET, SOCK_STREAM, 0);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 10);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    srvAddr.sin_port = htons(g_portClient);
+    g_portClient++;
+    ret = connect(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    ICUNIT_ASSERT_EQUAL(ret, 0, 11);
+
+    /* recv */
+    (void)memset_s(g_bufClient, sizeof(g_bufClient), 0, sizeof(g_bufClient));
+    ret = recv(sfd, g_bufClient, sizeof(g_bufClient), 0);
+    ICUNIT_ASSERT_EQUAL(ret, strlen(SRV_MSG), 19);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+    return 0;
+}
+
+static void TcpServerRoutine(void *p)
+{
+    (void)p;
+    g_testCase++;
+
+    int i;
+    for (i = 0; i < TEST_COUNT; i++) {
+        (void)SampleTcpServer();
+    }
+    LogPrintln("tcp server g_portServer = %d", g_portServer);
+}
+
+static void TcpClientRoutine(void *p)
+{
+    (void)p;
+    g_testCase++;
+
+    int i;
+    for (i = 0; i < TEST_COUNT; i++) {
+        (void)SampleTcpClient();
+    }
+    LogPrintln("tcp server g_portClient = %d", g_portClient);
+}
+
+void TcpTestDup()
+{
+    LogPrintln("net_socket_test_012.c enter");
+    g_testCase = TEST_CASE;
+    int ret;
+    ret = sys_thread_new("tcp_server_dup", TcpServerRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+
+    ret = sys_thread_new("tcp_client_dup", TcpClientRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 24);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/net_socket_test_013.c

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip_test.h"
+#include "lwipopts.h"
+#include <arch/sys_arch.h>
+#include <lwip/sys.h>
+
+#define TEST_CASE 230
+#define STACK_PORT_TCP_LONG 2231
+#define TCP_LONG_BUF_SIZE (2 * 1024)
+
+static int SampleTcpServer()
+{
+    int sfd, lsfd;
+    struct sockaddr_in srvAddr = { 0 };
+    struct sockaddr_in clnAddr = { 0 };
+    socklen_t clnAddrLen = sizeof(clnAddr);
+    int ret;
+    static char serverBuf[TCP_LONG_BUF_SIZE] = {0};
+
+    /* tcp server */
+    lsfd = socket(AF_INET, SOCK_STREAM, 0);
+    ICUNIT_ASSERT_NOT_EQUAL(lsfd, -1, 1);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(STACK_IP);
+    srvAddr.sin_port = htons(STACK_PORT_TCP_LONG);
+    ret = bind(lsfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    ICUNIT_ASSERT_EQUAL(ret, 0, 2);
+
+    ret = listen(lsfd, 0);
+    ICUNIT_ASSERT_EQUAL(ret, 0, 3);
+
+    sfd = accept(lsfd, (struct sockaddr*)&clnAddr, &clnAddrLen);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 4);
+
+    /* send */
+    ret = send(sfd, serverBuf, TCP_LONG_BUF_SIZE, 0);
+    ICUNIT_ASSERT_EQUAL(ret, TCP_LONG_BUF_SIZE, 6);
+
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 7);
+    ret = closesocket(lsfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 8);
+
+    return 0;
+}
+
+static int SampleTcpClient()
+{
+    int sfd;
+    struct sockaddr_in srvAddr = { 0 };
+    int ret, i;
+    int recvCount = 0;
+    static char clientBuf[TCP_LONG_BUF_SIZE] = {0};
+
+    /* tcp client connection */
+    sfd = socket(AF_INET, SOCK_STREAM, 0);
+    ICUNIT_ASSERT_NOT_EQUAL(sfd, -1, 9);
+
+    srvAddr.sin_family = AF_INET;
+    srvAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+    srvAddr.sin_port = htons(STACK_PORT_TCP_LONG);
+    ret = connect(sfd, (struct sockaddr*)&srvAddr, sizeof(srvAddr));
+    ICUNIT_ASSERT_EQUAL(ret, 0, 10);
+
+    /* recv */
+    for (i = 0; i < TCP_LONG_BUF_SIZE; i++) {
+        ret = recv(sfd, clientBuf, TCP_LONG_BUF_SIZE, 0);
+        recvCount += ret;
+        if (recvCount >= TCP_LONG_BUF_SIZE) {
+            LogPrintln("client recv on socket %d: %d, i = %d", sfd, recvCount, i);
+            break;
+        }
+    }
+    ICUNIT_ASSERT_NOT_EQUAL(i, TCP_LONG_BUF_SIZE, 12);
+    ret = closesocket(sfd);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 13);
+    return 0;
+}
+
+static void TcpServerRoutine(void *p)
+{
+    (void)p;
+    g_testCase++;
+    (void)SampleTcpServer();
+}
+
+static void TcpClientRoutine(void *p)
+{
+    (void)p;
+    g_testCase++;
+    (void)SampleTcpClient();
+}
+
+void TcpTestLong()
+{
+    LogPrintln("net_socket_test_013.c enter");
+    g_testCase = TEST_CASE;
+    int ret;
+    ret = sys_thread_new("tcp_server_long", TcpServerRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 23);
+
+    ret = sys_thread_new("tcp_client_long", TcpClientRoutine, NULL,
+        STACK_TEST_SIZE, TCPIP_THREAD_PRIO);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, 24);
+}

EVT/EXAM/HarmonyOS/LiteOS_m/LiteOS/components/net/test/test_main.c

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sys/socket.h"
+#include "hos_cmsis_adp.h"
+
+#define LWIP_TEST_TIMEOUT 1000 // timeout 1s
+#define LWIP_TEST_COUNT_FLAG 100
+
+#define SOCKET_TEST     310
+#define UDP_TEST        320
+#define TCP_TEST        330
+#define OPT_TEST        340
+#define ORDER_TEST      350
+#define INET_TEST       360
+#define UDP_MORE_TEST   370
+#define TCP_MORE_TEST   380
+#define TCP_SELECT_TEST 390
+#define TCP_POLL_TEST   400
+#define NETIF_TEST      410
+#define TCP_DUP_TEST    420
+#define TCP_LONG_TEST   430
+
+int g_lwipTimerCount = 0;
+int g_testCase = LWIP_TEST_COUNT_FLAG;
+int g_testError = 0;
+int g_testTemp = LWIP_TEST_COUNT_FLAG;
+extern void abort(void);
+extern int SocketTest(void);
+extern int UdpTest(void);
+extern void TcpTest();
+extern int SockOptTest();
+extern int ByteOrderTest(void);
+extern int InetTest();
+extern int UdpTestMore(void);
+extern void TcpTestMore();
+extern void TcpTestSelect();
+extern void TcpTestPoll();
+extern int UdpTestNetif(void);
+extern void TcpTestDup();
+extern void TcpTestLong();
+
+// time out 1s
+static void LwipTestTimeoutCallback(void const *argument)
+{
+    g_lwipTimerCount++;
+    switch (g_lwipTimerCount) {
+        case SOCKET_TEST:
+            SocketTest();
+            break;
+        case UDP_TEST:
+            UdpTest();
+            break;
+        case TCP_TEST:
+            TcpTest();
+            break;
+        case OPT_TEST:
+            SockOptTest();
+            break;
+        case ORDER_TEST:
+            ByteOrderTest();
+            break;
+        case INET_TEST:
+            InetTest();
+            break;
+        case UDP_MORE_TEST:
+            UdpTestMore();
+            break;
+        case TCP_MORE_TEST:
+            TcpTestMore();
+            break;
+        case TCP_SELECT_TEST:
+            TcpTestSelect();
+            break;
+        case TCP_POLL_TEST:
+            TcpTestPoll();
+            break;
+        case NETIF_TEST:
+            UdpTestNetif();
+            break;
+        case TCP_DUP_TEST:
+            TcpTestDup();
+            break;
+        case TCP_LONG_TEST:
+            TcpTestLong();
+            break;
+        default:
+          break;
+    }
+}
+
+osTimerId_t g_lwipTestTimerId = NULL;
+
+void LwipTestStartTimer(uint32_t timeout)
+{
+    osStatus_t status;
+    if (g_lwipTestTimerId != NULL) {
+        status = osTimerStart(g_lwipTestTimerId, timeout);
+        if (status != osOK) {
+            return;
+        }
+    } else {
+        g_lwipTestTimerId = osTimerNew((osTimerFunc_t)LwipTestTimeoutCallback, osTimerPeriodic, NULL, NULL);
+        if (g_lwipTestTimerId == NULL) {
+            return;
+        }
+        status = osTimerStart(g_lwipTestTimerId, timeout);
+        if (status != osOK) {
+            return;
+        }
+    }
+}
+
+void LwipTestEnter()
+{
+    LwipTestStartTimer(LWIP_TEST_TIMEOUT);
+}