api_shell.c 文件参考

浏览源代码.

结构体
struct	ping6_args
struct	ping6_stats
struct	ifconfig_option
struct	netstat_data
struct	if_cmd_data
struct	arp_option

类型定义
typedef struct ping6_args	ping6_args_t
typedef struct ping6_stats	ping6_stats_t

函数
int	get_unused_socket_num (void)
LWIP_STATIC int	print_netif (struct netif *netif, char *print_buf, unsigned int buf_len)
LWIP_STATIC void	lwip_ifconfig_show_internal (void *arg)
LWIP_STATIC void	lwip_ifconfig_internal (void *arg)
void	lwip_printsize (size_t size)
LWIP_STATIC void	lwip_ifconfig_usage (const char *cmd)
LWIP_STATIC void	lwip_arp_show_internal (struct netif *netif, char *printf_buf, unsigned int buf_len)
LWIP_STATIC void	lwip_arp_internal (void *arg)
LWIP_STATIC void	lwip_arp_usage (const char *cmd)
void	ifup_internal (void *arg)
void	ifdown_internal (void *arg)
LWIP_STATIC unsigned int	get_hostip (const char *hname)
LWIP_STATIC struct hostent *	gethostnameinfo (const char *host)
LWIP_STATIC u32_t	netdebug_memp (int argc, const char **argv)
LWIP_STATIC u32_t	netdebug_sock (int argc, const char **argv)
u32_t	osShellNetDebug (int argc, const char **argv)
u32_t	osShellIpDebug (int argc, const char **argv)
LWIP_STATIC void	update_ping6_stats (ping6_stats_t *ping6_stats, u32_t rtt, u32_t nreceived)
LWIP_STATIC int	parse_args_ping6 (int argc, const char **argv, ping6_args_t *ping6_params)
u32_t	osShellPing6 (int argc, const char **argv)
LWIP_STATIC int	create_ping6_socket (u8_t type, const void *param)
LWIP_STATIC const char *	convert_icmpv6_err_to_string (u8_t err_type)
u32_t	osTcpserver (int argc, const char **argv)
void	udpserver (int argc, const char **argv)
void	tcp_access (int sockfd)
int	netstat_get_udp_sendQLen6 (struct udp_pcb *udppcb, struct pbuf *udpbuf)
int	netstat_udp_sendq6 (struct udp_pcb *upcb)
int	netstat_get_udp_sendQLen (struct udp_pcb *udppcb, struct pbuf *udpbuf)
int	netstat_tcp_sendq (struct tcp_pcb *tpcb)
int	netstat_tcp_recvq (struct tcp_pcb *tpcb)
int	netstat_netconn_recvq (const struct netconn *conn)
int	netstat_udp_sendq (struct udp_pcb *upcb)
int	netstat_netconn_sendq (struct netconn *conn)
u32_t	lwip_ifconfig (int argc, const char **argv)
	SHELLCMD_ENTRY (ifconfig_shellcmd, CMD_TYPE_EX, "ifconfig", XARGS,(CmdCallBackFunc) lwip_ifconfig)
u32_t	lwip_arp (int argc, const char **argv)
	SHELLCMD_ENTRY (arp_shellcmd, CMD_TYPE_EX, "arp", 1,(CmdCallBackFunc) lwip_arp)
static void	lwip_ping_usage (void)
LWIP_STATIC int	osPingFunc (u32_t destip, u32_t cnt, u32_t interval, u32_t data_len)
static void	ping_cmd (unsigned int p0, unsigned int p1, unsigned int p2, unsigned int p3)
u32_t	osShellPing (int argc, const char **argv)
	SHELLCMD_ENTRY (ping_shellcmd, CMD_TYPE_EX, "ping", XARGS,(CmdCallBackFunc) osShellPing)
	SHELLCMD_ENTRY (ping6_shellcmd, CMD_TYPE_EX, "ping6", XARGS,(CmdCallBackFunc) osShellPing6)
u32_t	osShellNtpdate (int argc, const char **argv)
	SHELLCMD_ENTRY (ntpdate_shellcmd, CMD_TYPE_EX, "ntpdate", XARGS,(CmdCallBackFunc) osShellNtpdate)
u32_t	osShellDns (int argc, const char **argv)
	SHELLCMD_ENTRY (dns_shellcmd, CMD_TYPE_EX, "dns", XARGS,(CmdCallBackFunc) osShellDns)

变量
sys_sem_t	ip_conflict_detect
volatile int	tcpip_init_finish
const char *const	tcp_state_str []
static int	ping_taskid = -1
static int	ping_kill = 0
struct nd6_neighbor_cache_entry	neighbor_cache [LWIP_ND6_NUM_NEIGHBORS]

类型定义说明

ping6_args_t

typedef struct ping6_args ping6_args_t

ping6_stats_t

typedef struct ping6_stats ping6_stats_t

函数说明

convert_icmpv6_err_to_string()

LWIP_STATIC const char * convert_icmpv6_err_to_string

(

u8_t

err_type

)

在文件 api_shell.c 第 2567 行定义.

{
    switch (err_type) {
        case ICMP6_TYPE_DUR:
            return "Destination Unreachable";
        case ICMP6_TYPE_PTB:
            return "Packet too big";
        case ICMP6_TYPE_TE:
            return "Time Exceeded";
        case ICMP6_TYPE_PP:
            return "Parameter Problem";
        default:
            break;
    }
    return "Unknown Error";
}

这是这个函数的调用关系图:

create_ping6_socket()

LWIP_STATIC int create_ping6_socket	(	u8_t	type,
		const void *	param
	)

在文件 api_shell.c 第 2340 行定义.

