[net][netdev]add network interface device components, SAL component adaptation netdev change

components/finsh/msh_cmd.c

@@ -291,97 +291,6 @@ int cmd_echo(int argc, char** argv)
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_echo, __cmd_echo, echo string to file);
 #endif
 
-#ifdef RT_USING_LWIP
-int cmd_ifconfig(int argc, char **argv)
-{
-    extern void list_if(void);
-    extern void set_if(char *netif_name, char *ip_addr, char *gw_addr, char *nm_addr);
-
-
-    if (argc == 1)
-    {
-        list_if();
-    }
-    else if (argc == 5)
-    {
-        rt_kprintf("config : %s\n", argv[1]);
-        rt_kprintf("IP addr: %s\n", argv[2]);
-        rt_kprintf("Gateway: %s\n", argv[3]);
-        rt_kprintf("netmask: %s\n", argv[4]);
-        set_if(argv[1], argv[2], argv[3], argv[4]);
-    }
-    else
-    {
-        rt_kprintf("bad parameter! e.g: ifconfig e0 192.168.1.30 192.168.1.1 255.255.255.0\n");
-    }
-
-    return 0;
-}
-FINSH_FUNCTION_EXPORT_ALIAS(cmd_ifconfig, __cmd_ifconfig, list the information of network interfaces);
-
-#ifdef RT_LWIP_DNS
-#include <lwip/api.h>
-#include <lwip/dns.h>
-#include <lwip/ip_addr.h>
-#include <lwip/init.h>
-
-int cmd_dns(int argc, char **argv)
-{
-    extern void set_dns(char* dns_server);
-
-    if (argc == 1)
-    {
-        int index;
-
-#if (LWIP_VERSION) < 0x02000000U
-        ip_addr_t ip_addr;
-        for(index=0; index<DNS_MAX_SERVERS; index++)
-        {
-            ip_addr = dns_getserver(index);
-            rt_kprintf("dns server #%d: %s\n", index, ipaddr_ntoa(&ip_addr));
-        }
-#else
-        const ip_addr_t *ip_addr;
-        for(index=0; index<DNS_MAX_SERVERS; index++)
-        {
-            ip_addr = dns_getserver(index);
-            rt_kprintf("dns server #%d: %s\n", index, ipaddr_ntoa(ip_addr));
-        }
-#endif
-    }
-    else if (argc == 2)
-    {
-        rt_kprintf("dns : %s\n", argv[1]);
-        set_dns(argv[1]);
-    }
-    else
-    {
-        rt_kprintf("bad parameter! e.g: dns 114.114.114.114\n");
-    }
-    return 0;
-}
-FINSH_FUNCTION_EXPORT_ALIAS(cmd_dns, __cmd_dns, list the information of dns);
-#endif
-
-#if defined (RT_LWIP_TCP) || defined (RT_LWIP_UDP)
-int cmd_netstat(int argc, char **argv)
-{
-    extern void list_tcps(void);
-    extern void list_udps(void);
-
-#ifdef RT_LWIP_TCP
-    list_tcps();
-#endif
-#ifdef RT_LWIP_UDP
-    list_udps();
-#endif
-
-    return 0;
-}
-FINSH_FUNCTION_EXPORT_ALIAS(cmd_netstat, __cmd_netstat, list the information of TCP / IP);
-#endif
-#endif /* RT_USING_LWIP */
-
 int cmd_ps(int argc, char **argv)
 {
     extern long list_thread(void);

components/net/Kconfig

@@ -4,6 +4,8 @@ menu "Socket abstraction layer"
     
 config RT_USING_SAL
     bool "Enable socket abstraction layer"
+    select RT_USING_NETDEV
+    select RT_USING_SYSTEM_WORKQUEUE
     default n
 
     if RT_USING_SAL
@@ -46,10 +48,30 @@ config RT_USING_SAL
                 default 16
        
         endif
+
+    endif
+
+endmenu
+
+menu "Network interface device"
+
+config RT_USING_NETDEV
+    bool "Enable network interface device"
+    default n
+
+    if RT_USING_NETDEV
+
+        config NETDEV_USING_IFCONFIG
+            bool "Enable ifconfig features"
+            default y
+
+        config NETDEV_USING_PING
+            bool "Enable ping features"
+            default y
         
-        config SAL_PROTO_FAMILIES_NUM
-            int "the maximum number of protocol families"
-            default 4
+        config NETDEV_USING_NETSTAT
+            bool "Enable netstat features"
+            default y
 
     endif
 
@@ -79,9 +101,11 @@ config RT_USING_LWIP
         endchoice
 
         if (RT_USING_LWIP210 || RT_USING_LWIP202)
-            config RT_USING_LWIP_IPV6
-                bool "IPV6 protocol"
-                default n
+            if (!RT_USING_NETDEV || (RT_USING_NETDEV && NETDEV_IPV6))
+                config RT_USING_LWIP_IPV6
+                    bool "IPV6 protocol"
+                    default n
+            endif
         endif
 
         config RT_LWIP_IGMP
@@ -229,7 +253,11 @@ config RT_USING_LWIP
             default n
 
         config LWIP_NETIF_STATUS_CALLBACK
-            int "netif status callback"
+            int "Enable netif status callback"
+            default 1
+        
+        config LWIP_NETIF_LINK_CALLBACK
+            int "Enable netif link status callback"
             default 1
 
         config SO_REUSE
@@ -264,6 +292,13 @@ config RT_USING_LWIP
         config RT_LWIP_USING_HW_CHECKSUM
             bool "Enable hardware checksum"
             default n
+        
+        config RT_LWIP_USING_PING
+            bool "Enable ping features"
+            default y
+            select NETDEV_USING_PING
+            select RT_LWIP_ICMP
+            select RT_LWIP_RAW
 
         menuconfig RT_LWIP_DEBUG
             bool "Enable lwIP Debugging Options"

components/net/netdev/SConscript

@@ -0,0 +1,13 @@
+# RT-Thread building script for component
+
+from building import *
+
+cwd = GetCurrentDir()
+
+src = Glob('src/*.c')
+
+CPPPATH = [cwd + '/include']
+
+group = DefineGroup('netdev', src, depend = ['RT_USING_NETDEV'], CPPPATH = CPPPATH)
+
+Return('group')

components/net/sal_socket/include/socket/arpa/inet.h → components/net/netdev/include/arpa/inet.h

@@ -8,9 +8,9 @@
  * 2015-02-17     Bernard      First version
  */
 
-#ifndef INET_H__
-#define INET_H__
+#ifndef __INET_H__
+#define __INET_H__
 
-#include <sal_ipaddr.h>
+#include <netdev_ipaddr.h>
 
 #endif

components/net/netdev/include/netdev.h

@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2006-2019, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-03-18     ChenYong     First version
+ */
+
+#ifndef __NETDEV_H__
+#define __NETDEV_H__
+
+#include <rtthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* the maximum of all used hardware address lengths */
+#ifndef NETDEV_HWADDR_MAX_LEN
+#define NETDEV_HWADDR_MAX_LEN          8U
+#endif
+
+/* the maximum of dns server number supported */
+#ifndef NETDEV_DNS_SERVERS_NUM
+#define NETDEV_DNS_SERVERS_NUM         2U
+#endif
+
+/* whether the network interface device is 'up' (set by the network interface driver or application) */
+#define NETDEV_FLAG_UP                 0x01U
+/* if set, the network interface device has broadcast capability, only supported in the 'lwIP' stack */
+#define NETDEV_FLAG_BROADCAST          0x02U
+/* if set, the network interface device has an active link (set by the network interface driver) */
+#define NETDEV_FLAG_LINK_UP            0x04U
+/* if set, the network interface device is an ethernet device using ARP, only supported in the 'lwIP' stack */
+#define NETDEV_FLAG_ETHARP             0x08U
+/* if set, the network interface device is an ethernet device, only supported in the 'lwIP' stack */
+#define NETDEV_FLAG_ETHERNET           0x10U
+/* if set, the network interface device has IGMP capability, only supported in the 'lwIP' stack */
+#define NETDEV_FLAG_IGMP               0x20U
+/* if set, the network interface device has MLD6 capability, only supported in the 'lwIP' stack */
+#define NETDEV_FLAG_MLD6               0x40U
+/* if set, the network interface device connected to internet successfully (set by the network interface driver) */
+#define NETDEV_FLAG_INTERNET_UP        0x80U
+/* if set, the network interface device has DHCP capability (set by the network interface device driver or application) */
+#define NETDEV_FLAG_DHCP               0x100U
+
+enum netdev_cb_type
+{
+    NETDEV_CB_ADDR_IP,                 /* IP address */
+    NETDEV_CB_ADDR_NETMASK,            /* subnet mask */
+    NETDEV_CB_ADDR_GATEWAY,            /* netmask */
+    NETDEV_CB_ADDR_DNS_SERVER,         /* dns server */
+    NETDEV_CB_STATUS_UP,               /* changed to 'up' */
+    NETDEV_CB_STATUS_DOWN,             /* changed to 'down' */
+    NETDEV_CB_STATUS_LINK_UP,          /* changed to 'link up' */
+    NETDEV_CB_STATUS_LINK_DOWN,        /* changed to 'link down' */
+    NETDEV_CB_STATUS_INTERNET_UP,      /* changed to 'internet up' */
+    NETDEV_CB_STATUS_INTERNET_DOWN,    /* changed to 'internet down' */
+    NETDEV_CB_STATUS_DHCP_ENABLE,      /* enable DHCP capability */
+    NETDEV_CB_STATUS_DHCP_DISABLE,     /* disable DHCP capability */
+};
+
+struct netdev;
+
+/* function prototype for network interface device status or address change callback functions */
+typedef void (*netdev_callback_fn )(struct netdev *netdev, enum netdev_cb_type type);
+
+struct netdev_ops;
+
+/* network interface device object */
+struct netdev
+{
+    rt_slist_t list; 
+    
+    char name[RT_NAME_MAX];                            /* network interface device name */
+    ip_addr_t ip_addr;                                 /* IP address */
+    ip_addr_t netmask;                                 /* subnet mask */
+    ip_addr_t gw;                                      /* gateway */
+    ip_addr_t dns_servers[NETDEV_DNS_SERVERS_NUM];     /* DNS server */
+    uint8_t hwaddr_len;                                /* hardware address length */
+    uint8_t hwaddr[NETDEV_HWADDR_MAX_LEN];             /* hardware address */
+    
+    uint16_t flags;                                    /* network interface device status flag */
+    uint16_t mtu;                                      /* maximum transfer unit (in bytes) */
+    const struct netdev_ops *ops;                      /* network interface device operations */
+    
+    netdev_callback_fn status_callback;                /* network interface device flags change callback */
+    netdev_callback_fn addr_callback;                  /* network interface device address information change callback */
+
+#ifdef RT_USING_SAL
+    void *sal_user_data;                               /* user-specific data for SAL */
+#endif /* RT_USING_SAL */
+    void *user_data;                                   /* user-specific data */
+};
+
+/* The list of network interface device */
+extern struct netdev *netdev_list;
+/* The default network interface device */
+extern struct netdev *netdev_default;
+
+/* The network interface device ping response object */
+struct netdev_ping_resp
+{
+    ip_addr_t ip_addr;                           /* response IP address */
+    uint16_t data_len;                           /* response data length */
+    uint16_t ttl;                                /* time to live */
+    uint32_t ticks;                              /* response time, unit tick */
+    void *user_data;                             /* user-specific data */
+};
+
+/* The network interface device operations */
+struct netdev_ops
+{
+    /* set network interface device hardware status operations */
+    int (*set_up)(struct netdev *netdev);
+    int (*set_down)(struct netdev *netdev);
+
+    /* set network interface device address information operations */
+    int (*set_addr_info)(struct netdev *netdev, ip_addr_t *ip_addr, ip_addr_t *netmask, ip_addr_t *gw);
+    int (*set_dns_server)(struct netdev *netdev, ip_addr_t *dns_server);
+    int (*set_dhcp)(struct netdev *netdev, rt_bool_t is_enabled);
+
+    /* set network interface device common network interface device operations */
+    int (*ping)(struct netdev *netdev, const char *host, size_t data_len, uint32_t timeout, struct netdev_ping_resp *ping_resp);
+    void (*netstat)(struct netdev *netdev);
+
+};
+
+/* The network interface device registered and unregistered*/
+int netdev_register(struct netdev *netdev, const char *name, void *user_data);
+int netdev_unregister(struct netdev *netdev);
+
+/* Get network interface device object */
+struct netdev *netdev_get_first_link_up(void);
+struct netdev *netdev_get_by_ipaddr(ip_addr_t *ip_addr);
+struct netdev *netdev_get_by_name(const char *name);
+#ifdef RT_USING_SAL
+struct netdev *netdev_get_by_family(int family);
+#endif /* RT_USING_SAL */
+
+/* Set default network interface device in list */
+void netdev_set_default(struct netdev *netdev);
+
+/*  Set network interface device status */
+int netdev_set_up(struct netdev *netdev);
+int netdev_set_down(struct netdev *netdev);
+int netdev_dhcp_enabled(struct netdev *netdev, rt_bool_t is_enabled);
+
+/* Get network interface device status */
+#define netdev_is_up(netdev) (((netdev)->flags & NETDEV_FLAG_UP) ? (uint8_t)1 : (uint8_t)0)
+#define netdev_is_link_up(netdev) (((netdev)->flags & NETDEV_FLAG_LINK_UP) ? (uint8_t)1 : (uint8_t)0)
+#define netdev_is_internet_up(netdev) (((netdev)->flags & NETDEV_FLAG_INTERNET_UP) ? (uint8_t)1 : (uint8_t)0)
+#define netdev_is_dhcp_enabled(netdev) (((netdev)->flags & NETDEV_FLAG_DHCP) ? (uint8_t)1 : (uint8_t)0)
+
+/* Set network interface device address */
+int netdev_set_ipaddr(struct netdev *netdev, const ip_addr_t *ipaddr);
+int netdev_set_netmask(struct netdev *netdev, const ip_addr_t *netmask);
+int netdev_set_gw(struct netdev *netdev, const ip_addr_t *gw);
+int netdev_set_dns_server(struct netdev *netdev, uint8_t dns_num, const ip_addr_t *dns_server);
+
+/* Set network interface device callback, it can be called when the status or address changed */
+void netdev_set_status_callback(struct netdev *netdev, netdev_callback_fn status_callback);
+
+/* Set network interface device status and address, this function can only be called in the network interface device driver */
+void netdev_low_level_set_ipaddr(struct netdev *netdev, const ip_addr_t *ipaddr);
+void netdev_low_level_set_netmask(struct netdev *netdev, const ip_addr_t *netmask);
+void netdev_low_level_set_gw(struct netdev *netdev, const ip_addr_t *gw);
+void netdev_low_level_set_dns_server(struct netdev *netdev, uint8_t dns_num, const ip_addr_t *dns_server);
+void netdev_low_level_set_status(struct netdev *netdev, rt_bool_t is_up);
+void netdev_low_level_set_link_status(struct netdev *netdev, rt_bool_t is_up);
+void netdev_low_level_set_dhcp_status(struct netdev *netdev, rt_bool_t is_enable);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __NETDEV_H__ */

components/net/netdev/include/netdev_ipaddr.h

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-05-18     ChenYong     First version
+ */
+
+#ifndef __NETDEV_IPADDR_H__
+#define __NETDEV_IPADDR_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Only supports the IPV4 protocol */
+#ifndef NETDEV_IPV4
+#define NETDEV_IPV4           1
+#endif
+
+#ifndef NETDEV_IPV6
+#define NETDEV_IPV6           0
+#endif
+
+#ifdef NETDEV_IPV4
+/** IPv4 only: set the IP address given as an u32_t */
+#define ip4_addr_set_u32(dest_ipaddr, src_u32) ((dest_ipaddr)->addr = (src_u32))
+/** IPv4 only: get the IP address as an u32_t */
+#define ip4_addr_get_u32(src_ipaddr) ((src_ipaddr)->addr)
+
+#define IP4ADDR_STRLEN_MAX  16
+#endif /* NETIF_IPV4 */
+
+/* These macros should be calculated by the preprocessor and are used
+   with compile-time constants only (so that there is no little-endian
+   overhead at runtime). */
+#define PP_HTONS(x) ((((x) & 0x00ffUL) << 8) | (((x) & 0xff00UL) >> 8))
+#define PP_NTOHS(x) PP_HTONS(x)
+#define PP_HTONL(x) ((((x) & 0x000000ffUL) << 24) | \
+                     (((x) & 0x0000ff00UL) <<  8) | \
+                     (((x) & 0x00ff0000UL) >>  8) | \
+                     (((x) & 0xff000000UL) >> 24))
+#define PP_NTOHL(x) PP_HTONL(x)
+
+#define htons(x) (uint16_t)PP_HTONS(x)
+#define ntohs(x) (uint16_t)PP_NTOHS(x)
+#define htonl(x) (uint32_t)PP_HTONL(x)
+#define ntohl(x) (uint32_t)PP_NTOHL(x)
+
+/* If your port already typedef's in_addr_t, define IN_ADDR_T_DEFINED
+   to prevent this code from redefining it. */
+#if !defined(in_addr_t) && !defined(IN_ADDR_T_DEFINED)
+typedef uint32_t in_addr_t;
+#endif
+
+#if NETDEV_IPV4
+struct in_addr
+{
+    in_addr_t s_addr;
+};
+
+typedef struct ip4_addr
+{
+    uint32_t addr;
+} ip4_addr_t;
+
+typedef ip4_addr_t ip_addr_t;
+#endif /* NETIF_IPV4 */
+
+#if NETDEV_IPV6
+struct in6_addr
+{
+    union
+    {
+        uint32_t u32_addr[4];
+        uint8_t u8_addr[16];
+    } un;
+#define s6_addr  un.u8_addr
+};
+
+typedef struct ip6_addr
+{
+    uint32_t addr[4];
+} ip6_addr_t;
+
+typedef ip6_addr ip_addr_t
+#endif /* NETIF_IPV6 */
+
+#if NETDEV_IPV4 && NETDEV_IPV6
+/* IP address types for use in ip_addr_t.type member */
+enum netdev_ip_addr_type
+{
+    /** IPv4 */
+    IPADDR_TYPE_V4 = 0U,
+    /** IPv6 */
+    IPADDR_TYPE_V6 = 6U,
+    /** IPv4+IPv6 ("dual-stack") */
+    IPADDR_TYPE_ANY = 46U
+};
+
+/* A union struct for both IP version's addresses */
+typedef struct _ip_addr
+{
+    union
+    {
+        ip6_addr_t ip6;
+        ip4_addr_t ip4;
+    } u_addr;
+    /** @ref netdev_ip_addr_type */
+    uint8_t type;
+} ip_addr_t;
+#endif /* NETIF_IPV4 && NETIF_IPV6 */
+
+/** 255.255.255.255 */
+#define IPADDR_NONE         ((uint32_t)0xffffffffUL)
+/** 127.0.0.1 */
+#define IPADDR_LOOPBACK     ((uint32_t)0x7f000001UL)
+/** 0.0.0.0 */
+#define IPADDR_ANY          ((uint32_t)0x00000000UL)
+/** 255.255.255.255 */
+#define IPADDR_BROADCAST    ((uint32_t)0xffffffffUL)
+
+/** 255.255.255.255 */
+#define INADDR_NONE         IPADDR_NONE
+/** 127.0.0.1 */
+#define INADDR_LOOPBACK     IPADDR_LOOPBACK
+/** 0.0.0.0 */
+#define INADDR_ANY          IPADDR_ANY
+/** 255.255.255.255 */
+#define INADDR_BROADCAST    IPADDR_BROADCAST
+
+#define IPADDR_BROADCAST_STRING "255.255.255.255"
+
+#ifdef NETDEV_IPV4
+
+/** Copy IP address - faster than ip4_addr_set: no NULL check */
+#define ip4_addr_copy(dest, src)            ((dest).addr = (src).addr)
+#define ip4_addr_cmp(addr1, addr2)          ((addr1)->addr == (addr2)->addr)
+/** Set complete address to zero */
+#define ip4_addr_set_zero(ipaddr)           ((ipaddr)->addr = 0)
+#define ip4_addr_isany_val(ipaddr)          ((ipaddr).addr == IPADDR_ANY)
+#define ip4_addr_isany(ipaddr)              ((ipaddr) == NULL || ip4_addr_isany_val(*(ipaddr)))
+
+#define ip_addr_copy(dest, src)             ip4_addr_copy(dest, src)
+#define ip_addr_cmp(addr1, addr2)           ip4_addr_cmp(addr1, addr2)
+#define ip_addr_set_zero(ipaddr)            ip4_addr_set_zero(ipaddr)
+#define ip_addr_isany(ipaddr)               ip4_addr_isany(ipaddr)
+
+in_addr_t netdev_ipaddr_addr(const char *cp);
+int netdev_ip4addr_aton(const char *cp, ip4_addr_t *addr);
+char *netdev_ip4addr_ntoa(const ip4_addr_t *addr);
+char *netdev_ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen);
+
+#define inet_addr(cp)                       netdev_ipaddr_addr(cp)
+#define inet_aton(cp, addr)                 netdev_ip4addr_aton(cp,(ip4_addr_t*)addr)
+#define inet_ntoa(addr)                     netdev_ip4addr_ntoa((const ip4_addr_t*)&(addr))
+#define inet_ntoa_r(addr, buf, buflen)      netdev_ip4addr_ntoa_r((const ip4_addr_t*)&(addr), buf, buflen)
+
+#endif /* NETDEV_IPV4 */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __NETDEV_IPADDR_H__ */