{
    int sfd;
    int ret;
    struct sockaddr_in6 stHostAddr6;
    struct icmp6_filter icmp6_sock_filter;
 
    sfd = lwip_socket(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
    if (sfd == -1) {
        PRINTK("ping6 : Failed, socket creation failed\n");
        return -1;
    }
 
    if (param != NULL) {
        if (type == LWIP_PING6_SOURCE_ADDRESS_ARG) {
            /* Binding socket to the provided source address */
            (void)memset_s(&stHostAddr6, sizeof(stHostAddr6), 0, sizeof(stHostAddr6));
            stHostAddr6.sin6_family = AF_INET6;
            inet6_addr_from_ip6addr(&stHostAddr6.sin6_addr, (ip6_addr_t *)param);
            stHostAddr6.sin6_port = htons(IPPROTO_ICMPV6);
            stHostAddr6.sin6_scope_id = 0;
 
            ret = lwip_bind(sfd, (struct sockaddr *)&stHostAddr6, sizeof(stHostAddr6));
            if (ret == -1) {
                (void)lwip_close(sfd);
                PRINTK("ping6 : bind icmp socket: cannot assign requested address\n");
                return ret;
            }
        } else if (type == LWIP_PING6_INTERFACE_ARG) {
            /* Binding socket to the provided netif */
            ret = lwip_setsockopt(sfd, SOL_SOCKET, SO_BINDTODEVICE, (char *)(param), strlen((char *)(param)));
            if (ret == -1) {
                (void)lwip_close(sfd);
                PRINTK("ping6: unknownn iface %s\n", (char *)(param));
                return ret;
            }
        }
    }
 
    /* Setting socket filter since we are interested only in ECHO REPLY and ERROR messages */
    ICMP6_FILTER_SETBLOCKALL (&icmp6_sock_filter);
    ICMP6_FILTER_SETPASS (ICMP6_TYPE_EREP, &icmp6_sock_filter);
    ICMP6_FILTER_SETPASS (ICMP6_TYPE_DUR, &icmp6_sock_filter);
    ICMP6_FILTER_SETPASS (ICMP6_TYPE_PTB, &icmp6_sock_filter);
    ICMP6_FILTER_SETPASS (ICMP6_TYPE_TE, &icmp6_sock_filter);
 
    ret = lwip_setsockopt(sfd, IPPROTO_ICMPV6, ICMP6_FILTER, &icmp6_sock_filter, sizeof(struct icmp6_filter));
    if (ret == -1) {
        (void)lwip_close(sfd);
        PRINTK("ping6 : setsockopt: Invalid Argument\n");
        return -1;
    }
 
    return sfd;
}

函数调用图:

这是这个函数的调用关系图:

get_hostip()

LWIP_STATIC unsigned int get_hostip

(

const char *

hname

)

在文件 api_shell.c 第 1543 行定义.

{
    unsigned int ip = 0;
    int ret;
 
    struct hostent *pent = gethostnameinfo(hname);
    if (pent == NULL || pent->h_addr == NULL)
        return 0;
    ret = memcpy_s(&ip, sizeof(ip), pent->h_addr, 4);
    if (ret != 0) {
        return 0;
    }
    return ip;
}

函数调用图:

这是这个函数的调用关系图:

get_unused_socket_num()

int get_unused_socket_num

(

void

)

在文件 sockets.c 第 343 行定义.

{
    int unused = 0;
    SYS_ARCH_DECL_PROTECT(lev);
 
    SYS_ARCH_PROTECT(lev);
 
    for (int i = 0; i < NUM_SOCKETS; i++) {
        if (sockets[i].conn == NULL) {
#if LWIP_NETCONN_FULLDUPLEX
            if (sockets[i].fd_used) {
                continue;
            }
#endif
            unused++;
        }
    }
 
    SYS_ARCH_UNPROTECT(lev);
 
    return unused;
}

这是这个函数的调用关系图:

gethostnameinfo()

LWIP_STATIC struct hostent * gethostnameinfo

(

const char *

host

)

在文件 api_shell.c 第 1527 行定义.

{
    static struct hostent hostbuf;
    struct hostent *hp = NULL;
    const size_t hstbuflen = 1024;
    char tmphstbuf[1024];
    int res;
    int herr;
 
    res = lwip_gethostbyname_r(host, &hostbuf, tmphstbuf, hstbuflen, &hp, &herr);
    /*  Check for errors.  */
    if (res || hp == NULL)
        return NULL;
    return hp;
}

这是这个函数的调用关系图:

ifdown_internal()

void ifdown_internal

(

void *

arg

)

在文件 api_shell.c 第 1503 行定义.

{
    struct netif *netif = NULL;
    struct if_cmd_data *ifcmd_data = NULL;
 
    ifcmd_data = (struct if_cmd_data *)arg;
    if (ifcmd_data == NULL) {
        return;
    }
    netif = netif_find(ifcmd_data->if_name);
    if (netif == NULL) {
        ifcmd_data->err = ERR_VAL;
    } else {
        (void)netif_set_down(netif);
        ifcmd_data->err = ERR_OK;
    }
 
    sys_sem_signal(&ifcmd_data->cb_completed);
}

函数调用图:

ifup_internal()

void ifup_internal

(

void *

arg

)

在文件 api_shell.c 第 1483 行定义.

{
    struct netif *netif = NULL;
    struct if_cmd_data *ifcmd_data;
 
    ifcmd_data = (struct if_cmd_data *)arg;
    if (ifcmd_data == NULL) {
        return;
    }
    netif = netif_find(ifcmd_data->if_name);
    if (netif == NULL) {
        ifcmd_data->err = ERR_VAL;
    } else {
        (void)netif_set_up(netif);
        ifcmd_data->err = ERR_OK;
    }
 
    sys_sem_signal(&ifcmd_data->cb_completed);
}

函数调用图:

lwip_arp()

u32_t lwip_arp	(	int	argc,
		const char **	argv
	)

在文件 api_shell.c 第 1347 行定义.

{
    int i;
    struct arp_option arp_cmd;
    err_t ret;
    size_t interface_len = 0;
 
    (void)memset_s(&arp_cmd, sizeof(struct arp_option), 0, sizeof(struct arp_option));
    if (!tcpip_init_finish) {
        PRINTK("%s: tcpip_init have not been called\n", __FUNCTION__);
        return LOS_NOK;
    }
 
    arp_cmd.iface[0] = 'd';
    arp_cmd.iface[1] = 'e';
    arp_cmd.iface[2] = '0';
    arp_cmd.option = ARP_OPTION_SHOW;
    arp_cmd.print_buf_len = 0;
    if (sys_sem_new(&arp_cmd.cb_completed, 0) != ERR_OK) {
        PRINTK("%s: sys_sem_new fail\n", __FUNCTION__);
        return 1;
    }
 
    i = 0;
    while (argc > 0) {
        if (strcmp("-i", argv[i]) == 0 && (argc > 1)) {
            /* get the network interface's name */
            interface_len = strlen(argv[i + 1]);
            if (interface_len < IFNAMSIZ) {
                if (strncmp(argv[i + 1], "lo", (sizeof("lo") - 1)) == 0) {
                    PRINTK("Illegal operation\n");
                    goto arp_error;
                }
                if (strncpy_s(arp_cmd.iface, IFNAMSIZ, argv[i + 1], interface_len) != EOK) {
                    PRINTK("strncpy_s error\n");
                    goto arp_error;
                }
                arp_cmd.iface[interface_len] = '\0';
            } else {
                PRINTK("Iface name is big \n");
                goto arp_error;
            }
            i += 2;
            argc -= 2;
        } else if (strcmp("-d", argv[i]) == 0 && (argc > 1)) {
            /* arp delete */
            arp_cmd.option = ARP_OPTION_DEL;
            arp_cmd.ipaddr = inet_addr(argv[i + 1]);
 
            if (arp_cmd.ipaddr == IPADDR_NONE) {
                PRINTK("IP address is not correct!\n");
                goto arp_error;
            }
 
            i += 2;
            argc -= 2;
        } else if (strcmp("-s", argv[i]) == 0 && (argc > 2)) {
            /* arp add */
            char *digit = NULL;
            u32_t macaddrlen = strlen(argv[i + 2]) + 1;
            char tmpStr[MAX_MACADDR_STRING_LENGTH];
            char *tmpStr1 = NULL;
            char *saveptr1 = NULL;
            char *temp = NULL;
            int j;
 
            arp_cmd.option = ARP_OPTION_ADD;
            arp_cmd.ipaddr = inet_addr(argv[i + 1]);
 
            if (arp_cmd.ipaddr == IPADDR_NONE) {
                PRINTK("IP address is not correct!\n");
                goto arp_error;
            }
 
            /*cannot add an arp entry of 127.*.*.* */
            if ((arp_cmd.ipaddr & (u32_t)0x0000007fUL) == (u32_t)0x0000007fUL) {
                PRINTK("IP address is not correct!\n");
                goto arp_error;
            }
 
            if (macaddrlen != MAX_MACADDR_STRING_LENGTH) {
                PRINTK("Wrong MAC address length\n");
                goto arp_error;
            }
 
            if (strncpy_s(tmpStr, MAX_MACADDR_STRING_LENGTH, argv[i + 2], macaddrlen - 1) != 0) {
                PRINTK("Wrong MAC address\n");
                goto arp_error;
            }
 
            for (j = 0, tmpStr1 = tmpStr; j < 6; j++, tmpStr1 = NULL) {
                digit = strtok_r(tmpStr1, ":", &saveptr1);
                if ((digit == NULL) || (strlen(digit) > 2)) {
                    PRINTK("MAC address is not correct\n");
                    goto arp_error;
                }
 
                for (temp = digit; *temp != '\0'; temp++) {
                    if (!isxdigit(*temp)) {
                        PRINTK("MAC address is not correct\n");
                        goto arp_error;
                    }
                }
 
                CONVERT_STRING_TO_HEX(digit, arp_cmd.ethaddr[j]);
            }
 
            i += 3;
            argc -= 3;
        } else {
            goto arp_error;
        }
    }
 
    ret = tcpip_callback(lwip_arp_internal, &arp_cmd);
    if (ret != ERR_OK) {
        PRINTK("%s : tcpip_callback failed in line %d : errnu %d", __FUNCTION__, __LINE__, ret);
        sys_sem_free(&arp_cmd.cb_completed);
        return 1;
    }
    (void)sys_arch_sem_wait(&arp_cmd.cb_completed, 0);
    sys_sem_free(&arp_cmd.cb_completed);
    arp_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
    PRINTK("%s", arp_cmd.cb_print_buf);
    return 0;
 
arp_error:
    lwip_arp_usage("arp");
    sys_sem_free(&arp_cmd.cb_completed);
    return 1;
}

函数调用图:

lwip_arp_internal()

LWIP_STATIC void lwip_arp_internal

(

void *

arg

)

在文件 api_shell.c 第 1249 行定义.

{
#if LWIP_IPV4
    struct arp_option *arp_cmd = (struct arp_option *)arg;
    struct netif *netif = NULL;
    struct eth_addr ethaddr;
    ip4_addr_t ipaddr;
    err_t ret = 0;
    int type = 0;
 
    if (arp_cmd->iface[0] == 'd' && arp_cmd->iface[1] == 'e') {
        netif = NULL;
    } else {
        /* find the specified netif by it's name */
        netif = netif_find(arp_cmd->iface);
        if (netif == NULL) {
            (void)snprintf_s(arp_cmd->cb_print_buf, PRINT_BUF_LEN, (PRINT_BUF_LEN - 1), "No such device\n");
            goto out;
        }
    }
 
    type = arp_cmd->option;
    switch (type) {
        case ARP_OPTION_SHOW:
            if (netif != NULL) {
                lwip_arp_show_internal(netif, arp_cmd->cb_print_buf, PRINT_BUF_LEN);
            } else {
                lwip_arp_show_internal(NULL, arp_cmd->cb_print_buf, PRINT_BUF_LEN);
            }
            break;
 
        case ARP_OPTION_ADD:
#if ETHARP_SUPPORT_STATIC_ENTRIES
            ipaddr.addr = arp_cmd->ipaddr;
            (void)memcpy_s(ethaddr.addr, sizeof(ethaddr.addr), arp_cmd->ethaddr, 6);
            if (netif != NULL) {
                if (ip4_addr_netcmp(&ipaddr, ip_2_ip4(&(netif->ip_addr)), ip_2_ip4(&(netif->netmask)))) {
                    ret = etharp_update_arp_entry(netif, &ipaddr, &ethaddr,
                                                  ETHARP_FLAG_TRY_HARD | ETHARP_FLAG_STATIC_ENTRY);
                } else {
                    ret = ERR_RTE;
                }
            } else {
                ret = etharp_add_static_entry(&ipaddr, &ethaddr);
            }
#else
            ret = ERR_ARG;
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
            break;
 
        case ARP_OPTION_DEL:
            ipaddr.addr = arp_cmd->ipaddr;
            (void)memcpy_s(ethaddr.addr, sizeof(ethaddr.addr), arp_cmd->ethaddr, 6);
            if (netif != NULL) {
                ret = etharp_delete_arp_entry(netif, &ipaddr);
            } else {
                for (netif = netif_list; netif != NULL; netif = netif->next) {
                    ret = etharp_delete_arp_entry(netif, &ipaddr);
                    if (ret == ERR_OK) {
                        /*only can del success one time*/
                        break;
                    }
                }
            }
            break;
 
        default:
            (void)snprintf_s(arp_cmd->cb_print_buf, PRINT_BUF_LEN, (PRINT_BUF_LEN - 1), "Error\n");
            goto out;
    }
 
out:
    if (type == ARP_OPTION_ADD || type == ARP_OPTION_DEL) {
        if (ret == ERR_MEM) {
            (void)snprintf_s(arp_cmd->cb_print_buf, PRINT_BUF_LEN, (PRINT_BUF_LEN - 1), "Out of memory error\n");
        } else if (ret == ERR_ARG) {
            (void)snprintf_s(arp_cmd->cb_print_buf, PRINT_BUF_LEN, (PRINT_BUF_LEN - 1), "Illegal argument\n");
        } else if (ret == ERR_RTE) {
            (void)snprintf_s(arp_cmd->cb_print_buf, PRINT_BUF_LEN, (PRINT_BUF_LEN - 1), "Network is unreachable\n");
        } else {
            (void)snprintf_s(arp_cmd->cb_print_buf, PRINT_BUF_LEN, (PRINT_BUF_LEN - 1), "Successed\n");
        }
    }
#endif
 
    sys_sem_signal(&arp_cmd->cb_completed);
}

函数调用图:

这是这个函数的调用关系图:

lwip_arp_show_internal()

LWIP_STATIC void lwip_arp_show_internal	(	struct netif *	netif,
		char *	printf_buf,
		unsigned int	buf_len
	)

在文件 api_shell.c 第 1172 行定义.

{
    u8_t state, i;
    int ret;
    char *tmp = printf_buf;
    if (buf_len < 1) {
        return;
    }
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%-24s%-24s%-12s%-12s\n", "Address", "HWaddress", "Iface", "Type");
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        return;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    if (netif != NULL) {
        for (i = 0; i < ARP_TABLE_SIZE; ++i) {
            state = arp_table[i].state;
            if (((state == ETHARP_STATE_STABLE)
                 #if ETHARP_SUPPORT_STATIC_ENTRIES
                 || (state == ETHARP_STATE_STATIC)
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
                ) && arp_table[i].netif) {
 
                if (strcmp(netif_get_name(netif), netif_get_name(arp_table[i].netif)) != 0) {
                    continue;
                }
 
                ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%-24s%02X:%02X:%02X:%02X:%02X:%02X       %s        %s\n",
                                 ip4addr_ntoa(&arp_table[i].ipaddr),
                                 arp_table[i].ethaddr.addr[0], arp_table[i].ethaddr.addr[1],
                                 arp_table[i].ethaddr.addr[2], arp_table[i].ethaddr.addr[3],
                                 arp_table[i].ethaddr.addr[4], arp_table[i].ethaddr.addr[5],
                                 netif_get_name(netif),
#if ETHARP_SUPPORT_STATIC_ENTRIES
                                 ((state == ETHARP_STATE_STATIC) ? "static" : "dynamic")
#else
                    "dynamic"
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
                );
                if ((ret <= 0) || ((unsigned int)ret >= buf_len))
                    return;
                tmp += ret;
                buf_len -= (unsigned int)ret;
            }
        }
    } else {
        for (i = 0; i < ARP_TABLE_SIZE; ++i) {
            state = arp_table[i].state;
            if (((state == ETHARP_STATE_STABLE)
                 #if ETHARP_SUPPORT_STATIC_ENTRIES
                 || (state == ETHARP_STATE_STATIC)
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
                ) && arp_table[i].netif) {
                ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%-24s%02X:%02X:%02X:%02X:%02X:%02X       %s        %s\n",
                                 ip4addr_ntoa(&arp_table[i].ipaddr),
                                 arp_table[i].ethaddr.addr[0], arp_table[i].ethaddr.addr[1],
                                 arp_table[i].ethaddr.addr[2], arp_table[i].ethaddr.addr[3],
                                 arp_table[i].ethaddr.addr[4], arp_table[i].ethaddr.addr[5],
                                 netif_get_name(arp_table[i].netif),
#if ETHARP_SUPPORT_STATIC_ENTRIES
                                 ((state == ETHARP_STATE_STATIC) ? "static" : "dynamic")
#else
                    "dynamic"
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
                );
                if ((ret <= 0) || ((unsigned int)ret >= buf_len))
                    return;
                tmp += ret;
                buf_len -= (unsigned int)ret;
            }
        }
    }
}

这是这个函数的调用关系图:

lwip_arp_usage()

LWIP_STATIC void lwip_arp_usage

(

const char *

cmd

)

在文件 api_shell.c 第 1338 行定义.

{
    PRINTK("Usage:"
           "\n%s"
           "\n%s [-i IF] -s IPADDR HWADDR"
           "\n%s [-i IF] -d IPADDR\n",
           cmd, cmd, cmd);
}

这是这个函数的调用关系图:

lwip_ifconfig()

u32_t lwip_ifconfig	(	int	argc,
		const char **	argv
	)

在文件 api_shell.c 第 684 行定义.

{
    int i;
    static struct ifconfig_option ifconfig_cmd;
    err_t ret;
 
#if LWIP_STATS
    u32_t stat_err_cnt;
    u32_t stat_drop_cnt;
    u32_t stat_rx_or_tx_cnt;
    u32_t stat_rx_or_tx_bytes;
#endif
 
#if LWIP_ARP
    u32_t retval;
    struct netif *netiftmp = NULL;
#if LWIP_ENABLE_IP_CONFLICT_SIGNAL
    u32_t old_ip4addr;
    err_t        err;
    extern sys_sem_t ip_conflict_detect;
    extern u32_t is_ip_conflict_signal;
#endif /* LWIP_ENABLE_IP_CONFLICT_SIGNAL */
#endif /* LWIP_ARP */
#if LWIP_IPV6
    extern sys_sem_t dup_addr_detect;
    extern u32_t is_dup_detect_initialized;
#endif
    if (!tcpip_init_finish) {
        PRINTK("%s: tcpip_init have not been called\n", __FUNCTION__);
        return 2;
    }
    /* To support "ifconfig -a" command
         RX packets:XXXX errors:X dropped:X overruns:X bytes:XXXX (Human readable format)
         TX packets:XXXX errors:X dropped:X overruns:X bytes:XXXX (Human readable format)
 
         Below is assumed for 'overrun' stat.
         Linux Kernel:
                RX: FIFO overrun
                    Data structure: net_device->stats->rx_fifo_errors
                    Flag which is marked when FIFO overrun: ENRSR_FO
 
                Function: ei_receive->ENRSR_FO
 
                TX: A "FIFO underrun" occurred during transmit.
                    Data structure: net_device->stats->tx_fifo_errors
                    Flag which is marked when FIFO underrun: ENTSR_FU
 
                Function: ei_tx_intr->ENTSR_FU
 
        LWIP:
            So in our case,
            while receiving a packet RX case, if the buffer is full (trypost - it is sys_mbox_trypost)
            the error will be returned, we can consider that an overflow has happened.
            So this can be RX overrun.
 
            But while transmitting a packet TX case, underrun cannot happen because it block on the
            message Q if it is full (NOT trypost - it is sys_mbox_post). So TX overrun is always 0.
    */
    if (argc) {
        if (strcmp("-a", argv[0]) == 0) {
#if LWIP_STATS
            stat_rx_or_tx_cnt = lwip_stats.ip.recv;
            stat_err_cnt = (u32_t)(lwip_stats.ip.ip_rx_err +
                                   lwip_stats.ip.lenerr +
                                   lwip_stats.ip.chkerr +
                                   lwip_stats.ip.opterr +
                                   lwip_stats.ip.proterr);
            stat_drop_cnt = (u32_t)(lwip_stats.ip.drop + lwip_stats.link.link_rx_drop);
            stat_rx_or_tx_bytes = lwip_stats.ip.ip_rx_bytes;
 
            PRINTK("%18s:%u\t errors:%u\t ip dropped:%u\t link dropped:%u\t overrun:%d\t bytes:%u ",
                   "RX packets",
                   stat_rx_or_tx_cnt,
                   stat_err_cnt,
                   stat_drop_cnt,
                   lwip_stats.link.link_rx_drop,
                   lwip_stats.ip.link_rx_overrun,
                   stat_rx_or_tx_bytes);
 
            /* Print in Human readable format of the incoming bytes */
            lwip_printsize(lwip_stats.ip.ip_rx_bytes);
#if IP6_STATS
            stat_rx_or_tx_cnt = lwip_stats.ip6.recv;
            stat_err_cnt = (u32_t)(lwip_stats.ip6.ip_rx_err +
                                   lwip_stats.ip6.lenerr +
                                   lwip_stats.ip6.chkerr +
                                   lwip_stats.ip6.opterr +
                                   lwip_stats.ip6.proterr);
            stat_drop_cnt = lwip_stats.ip6.drop;
            stat_rx_or_tx_bytes = lwip_stats.ip6.ip_rx_bytes;
 
            PRINTK("%18s:%u\t errors:%u\t dropped:%u\t overrun:%d\t bytes:%u ",
                   "RX packets(ip6)",
                   stat_rx_or_tx_cnt,
                   stat_err_cnt,
                   stat_drop_cnt,
                   lwip_stats.ip.link_rx_overrun,
                   stat_rx_or_tx_bytes);
 
            /* Print in Human readable format of the incoming bytes */
            lwip_printsize(lwip_stats.ip6.ip_rx_bytes);
#endif
            stat_rx_or_tx_cnt = (u32_t)(lwip_stats.ip.fw + lwip_stats.ip.xmit);
            stat_err_cnt = (u32_t)(lwip_stats.ip.rterr + lwip_stats.ip.ip_tx_err);
            /* IP layer drop stat param is not maintained, failure at IP is considered in 'errors' stat */
            stat_drop_cnt = lwip_stats.link.link_tx_drop;
            stat_rx_or_tx_bytes = lwip_stats.ip.ip_tx_bytes;
 
            PRINTK("%18s:%u\t errors:%u\t link dropped:%u\t overrun:0\t bytes:%u",
                   "TX packets",
                   stat_rx_or_tx_cnt,
                   stat_err_cnt,
                   stat_drop_cnt,
                   stat_rx_or_tx_bytes);
 
            /* Print in Human readable format of the outgoing bytes */
            lwip_printsize(lwip_stats.ip.ip_tx_bytes);
 
            stat_rx_or_tx_cnt = (u32_t)(lwip_stats.ip6.fw + lwip_stats.ip6.xmit);
            stat_err_cnt = (u32_t)(lwip_stats.ip6.rterr + lwip_stats.ip6.ip_tx_err);
            stat_rx_or_tx_bytes = lwip_stats.ip6.ip_tx_bytes;
 
            PRINTK("%18s:%u\t errors:%u\t overrun:0\t bytes:%u",
                   "TX packets(ip6)",
                   stat_rx_or_tx_cnt,
                   stat_err_cnt,
                   stat_rx_or_tx_bytes);
 
            /* Print in Human readable format of the outgoing bytes */
            lwip_printsize(lwip_stats.ip6.ip_tx_bytes);
#endif /* LWIP_STATS */
            return 0;
        }
    }
 
    (void)memset_s(&ifconfig_cmd, sizeof(ifconfig_cmd), 0, sizeof(ifconfig_cmd));
    if (sys_sem_new(&ifconfig_cmd.cb_completed, 0) != ERR_OK) {
        PRINTK("%s: sys_sem_new fail\n", __FUNCTION__);
        return 1;
    }
 
    i = 0;
    /* Get the interface */
    if (argc > 0) {
        if (strlen(argv[i]) < IFNAMSIZ) {
            if (strncpy_s(ifconfig_cmd.iface, IFNAMSIZ, argv[i], (strlen(argv[i]))) != EOK) {
                sys_sem_free(&ifconfig_cmd.cb_completed);
                PRINTK("ifconfig : strncpy_s error\n");
                return 1;
            }
            ifconfig_cmd.iface[IFNAMSIZ - 1] = '\0';
        } else {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            PRINTK("ifconfig : interface name is too big\n");
            return 1;
        }
        i++;
        argc--;
        if (argc == 0) {
            /* no more arguments, show the interface state. */
            ret = tcpip_callback(lwip_ifconfig_show_internal, &ifconfig_cmd);
            if (ret != ERR_OK) {
                sys_sem_free(&ifconfig_cmd.cb_completed);
                PRINTK("ifconfig : internal error, l:%d err:%d\n", __LINE__, ret);
                return 1;
            }
            (void)sys_arch_sem_wait(&ifconfig_cmd.cb_completed, 0);
            sys_sem_free(&ifconfig_cmd.cb_completed);
            ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
            PRINTK("%s", ifconfig_cmd.cb_print_buf);
            return 0;
        }
    } else {
        /* no more arguments, show all the interface state. */
        ret = tcpip_callback(lwip_ifconfig_show_internal, &ifconfig_cmd);
        if (ret != ERR_OK) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            PRINTK("ifconfig : internal error, l:%d err:%d\n", __LINE__, ret);
            return 1;
        }
        (void)sys_arch_sem_wait(&ifconfig_cmd.cb_completed, 0);
        sys_sem_free(&ifconfig_cmd.cb_completed);
        ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
        PRINTK("%s", ifconfig_cmd.cb_print_buf);
 
        return 0;
    }
 
    /* ifup/ifdown */
    if (strcmp("up", argv[i]) == 0) {
        ifconfig_cmd.option |= IFCONFIG_OPTION_SET_UP;
        /* setup the interface, other arguments is ignored. */
        ret = tcpip_callback(lwip_ifconfig_internal, &ifconfig_cmd);
        if (ret != ERR_OK) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            PRINTK("ifconfig : internal error, l:%d err:%d\n", __LINE__, ret);
            return 1;
        }
        (void)sys_arch_sem_wait(&ifconfig_cmd.cb_completed, 0);
        sys_sem_free(&ifconfig_cmd.cb_completed);
        ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
        PRINTK("%s", ifconfig_cmd.cb_print_buf);
        return 0;
    } else if (strcmp("down", argv[i]) == 0) {
        ifconfig_cmd.option |= IFCONFIG_OPTION_SET_DOWN;
        /* setdown the interface, other arguments is ignored. */
        ret = tcpip_callback(lwip_ifconfig_internal, &ifconfig_cmd);
        if (ret != ERR_OK) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            PRINTK("ifconfig : internal error, l:%d err:%d\n", __LINE__, ret);
            return 1;
        }
        (void)sys_arch_sem_wait(&ifconfig_cmd.cb_completed, 0);
        sys_sem_free(&ifconfig_cmd.cb_completed);
        ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
        PRINTK("%s", ifconfig_cmd.cb_print_buf);
        return 0;
    }
    /* check if set the ip address. */
#if LWIP_ARP
    netiftmp = netifapi_netif_find_by_name(ifconfig_cmd.iface);
    if (netiftmp == NULL) {
        sys_sem_free(&ifconfig_cmd.cb_completed);
        PRINTK("ifconfig : Interface %s not found\n", ifconfig_cmd.iface);
        return 1;
    }
#if LWIP_ENABLE_IP_CONFLICT_SIGNAL
    old_ip4addr = ipaddr_addr(ipaddr_ntoa(&netiftmp->ip_addr));
#endif /* LWIP_ENABLE_IP_CONFLICT_SIGNAL */
#endif /* LWIP_ARP */
    if (!strcmp(argv[i], "inet") || ip4addr_aton(argv[i], ip_2_ip4(&ifconfig_cmd.ip_addr))) {
        if (!strcmp(argv[i], "inet")) {
            if (argc <= 1) {
                sys_sem_free(&ifconfig_cmd.cb_completed);
                goto ifconfig_error;
            }
 
            if (!ip4addr_aton(argv[i + 1], ip_2_ip4(&ifconfig_cmd.ip_addr))) {
                sys_sem_free(&ifconfig_cmd.cb_completed);
                PRINTK("ifconfig : Invalid IPv4 Address\n");
                return 1;
            }
            argc--;
            i++;
        }
        IP_SET_TYPE_VAL((ifconfig_cmd.ip_addr), IPADDR_TYPE_V4);
#if LWIP_ARP
        if (!ip_addr_cmp(&ifconfig_cmd.ip_addr, &netiftmp->ip_addr)) {
            ifconfig_cmd.option |= IFCONFIG_OPTION_SET_IP;
        }
#else
        ifconfig_cmd.option |= IFCONFIG_OPTION_SET_IP;
#endif /* LWIP_ARP */
        argc--;
        i++;
    } else if (!strcmp(argv[i], "inet6")) {
        if (argc < 3) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            goto ifconfig_error;
        }
        if (strcmp(argv[i + 1], "add") && strcmp(argv[i + 1], "del")) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            goto ifconfig_error;
        }
 
        if (!ip6addr_aton(argv[i + 2], ip_2_ip6(&ifconfig_cmd.ip_addr))) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            PRINTK("ifconfig : Invalid IPv6 Address\n");
            return 1;
        }
 
        IP_SET_TYPE_VAL((ifconfig_cmd.ip_addr), IPADDR_TYPE_V6);
        ifconfig_cmd.option |= (!strcmp(argv[i + 1], "add") ? IFCONFIG_OPTION_SET_IP : IFCONFIG_OPTION_DEL_IP);
        argc -= 3;
        i += 3;
    }
 
    if (ifconfig_cmd.option & IFCONFIG_OPTION_DEL_IP) {
        if (argc != 0) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            goto ifconfig_error;
        }
    }
 
    while (argc > 0) {
        if (strcmp("netmask", argv[i]) == 0 && (argc > 1) && (ipaddr_addr(argv[i + 1]) != IPADDR_NONE)) {
            /* if set netmask */
            ip_addr_set_ip4_u32_val((ifconfig_cmd.netmask), ipaddr_addr(argv[i + 1]));
            ifconfig_cmd.option |= IFCONFIG_OPTION_SET_NETMASK;
            i += 2;
            argc -= 2;
        } else if (strcmp("gateway", argv[i]) == 0 && (argc > 1) && (ipaddr_addr(argv[i + 1]) != IPADDR_NONE)) {
            /* if set gateway */
            ip_addr_set_ip4_u32_val((ifconfig_cmd.gw), ipaddr_addr(argv[i + 1]));
            ifconfig_cmd.option |= IFCONFIG_OPTION_SET_GW;
            i += 2;
            argc -= 2;
        } else if (strcmp("hw", argv[i]) == 0 && argc > 2 && strcmp("ether", argv[i + 1]) == 0) {
            /* if set HWaddr */
            char *digit = NULL;
            u32_t macaddrlen = strlen(argv[i + 2]) + 1;
            char tmpStr[MAX_MACADDR_STRING_LENGTH];
            char *tmpStr1 = NULL;
            char *saveptr = NULL;
            int j;
 
            if (macaddrlen != MAX_MACADDR_STRING_LENGTH) {
                sys_sem_free(&ifconfig_cmd.cb_completed);
                PRINTK("ifconfig : wrong MAC address format\n");
                return 1;
            }
 
            if (strncpy_s(tmpStr, MAX_MACADDR_STRING_LENGTH, argv[i + 2], macaddrlen - 1) != 0) {
                sys_sem_free(&ifconfig_cmd.cb_completed);
                PRINTK("ifconfig : wrong MAC address\n");
                return 1;
            }
            for (j = 0, tmpStr1 = tmpStr; j < 6; j++, tmpStr1 = NULL) {
                digit = strtok_r(tmpStr1, ":", &saveptr);
                if ((digit == NULL) || (strlen(digit) > 2)) {
                    sys_sem_free(&ifconfig_cmd.cb_completed);
                    PRINTK("ifconfig : wrong MAC address format\n");
                    return 1;
                }
                CONVERT_STRING_TO_HEX(digit, ifconfig_cmd.ethaddr[j]);
            }
            ifconfig_cmd.option |= IFCONFIG_OPTION_SET_HW;
            i += 3;
            argc -= 3;
        } else if (!strcmp("mtu", argv[i]) && (argc > 1)) {
            /* if set mtu */
            if ((atoi(argv[i + 1]) < 0) || (atoi(argv[i + 1]) > 0xFFFF)) {
                sys_sem_free(&ifconfig_cmd.cb_completed);
                PRINTK("\nifconfig: Invalid argument for mtu\n");
                goto ifconfig_error;
            }
 
            ifconfig_cmd.mtu = (u16_t)(atoi(argv[i + 1]));
            ifconfig_cmd.option |= IFCONFIG_OPTION_SET_MTU;
            i += 2;
            argc -= 2;
        } else {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            goto ifconfig_error;
        }
    }
 