components/net/netdev/src/netdev.c

@@ -0,0 +1,1115 @@
+/*
+ * Copyright (c) 2006-2019, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-03-18     ChenYong     First version
+ */
+
+#include <stdio.h>
+
+#include <rtthread.h>
+#include <rthw.h>
+
+#include <netdev_ipaddr.h>
+#include <netdev.h>
+
+#ifdef RT_USING_SAL
+#include <sal_netdb.h>
+#include <sal.h>
+#endif /* RT_USING_SAL */
+
+#define DBG_TAG              "netdev"
+#define DBG_LVL              DBG_INFO
+#include <rtdbg.h>
+
+/* The list of network interface device */
+struct netdev *netdev_list;
+/* The default network interface device */
+struct netdev *netdev_default;
+
+/**
+ * This function will register network interface device and
+ * add it to network interface device list.
+ * 
+ * @param netdev the network interface device object
+ * @param name the network interface device name
+ * @param user_data user-specific data
+ * 
+ * @return  0: registered successfully
+ *         -1: registered failed
+ */
+int netdev_register(struct netdev *netdev, const char *name, void *user_data)
+{
+    rt_base_t level;
+    uint16_t flags_mask;
+    int index;
+
+    RT_ASSERT(netdev);
+    RT_ASSERT(name);
+
+    /* clean network interface device */
+    flags_mask = NETDEV_FLAG_UP | NETDEV_FLAG_LINK_UP | NETDEV_FLAG_INTERNET_UP | NETDEV_FLAG_DHCP;
+    netdev->flags &= ~flags_mask;
+
+    ip_addr_set_zero(&(netdev->ip_addr));
+    ip_addr_set_zero(&(netdev->netmask));
+    ip_addr_set_zero(&(netdev->gw));
+    for (index = 0; index < NETDEV_DNS_SERVERS_NUM; index++)
+    {
+        ip_addr_set_zero(&(netdev->dns_servers[index]));
+    }
+    netdev->status_callback = RT_NULL;
+    netdev->addr_callback = RT_NULL;
+
+    /* fill network interface device */
+    rt_strncpy(netdev->name, name, rt_strlen(name));
+    netdev->user_data = user_data;
+
+    /* initialize current network interface device single list */
+    rt_slist_init(&(netdev->list));
+
+    level = rt_hw_interrupt_disable();
+
+    if (netdev_list == RT_NULL)
+    {
+        netdev_list = netdev;
+        netdev_default = netdev;
+    }
+    else
+    {
+        /* tail insertion */
+        rt_slist_append(&(netdev_list->list), &(netdev->list));
+    }
+
+    rt_hw_interrupt_enable(level);
+
+    return RT_EOK;    
+}
+
+/**
+ * This function will unregister network interface device and
+ * delete it from network interface device list.
+ * 
+ * @param netdev the network interface device object
+ * 
+ * @return  0: unregistered successfully
+ *         -1: unregistered failed
+ */
+int netdev_unregister(struct netdev *netdev)
+{
+    rt_base_t level;
+    rt_slist_t *node = RT_NULL;
+    struct netdev *cur_netdev = RT_NULL;
+
+    RT_ASSERT(netdev);
+    
+    if (netdev_list == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(netdev_list->list); node; node = rt_slist_next(node))
+    {
+        cur_netdev = rt_slist_entry(node, struct netdev, list);
+        if (cur_netdev && (rt_memcpy(cur_netdev, netdev, sizeof(struct netdev)) == 0))
+        {
+            rt_slist_remove(&(netdev_list->list), &(cur_netdev->list));
+            rt_hw_interrupt_enable(level);
+
+            return RT_EOK;
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+
+    /* not find this network interface device in network interface device list */
+    return -RT_ERROR;
+}
+
+/**
+ * This function will get the first network interface device
+ * with the link_up status in network interface device list.
+ * 
+ * @return != NULL: network interface device object
+ *            NULL: get failed 
+ */
+struct netdev *netdev_get_first_link_up(void)
+{
+    rt_base_t level;
+    rt_slist_t *node = RT_NULL;
+    struct netdev *netdev = RT_NULL;
+
+    if (netdev_list == RT_NULL)
+    {
+        return RT_NULL;
+    }
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_slist_entry(node, struct netdev, list);
+        if (netdev && netdev_is_up(netdev) && netdev_is_link_up(netdev))
+        {
+            rt_hw_interrupt_enable(level);
+            return netdev;
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+
+    return RT_NULL;
+}
+
+/**
+ * This function will get the first network interface device
+ * in network interface device list by IP address.
+ * 
+ * @param addr the network interface device IP address
+ * 
+ * @return != NULL: network interface device object
+ *            NULL: get failed 
+ */
+struct netdev *netdev_get_by_ipaddr(ip_addr_t *ip_addr)
+{
+    rt_base_t level;
+    rt_slist_t *node = RT_NULL;
+    struct netdev *netdev = RT_NULL;
+
+    if (netdev_list == RT_NULL)
+    {
+        return RT_NULL;
+    }
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_slist_entry(node, struct netdev, list);
+        if (netdev && ip_addr_cmp(&(netdev->ip_addr), ip_addr))
+        {
+            rt_hw_interrupt_enable(level);
+            return netdev;
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+
+    return RT_NULL;
+}
+
+/**
+ * This function will get network interface device
+ * in network interface device list by netdev name.
+ * 
+ * @param name the network interface device name
+ * 
+ * @return != NULL: network interface device object
+ *            NULL: get failed 
+ */
+struct netdev *netdev_get_by_name(const char *name)
+{
+    rt_base_t level;
+    rt_slist_t *node = RT_NULL;
+    struct netdev *netdev = RT_NULL;
+
+    if (netdev_list == RT_NULL)
+    {
+        return RT_NULL;
+    }
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_slist_entry(node, struct netdev, list);
+        if (netdev && (rt_strncmp(netdev->name, name, rt_strlen(netdev->name)) == 0))
+        {
+            rt_hw_interrupt_enable(level);
+            return netdev;
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+
+    return RT_NULL;
+}
+
+#ifdef RT_USING_SAL
+/**
+ * This function will get the first network interface device
+ * in network interface device list by protocol family type.
+ * 
+ * @param family the network interface device protocol family type
+ * 
+ * @return != NULL: network interface device object
+ *            NULL: get failed 
+ */
+struct netdev *netdev_get_by_family(int family)
+{
+    rt_base_t level;
+    rt_slist_t *node = RT_NULL;
+    struct netdev *netdev = RT_NULL;
+    struct sal_proto_family *pf = RT_NULL;
+
+    if (netdev_list == RT_NULL)
+    {
+        return RT_NULL;
+    }
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_slist_entry(node, struct netdev, list);
+        pf = (struct sal_proto_family *) netdev->sal_user_data;
+        if (pf && pf->skt_ops && pf->family == family &&
+                netdev_is_up(netdev) && netdev_is_link_up(netdev))
+        {
+            rt_hw_interrupt_enable(level);
+            return netdev;
+        }
+    }
+
+    for (node = &(netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_slist_entry(node, struct netdev, list);
+        pf = (struct sal_proto_family *) netdev->sal_user_data;
+        if (pf && pf->skt_ops && pf->sec_family == family &&
+                netdev_is_up(netdev) && netdev_is_link_up(netdev))
+        {
+            rt_hw_interrupt_enable(level);
+            return netdev;
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+
+    return RT_NULL;
+}
+
+#endif /* RT_USING_SAL */
+
+/**
+ * This function will set default network interface device.
+ * 
+ * @param netdev the network interface device to change
+ */
+void netdev_set_default(struct netdev *netdev)
+{
+    if (netdev)
+    {
+        netdev_default = netdev;
+        LOG_D("Setting default network interface device name(%s) successfully.", netdev->name);       
+    }
+}
+
+/**
+ * This function will enable network interface device .
+ * 
+ * @param netdev the network interface device to change
+ * 
+ * @return  0: set status successfully
+ *         -1: set status failed
+ */
+int netdev_set_up(struct netdev *netdev)
+{
+    RT_ASSERT(netdev);
+
+    if (!netdev->ops || !netdev->ops->set_up)
+    {
+        LOG_E("The network interface device(%s) not support to set status.", netdev->name);
+        return -RT_ERROR;
+    }
+    
+    /* network interface device status flags check */
+    if (netdev_is_up(netdev))
+    {
+        return RT_EOK;
+    }
+
+    /* execute enable network interface device operations by network interface device driver */
+    return netdev->ops->set_up(netdev);
+}
+/**
+ * This function will disable network interface device.
+ * 
+ * @param netdev the network interface device to change
+ * 
+ * @return  0: set status successfully
+ *         -1: set sttaus failed
+ */
+int netdev_set_down(struct netdev *netdev)
+{
+    RT_ASSERT(netdev);
+
+    if (!netdev->ops || !netdev->ops->set_down)
+    {
+        LOG_E("The network interface device(%s) not support to set status.", netdev->name);
+        return -RT_ERROR;
+    }
+    
+    /* network interface device status flags check */
+    if (!netdev_is_up(netdev))
+    {
+        return RT_EOK;
+    }
+
+    /* execute disable network interface device operations by network interface driver */
+    return netdev->ops->set_down(netdev);
+}
+
+/**
+ * This function will control network interface device DHCP capability enable or disable.
+ * 
+ * @param netdev the network interface device device to change
+ * @param is_enable the new DHCP status
+ * 
+ * @return  0: set DHCP status successfully
+ *         -1: set DHCP status failed
+ */
+int netdev_dhcp_enabled(struct netdev *netdev, rt_bool_t is_enabled)
+{
+    RT_ASSERT(netdev);
+
+    if (!netdev->ops || !netdev->ops->set_dhcp)
+    {
+        LOG_E("The network interface device(%s) not support to set DHCP status.", netdev->name);
+        return -RT_ERROR;
+    }
+
+    /* network interface device DHCP flags check */
+    if (netdev_is_dhcp_enabled(netdev) == is_enabled)
+    {
+        return RT_EOK;
+    }
+    
+    /* execute network interface device DHCP capability control operations */
+    return netdev->ops->set_dhcp(netdev, is_enabled);
+}
+
+/**
+ * This function will set network interface device IP address.
+ * 
+ * @param netdev the network interface device to change
+ * @param ipaddr the new IP address
+ * 
+ * @return  0: set IP address successfully
+ *         -1: set IP address failed
+ */
+int netdev_set_ipaddr(struct netdev *netdev, const ip_addr_t *ip_addr)
+{
+    RT_ASSERT(netdev);
+    RT_ASSERT(ip_addr);
+
+    if (!netdev->ops || !netdev->ops->set_addr_info)
+    {
+        LOG_E("The network interface device(%s) not support to set IP address.", netdev->name);
+        return -RT_ERROR;
+    }
+    
+    if (netdev_is_dhcp_enabled(netdev))
+    {
+        LOG_E("The network interface device(%s) DHCP capability is enable, not support set IP address.", netdev->name);
+        return -RT_ERROR;
+    }
+
+     /* execute network interface device set IP address operations */
+    return netdev->ops->set_addr_info(netdev, (ip_addr_t *)ip_addr, RT_NULL, RT_NULL);
+}
+
+/**
+ * This function will set network interface device netmask address.
+ * 
+ * @param netdev the network interface device to change
+ * @param netmask the new netmask address
+ * 
+ * @return  0: set netmask address successfully
+ *         -1: set netmask address failed
+ */
+int netdev_set_netmask(struct netdev *netdev, const ip_addr_t *netmask)
+{
+    RT_ASSERT(netdev);
+    RT_ASSERT(netmask);
+
+    if (!netdev->ops || !netdev->ops->set_addr_info)
+    {
+        LOG_E("The network interface device(%s) not support to set netmask address.", netdev->name);
+        return -RT_ERROR;
+    }
+    
+    if (netdev_is_dhcp_enabled(netdev))
+    {
+        LOG_E("The network interface device(%s) DHCP capability is enable, not support set netmask address.", netdev->name);
+        return -RT_ERROR;
+    }
+
+    /* execute network interface device set netmask address operations */
+    return netdev->ops->set_addr_info(netdev, RT_NULL, (ip_addr_t *)netmask, RT_NULL);
+}
+
+/**
+ * This function will set network interface device gateway address.
+ * 
+ * @param netdev the network interface device to change
+ * @param gateway the new gateway address 
+ * 
+ * @return  0: set gateway address successfully
+ *         -1: set gateway address failed
+ */
+int netdev_set_gw(struct netdev *netdev, const ip_addr_t *gw)
+{
+    RT_ASSERT(netdev);
+    RT_ASSERT(gw);
+
+    if (!netdev->ops || !netdev->ops->set_addr_info)
+    {
+        LOG_E("The network interface device(%s) not support to set gateway address.", netdev->name);
+        return -RT_ERROR;
+    }
+    
+    if (netdev_is_dhcp_enabled(netdev))
+    {
+        LOG_E("The network interface device(%s) DHCP capability is enable, not support set gateway address.", netdev->name);
+        return -RT_ERROR;
+    }
+
+    /* execute network interface device set gateway address operations */
+    return netdev->ops->set_addr_info(netdev, RT_NULL, RT_NULL, (ip_addr_t *)gw);
+}
+
+/**
+ * This function will set network interface device DNS server address.
+ * 
+ * @param netdev the network interface device to change
+ * @param dns_server the new DNS server address
+ * 
+ * @return  0: set netmask address successfully
+ *         -1: set netmask address failed
+ */
+int netdev_set_dns_server(struct netdev *netdev, uint8_t dns_num, const ip_addr_t *dns_server)
+{
+    RT_ASSERT(netdev);
+    RT_ASSERT(dns_server);
+
+    if (dns_num >= NETDEV_DNS_SERVERS_NUM)
+    {
+        LOG_E("The number of DNS servers(%d) set exceeds the maximum number(%d).", dns_num + 1, NETDEV_DNS_SERVERS_NUM);
+        return -RT_ERROR;
+    }
+
+    if (!netdev->ops || !netdev->ops->set_dns_server)
+    {
+        LOG_E("The network interface device(%s) not support to set DNS server address.", netdev->name);
+        return -RT_ERROR;
+    }
+
+    /* execute network interface device set DNS server address operations */
+    return netdev->ops->set_dns_server(netdev, (ip_addr_t *)dns_server);
+}
+
+/**
+ * This function will set callback to be called when the network interface device status has been changed.
+ * 
+ * @param netdev the network interface device to change
+ * @param status_callback the callback be called when the status has been changed.
+ */
+void netdev_set_status_callback(struct netdev *netdev, netdev_callback_fn status_callback)
+{
+    RT_ASSERT(netdev);
+    RT_ASSERT(status_callback);
+
+    netdev->status_callback = status_callback;
+}
+
+/**
+ * This function will set callback to be called when the network interface device address has been changed.
+ * 
+ * @param netdev the network interface device to change
+ * @param addr_callback the callback be called when the address has been changed.
+ */
+void netdev_set_addr_callback(struct netdev *netdev, netdev_callback_fn addr_callback)
+{
+    RT_ASSERT(netdev);
+    RT_ASSERT(addr_callback);
+
+    netdev->addr_callback = addr_callback;
+}
+
+
+/**
+ * This function will set network interface device IP address.
+ * @NOTE it can only be called in the network interface device driver.
+ * 
+ * @param netdev the network interface device to change
+ * @param ipaddr the new IP address
+ */
+void netdev_low_level_set_ipaddr(struct netdev *netdev, const ip_addr_t *ip_addr)
+{
+    RT_ASSERT(ip_addr);
+
+    if (netdev && ip_addr_cmp(&(netdev->ip_addr), ip_addr) == 0)
+    {
+        ip_addr_copy(netdev->ip_addr, *ip_addr);
+
+#ifdef RT_USING_SAL
+        /* set network interface device flags to internet up */
+        if (netdev_is_up(netdev) && netdev_is_link_up(netdev))
+        {
+            sal_check_netdev_internet_up(netdev);
+        }
+#endif /* RT_USING_SAL */
+
+        /* execute IP address change callback function */
+        if (netdev->addr_callback)
+        {
+            netdev->addr_callback(netdev, NETDEV_CB_ADDR_IP);
+        }
+    }
+}
+
+/**
+ * This function will set network interface device netmask address.
+ * @NOTE it can only be called in the network interface device driver.
+ * 
+ * @param netdev the network interface device to change
+ * @param netmask the new netmask address
+ */
+void netdev_low_level_set_netmask(struct netdev *netdev, const ip_addr_t *netmask)
+{
+    RT_ASSERT(netmask);
+
+    if (netdev && ip_addr_cmp(&(netdev->netmask), netmask) == 0)
+    {
+        ip_addr_copy(netdev->netmask, *netmask);
+
+#ifdef RT_USING_SAL
+        /* set network interface device flags to internet up */
+        if (netdev_is_up(netdev) && netdev_is_link_up(netdev) && 
+                !ip_addr_isany(&(netdev->ip_addr)))
+        {
+            sal_check_netdev_internet_up(netdev);
+        }
+#endif /* RT_USING_SAL */
+
+        /* execute netmask address change callback function */
+        if (netdev->addr_callback)
+        {
+            netdev->addr_callback(netdev, NETDEV_CB_ADDR_NETMASK);
+        }
+    }
+}
+
+/**
+ * This function will set network interface device gateway address.
+ * @NOTE it can only be called in the network interface device driver.
+ * 
+ * @param netdev the network interface device to change
+ * @param gateway the new gateway address
+ */
+void netdev_low_level_set_gw(struct netdev *netdev, const ip_addr_t *gw)
+{
+    RT_ASSERT(gw);
+
+    if (netdev && ip_addr_cmp(&(netdev->gw), gw) == 0)
+    {
+        ip_addr_copy(netdev->gw, *gw);
+
+#ifdef RT_USING_SAL
+        /* set network interface device flags to internet up */
+        if (netdev_is_up(netdev) && netdev_is_link_up(netdev) && 
+                !ip_addr_isany(&(netdev->ip_addr)))
+        {
+            sal_check_netdev_internet_up(netdev);
+        }
+#endif /* RT_USING_SAL */
+
+        /* execute gateway address change callback function */
+        if (netdev->addr_callback)
+        {
+            netdev->addr_callback(netdev, NETDEV_CB_ADDR_GATEWAY);
+        }
+    }
+}
+
+/**
+ * This function will set network interface device DNS server address.
+ * @NOTE it can only be called in the network interface device driver.
+ * 
+ * @param netdev the network interface device to change
+ * @param dns_server the new DNS server address
+ * 
+ */
+void netdev_low_level_set_dns_server(struct netdev *netdev, uint8_t dns_num, const ip_addr_t *dns_server)
+{
+    int index;
+
+    RT_ASSERT(dns_server);
+
+    /* check DNS servers is exist */
+    for (index = 0; index < NETDEV_DNS_SERVERS_NUM; index++)
+    {
+        if (ip_addr_cmp(&(netdev->dns_servers[index]), dns_server))
+        {
+            return;
+        }
+    }
+
+    if (netdev && dns_num < NETDEV_DNS_SERVERS_NUM)
+    {
+        ip_addr_copy(netdev->dns_servers[dns_num], *dns_server);
+
+        /* execute DNS servers address change callback function */
+        if (netdev->addr_callback)
+        {
+            netdev->addr_callback(netdev, NETDEV_CB_ADDR_DNS_SERVER);
+        }
+    }
+}
+
+/**
+ * This function will set network interface device status.
+ * @NOTE it can only be called in the network interface device driver.
+ * 
+ * @param netdev the network interface device to change
+ * @param is_up the new status
+ */
+void netdev_low_level_set_status(struct netdev *netdev, rt_bool_t is_up)
+{
+    if (netdev && netdev_is_up(netdev) != is_up)
+    {
+        if (is_up)
+        {
+            netdev->flags |= NETDEV_FLAG_UP;
+        }
+        else
+        {
+            netdev->flags &= ~NETDEV_FLAG_UP;
+        }
+
+        /* execute  network interface device status change callback function */
+        if (netdev->status_callback)
+        {
+            netdev->status_callback(netdev, is_up ? NETDEV_CB_STATUS_UP : NETDEV_CB_STATUS_DOWN);
+        }
+    }
+}
+
+/**
+ * This function will set network interface device active link status.
+ * @NOTE it can only be called in the network interface device driver.
+ * 
+ * @param netdev the network interface device to change
+ * @param is_up the new link status
+ */
+void netdev_low_level_set_link_status(struct netdev *netdev, rt_bool_t is_up)
+{
+    if (netdev && netdev_is_link_up(netdev) != is_up)
+    {   
+        if (is_up)
+        {
+            netdev->flags |= NETDEV_FLAG_LINK_UP;
+
+#ifdef RT_USING_SAL
+            /* set network interface device flags to internet up */
+            if (netdev_is_up(netdev) && !ip_addr_isany(&(netdev->ip_addr)))
+            {
+                sal_check_netdev_internet_up(netdev);
+            }
+#endif /* RT_USING_SAL */
+        }
+        else
+        {
+            netdev->flags &= ~NETDEV_FLAG_LINK_UP;
+            
+            /* set network interface device flags to internet down */
+            netdev->flags &= ~NETDEV_FLAG_INTERNET_UP;
+        }
+
+        /* execute link status change callback function */
+        if (netdev->status_callback)
+        {
+            netdev->status_callback(netdev, is_up ? NETDEV_CB_STATUS_LINK_UP : NETDEV_CB_STATUS_LINK_DOWN);
+        }
+    }
+}
+
+/**
+ * This function will set network interface device DHCP status.
+ * @NOTE it can only be called in the network interface device driver.
+ * 
+ * @param netdev the network interface device to change
+ * @param is_up the new DHCP status
+ */
+void netdev_low_level_set_dhcp_status(struct netdev *netdev, rt_bool_t is_enable)
+{
+    if (netdev && netdev_is_dhcp_enabled(netdev) != is_enable)
+    {
+        if (is_enable)
+        {
+            netdev->flags |= NETDEV_FLAG_DHCP;
+        }
+        else
+        {
+            netdev->flags &= ~NETDEV_FLAG_DHCP;
+        }
+
+        /* execute DHCP status change callback function */
+        if (netdev->status_callback)
+        {
+            netdev->status_callback(netdev, is_enable ? NETDEV_CB_STATUS_DHCP_ENABLE : NETDEV_CB_STATUS_DHCP_DISABLE);
+        }
+    }
+}
+
+#ifdef FINSH_USING_MSH
+
+#include <finsh.h>
+
+#ifdef NETDEV_USING_IFCONFIG
+static void netdev_list_if(void)
+{
+#define NETDEV_IFCONFIG_MAC_MAX_LEN    6
+#define NETDEV_IFCONFIG_IEMI_MAX_LEN   8
+
+    rt_ubase_t index;
+    rt_base_t level;
+    rt_slist_t *node  = RT_NULL;
+    struct netdev *netdev = RT_NULL;
+    struct netdev *cur_netdev_list = netdev_list;
+
+    if (cur_netdev_list == RT_NULL)
+    {
+        rt_kprintf("ifconfig: network interface device list error.\n");
+        return;
+    }
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(cur_netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_list_entry(node, struct netdev, list);
+
+        rt_kprintf("network interface device: %s%s\n",
+                   netdev->name,
+                   (netdev == netdev_default)?" (Default)":"");
+        rt_kprintf("MTU: %d\n", netdev->mtu);
+
+        /* 6 - MAC address, 8 - IEMI */
+        if (netdev->hwaddr_len == NETDEV_IFCONFIG_MAC_MAX_LEN)
+        {
+            rt_kprintf("MAC: ");
+            for (index = 0; index < netdev->hwaddr_len; index++)
+            {
+                rt_kprintf("%02x ", netdev->hwaddr[index]);
+            }
+        }
+        else if (netdev->hwaddr_len == NETDEV_IFCONFIG_IEMI_MAX_LEN)
+        {
+            rt_kprintf("IEMI: ");
+            for (index = 0; index < netdev->hwaddr_len; index++)
+            {
+                /* two numbers are displayed at one time*/
+                if (netdev->hwaddr[index] < 10 && index != netdev->hwaddr_len - 1)
+                    rt_kprintf("0");
+                
+                rt_kprintf("%d", netdev->hwaddr[index]);
+            }
+        }
+
+        rt_kprintf("\nFLAGS:");
+        if (netdev->flags & NETDEV_FLAG_UP) rt_kprintf(" UP");
+        else rt_kprintf(" DOWN");
+        if (netdev->flags & NETDEV_FLAG_LINK_UP) rt_kprintf(" LINK_UP");
+        else rt_kprintf(" LINK_DOWN");
+        if (netdev->flags & NETDEV_FLAG_INTERNET_UP) rt_kprintf(" INTERNET_UP");
+        else rt_kprintf(" INTERNET_DOWN");
+        if (netdev->flags & NETDEV_FLAG_DHCP) rt_kprintf(" DHCP_ENABLE");
+        else rt_kprintf(" DHCP_DISABLE");
+        if (netdev->flags & NETDEV_FLAG_ETHARP) rt_kprintf(" ETHARP");
+        if (netdev->flags & NETDEV_FLAG_BROADCAST) rt_kprintf(" BROADCAST");
+        if (netdev->flags & NETDEV_FLAG_IGMP) rt_kprintf(" IGMP");
+        rt_kprintf("\n");
+        rt_kprintf("ip address: %s\n", inet_ntoa(netdev->ip_addr));
+        rt_kprintf("gw address: %s\n", inet_ntoa(netdev->gw));
+        rt_kprintf("net mask  : %s\n", inet_ntoa(netdev->netmask));
+
+        for (index = 0; index < NETDEV_DNS_SERVERS_NUM; index++)
+        {
+            rt_kprintf("dns server #%d: %s\n", index, inet_ntoa(netdev->dns_servers[index]));
+        }
+        
+        if (rt_slist_next(node))
+        {
+            rt_kprintf("\n");
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+}
+
+static void netdev_set_if(char* netdev_name, char* ip_addr, char* gw_addr, char* nm_addr)
+{
+    struct netdev *netdev = RT_NULL;
+    ip_addr_t addr;
+
+    netdev = netdev_get_by_name(netdev_name);
+    if (netdev == RT_NULL)
+    {
+        rt_kprintf("bad network interface device name(%s).\n", netdev_name);
+        return;
+    }
+
+    /* set IP address */
+    if ((ip_addr != RT_NULL) && inet_aton(ip_addr, &addr))
+    {
+        netdev_set_ipaddr(netdev, &addr);
+    }
+
+    /* set gateway address */
+    if ((gw_addr != RT_NULL) && inet_aton(gw_addr, &addr))
+    {
+        netdev_set_gw(netdev, &addr);
+    }
+
+    /* set netmask address */
+    if ((nm_addr != RT_NULL) && inet_aton(nm_addr, &addr))
+    {
+        netdev_set_netmask(netdev, &addr);
+    }
+}
+
+int netdev_ifconfig(int argc, char **argv)
+{
+    if (argc == 1)
+    {
+        netdev_list_if();
+    }
+    else if (argc == 5)
+    {
+        rt_kprintf("config : %s\n", argv[1]);
+        rt_kprintf("IP addr: %s\n", argv[2]);
+        rt_kprintf("Gateway: %s\n", argv[3]);
+        rt_kprintf("netmask: %s\n", argv[4]);
+        netdev_set_if(argv[1], argv[2], argv[3], argv[4]);
+    }
+    else
+    {
+        rt_kprintf("bad parameter! e.g: ifconfig e0 192.168.1.30 192.168.1.1 255.255.255.0\n");
+    }
+
+    return 0;
+}
+FINSH_FUNCTION_EXPORT_ALIAS(netdev_ifconfig, __cmd_ifconfig, list the information of all network interfaces);
+#endif /* NETDEV_USING_IFCONFIG */
+
+#ifdef NETDEV_USING_PING
+static int netdev_cmd_ping(char* target_name, rt_uint32_t times, rt_size_t size)
+{
+#define NETDEV_PING_DATA_SIZE       32
+/** ping receive timeout - in milliseconds */
+#define NETDEV_PING_RECV_TIMEO      (2 * RT_TICK_PER_SECOND)
+/** ping delay - in milliseconds */
+#define NETDEV_PING_DELAY           (1 * RT_TICK_PER_SECOND)
+/* check netdev ping options */
+#define NETDEV_PING_IS_COMMONICABLE(netdev) \
+    ((netdev) && (netdev)->ops && (netdev)->ops->ping && \
+        netdev_is_up(netdev) && netdev_is_link_up(netdev)) \
+
+    struct netdev *netdev = RT_NULL;
+    struct netdev_ping_resp ping_resp;
+    int index, ret = 0;
+    
+    if (size == 0)
+    {
+        size = NETDEV_PING_DATA_SIZE;
+    }
+
+    if (NETDEV_PING_IS_COMMONICABLE(netdev_default))
+    {
+        /* using default network interface device for ping */
+        netdev = netdev_default;
+    }
+    else
+    {
+        /* using first internet up status network interface device */
+        netdev = netdev_get_first_link_up();
+        if (netdev == RT_NULL || NETDEV_PING_IS_COMMONICABLE(netdev) == 0)
+        {
+            rt_kprintf("ping: network interface device get error.\n");
+            return -RT_ERROR;
+        }
+    }
+
+    for (index = 0; index < times; index++)
+    {
+        rt_memset(&ping_resp, 0x00, sizeof(struct netdev_ping_resp));
+        ret = netdev->ops->ping(netdev, (const char *)target_name, size, NETDEV_PING_RECV_TIMEO, &ping_resp);
+        if (ret == -RT_ETIMEOUT)
+        {
+            rt_kprintf("ping: from %s icmp_seq=%d timeout\n", 
+                (ip_addr_isany(&(ping_resp.ip_addr))) ? target_name : inet_ntoa(ping_resp.ip_addr), index);
+        }
+        else if (ret == -RT_ERROR)
+        {
+            rt_kprintf("ping: unknown %s %s\n",
+                (ip_addr_isany(&(ping_resp.ip_addr))) ? "host" : "address",
+                    (ip_addr_isany(&(ping_resp.ip_addr))) ? target_name : inet_ntoa(ping_resp.ip_addr));
+        }
+        else
+        {
+            if (ping_resp.ttl == 0)
+            {
+                rt_kprintf("%d bytes from %s icmp_seq=%d time=%d ms\n", 
+                            ping_resp.data_len, inet_ntoa(ping_resp.ip_addr), index, ping_resp.ticks);
+            }
+            else
+            {
+                rt_kprintf("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n", 
+                            ping_resp.data_len, inet_ntoa(ping_resp.ip_addr), index, ping_resp.ttl, ping_resp.ticks);
+            }
+        }
+        
+        rt_thread_mdelay(NETDEV_PING_DELAY);
+    }
+
+    return RT_EOK;
+}
+
+int netdev_ping(int argc, char **argv)
+{
+    if (argc == 1)
+    {
+        rt_kprintf("Please input: ping <host address>\n");
+    }
+    else
+    {
+        netdev_cmd_ping(argv[1], 4, 0);
+    }
+
+    return 0;
+}
+FINSH_FUNCTION_EXPORT_ALIAS(netdev_ping, __cmd_ping, ping network host);
+#endif /* NETDEV_USING_IFCONFIG */
+
+static void netdev_list_dns(void)
+{
+    rt_base_t level;
+    int index = 0;
+    struct netdev *netdev = RT_NULL;
+    rt_slist_t *node  = RT_NULL;
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_list_entry(node, struct netdev, list);
+
+        rt_kprintf("network interface device: %s%s\n",
+                netdev->name,
+                (netdev == netdev_default)?" (Default)":"");
+
+        for(index = 0; index < NETDEV_DNS_SERVERS_NUM; index++)
+        {
+            rt_kprintf("dns server #%d: %s\n", index, inet_ntoa(netdev->dns_servers[index]));
+        }
+        
+        if (rt_slist_next(node))
+        {
+            rt_kprintf("\n");
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+}
+
+static void netdev_set_dns(char *netdev_name, char *dns_server)
+{
+    struct netdev *netdev = RT_NULL;
+    ip_addr_t dns_addr;
+
+    netdev = netdev_get_by_name(netdev_name);
+    if (netdev == RT_NULL)
+    {
+        rt_kprintf("bad network interface device name(%s).\n", netdev_name);
+        return;
+    }
+
+    inet_aton(dns_server, &dns_addr);
+    netdev_set_dns_server(netdev, 0, &dns_addr);
+
+    rt_kprintf("set network interface device(%s) dns server #0: %s\n", netdev_name, dns_server);
+}
+
+int netdev_dns(int argc, char **argv)
+{
+    if (argc == 1)
+    {
+        netdev_list_dns();
+    }
+    else if (argc == 3)
+    {
+        netdev_set_dns(argv[1], argv[2]);
+    }
+    else
+    {
+        rt_kprintf("bad parameter! e.g: dns name 114.114.114.114\n");
+    }
+
+    return 0;
+}
+FINSH_FUNCTION_EXPORT_ALIAS(netdev_dns, __cmd_dns, list and set the information of dns);
+
+#ifdef NETDEV_USING_NETSTAT
+static void netdev_cmd_netstat(void)
+{
+    rt_base_t level;
+    rt_slist_t *node  = RT_NULL;
+    struct netdev *netdev = RT_NULL;
+    struct netdev *cur_netdev_list = netdev_list;
+
+    if (cur_netdev_list == RT_NULL)
+    {
+        rt_kprintf("netstat: network interface device list error.\n");
+        return;
+    }
+
+    level = rt_hw_interrupt_disable();
+
+    for (node = &(cur_netdev_list->list); node; node = rt_slist_next(node))
+    {
+        netdev = rt_list_entry(node, struct netdev, list);
+
+        if (netdev && netdev->ops && netdev->ops->netstat)
+        {
+            break;
+        }
+    }
+
+    rt_hw_interrupt_enable(level);
+
+    netdev->ops->netstat(netdev);
+}
+
+int netdev_netstat(int argc, char **argv)
+{
+    if (argc != 1)
+    {
+        rt_kprintf("Please input: netstat \n");
+    }
+    else 
+    {
+        netdev_cmd_netstat();
+    }
+
+    return 0;
+}
+FINSH_FUNCTION_EXPORT_ALIAS(netdev_netstat, __cmd_netstat, list the information of TCP / IP);
+#endif /* NETDEV_USING_NETSTAT */
+
+#endif /* FINSH_USING_MSH */

components/net/sal_socket/src/sal_ipaddr.c → components/net/netdev/src/netdev_ipaddr.c

@@ -8,12 +8,12 @@
  * 2018-05-18     ChenYong     First version
  */
 
-#include <sal_ipaddr.h>
 #include <rtthread.h>
+#include <netdev_ipaddr.h>
 
 /* Here for now until needed in other places in lwIP */
 #ifndef isprint
-#define in_range(c, lo, up)  ((u8_t)c >= lo && (u8_t)c <= up)
+#define in_range(c, lo, up)  ((uint8_t)c >= lo && (uint8_t)c <= up)
 #define isprint(c)           in_range(c, 0x20, 0x7f)
 #define isdigit(c)           in_range(c, '0', '9')
 #define isxdigit(c)          (isdigit(c) || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'))
@@ -33,13 +33,13 @@
  * @param addr pointer to which to save the ip address in network order
  * @return 1 if cp could be converted to addr, 0 on failure
  */
-int sal_ip4addr_aton(const char *cp, ip4_addr_t *addr)
+int netdev_ip4addr_aton(const char *cp, ip4_addr_t *addr)
 {
-    u32_t val;
-    u8_t base;
+    uint32_t val;
+    uint8_t base;
     char c;
-    u32_t parts[4];
-    u32_t *pp = parts;
+    uint32_t parts[4];
+    uint32_t *pp = parts;
 
     c = *cp;
     for (;;)
@@ -72,12 +72,12 @@ int sal_ip4addr_aton(const char *cp, ip4_addr_t *addr)
         {
             if (isdigit(c))
             {
-                val = (val * base) + (u32_t) (c - '0');
+                val = (val * base) + (uint32_t) (c - '0');
                 c = *++cp;
             }
             else if (base == 16 && isxdigit(c))
             {
-                val = (val << 4) | (u32_t) (c + 10 - (islower(c) ? 'a' : 'A'));
+                val = (val << 4) | (uint32_t) (c + 10 - (islower(c) ? 'a' : 'A'));
                 c = *++cp;
             }
             else
@@ -180,28 +180,28 @@ int sal_ip4addr_aton(const char *cp, ip4_addr_t *addr)
  * @return either pointer to buf which now holds the ASCII
  *         representation of addr or NULL if buf was too small
  */
-char *sal_ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen)
+char *netdev_ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen)
 {
-    u32_t s_addr;
+    uint32_t s_addr;
     char inv[3];
     char *rp;
-    u8_t *ap;
-    u8_t rem;
-    u8_t n;
-    u8_t i;
+    uint8_t *ap;
+    uint8_t rem;
+    uint8_t n;
+    uint8_t i;
     int len = 0;
 
     s_addr = ip4_addr_get_u32(addr);
 
     rp = buf;
-    ap = (u8_t *) &s_addr;
+    ap = (uint8_t *) &s_addr;
     for (n = 0; n < 4; n++)
     {
         i = 0;
         do
         {
-            rem = *ap % (u8_t) 10;
-            *ap /= (u8_t) 10;
+            rem = *ap % (uint8_t) 10;
+            *ap /= (uint8_t) 10;
             inv[i++] = (char) ('0' + rem);
         } while (*ap);
         while (i--)
@@ -232,10 +232,10 @@ char *sal_ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen)
  * @return pointer to a global static (!) buffer that holds the ASCII
  *         representation of addr
  */
-char *sal_ip4addr_ntoa(const ip4_addr_t *addr)
+char *netdev_ip4addr_ntoa(const ip4_addr_t *addr)
 {
     static char str[IP4ADDR_STRLEN_MAX];
-    return sal_ip4addr_ntoa_r(addr, str, IP4ADDR_STRLEN_MAX);
+    return netdev_ip4addr_ntoa_r(addr, str, IP4ADDR_STRLEN_MAX);
 }
 
 
@@ -246,11 +246,11 @@ char *sal_ip4addr_ntoa(const ip4_addr_t *addr)
  * @param cp IP address in ascii representation (e.g. "127.0.0.1")
  * @return ip address in network order
  */
-in_addr_t sal_ipaddr_addr(const char *cp)
+in_addr_t netdev_ipaddr_addr(const char *cp)
 {
     ip4_addr_t val;
 
-    if (sal_ip4addr_aton(cp, &val)) {
+    if (netdev_ip4addr_aton(cp, &val)) {
         return ip4_addr_get_u32(&val);
     }
     return (IPADDR_NONE);

components/net/sal_socket/impl/af_inet.h

@@ -18,14 +18,18 @@ extern "C" {
 #endif
 
 #ifdef SAL_USING_LWIP
-/* lwIP protocol family register */
-int lwip_inet_init(void);
-#endif
+
+/* Set lwIP network interface device protocol family information  */
+int sal_lwip_netdev_set_pf_info(struct netdev *netdev);
+
+#endif /* SAL_USING_LWIP */
 
 #ifdef SAL_USING_AT
-/* AT protocol family register */
-int at_inet_init(void);
-#endif
+
+/* Set AT network interface device protocol family information */
+int sal_at_netdev_set_pf_info(struct netdev *netdev);
+
+#endif /* SAL_USING_AT */
 
 #ifdef __cplusplus
 }

components/net/sal_socket/impl/af_inet_at.c

@@ -16,6 +16,8 @@
 #include <at_socket.h>
 #include <af_inet.h>
 
+#include <netdev.h>
+
 #ifdef SAL_USING_POSIX
 #include <dfs_poll.h>
 #endif
@@ -78,24 +80,12 @@ static const struct sal_socket_ops at_socket_ops =
     NULL,
     NULL,
     NULL,
-
 #ifdef SAL_USING_POSIX
     at_poll,
 #endif /* SAL_USING_POSIX */
 };
 
-static int at_create(struct sal_socket *socket, int type, int protocol)
-{
-    RT_ASSERT(socket);
-
-    //TODO Check type & protocol
-
-    socket->ops = &at_socket_ops;
-
-    return 0;
-}
-
-static struct sal_proto_ops at_proto_ops =
+static const struct sal_netdb_ops at_netdb_ops = 
 {
     at_gethostbyname,
     NULL,
@@ -107,16 +97,18 @@ static const struct sal_proto_family at_inet_family =
 {
     AF_AT,
     AF_INET,
-    at_create,
-    &at_proto_ops,
+    &at_socket_ops,
+    &at_netdb_ops,
 };
 
-int at_inet_init(void)
+
+/* Set AT network interface device protocol family information */
+int sal_at_netdev_set_pf_info(struct netdev *netdev)
 {
-    sal_proto_family_register(&at_inet_family);
+    RT_ASSERT(netdev);
 
+    netdev->sal_user_data = (void *) &at_inet_family;
     return 0;
 }
-INIT_COMPONENT_EXPORT(at_inet_init);
 
 #endif /* SAL_USING_AT */

components/net/sal_socket/impl/af_inet_lwip.c

@@ -14,6 +14,7 @@
 #include <lwip/netdb.h>
 #include <lwip/api.h>
 #include <lwip/init.h>
+#include <lwip/netif.h>
 
 #ifdef SAL_USING_POSIX
 #include <dfs_poll.h>
@@ -22,6 +23,8 @@
 #include <sal.h>
 #include <af_inet.h>
 
+#include <netdev.h>
+
 #if LWIP_VERSION < 0x2000000
 #define SELWAIT_T int
 #else
@@ -281,18 +284,7 @@ static const struct sal_socket_ops lwip_socket_ops =
 #endif
 };
 
-static int inet_create(struct sal_socket *socket, int type, int protocol)
-{
-    RT_ASSERT(socket);
-
-    //TODO Check type & protocol
-
-    socket->ops = &lwip_socket_ops;
-
-    return 0;
-}
-
-static struct sal_proto_ops lwip_proto_ops =
+static const struct sal_netdb_ops lwip_netdb_ops =
 {
     lwip_gethostbyname,
     lwip_gethostbyname_r,
@@ -304,16 +296,17 @@ static const struct sal_proto_family lwip_inet_family =
 {
     AF_INET,
     AF_INET,
-    inet_create,
-    &lwip_proto_ops,
+    &lwip_socket_ops,
+    &lwip_netdb_ops,
 };
 
-int lwip_inet_init(void)
+/* Set lwIP network interface device protocol family information */
+int sal_lwip_netdev_set_pf_info(struct netdev *netdev)
 {
-    sal_proto_family_register(&lwip_inet_family);
-
+    RT_ASSERT(netdev);
+    
+    netdev->sal_user_data = (void *) &lwip_inet_family;
     return 0;
 }
-INIT_COMPONENT_EXPORT(lwip_inet_init);
 
 #endif /* SAL_USING_LWIP */

components/net/sal_socket/impl/proto_mbedtls.c

@@ -20,6 +20,8 @@
 #include <netdb.h>
 #include <sal.h>
 
+#include <netdev.h>
+
 #ifdef SAL_USING_TLS
 
 #if !defined(MBEDTLS_CONFIG_FILE)
@@ -76,6 +78,7 @@ int mbedtls_net_send_cb(void *ctx, const unsigned char *buf, size_t len)
 {
     struct sal_socket *sock;
     int socket, ret;
+    struct sal_proto_family *pf;
 
     RT_ASSERT(ctx);
     RT_ASSERT(buf);
@@ -86,9 +89,11 @@ int mbedtls_net_send_cb(void *ctx, const unsigned char *buf, size_t len)
     {
         return -1;
     }
+    
+    pf = (struct sal_proto_family *)sock->netdev->sal_user_data;
 
     /* Register scoket sendto option to TLS send data callback */
-    ret = sock->ops->sendto((int) sock->user_data, (void *)buf, len, 0, RT_NULL, RT_NULL);
+    ret = pf->skt_ops->sendto((int) sock->user_data, (void *)buf, len, 0, RT_NULL, RT_NULL);
     if (ret < 0)
     {
 #ifdef RT_USING_DFS
@@ -109,6 +114,7 @@ int mbedtls_net_send_cb(void *ctx, const unsigned char *buf, size_t len)
 int mbedtls_net_recv_cb( void *ctx, unsigned char *buf, size_t len)
 {
     struct sal_socket *sock;
+    struct sal_proto_family *pf;
     int socket, ret;
 
     RT_ASSERT(ctx);
@@ -121,8 +127,10 @@ int mbedtls_net_recv_cb( void *ctx, unsigned char *buf, size_t len)
         return -1;
     }
 
+    pf = (struct sal_proto_family *)sock->netdev->sal_user_data;
+    
     /* Register scoket recvfrom option to TLS recv data callback */
-    ret = sock->ops->recvfrom((int) sock->user_data, (void *)buf, len, 0, RT_NULL, RT_NULL);
+    ret = pf->skt_ops->recvfrom((int) sock->user_data, (void *)buf, len, 0, RT_NULL, RT_NULL);
     if (ret < 0)
     {
 #ifdef RT_USING_DFS

components/net/sal_socket/include/sal.h

@@ -43,6 +43,24 @@ typedef uint32_t socklen_t;
 #define SAL_SOCKET_OFFSET              0
 #endif
 
+struct sal_socket
+{
+    uint32_t magic;                    /* SAL socket magic word */
+
+    int socket;                        /* SAL socket descriptor */
+    int domain;
+    int type;
+    int protocol;
+
+    struct netdev *netdev;             /* SAL network interface device */
+
+    void *user_data;                   /* user-specific data */
+#ifdef SAL_USING_TLS
+    void *user_data_tls;               /* user-specific TLS data */
+#endif
+};
+
+/* network interface socket opreations */
 struct sal_socket_ops
 {
     int (*socket)     (int domain, int type, int protocol);
@@ -64,7 +82,8 @@ struct sal_socket_ops
 #endif
 };
 
-struct sal_proto_ops
+/* sal network database name resolving */
+struct sal_netdb_ops
 {
     struct hostent* (*gethostbyname)  (const char *name);
     int             (*gethostbyname_r)(const char *name, struct hostent *ret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
@@ -72,42 +91,21 @@ struct sal_proto_ops
     void            (*freeaddrinfo)   (struct addrinfo *ai);
 };
 
-struct sal_socket
-{
-    uint32_t magic;                    /* SAL socket magic word */
-
-    int socket;                        /* SAL socket descriptor */
-    int domain;
-    int type;
-    int protocol;
-
-    const struct sal_socket_ops *ops;  /* socket options */
-
-    void *user_data;                   /* user-specific data */
-#ifdef SAL_USING_TLS
-    void *user_data_tls;               /* user-specific TLS data */
-#endif
-};
-
 struct sal_proto_family
 {
-    int family;                        /* primary protocol families type */
-    int sec_family;                    /* secondary protocol families type */
-    int (*create)(struct sal_socket *sal_socket, int type, int protocol);   /* register socket options */
-
-    struct sal_proto_ops *ops;             /* protocol family options */
+    int family;                                  /* primary protocol families type */
+    int sec_family;                              /* secondary protocol families type */
+    const struct sal_socket_ops *skt_ops;        /* socket opreations */
+    const struct sal_netdb_ops *netdb_ops;       /* network database opreations */
 };
 
 /* SAL(Socket Abstraction Layer) initialize */
 int sal_init(void);
-
+/* Get SAL socket object by socket descriptor */
 struct sal_socket *sal_get_socket(int sock);
 
-/* SAL protocol family register and unregister operate */
-int sal_proto_family_register(const struct sal_proto_family *pf);
-int sal_proto_family_unregister(int family);
-rt_bool_t sal_proto_family_is_registered(int family);
-struct sal_proto_family *sal_proto_family_find(int family);
+/* check SAL socket netweork interface device internet status */
+int sal_check_netdev_internet_up(struct netdev *netdev);
 
 #ifdef __cplusplus
 }

components/net/sal_socket/include/sal_ipaddr.h

@@ -1,128 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author       Notes
- * 2018-05-18     ChenYong     First version
- */
-#ifndef SAL_IPADDR_H__
-#define SAL_IPADDR_H__
-
-#include "sal_type.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** IPv4 only: set the IP address given as an u32_t */
-#define ip4_addr_set_u32(dest_ipaddr, src_u32) ((dest_ipaddr)->addr = (src_u32))
-/** IPv4 only: get the IP address as an u32_t */
-#define ip4_addr_get_u32(src_ipaddr) ((src_ipaddr)->addr)
-
-#define IP4ADDR_STRLEN_MAX  16
-
-/* These macros should be calculated by the preprocessor and are used
-   with compile-time constants only (so that there is no little-endian
-   overhead at runtime). */
-#define PP_HTONS(x) ((((x) & 0x00ffUL) << 8) | (((x) & 0xff00UL) >> 8))
-#define PP_NTOHS(x) PP_HTONS(x)
-#define PP_HTONL(x) ((((x) & 0x000000ffUL) << 24) | \
-                     (((x) & 0x0000ff00UL) <<  8) | \
-                     (((x) & 0x00ff0000UL) >>  8) | \
-                     (((x) & 0xff000000UL) >> 24))
-#define PP_NTOHL(x) PP_HTONL(x)
-
-#define htons(x) (u16_t)PP_HTONS(x)
-#define ntohs(x) (u16_t)PP_NTOHS(x)
-#define htonl(x) (u32_t)PP_HTONL(x)
-#define ntohl(x) (u32_t)PP_NTOHL(x)
-
-/* If your port already typedef's in_addr_t, define IN_ADDR_T_DEFINED
-   to prevent this code from redefining it. */
-#if !defined(in_addr_t) && !defined(IN_ADDR_T_DEFINED)
-typedef u32_t in_addr_t;
-#endif
-
-struct in_addr
-{
-    in_addr_t s_addr;
-};
-
-struct in6_addr
-{
-    union
-    {
-        u32_t u32_addr[4];
-        u8_t u8_addr[16];
-    } un;
-#define s6_addr  un.u8_addr
-};
-
-enum sal_ip_addr_type
-{
-    /** IPv4 */
-    IPADDR_TYPE_V4 = 0U,
-    /** IPv6 */
-    IPADDR_TYPE_V6 = 6U,
-    /** IPv4+IPv6 ("dual-stack") */
-    IPADDR_TYPE_ANY = 46U
-};
-
-typedef struct ip4_addr
-{
-    u32_t addr;
-} ip4_addr_t;
-
-typedef struct ip6_addr
-{
-    u32_t addr[4];
-} ip6_addr_t;
-
-typedef struct _ip_addr
-{
-    union
-    {
-        ip6_addr_t ip6;
-        ip4_addr_t ip4;
-    } u_addr;
-    /** @ref sal_ip_addr_type */
-    u8_t type;
-} ip_addr_t;
-
-/** 255.255.255.255 */
-#define IPADDR_NONE         ((u32_t)0xffffffffUL)
-/** 127.0.0.1 */
-#define IPADDR_LOOPBACK     ((u32_t)0x7f000001UL)
-/** 0.0.0.0 */
-#define IPADDR_ANY          ((u32_t)0x00000000UL)
-/** 255.255.255.255 */
-#define IPADDR_BROADCAST    ((u32_t)0xffffffffUL)
-
-/** 255.255.255.255 */
-#define INADDR_NONE         IPADDR_NONE
-/** 127.0.0.1 */
-#define INADDR_LOOPBACK     IPADDR_LOOPBACK
-/** 0.0.0.0 */
-#define INADDR_ANY          IPADDR_ANY
-/** 255.255.255.255 */
-#define INADDR_BROADCAST    IPADDR_BROADCAST
-
-#define IPADDR_BROADCAST_STRING "255.255.255.255"
-
-in_addr_t sal_ipaddr_addr(const char *cp);
-int sal_ip4addr_aton(const char *cp, ip4_addr_t *addr);
-char *sal_ip4addr_ntoa(const ip4_addr_t *addr);
-char *sal_ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen);
-
-#define inet_addr(cp) sal_ipaddr_addr(cp)
-#define inet_aton(cp,addr) sal_ip4addr_aton(cp,(ip4_addr_t*)addr)
-#define inet_ntoa(addr) sal_ip4addr_ntoa((const ip4_addr_t*)&(addr))
-#define inet_ntoa_r(addr, buf, buflen)  sal_ip4addr_ntoa_r((const ip4_addr_t*)&(addr), buf, buflen)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SAL_IPADDR_H__ */

components/net/sal_socket/include/sal_netdb.h

@@ -10,7 +10,7 @@
 #ifndef SAL_NETDB_H__
 #define SAL_NETDB_H__
 
-#include <sal_socket.h>
+#include "sal_socket.h"
 
 #ifdef __cplusplus
 extern "C" {

components/net/sal_socket/include/sal_socket.h

@@ -11,7 +11,7 @@
 #ifndef SAL_SOCKET_H__
 #define SAL_SOCKET_H__
 
-#include "sal_ipaddr.h"
+#include <arpa/inet.h>
 
 #ifdef __cplusplus
 extern "C" {

components/net/sal_socket/include/sal_type.h

@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2006-2018, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author       Notes
- * 2018-05-17     ChenYong     First version
- */
-
-#ifndef SAL_TYPE_H__
-#define SAL_TYPE_H__
-
-#include <stdlib.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef int8_t    err_t;
-typedef uint8_t   u8_t;
-typedef int8_t    s8_t;
-typedef uint16_t  u16_t;
-typedef int16_t   s16_t;
-typedef uint32_t  u32_t;
-typedef int32_t   s32_t;
-typedef uintptr_t mem_ptr_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SAL_TYPE_H__ */