#if LWIP_ARP && LWIP_ENABLE_IP_CONFLICT_SIGNAL
    if ((ifconfig_cmd.option & IFCONFIG_OPTION_SET_IP) && IP_IS_V4_VAL((ifconfig_cmd.ip_addr))) {
      /* Create the semaphore for ip conflict detection. */
      if (sys_sem_new(&ip_conflict_detect, 0) != ERR_OK) {
        sys_sem_free(&ifconfig_cmd.cb_completed);
        PRINTK("ifconfig: internal error\n");
        return 1;
      }
      is_ip_conflict_signal = 1;
    }
#endif /* LWIP_ARP && LWIP_ENABLE_IP_CONFLICT_SIGNAL */
 
#if LWIP_IPV6
    if ((ifconfig_cmd.option & IFCONFIG_OPTION_SET_IP) && IP_IS_V6_VAL((ifconfig_cmd.ip_addr))) {
        /* Create the semaphore for duplicate address detection. */
        if (sys_sem_new(&dup_addr_detect, 0) != ERR_OK) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            PRINTK("ifconfig: internal error\n");
            return 1;
        }
        is_dup_detect_initialized = 1;
    }
#endif /* LWIP_IPV6 */
 
    ret = tcpip_callback(lwip_ifconfig_internal, &ifconfig_cmd);
    if (ret != ERR_OK) {
        sys_sem_free(&ifconfig_cmd.cb_completed);
#if LWIP_ARP && LWIP_ENABLE_IP_CONFLICT_SIGNAL
        if ((ifconfig_cmd.option & IFCONFIG_OPTION_SET_IP) && IP_IS_V4_VAL((ifconfig_cmd.ip_addr))) {
          is_ip_conflict_signal = 0;
          sys_sem_free(&ip_conflict_detect);
        }
#endif /* LWIP_ARP && LWIP_ENABLE_IP_CONFLICT_SIGNAL */
 
#if LWIP_IPV6
        if ((ifconfig_cmd.option & IFCONFIG_OPTION_SET_IP) && IP_IS_V6_VAL((ifconfig_cmd.ip_addr))) {
            is_dup_detect_initialized = 0;
            sys_sem_free(&dup_addr_detect);
        }
#endif /* LWIP_IPV6 */
 
        PRINTK("%s : tcpip_callback failed in line %d : errnu %d", __FUNCTION__, __LINE__, ret);
        return 1;
    }
    (void)sys_arch_sem_wait(&ifconfig_cmd.cb_completed, 0);
    ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
    PRINTK("%s", ifconfig_cmd.cb_print_buf);
#if LWIP_ARP && LWIP_ENABLE_IP_CONFLICT_SIGNAL
    /* Pend 2 seconds for waiting the arp reply if the ip is already in use.*/
    if ((ifconfig_cmd.option & IFCONFIG_OPTION_SET_IP) && IP_IS_V4_VAL((ifconfig_cmd.ip_addr))) {
      err = (err_t)sys_arch_sem_wait(&ip_conflict_detect, DUP_ARP_DETECT_TIME);
      is_ip_conflict_signal = 0;
      sys_sem_free(&ip_conflict_detect);
      if (err < 0) {
        /* The result neither conflict nor timeout. */
        PRINT_ERR("ifconfig: internal error\n");
        sys_sem_free(&ifconfig_cmd.cb_completed);
        return 1;
      } else if (err < DUP_ARP_DETECT_TIME) {
        /* Duplicate use of new ip, restore it to the old one. */
        PRINT_ERR("ifconfig: ip conflict!\n");
        ip_addr_set_ip4_u32_val(ifconfig_cmd.ip_addr, old_ip4addr);
        ret = tcpip_callback(lwip_ifconfig_internal, &ifconfig_cmd);
        if (ret != ERR_OK) {
          sys_sem_free(&ifconfig_cmd.cb_completed);
          PRINTK("%s : tcpip_callback failed in line %d : errnu %d", __FUNCTION__, __LINE__, ret);
          return 1;
        }
        (void)sys_arch_sem_wait(&ifconfig_cmd.cb_completed, 0);
        sys_sem_free(&ifconfig_cmd.cb_completed);
        ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
        PRINTK("%s", ifconfig_cmd.cb_print_buf);
        return 1;
      }
    }
#endif /* LWIP_ARP && LWIP_ENABLE_IP_CONFLICT_SIGNAL */
#if LWIP_IPV6
    if ((ifconfig_cmd.option & IFCONFIG_OPTION_SET_IP) && IP_IS_V6_VAL(ifconfig_cmd.ip_addr)) {
        /* Pend 2 seconds for waiting the arp reply if the ip is already in use.*/
        retval = sys_arch_sem_wait(&dup_addr_detect, DUP_ARP_DETECT_TIME);
        is_dup_detect_initialized = 0;
        sys_sem_free(&dup_addr_detect);
        if (retval == SYS_ARCH_ERROR) {
            sys_sem_free(&ifconfig_cmd.cb_completed);
            /* The result neither conflict nor timeout. */
            PRINT_ERR("ifconfig: internal error\n");
            return 1;
        } else if (retval < DUP_ARP_DETECT_TIME) {
            /* Duplicate use of new ip, restore it to the old one. */
            struct netif *netif = NULL;
            PRINT_ERR("ifconfig: IP conflict!\n");
            netif = netifapi_netif_find_by_name(ifconfig_cmd.iface);
            i = netif_get_ip6_addr_match(netif, &ifconfig_cmd.ip_addr.u_addr.ip6);
            if (i >= 0) {
                netif->ip6_addr_state[i] = IP6_ADDR_INVALID;
            }
 
            sys_sem_free(&ifconfig_cmd.cb_completed);
            ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
            PRINTK("%s", ifconfig_cmd.cb_print_buf);
            return 1;
        }
    }
#endif /* LWIP_IPV6 */
    sys_sem_free(&ifconfig_cmd.cb_completed);
    return 0;
ifconfig_error:
    lwip_ifconfig_usage("ifconfig");
    return 1;
}

函数调用图:

lwip_ifconfig_internal()

LWIP_STATIC void lwip_ifconfig_internal

(

void *

arg

)

在文件 api_shell.c 第 476 行定义.

{
    struct ifconfig_option *ifconfig_cmd = NULL;
    struct netif *netif = NULL;
    ip_addr_t ip_addr;
    ip_addr_t netmask;
    ip_addr_t gw;
    unsigned short mtu;
    struct netif *loc_netif = NULL;
    int ret;
    s8_t idx;
    err_t err;
 
    ifconfig_cmd = (struct ifconfig_option *)arg;
    netif = netif_find(ifconfig_cmd->iface);
    if (netif == NULL) {
        ERR_IFCONFIG_STRING_PUT(ret, "Device not found\n");
        goto out;
    }
 
    if (ifconfig_cmd->option & IFCONFIG_OPTION_SET_UP) {
        (void)netif_set_up(netif);
        goto out;
    } else if (ifconfig_cmd->option & IFCONFIG_OPTION_SET_DOWN) {
        (void)netif_set_down(netif);
        goto out;
    }
 
    if ((ifconfig_cmd->option & IFCONFIG_OPTION_SET_IP) ||
        (ifconfig_cmd->option & IFCONFIG_OPTION_SET_NETMASK) ||
        (ifconfig_cmd->option & IFCONFIG_OPTION_SET_HW)) {
        (void)netif_set_down(netif);
    }
 
    if (ifconfig_cmd->option & IFCONFIG_OPTION_SET_IP) {
        ip_addr_set_val(&ip_addr, &(ifconfig_cmd->ip_addr));
        if (IP_IS_V4_VAL(ifconfig_cmd->ip_addr)) {
            /* check the address is not multicast/broadcast/0/loopback */
            if (ip_addr_ismulticast_val(&ip_addr) || ip_addr_isbroadcast_val(&ip_addr, netif) ||
                ip_addr_isany(&ip_addr) || ip_addr_isloopback(&ip_addr)) {
                ERR_IFCONFIG_STRING_PUT(ret, "Don't set ip as a multicast/broadcast/0/loopback address!\n");
                goto out;
            }
 
            /* reset gateway if new and previous ipaddr not in same net */
            if (!ip_addr_netcmp_val(&ip_addr, &netif->ip_addr, ip_2_ip4(&netif->netmask))) {
                ip_addr_set_zero(&netif->gw);
                if (netif == netif_default) {
                    (void)netif_set_default(NULL);
                }
            }
 
            /* lwip disallow two netif sit in same net at the same time */
            loc_netif = netif_list;
            while (loc_netif != NULL) {
                if (loc_netif == netif) {
                    loc_netif = loc_netif->next;
                    continue;
                }
                if (IP_IS_V4_VAL(ifconfig_cmd->ip_addr) && ip_addr_cmp(&netif->netmask, &loc_netif->netmask) &&
                    ip_addr_netcmp_val(&loc_netif->ip_addr, &ip_addr, ip_2_ip4(&netif->netmask))) {
                    ERR_IFCONFIG_STRING_PUT(ret, "Duplicate network!\n");
                    goto out;
                }
                loc_netif = loc_netif->next;
            }
 
#if LWIP_DHCP
            if (netif_dhcp_data(netif) && netif_dhcp_data(netif)->state != DHCP_STATE_OFF) {
                (void)netif_dhcp_off(netif);
            }
#endif
            netif_set_ipaddr(netif, ip_2_ip4(&ip_addr));
        } else if (IP_IS_V6_VAL(ifconfig_cmd->ip_addr)) {
            idx = -1;
            err = netif_add_ip6_address(netif, ip_2_ip6(&ip_addr), &idx);
            if (err != ERR_OK || idx == -1) {
                ERR_IFCONFIG_STRING_PUT(ret, "The IPv6 has reached the Global address limit, "
                                             "you should delete one address before add!\n");
                goto out;
            }
        }
    }
 
    if (ifconfig_cmd->option & IFCONFIG_OPTION_DEL_IP) {
        (void)netif_do_rmv_ipv6_addr(netif, &ifconfig_cmd->ip_addr);
    }
 
    if (ifconfig_cmd->option & IFCONFIG_OPTION_SET_NETMASK) {
        ip_addr_set_val(&netmask, &(ifconfig_cmd->netmask));
        /* check data valid */
        if (!ip_addr_netmask_valid(ip_2_ip4(&netmask))) {
            ERR_IFCONFIG_STRING_PUT(ret, "ifconfig: netmask is invalid!\n");
            goto out;
        }
 
#if LWIP_DHCP
        if (netif_dhcp_data(netif) && netif_dhcp_data(netif)->state != DHCP_STATE_OFF) {
            (void)netif_dhcp_off(netif);
        }
#endif
        if (netif_ip4_netmask(netif)->addr != ip_2_ip4(&netmask)->addr) {
            /* lwip disallow two netif sit in same net at the same time */
            loc_netif = netif_list;
            while (loc_netif != NULL) {
                if (loc_netif == netif) {
                    loc_netif = loc_netif->next;
                    continue;
                }
                if (ip_addr_cmp(&loc_netif->netmask, &netmask) &&
                    ip_addr_netcmp(&loc_netif->ip_addr, &netif->ip_addr, ip_2_ip4(&netmask))) {
                    ERR_IFCONFIG_STRING_PUT(ret, "Duplicate network!\n");
                    goto out;
                }
                loc_netif = loc_netif->next;
            }
            netif_set_netmask(netif, ip_2_ip4(&netmask));
            /* check if gateway still reachable */
            if (!ip_addr_netcmp(&netif->gw, &netif->ip_addr, ip_2_ip4(&netmask))) {
                ip_addr_set_zero(&(netif->gw));
                if (netif == netif_default) {
                    (void)netif_set_default(NULL);
                }
            }
        }
    }
 
    if ((ifconfig_cmd->option & IFCONFIG_OPTION_SET_HW) &&
        netif_set_hwaddr(netif, ifconfig_cmd->ethaddr, NETIF_MAX_HWADDR_LEN) != ERR_OK) {
        ERR_IFCONFIG_STRING_PUT(ret, "Failed to update the hwaddr of the device!\n");
        (void)netif_set_up(netif);
        goto out;
    }
 
    if ((ifconfig_cmd->option & IFCONFIG_OPTION_SET_IP) ||
        (ifconfig_cmd->option & IFCONFIG_OPTION_SET_NETMASK) ||
        (ifconfig_cmd->option & IFCONFIG_OPTION_SET_HW)) {
        (void)netif_set_up(netif);
    }
 
    if (ifconfig_cmd->option & IFCONFIG_OPTION_SET_GW) {
        ip_addr_set_val(&gw, &ifconfig_cmd->gw);
 
        /* check the address multicast/0/loopback */
        if (ip_addr_ismulticast_val(&gw) || ip_addr_isbroadcast_val(&gw, netif) ||
            ip_addr_isany(&gw) || ip_addr_isloopback(&gw)) {
            ERR_IFCONFIG_STRING_PUT(ret, "Don't set gateway as a multicast/broadcast/0/loopback address!\n");
            goto out;
        }
 
        /* check if reachable */
        if (!ip_addr_netcmp_val(&gw, &netif->ip_addr, ip_2_ip4(&netif->netmask))) {
            ERR_IFCONFIG_STRING_PUT(ret, "The address is unreachable!\n");
            goto out;
        }
 
        if (netif_default != netif) {
            ip_addr_set_zero(&netif->gw);
            (void)netif_set_default(netif);
        }
 
#if LWIP_DHCP
        if (netif_dhcp_data(netif) && netif_dhcp_data(netif)->state != DHCP_STATE_OFF) {
            (void)netif_dhcp_off(netif);
        }
#endif
        netif_set_gw(netif, ip_2_ip4(&gw));
    }
 
    if (ifconfig_cmd->option & IFCONFIG_OPTION_SET_MTU) {
        mtu = ifconfig_cmd->mtu;
        if (netif_set_mtu(netif, mtu) != ERR_OK) {
            ERR_IFCONFIG_STRING_PUT(ret, "Invalid MTU\n");
        }
    }
out:
    sys_sem_signal(&ifconfig_cmd->cb_completed);
}

函数调用图:

这是这个函数的调用关系图:

lwip_ifconfig_show_internal()

LWIP_STATIC void lwip_ifconfig_show_internal

(

void *

arg

)

在文件 api_shell.c 第 429 行定义.

{
    struct netif *netif = NULL;
    struct ifconfig_option *ifconfig_cmd = (struct ifconfig_option *)arg;
    int ret;
 
    if (netif_list == NULL) {
        ret = snprintf_s(ifconfig_cmd->cb_print_buf, PRINT_BUF_LEN - ifconfig_cmd->print_len,
                         ((PRINT_BUF_LEN - ifconfig_cmd->print_len) - 1), "Device not init\n");
        if ((ret > 0) && ((unsigned int)ret < (PRINT_BUF_LEN - ifconfig_cmd->print_len))) {
            ifconfig_cmd->print_len += (unsigned int)ret;
        }
        sys_sem_signal(&ifconfig_cmd->cb_completed);
        return;
    }
 
    if (ifconfig_cmd->iface[0] == '\0') {
        /* display all netif */
        for (netif = netif_list; netif != NULL; netif = netif->next) {
            ret = print_netif(netif, ifconfig_cmd->cb_print_buf + ifconfig_cmd->print_len,
                              PRINT_BUF_LEN - ifconfig_cmd->print_len);
            ifconfig_cmd->print_len += (unsigned int)ret;
        }
    } else {
        netif = netif_find(ifconfig_cmd->iface);
        if (netif == NULL) {
            ret = snprintf_s(ifconfig_cmd->cb_print_buf + ifconfig_cmd->print_len,
                             (PRINT_BUF_LEN - ifconfig_cmd->print_len),
                             ((PRINT_BUF_LEN - ifconfig_cmd->print_len) - 1), "Device not found\n");
            if ((ret > 0) && ((unsigned int)ret < (PRINT_BUF_LEN - ifconfig_cmd->print_len))) {
                ifconfig_cmd->print_len += (unsigned int)ret;
            }
 
            sys_sem_signal(&ifconfig_cmd->cb_completed);
            return;
        }
 
        ret = print_netif(netif, ifconfig_cmd->cb_print_buf + ifconfig_cmd->print_len,
                          PRINT_BUF_LEN - ifconfig_cmd->print_len);
        ifconfig_cmd->print_len += (unsigned int)ret;
    }
    sys_sem_signal(&ifconfig_cmd->cb_completed);
}

函数调用图:

这是这个函数的调用关系图:

lwip_ifconfig_usage()

LWIP_STATIC void lwip_ifconfig_usage

(

const char *

cmd

)

在文件 api_shell.c 第 671 行定义.

{
    PRINTK("Usage:"\
         "\n%s [-a] "\
         "\n[interface]"\
         "\n[interface ipaddr] <netmask mask> <gateway gw>"\
         "\n[interface inet6 add|del ipaddr]"\
         "\n[interface hw ether MAC]"\
         "\n[interface mtu NN]"\
         "\n[interface up|down]\n",
           cmd);
}

这是这个函数的调用关系图:

lwip_ping_usage()

static void lwip_ping_usage ( void  )

static

在文件 api_shell.c 第 1563 行定义.

{
    PRINTK("Usage:"\
         "\n  ping"
           "\n  ping [-n cnt] [-w interval] [-l data_len] destination"
           "\n  ping [-t] [-w interval] destination"
           "\n  ping -k");
    PRINTK("\n  -t means ping forever, user can use -k to stop the forever ping\n");
}

这是这个函数的调用关系图:

lwip_printsize()

void lwip_printsize

(

size_t

size

)

在文件 api_shell.c 第 656 行定义.

{
    static const char *SIZES[] = {"B", "KB", "MB", "GB"};
    size_t divis = 0;
    size_t rem = 0;
 
    while ((size >= 1024) && (divis < ((sizeof(SIZES) / sizeof(char *)) - 1))) {
        rem = (size % 1024);
        divis++;
        size /= 1024;
    }
 
    PRINTK("(%.1f %s) \r\n", (float)size + (float)rem / 1024.0, SIZES[divis]);
}

这是这个函数的调用关系图:

netdebug_memp()

LWIP_STATIC u32_t netdebug_memp	(	int	argc,
		const char **	argv
	)

这是这个函数的调用关系图:

netdebug_sock()

LWIP_STATIC u32_t netdebug_sock	(	int	argc,
		const char **	argv
	)

这是这个函数的调用关系图:

netstat_get_udp_sendQLen()

int netstat_get_udp_sendQLen	(	struct udp_pcb *	udppcb,
		struct pbuf *	udpbuf
	)

在文件 api_shell.c 第 2802 行定义.

函数调用图:

这是这个函数的调用关系图:

netstat_get_udp_sendQLen6()

int netstat_get_udp_sendQLen6	(	struct udp_pcb *	udppcb,
		struct pbuf *	udpbuf
	)

在文件 api_shell.c 第 2710 行定义.

{
    int sendLen = -1;
    u16_t offset = 0, len;
    struct ip6_hdr *iphdr = NULL;
    struct udp_hdr *udphdr = NULL;
    struct ip6_dest_hdr *dest_hdr = NULL;
    struct ip6_frag_hdr *frag_hdr = NULL;
    u8_t nexth;
    u16_t hlen = 0;
 
    LWIP_ERROR("netstat_get_udp6_sendQLen: NULL pcb received\n", (udppcb != NULL), return -1);
    LWIP_ERROR("netstat_get_udp6_sendQLen: NULL pbuf received\n", (udpbuf != NULL), return -1);
 
    iphdr = (struct ip6_hdr *)udpbuf->payload;
 
    if (!(ip6_addr_cmp(&iphdr->dest, ip_2_ip6(&udppcb->remote_ip)) &&
          (ip_addr_isany(&udppcb->local_ip) ||
           ip6_addr_cmp(&iphdr->src, ip_2_ip6(&udppcb->local_ip))))) {
        goto FUNC_OUT;
    }
 
    len = IP6_HLEN;
    if (pbuf_header(udpbuf, (s16_t)(-(s16_t)(len)))) {
        goto FUNC_OUT;
    }
 
    offset = len;
 
    nexth = IP6H_NEXTH(iphdr);
    while (offset < udpbuf->tot_len) {
        if (nexth == IP6_NEXTH_NONE || nexth == IP6_NEXTH_UDP || nexth == IP6_NEXTH_UDPLITE) {
            break;
        }
        switch (nexth) {
            case IP6_NEXTH_HOPBYHOP:
            case IP6_NEXTH_ROUTING:
                nexth = *((u8_t *)udpbuf->payload);
                hlen = (u16_t)(8 * (1 + *((u8_t *)udpbuf->payload + 1)));
                break;
            case IP6_NEXTH_DESTOPTS:
                nexth = *((u8_t *)udpbuf->payload);
                dest_hdr = (struct ip6_dest_hdr *)udpbuf->payload;
                hlen = (u16_t)(8 * (1 + dest_hdr->_hlen));
                break;
            case IP6_NEXTH_FRAGMENT:
                frag_hdr = (struct ip6_frag_hdr *)udpbuf->payload;
                nexth = frag_hdr->_nexth;
                hlen = IP6_FRAG_HLEN;
                break;
            default:
                /* Unknown next_header */
                goto FUNC_OUT;
        }
 
        (void)pbuf_header(udpbuf, (s16_t)(-(s16_t)hlen));
        offset = (u16_t)(offset + hlen);
    }
 
    /* If the while loop test condition failed , then revert the last offset change */
    if (offset >= udpbuf->tot_len) {
        offset = (u16_t)(offset - hlen);
        goto FUNC_OUT;
    }
 
    LWIP_ERROR("Transport option should be UDP", (nexth == IP6_NEXTH_UDP || nexth == IP6_NEXTH_UDPLITE), goto FUNC_OUT);
 
    if (offset > iphdr->_plen) {
        goto FUNC_OUT;
    }
 
    /* check if there is enough space for atleast udp header available */
    if (udpbuf->tot_len < UDP_HLEN) {
        goto FUNC_OUT;
    }
 
    udphdr = (struct udp_hdr *)udpbuf->payload;
    if ((ntohs(udphdr->dest) == udppcb->remote_port) && (ntohs(udphdr->src) == udppcb->local_port)) {
        if (ntohs(udphdr->len) > UDP_HLEN) {
            sendLen = ntohs(udphdr->len) - UDP_HLEN;
        } else {
            sendLen = udpbuf->tot_len - UDP_HLEN;
        }
    }
 
FUNC_OUT:
    (void)pbuf_header(udpbuf, (s16_t)offset); // can not cross max limit of s16_t
    return sendLen;
}

函数调用图:

这是这个函数的调用关系图:

netstat_netconn_recvq()

int netstat_netconn_recvq

(

const struct netconn *

conn

)

这是这个函数的调用关系图:

netstat_netconn_sendq()

int netstat_netconn_sendq

(

struct netconn *

conn

)

这是这个函数的调用关系图:

netstat_tcp_recvq()

int netstat_tcp_recvq

(

struct tcp_pcb *

tpcb

)

这是这个函数的调用关系图:

netstat_tcp_sendq()

int netstat_tcp_sendq

(

struct tcp_pcb *

tpcb

)

这是这个函数的调用关系图:

netstat_udp_sendq()

int netstat_udp_sendq

(

struct udp_pcb *

upcb

)

这是这个函数的调用关系图:

netstat_udp_sendq6()

int netstat_udp_sendq6

(

struct udp_pcb *

upcb

)

这是这个函数的调用关系图:

osPingFunc()

LWIP_STATIC int osPingFunc	(	u32_t	destip,
		u32_t	cnt,
		u32_t	interval,
		u32_t	data_len
	)

在文件 api_shell.c 第 1573 行定义.

{
    int sfd;
    struct sockaddr_in to;
    struct pbuf *pbuf_resp = NULL;
    struct icmp_echo_hdr *iecho = NULL;
    struct icmp_echo_hdr *iecho_resp = NULL;
    struct ip_hdr *iphdr_resp = NULL;
    u32_t iecho_len;
    s16_t ip_hlen;
    u32_t forever;
    u32_t i = 0;
    u32_t succ_cnt = 0;
    u32_t failed_cnt = 0;
    struct timespec start, end;
    long timout_ms = 0;
    struct pollfd pfd;
    long rtt;
    int ret = 0;
    u32_t intrvl = 0;
    char *data_buf = NULL;
    BOOL timeout_flag = false;
    char buf[50];
 
    iecho_len = sizeof(struct icmp_echo_hdr) + data_len;
    sfd = lwip_socket(PF_INET, SOCK_RAW, IPPROTO_ICMP);
    if (sfd < 0) {
        perror("Ping socket");
        return -1;
    }
    pbuf_resp = pbuf_alloc(PBUF_RAW, IP_HLEN + sizeof(struct icmp_echo_hdr), PBUF_RAM);
    if (pbuf_resp == NULL) {
        PRINTK("Ping: pbuf_resp malloc failed\n");
        ret = -1;
        goto FAILURE;
    }
    iecho = (struct icmp_echo_hdr *)mem_malloc(iecho_len);
    if (iecho == NULL) {
        PRINTK("Ping: echo request malloc failed\n");
        ret = -1;
        goto FAILURE;
    }
 
    to.sin_family = AF_INET;
    to.sin_addr.s_addr = destip; /* already in network order */
    to.sin_port = 0;
 
    if (data_len > PING_ZERO_DATA_LEN) {
        (void)memset_s(iecho, sizeof(struct icmp_echo_hdr) + PING_ZERO_DATA_LEN,
                       0, sizeof(struct icmp_echo_hdr) + PING_ZERO_DATA_LEN);
        data_buf = (char *)iecho + sizeof(struct icmp_echo_hdr) + PING_ZERO_DATA_LEN;
        for (i = 0; i < data_len - PING_ZERO_DATA_LEN; i++) {
            *(data_buf + i) = i + 0x10;
        }
    } else {
        (void)memset_s(iecho, sizeof(struct icmp_echo_hdr) + data_len, 0, sizeof(struct icmp_echo_hdr) + data_len);
    }
    iecho->id = htons((u16_t)LOS_CurTaskIDGet());
    ICMPH_TYPE_SET(iecho, (u8_t)ICMP_ECHO);
    forever = (cnt ? 0 : 1);
    i = 0;
    while (!ping_kill && (forever || (i < cnt))) {
        iecho->seqno = htons((u16_t)i);
        iecho->chksum = 0;
        iecho->chksum = inet_chksum((void *)iecho, iecho_len);
 
        ret = sendto(sfd, iecho, iecho_len, 0, (struct sockaddr *)&to, (socklen_t)sizeof(to));
        if (ret < 0) {
            perror("Ping: sending ICMP echo request failed\n");
            goto FAILURE;
        }
 
        /* capture the start time to calculate RTT */
        (void)clock_gettime(CLOCK_MONOTONIC_RAW, &start);
 
        /* poll for ICMP echo response msg */
        pfd.fd = sfd;
 
        do {
            pfd.events = POLLIN;
            pfd.revents = 0;
            timeout_flag = false;
            ret = poll(&pfd, 1, LWIP_SHELL_CMD_PING_TIMEOUT);
            if (ret < 0) {
                perror("Ping: poll\n");
                goto FAILURE;
            } else if (ret == 0) {
                /* first type timeout event */
                timeout_flag = true;
                break;
            }
 
            ret = recv(sfd, pbuf_resp->payload, pbuf_resp->len, MSG_DONTWAIT);
            if (ret < 0) {
                perror("Ping: recv echo reply failed\n");
                goto FAILURE;
            }
 
            /* Accessing ip header and icmp header */
            iphdr_resp = pbuf_resp->payload;
 
            ip_hlen = (IPH_HL(iphdr_resp) << 2);
            if (pbuf_header(pbuf_resp, -ip_hlen)) {
                /* this failure will never happen, but failure handle is written just to be in safe side */
                PRINTK("Ping : memory management failure\n");
                goto FAILURE;
            }
            iecho_resp = (struct icmp_echo_hdr *)pbuf_resp->payload;
            /* Reverting back pbuf to its original state */
            if (pbuf_header(pbuf_resp, ip_hlen)) {
                /* this failure will never happen, but failure handle is written just to be in safe side */
                PRINTK("ping : memory management failure\n");
                goto FAILURE;
            }
 
            if ((iphdr_resp->src.addr != to.sin_addr.s_addr) ||
                ((ICMPH_TYPE(iecho_resp) == ICMP_ECHO) && (iphdr_resp->src.addr == to.sin_addr.s_addr))) {
                /* second type timeout event */
                (void)clock_gettime(CLOCK_MONOTONIC_RAW, &end);
                timout_ms = ((end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000);
                timout_ms = LWIP_SHELL_CMD_PING_TIMEOUT - timout_ms;
            } else {
                timout_ms = 0;
                break;
            }
        } while (timout_ms >= 0);
 
        /* all timeout events are true timeout */
        if ((timout_ms < 0) || (timeout_flag == true)) {
            failed_cnt++;
            i++;
            PRINTK("\nPing: destination unreachable ...");
            continue;
        }
        /* capture the end time to calculate round trip time */
        (void)clock_gettime(CLOCK_MONOTONIC_RAW, &end);
        rtt = ((end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000);
 
        if (iphdr_resp->src.addr == to.sin_addr.s_addr) {
            switch (ICMPH_TYPE(iecho_resp)) {
                case ICMP_ER:
                    PRINTK("\n[%u]Reply from %s: ", i, inet_ntop(AF_INET, &to.sin_addr, buf, sizeof(buf)));
                    if (rtt > 0) {
                        PRINTK("time=%ims ", rtt);
                    } else {
                        PRINTK("time<1ms ");
                    }
                    PRINTK("TTL=%u", iphdr_resp->_ttl);
 
                    /* delay 1s for every successful ping */
                    intrvl = interval;
                    do {
                        if (intrvl < 1000) {
                            sys_msleep(intrvl);
                            break;
                        }
                        intrvl -= 1000;
                        sys_msleep(1000);
                        if (ping_kill == 1)
                            break;
                    } while (intrvl > 0);
                    succ_cnt++;
                    break;
                case ICMP_DUR:
                    PRINTK("\nPing: destination host unreachable ...");
                    break;
                case ICMP_SQ:
                    PRINTK("\nPing: source quench ...");
                    break;
                case ICMP_RD:
                    PRINTK("\nPing: redirect ...");
                    break;
                case ICMP_TE:
                    PRINTK("\nPing: time exceeded ...");
                    break;
                case ICMP_PP:
                    PRINTK("\nPing: parameter problem ...");
                    break;
                default :
                    PRINTK("\nPing: unknown error ...");
                    break;
            }
            i++;
        }
    }
 
    PRINTK("\n--- %s ping statistics ---\n", inet_ntop(AF_INET, &to.sin_addr, buf, sizeof(buf)));
    PRINTK("%u packets transmitted, %u received, %u loss\n", i, succ_cnt, failed_cnt);
 
FAILURE:
    ping_kill = 0;
    (void)lwip_close(sfd);
    if (pbuf_resp != NULL) {
        (void)pbuf_free(pbuf_resp);
    }
    if (iecho != NULL) {
        mem_free(iecho);
    }
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

osShellDns()

u32_t osShellDns	(	int	argc,
		const char **	argv
	)

在文件 api_shell.c 第 2635 行定义.

{
    ip_addr_t dns = {0};
    err_t err;
    int i;
    if (argc < 1 || argv == NULL) {
        goto usage;
    }
 
    if (tcpip_init_finish == 0) {
        PRINTK("%s: tcpip_init have not been called\n", __FUNCTION__);
        return LOS_NOK;
    }
 
    if (argc == 1 && (strcmp(argv[0], "-a") == 0)) {
        for (i = 0; i < DNS_MAX_SERVERS; i++) {
            err = lwip_dns_getserver((u8_t)i, &dns);
            if (err == ERR_OK) {
                PRINTK("dns %d: %s\n", i + 1, ipaddr_ntoa_unsafe(&dns));
            } else {
                PRINTK("dns: failed\n");
                return LOS_NOK;
            }
        }
        return LOS_OK;
    } else if (argc == 2) {
        i = atoi(argv[0]);
        if ((i <= 0) || (i > DNS_MAX_SERVERS))
            goto usage;
#if LWIP_IPV6
        if (ip6addr_aton(argv[1], ((ip6_addr_t *)&dns))) {
#if LWIP_IPV4 && LWIP_IPV6
            dns.type = IPADDR_TYPE_V6;
#endif
            if (!ip6_addr_isglobal((ip6_addr_t *)&dns)) {
                PRINTK("ip address<%s> is wrong\n", argv[1]);
                return LOS_NOK;
            }
        } else
#endif
        {
#if LWIP_IPV4
            ((ip4_addr_t *)&dns)->addr = ipaddr_addr(argv[1]);
            if (((ip4_addr_t *)&dns)->addr == IPADDR_NONE) {
                PRINTK("ip address<%s> is wrong\n", argv[1]);
                return LOS_NOK;
            }
#if LWIP_IPV4 && LWIP_IPV6
            dns.type = IPADDR_TYPE_V4;
#endif
#endif
        }
 
        err = lwip_dns_setserver((u8_t)(i - 1), &dns);
        if (err != ERR_OK) {
            PRINTK("dns : failed\n");
            return LOS_NOK;
        }
        return LOS_OK;
    }
usage:
    PRINTK("usage:\n");
    PRINTK("\tdns <1-%d> <IP>\n", DNS_MAX_SERVERS);
    PRINTK("\tdns -a\n");
    return LOS_NOK;
}

函数调用图:

osShellIpDebug()

u32_t osShellIpDebug	(	int	argc,
		const char **	argv
	)

这是这个函数的调用关系图:

osShellNetDebug()

u32_t osShellNetDebug	(	int	argc,
		const char **	argv
	)

这是这个函数的调用关系图:

osShellNtpdate()

u32_t osShellNtpdate	(	int	argc,
		const char **	argv
	)

在文件 api_shell.c 第 2590 行定义.

{
    int server_num = 0;
    char *ret = NULL;
    struct timeval get_time;
    char buf[50];
 
    (void)memset_s(&get_time, sizeof(struct timeval), 0, sizeof(struct timeval));
 
    if (!tcpip_init_finish) {
        PRINTK("%s: tcpip_init have not been called\n", __FUNCTION__);
        return LOS_NOK;
    }
 
    if (argc < 1 || argv == NULL) {
        goto usage;
    }
 
    server_num = lwip_sntp_start(argc, (char **)argv, &get_time);
    if (server_num >= 0 && server_num < argc) {
        ret = ctime_r((time_t *)&get_time.tv_sec, buf);
        if (ret != NULL) {
            PRINTK("time server %s: %s\n", argv[server_num], ret);
        } else {
            PRINTK("ctime return null error\n");
        }
    } else {
        PRINTK("no server suitable for synchronization found\n");
    }
 
    return LOS_OK;
 
usage:
    PRINTK("\nUsage:\n");
    PRINTK("ntpdate [SERVER_IP1] [SERVER_IP2] ...\n");
    return LOS_NOK;
}

函数调用图:

osShellPing()

u32_t osShellPing	(	int	argc,
		const char **	argv
	)

在文件 api_shell.c 第 1790 行定义.

{
    int ret;
    u32_t i = 0;
    u32_t count = 0;
    int count_set = 0;
    u32_t interval = 1000; /* default ping interval */
    u32_t data_len = 48; /* default data length */
    ip4_addr_t dst_ipaddr;
    TSK_INIT_PARAM_S stPingTask;
 
    if (!tcpip_init_finish) {
        PRINTK("Ping: tcpip_init have not been called\n");
        return LOS_NOK;
    }
 
    if ((argc < 1) || (argv == NULL)) {
        PRINTK("Ping: require dest ipaddr at least\n");
        goto ping_error;
    }
 
    /* could add more param support */
    while (argc > 0) {
        if (strcmp("-n", argv[i]) == 0 && (argc > 1)) {
            ret = atoi(argv[i + 1]);
            if (ret <= 0) {
                PRINTK("Ping count should be greater than 0 \n");
                goto ping_error;
            }
            count = ret;
            count_set = 1;
            i += 2;
            argc -= 2;
        } else if (strcmp("-t", argv[i]) == 0) {
            count = 0; /* ping forerver */
            count_set = 1;
            i++;
            argc--;
        } else if (strcmp("-w", argv[i]) == 0 && (argc > 1)) {
            ret = atoi(argv[i + 1]);
            if (ret <= 0) {
                PRINTK("Ping interval should be greater than 0 \n");
                goto ping_error;
            }
 
            interval = ret;
            i += 2;
            argc -= 2;
        } else if (strcmp("-l", argv[i]) == 0 && (argc > 1)) {
            ret = atoi(argv[i + 1]);
            if (ret < 0 || ret > (int)(LWIP_MAX_UDP_RAW_SEND_SIZE - sizeof(struct icmp_echo_hdr))) {
                PRINTK("Ping data length error, should be in range of [0, %d] \n",
                       LWIP_MAX_UDP_RAW_SEND_SIZE - sizeof(struct icmp_echo_hdr));
                goto ping_error;
            }
            data_len = ret;
            i += 2;
            argc -= 2;
        } else if (strcmp("-k", argv[i]) == 0) {
            if (ping_taskid > 0) {
                ping_kill = 1; /* stop the current ping task */
                return LOS_OK;
            } else {
                PRINTK("No ping task running...\n");
                return LOS_NOK;
            }
        } else {
            if (argc == 1) {
                break;
            } else {
                PRINTK("Invalid Ping param\n");
                goto ping_error;
            }
        }
    }
 
    if (!count_set) {
        count = LWIP_SHELL_CMD_PING_RETRY_TIMES;
    }
 
    /* initialize dst IP address */
    if (argc <= 0) {
        goto ping_error;
    }
#if LWIP_DNS
    dst_ipaddr.addr = get_hostip(argv[i]);
#else /* LWIP_DNS */
    dst_ipaddr.addr = inet_addr(argv[i]);
#endif /* LWIP_DNS */
 
    if (dst_ipaddr.addr == IPADDR_NONE || dst_ipaddr.addr == IPADDR_ANY) {
        PRINTK("Invalid dest ipaddr: NONE or ANY\n");
        return LOS_NOK;
    }
 
    /* start one task if ping forever or ping count greater than 60 */
    if (count == 0 || count > LWIP_SHELL_CMD_PING_RETRY_TIMES) {
        if (ping_taskid > 0) {
            PRINTK("Ping task already running and only support one now\n");
            return LOS_NOK;
        }
        stPingTask.pfnTaskEntry = (TSK_ENTRY_FUNC)ping_cmd;
        stPingTask.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
        stPingTask.pcName = "ping_task";
        stPingTask.usTaskPrio = 8; /* higher than shell */
        stPingTask.uwResved = LOS_TASK_STATUS_DETACHED;
        stPingTask.auwArgs[0] = dst_ipaddr.addr; /* network order */
        stPingTask.auwArgs[1] = count;
        stPingTask.auwArgs[2] = interval;
        stPingTask.auwArgs[3] = data_len;
        ret = LOS_TaskCreate((UINT32 *)(&ping_taskid), &stPingTask);
        if (ret != LOS_OK) {
            PRINTK("ping_task create failed 0x%08x.\n", ret);
            count = LWIP_SHELL_CMD_PING_RETRY_TIMES;
        } else {
            return LOS_OK;
        }
    }
 
    /* two cases:
     1, ping cout less than LWIP_SHELL_CMD_PING_RETRY_TIMES;
     2, ping task create failed;
    */
    if (osPingFunc(dst_ipaddr.addr, count, interval, data_len) < 0) {
        PRINTK("Ping cmd failed due some errors\n");
    }
 
    return LOS_OK;
ping_error:
    lwip_ping_usage();
    return LOS_NOK;
}

函数调用图:

osShellPing6()

u32_t osShellPing6	(	int	argc,
		const char **	argv
	)

在文件 api_shell.c 第 2082 行定义.

{
    u16_t icmpv6_id;
    u16_t icmpv6_seq;
    u32_t nsent;
    u32_t nrecieve;
    u32_t last_received;
    struct timespec start, end, start_in_reply;
    struct timespec first, last;
    long rtt;
    int ret;
    fd_set fdReadSet;
    void *param = NULL;
    ping6_args_t ping6_params;
    ping6_stats_t ping6_stats;
    struct sockaddr_in6 to;
    struct icmp6_echo_hdr *iecho_resp = NULL;
    struct icmp6_echo_hdr *iecho = NULL;
    struct timeval stTimeVal;
    struct timeval deltaTimeVal;
    struct pbuf *pbuf_resp = NULL;
    struct pbuf *pbuf_req = NULL;
    int sfd = -1;
    u8_t type;
    u8_t select_on_socket = 0;
    char buf[INET6_ADDRSTRLEN];
 
    if (!tcpip_init_finish) {
        PRINTK("%s: tcpip_init have not been called\n", __FUNCTION__);
        ret = -1;
        goto exit;
    }
 
    if ((argc < 1) || (argc > LWIP_MAX_PING6_ARG_COUNT) || (argv == NULL)) {
        goto usage;
    }
 
    ret = parse_args_ping6(argc, argv, &ping6_params);
    if (ret == -1) {
        goto exit;
    }
 
    if (ping6_params.args_found & LWIP_PING6_SOURCE_ADDRESS_ARG) {
        type = LWIP_PING6_SOURCE_ADDRESS_ARG;
        param = (void *)(&ping6_params.src_addr);
    } else if (ping6_params.args_found & LWIP_PING6_INTERFACE_ARG) {
        type = LWIP_PING6_INTERFACE_ARG;
        param = (void *)(argv[ping6_params.interface_index]);
    } else {
        type = LWIP_PING6_DEFAULT_SOCKET;
        param = NULL;
    }
 
    /* Create a socket for sending and receiving pings with appropriate bindings */
    sfd = create_ping6_socket(type, param);
    if (sfd == -1) {
        ret = -1;
        goto exit;
    }
 
    pbuf_req = pbuf_alloc(PBUF_RAW, LWIP_PING6_STANDARD_PKT_SIZE, PBUF_RAM);
    pbuf_resp = pbuf_alloc(PBUF_RAW, LWIP_PING6_STANDARD_PKT_SIZE, PBUF_RAM);
    if ((pbuf_resp == NULL) || (pbuf_req == NULL)) {
        PRINTK("ping6 : Memory Allocation Failed\n");
        ret = -1;
        goto exit;
    }
 
    to.sin6_family = AF_INET6;
    inet6_addr_from_ip6addr(&to.sin6_addr, &(ping6_params.dst_addr));
    to.sin6_port = htons(IPPROTO_ICMPV6);
 
#if LWIP_DNS
    if (lwip_strnicmp(inet_ntop(AF_INET6, &to.sin6_addr, buf, sizeof(buf)), argv[ping6_params.host_index],
                      sizeof(to.sin6_addr))) {
        /* If There Was A DNS Resolution */
        PRINTK("PING %s (%s) with %d bytes of data.\n",
               argv[ping6_params.host_index], buf, LWIP_PING6_STANDARD_PKT_SIZE);
    } else {
        PRINTK("PING %s with %d bytes of data.\n", buf, LWIP_PING6_STANDARD_PKT_SIZE);
    }
#else
    PRINTK("PING %s with %d bytes of data\n", inet_ntop(AF_INET6, &to.sin6_addr, buf, sizeof(buf)), LWIP_PING6_STANDARD_PKT_SIZE);
#endif /* LWIP_DNS */
 
    nrecieve = 0;
    ping6_stats.flag = 0;
    ping6_stats.avg_rtt = 0;
    ping6_stats.max_rtt = 0;
    ping6_stats.min_rtt = 0;
    last_received = LWIP_PING6_STARTING_SEQ_NUM + LWIP_PING6_OUT_OF_ORDER_MAGNITUDE + 1;
    icmpv6_id = (u16_t)LWIP_RAND();
    icmpv6_seq = LWIP_PING6_STARTING_SEQ_NUM;
    /* Setting the start time of the entire ping task for statistics */
    (void)clock_gettime(CLOCK_MONOTONIC_RAW, &first);
 
    nsent = 0;
 
    for (nsent = 0; nsent < ping6_params.pingcount; nsent++) {
        /* capture the start tick to calculate rtt */
        (void)clock_gettime(CLOCK_MONOTONIC_RAW, &start);
        /* Initialize Memory To Prevent Unintialized Memory Read Write Issues */
        if (memset_s(pbuf_req->payload, pbuf_req->len, (int)(start.tv_nsec), pbuf_req->len) != 0) {
            goto exit;
        }
 
        iecho = (struct icmp6_echo_hdr *)pbuf_req->payload;
        iecho->type = ICMP6_TYPE_EREQ;
        iecho->id = icmpv6_id;
        icmpv6_seq++;
        iecho->seqno = icmpv6_seq;
        iecho->code = 0;
 
        /* Embedding the start_tick as data into the icmp_payload */
        (void)pbuf_header(pbuf_req, (s16_t)(-(s16_t)(sizeof(struct icmp6_echo_hdr))));
        if (memcpy_s(pbuf_req->payload, pbuf_req->len, (void *)&start, sizeof(start)) != 0) {
            goto exit;
        }
        (void)pbuf_header(pbuf_req, (s16_t)((s16_t)(sizeof(struct icmp6_echo_hdr))));
 
        ret = lwip_sendto(sfd, iecho, pbuf_req->len, 0, (struct sockaddr *)&to, (socklen_t)sizeof(to));
        if (ret == -1) {
            PRINTK("ping6 : Sending ICMP Echo message failed\n");
            goto exit;
        }
 
        /* Wait in select for ICMP response msg */
        FD_ZERO(&fdReadSet);
        FD_SET(sfd, &fdReadSet);
        stTimeVal.tv_sec = LWIP_MSECS_TO_SECS(LWIP_SHELL_CMD_PING_TIMEOUT);
        stTimeVal.tv_usec = 0;
        select_on_socket = 1;
 
        while (select_on_socket) {
            select_on_socket = 0;
            ret = select(sfd + 1, &fdReadSet, 0, 0, &stTimeVal);
            if (ret < 0) {
                PRINTK("ping6 : select failure\n");
                goto exit;
            } else if (ret == 0) {
                (void)clock_gettime(CLOCK_MONOTONIC_RAW, &end);
                PRINTK("Request timed out\n");
                continue;
            }
 
            /* capture the end time to calculate round trip time */
            (void)clock_gettime(CLOCK_MONOTONIC_RAW, &end);
 
            ret = lwip_recv(sfd, pbuf_resp->payload, pbuf_resp->len, 0);
            if (ret == -1) {
                PRINTK("ping6 : receiving ICMP echo response msg failed\n");
                goto exit;
            }
 
            if ((u32_t)ret < sizeof(struct icmp6_echo_hdr *)) {
                /* Drop the packet if its too short [Doesnot contain even the header !!] */
                PRINTK("ping6 : received ICMP echo response too short\n");
                goto REDUCE_SELECT_TIME;
            }
 
            /* Acceping the ICMPv6 payload. */
            /* Here, pbuf_resp->payload wont contain IPv6 Header since its an AF_INET6 RAW Socket */
            iecho_resp = (struct icmp6_echo_hdr *)pbuf_resp->payload;
 
            if (iecho_resp->id == icmpv6_id) {
                if (iecho_resp->type == ICMP6_TYPE_EREP) {
                    if (ret < LWIP_PING6_STANDARD_PKT_SIZE) {
                        /* Drop the packet if its too short */
                        PRINTK("ping6 : received ICMP echo response too short\n");
                        goto REDUCE_SELECT_TIME;
                    }
                    /* Accept and process only those delayed EREP only if its sequence num is within out-of-order magnitude */
                    if (nsent && iecho_resp->seqno != icmpv6_seq &&
                        (iecho_resp->seqno<(u16_t)(last_received - LWIP_PING6_OUT_OF_ORDER_MAGNITUDE) ||
                                           iecho_resp->seqno>(u16_t)(
                            last_received + LWIP_PING6_OUT_OF_ORDER_MAGNITUDE))) {
                        /* Otherwise drop it and wait for more packets */
                        goto REDUCE_SELECT_TIME;
                    }
                    ++nrecieve;
                    last_received = iecho_resp->seqno;
                    /* Retrieving the start_tick from the packet which was embedded when the request was transmitted */
                    (void)pbuf_header(pbuf_resp, (s16_t)(-(s16_t)(sizeof(struct icmp6_echo_hdr))));
                    if (memcpy_s((void *)&start_in_reply, sizeof(start_in_reply),
                                 pbuf_resp->payload, sizeof(start_in_reply)) != EOK) {
                        goto REDUCE_SELECT_TIME;
                    }
                    (void)pbuf_header(pbuf_resp, (s16_t)((s16_t)(sizeof(struct icmp6_echo_hdr))));
 
                    rtt = ((end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000);
 
                    PRINTK("%d bytes from %s : icmp_seq=%d time", ret,
                           inet_ntop(AF_INET6, &to.sin6_addr, buf, sizeof(buf)),
                           ((iecho_resp->seqno) - LWIP_PING6_STARTING_SEQ_NUM));
                    if (rtt < 1) {
                        PRINTK("<1 ms\n");
                    } else {
                        PRINTK("=%i ms\n", rtt);
                    }
 
                    update_ping6_stats(&ping6_stats, (u32_t)(rtt), nrecieve);
 
                    /* Checking if its a delayed packet */
                    if ((iecho_resp->seqno != icmpv6_seq) && (nsent < ping6_params.pingcount)) {
                        /* Incase of delayed packet wait on socket for other response before sending a new PING */
                        /* We have to reduce the timeout value now when selecting on socket */
                        goto REDUCE_SELECT_TIME;
                    }
                } else {
                    PRINTK("[%u]ping6 : %s\n", nsent, convert_icmpv6_err_to_string(iecho_resp->type));
                }
            } else {
                /* If incoming packet does not matches with icmp_id, it should be ignored  */
                /* Reduce the timeout for select on socket */
REDUCE_SELECT_TIME:
                deltaTimeVal.tv_sec = (long)(end.tv_sec - start.tv_sec);
                deltaTimeVal.tv_usec = (long)((end.tv_nsec - start.tv_nsec) / 1000);
                /* Subtract deltaTime from stTime and store in stTime */
                /* This will reduce the select time on the socket */
                timersub(&stTimeVal, &deltaTimeVal, &stTimeVal);
                select_on_socket = 1;
            }
        }
    }
 
    ret = ERR_OK;
 
    (void)clock_gettime(CLOCK_MONOTONIC_RAW, &last);
    /* Display ping stats */
    PRINTK("--- %s ping statistics ---\n", argv[ping6_params.host_index]);
    PRINTK("%d packets transmitted, %d received, %.2f%% packet loss, time %dms\n",
           nsent, nrecieve, (float)(((float)(nsent - nrecieve)) * ((float)(100)) / ((float)(nsent))),
           ((last.tv_sec - first.tv_sec) * 1000 + (last.tv_nsec - first.tv_nsec) / 1000000));
    if (nrecieve) {
        /* Display rtt stats only if atleast one packet is recieved */
        PRINTK("rtt min/avg/max = %u/%.2f/%u ms\n", ping6_stats.min_rtt, ping6_stats.avg_rtt, ping6_stats.max_rtt);
    }
 
exit:
    if (sfd != -1) {
        (void)lwip_close(sfd);
    }
 
    if (pbuf_resp != NULL) {
        (void)pbuf_free(pbuf_resp);
    }
 
    if (pbuf_req != NULL) {
        (void)pbuf_free(pbuf_req);
    }
    return (u32_t)((ret == (int)ERR_OK) ? LOS_OK : LOS_NOK);
 
usage:
    PRINTK("Usage:\n");
    PRINTK("\tping6 [-c count] [-I interface/sourceAddress] destination\n");
    return LOS_NOK;
}

函数调用图:

osTcpserver()

u32_t osTcpserver	(	int	argc,
		const char **	argv
	)

这是这个函数的调用关系图:

parse_args_ping6()

LWIP_STATIC int parse_args_ping6	(	int	argc,
		const char **	argv,
		ping6_args_t *	ping6_params
	)

在文件 api_shell.c 第 2402 行定义.

{
    int pingcount;
    int ret = -1;
#if LWIP_DNS
    struct addrinfo *res = NULL;
    struct addrinfo hints_structure;
#endif
    u8_t i = 0;
 
    IP6_ADDR(&(ping6_params->dst_addr), 0, 0, 0, 0);
    IP6_ADDR(&(ping6_params->src_addr), 0, 0, 0, 0);
 
    ping6_params->pingcount = LWIP_SHELL_CMD_PING_RETRY_TIMES;
    ping6_params->host_index = 0;
    ping6_params->args_found = 0;
 
    while (i < argc) {
        if (strcmp("-c", argv[i]) == 0) {
            /* Handle number of ICMP packets to transmit :: -c [number_of_packets] */
            if (ping6_params->args_found & LWIP_PING6_COUNT_ARG) {
                PRINTK("ping6: -c option present multiple times \n");
                ret = -1;
                goto exit;
            }
 
            if (i + 2 > argc) {
                PRINTK("ping6: ping count(-c) should require an argument \n");
                ret = -1;
                goto exit;
            }
 
            pingcount = atoi(argv[i + 1]);
            if (pingcount <= 0) {
                PRINTK("ping6: bad number of packets to transmit \n");
                ret = -1;
                goto exit;
            }
 
            ping6_params->args_found |= LWIP_PING6_COUNT_ARG;
            ping6_params->pingcount = (u32_t)pingcount;
            i = (u8_t)(i + 2);
        } else if (strcmp("-I", argv[i]) == 0) {
            /* Handle interface ID / sourceAddress using which the ICMP Packets has to be transmitted :: -I [interface_id/source_address] */
 
            if ((ping6_params->args_found & LWIP_PING6_SOURCE_ADDRESS_ARG) ||
                (ping6_params->args_found & LWIP_PING6_INTERFACE_ARG)) {
                PRINTK("ping6: -I option present multiple times \n");
                ret = -1;
                goto exit;
            }
 
            if (i + 2 > argc) {
                PRINTK("ping6: interface/source address(-I) should require an argument \n");
                ret = -1;
                goto exit;
            }
 
            /* Check whether the given argument to -I is source address */
            if (ip6addr_aton(argv[i + 1], &(ping6_params->src_addr))) {
                ping6_params->args_found |= LWIP_PING6_SOURCE_ADDRESS_ARG;
                i = (u8_t)(i + 2);
                continue;
            }
 
            /* Storing the index where interface name is found */
            /* If this name is not valid, then it will fail later in setsockopt(BIND_TO_DEVICE) */
            ping6_params->interface_index = (u8_t)(i + 1);
            ping6_params->args_found |= LWIP_PING6_INTERFACE_ARG;
 
            i = (u8_t)(i + 2);
        } else {
            if (argv[i][0] == '-') {
                /* Check whether its a bad option */
                PRINTK("ping6: bad option %s\n", argv[i]);
                ret = -1;
                goto exit;
            } else if (ping6_params->args_found & LWIP_PING6_HOSTNAME_ARG) {
                /* Check whether hostname is already found and there are extra arguments */
                PRINTK("ping6: bad parameter %s\n", argv[i]);
                ret = -1;
                goto exit;
            }
 
#if LWIP_DNS
            /* Resolve the given hostname */
            hints_structure.ai_family = AF_INET6;
            hints_structure.ai_flags = 0;
            ret = lwip_getaddrinfo(argv[i], NULL, &hints_structure, &res);
            if (ret != ERR_OK) {
                PRINTK("ping6 : Host : %s can't be resolved to IPv6 address\n", argv[i]);
                ret = -1;
                goto exit;
            }
 
            inet6_addr_to_ip6addr(&(ping6_params->dst_addr),
                                  &(((const struct sockaddr_in6 *)(res->ai_addr))->sin6_addr));
#else
            /* Convert the string representation to network form */
            if (!ip6addr_aton(argv[i], &(ping6_params->dst_addr))) {
                PRINTK("ping6 : Invalid IPv6 Address : %s\n", argv[i]);
                ret = -1;
                goto exit;
            }
#endif /* LWIP_DNS */
            if (ip6_addr_isany(&(ping6_params->dst_addr)) || ip6_addr_isnone(&(ping6_params->dst_addr))) {
#if LWIP_DNS
                PRINTK("ping6 : IPv6 address of host : %s (%s) is invalid\n", argv[i],
                       ip6addr_ntoa((const ip6_addr_t *)&(ping6_params->dst_addr)));
#else
                PRINTK("ping6 : Invalid IPv6 address : %s\n", argv[i]);
#endif /* LWIP_DNS */
                goto exit;
            }
            /* Setting host_index to the index of argv[] where the host/IP is present */
            ping6_params->args_found |= LWIP_PING6_HOSTNAME_ARG;
            ping6_params->host_index = (u8_t)(i);
            i = (u8_t)(i + 1);
        }
    }
 
    if (!(ping6_params->args_found & LWIP_PING6_HOSTNAME_ARG)) {
        /* Hostname/IPv6 address not found */
        PRINTK("ping6 : Hostname/IPv6 address to ping is not specified\n");
        ret = -1;
        goto exit;
    }
 
    if (ip6_addr_islinklocal(&(ping6_params->dst_addr)) &&
        !(ping6_params->args_found & (LWIP_PING6_INTERFACE_ARG | LWIP_PING6_SOURCE_ADDRESS_ARG))) {
        /* For link-local addresses, -I is mandatory */
        PRINTK("ping6 : Interface specification is mandatory for link-local addresses\n");
        ret = -1;
        goto exit;
    }
 
    ret = ERR_OK;
 
exit:
#if LWIP_DNS
    lwip_freeaddrinfo(res);
#endif /* LWIP_DNS */
 
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

ping_cmd()

static void ping_cmd ( unsigned int  p0, unsigned int  p1, unsigned int  p2, unsigned int  p3  )

static

在文件 api_shell.c 第 1774 行定义.

{
    u32_t destip = p0;
    u32_t count = p1;
    u32_t interval = p2;
    u32_t data_len = p3;
    int ret;
 
    ret = osPingFunc(destip, count, interval, data_len);
    if (ret < 0) {
        PRINTK("Ping cmd failed due to some errors\n");
    }
 
    ping_taskid = -1;
}

函数调用图:

这是这个函数的调用关系图:

print_netif()

LWIP_STATIC int print_netif	(	struct netif *	netif,
		char *	print_buf,
		unsigned int	buf_len
	)

在文件 api_shell.c 第 269 行定义.

{
    int i, ret;
    char *tmp = print_buf;
#if LWIP_IPV6
    char *addr = NULL;
#endif
 
    if (buf_len < 1) {
        goto out;
    }
    if (netif->link_layer_type == LOOPBACK_IF) {
        ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%.2s\t", netif->name);
    } else {
        ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%s\t", netif_get_name(netif));
    }
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
#if LWIP_IPV4
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "ip:%s ", ipaddr_ntoa(&netif->ip_addr));
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "netmask:%s ", ipaddr_ntoa(&netif->netmask));
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "gateway:%s\n", ipaddr_ntoa(&netif->gw));
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
#endif
 
#if LWIP_IPV6
    for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
        /* only PREFERRED addresses are displyaed */
        if (!ip6_addr_isvalid(netif->ip6_addr_state[i])) {
            continue;
        }
        addr = ip6addr_ntoa((const ip6_addr_t *)&netif->ip6_addr[i]);
        ret = snprintf_s(tmp, buf_len, (buf_len - 1), "\tip6: %s/64\n", addr ? addr : "::");
        if ((ret <= 0) || ((unsigned int)ret >= buf_len))
            goto out;
        tmp += ret;
        buf_len -= (unsigned int)ret;
    }
#endif
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "\tHWaddr ");
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    for (i = 0; i < netif->hwaddr_len - 1; i++) {
        ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%02x:", netif->hwaddr[i]);
        if ((ret <= 0) || ((unsigned int)ret >= buf_len))
            goto out;
        tmp += ret;
        buf_len -= (unsigned int)ret;
    }
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%02x", netif->hwaddr[i]);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), " MTU:%d %s", netif->mtu,
                     netif->flags & NETIF_FLAG_UP ? "Running" : "Stop");
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    if (netif_default == netif && netif_is_up(netif)) {
        ret = snprintf_s(tmp, buf_len, (buf_len - 1), " %s", "Default");
        if ((ret <= 0) || ((unsigned int)ret >= buf_len))
            goto out;
        tmp += ret;
        buf_len -= (unsigned int)ret;
    }
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), " %s\n", netif->flags & NETIF_FLAG_LINK_UP ? "Link UP" : "Link Down");
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
        goto out;
    tmp += ret;
 
#if MIB2_STATS
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "\tRX packets:%u ",
                     netif->mib2_counters.ifinucastpkts + netif->mib2_counters.ifinnucastpkts);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "errors:%u ", netif->mib2_counters.ifinerrors);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "dropped:%u ", netif->mib2_counters.ifindiscards);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "overruns:%u\n", netif->mib2_counters.ifinoverruns);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "\tTX packets:%u ",
                     netif->mib2_counters.ifoutucastpkts + netif->mib2_counters.ifoutnucastpkts);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "errors:%u ", netif->mib2_counters.ifouterrors);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "dropped:%u\n", netif->mib2_counters.ifoutdiscards);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "\tRX bytes:%u ", netif->mib2_counters.ifinoctets);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
 
    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "TX bytes:%u\n", netif->mib2_counters.ifoutoctets);
    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
      goto out;
    tmp += ret;
    buf_len -= (unsigned int)ret;
#endif
 
out:
    return (int)(tmp - print_buf);
}

这是这个函数的调用关系图:

SHELLCMD_ENTRY() [1/6]

SHELLCMD_ENTRY	(	arp_shellcmd	,
		CMD_TYPE_EX	,
		"arp"	,
		1	,
		(CmdCallBackFunc)	lwip_arp
	)

SHELLCMD_ENTRY() [2/6]

SHELLCMD_ENTRY	(	dns_shellcmd	,
		CMD_TYPE_EX	,
		"dns"	,
		XARGS	,
		(CmdCallBackFunc)	osShellDns
	)

SHELLCMD_ENTRY() [3/6]

SHELLCMD_ENTRY	(	ifconfig_shellcmd	,
		CMD_TYPE_EX	,
		"ifconfig"	,
		XARGS	,
		(CmdCallBackFunc)	lwip_ifconfig
	)

这是这个函数的调用关系图:

SHELLCMD_ENTRY() [4/6]

SHELLCMD_ENTRY	(	ntpdate_shellcmd	,
		CMD_TYPE_EX	,
		"ntpdate"	,
		XARGS	,
		(CmdCallBackFunc)	osShellNtpdate
	)

SHELLCMD_ENTRY() [5/6]

SHELLCMD_ENTRY	(	ping6_shellcmd	,
		CMD_TYPE_EX	,
		"ping6"	,
		XARGS	,
		(CmdCallBackFunc)	osShellPing6
	)

SHELLCMD_ENTRY() [6/6]

SHELLCMD_ENTRY	(	ping_shellcmd	,
		CMD_TYPE_EX	,
		"ping"	,
		XARGS	,
		(CmdCallBackFunc)	osShellPing
	)

tcp_access()

void tcp_access

(

int

sockfd

)

这是这个函数的调用关系图:

udpserver()

void udpserver	(	int	argc,
		const char **	argv
	)

这是这个函数的调用关系图:

update_ping6_stats()

LWIP_STATIC void update_ping6_stats	(	ping6_stats_t *	ping6_stats,
		u32_t	rtt,
		u32_t	nreceived
	)

在文件 api_shell.c 第 2552 行定义.

{
    if (rtt > ping6_stats->max_rtt) {
        ping6_stats->max_rtt = rtt;
    }
 
    if (ping6_stats->flag == 0 || rtt < ping6_stats->min_rtt) {
        ping6_stats->min_rtt = rtt;
        ping6_stats->flag = 1;
    }
 
    ping6_stats->avg_rtt = (float)(ping6_stats->avg_rtt +
                                   (float)((float)((float)rtt - ping6_stats->avg_rtt) / (float)(nreceived)));
}

这是这个函数的调用关系图:

变量说明

ip_conflict_detect

sys_sem_t ip_conflict_detect

extern

在文件 fixme.c 第 369 行定义.

neighbor_cache

struct nd6_neighbor_cache_entry neighbor_cache[LWIP_ND6_NUM_NEIGHBORS]

extern

ping_kill

int ping_kill = 0

static

在文件 api_shell.c 第 1561 行定义.

ping_taskid

int ping_taskid = -1

static

在文件 api_shell.c 第 1560 行定义.

tcp_state_str

const char* const tcp_state_str[]

extern

在文件 fixme.c 第 389 行定义.

tcpip_init_finish

volatile int tcpip_init_finish

extern

在文件 fixme.c 第 403 行定义.