api_shell.h 文件参考

浏览源代码.

函数
u32_t	lwip_ifconfig (int argc, const char **argv)
u32_t	lwip_arp (int argc, const char **argv)
u32_t	osShellNetIfUp (int argc, const char **argv)
u32_t	osShellNetIfDown (int argc, const char **argv)
u32_t	osShellPing (int argc, const char **argv)
u32_t	osShellTftp (int argc, const char **argv)
u32_t	osShellNtpdate (int argc, const char **argv)
u32_t	osShellDns (int argc, const char **argv)
u32_t	osShellNetstat (int argc, const char **argv)
void	netstat_internal (void *ctx)

函数说明

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_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;
}

函数调用图:

netstat_internal()

void netstat_internal

(

void *

ctx

)

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

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;
}

函数调用图:

osShellNetIfDown()

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

osShellNetIfUp()

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

osShellNetstat()

u32_t osShellNetstat	(	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 第 1928 行定义.

{
    int sfd;
    struct sockaddr_in to;
    struct icmp_echo_hdr iecho;
    struct pbuf *pbuf_resp = NULL;
    struct icmp_echo_hdr *iecho_resp = NULL;
    struct ip_hdr *iphdr_resp = NULL;
    s16_t ip_hlen;
    ip_addr_t dst_ipaddr;
    fd_set fdReadSet;
    struct timeval stTimeVal;
    struct timespec start, end;
    int ret;
    s32_t i;
    long rtt;
    s32_t pingcount;
    char buf[50];
 
    if (!tcpip_init_finish) {
        PRINTK("ping: tcpip_init have not been called\n");
        return LOS_NOK;
    }
 
    if ((argc < 1) || (argv == NULL)) {
        PRINTK("ping : invalid arguments, ping command receives ip as command line argument \n");
        return LOS_NOK;
    }
 
    if (argc == 2) {
        pingcount = atoi(argv[1]);
        if (pingcount < 1)
            pingcount = LWIP_SHELL_CMD_PING_RETRY_TIMES;
    } else {
        pingcount = LWIP_SHELL_CMD_PING_RETRY_TIMES;
    }
    PRINTK("ping %u packets start.\n", pingcount);
 
    /* initialize dst IP address */
#if LWIP_DNS
    ip_2_ip4(&dst_ipaddr)->addr = get_hostip(argv[0]);
#else /* LWIP_DNS */
    ip_2_ip4(&dst_ipaddr)->addr = inet_addr(argv[0]);
#endif /* LWIP_DNS */
 
    to.sin_family = AF_INET;
    to.sin_addr.s_addr = ip_2_ip4(&dst_ipaddr)->addr;
    to.sin_port = 0;
 
    if (to.sin_addr.s_addr == IPADDR_NONE || to.sin_addr.s_addr == IPADDR_ANY) {
        PRINTK("ping : invalid ip address : NONE or ANY\n");
        return LOS_NOK;
    }
 
    sfd = lwip_socket(PF_INET, SOCK_RAW, IPPROTO_ICMP);
    if (sfd == -1) {
        PRINTK("ping : failed, socket creation failed\n");
        return LOS_NOK;
    }
 
    pbuf_resp = pbuf_alloc(PBUF_RAW, IP_HLEN + sizeof(struct icmp_echo_hdr), PBUF_RAM);
    if (pbuf_resp == NULL) {
        PRINTK("ping : memory allocation failed\n");
        goto FAILURE;
    }
 
    for (i = 0; i < pingcount; i++) {
        (void)memset_s(&iecho, sizeof(iecho), 0, sizeof(iecho));
        ICMPH_TYPE_SET(&iecho, (u8_t)ICMP_ECHO);
        iecho.chksum = inet_chksum(&iecho, sizeof(struct icmp_echo_hdr));
 
        ret = lwip_sendto(sfd, &iecho, sizeof(struct icmp_echo_hdr), 0, (struct sockaddr *)&to, (socklen_t)sizeof(to));
        if (ret == -1) {
            PRINTK("ping : sending ICMP echo msg failed\n");
            goto FAILURE;
        }
 
        /* capture the start time to calculate round trip time */
        (void)clock_gettime(CLOCK_MONOTONIC_RAW, &start);
        /* Wait in select for ICMP response msg */
        FD_ZERO(&fdReadSet);
        FD_SET(sfd, &fdReadSet);
        stTimeVal.tv_sec = LWIP_SHELL_CMD_PING_TIMEOUT / 1000;
        stTimeVal.tv_usec = 0;
 
DO_SELECT:
        ret = select(sfd + 1, &fdReadSet, 0, 0, &stTimeVal);
        if (ret < 0) {
            PRINTK("ping : select failure\n");
            goto FAILURE;
        } else if (ret == 0) {
            PRINTK("Request timed out.\n");
            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);
 
        ret = lwip_recv(sfd, pbuf_resp->payload, pbuf_resp->len, 0);
        if (ret == -1) {
            PRINTK("ping : receiving ICMP echo response msg failed\n");
            goto FAILURE;
        }
 
        /* Accessing ip header and icmp header */
        iphdr_resp = (struct ip_hdr *)(pbuf_resp->payload);
        ip_hlen = (s16_t)(IPH_HL(iphdr_resp) * 4);
        if (pbuf_header(pbuf_resp, (s16_t)(-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) {
            if (ICMPH_TYPE(iecho_resp) == ICMP_ER) {
                PRINTK("[%u]Reply from %s: time=%ims TTL=%u\n", i,
                       inet_ntoa_r(to.sin_addr.s_addr, buf, sizeof(buf)), rtt, iphdr_resp->_ttl);
            } else if (ICMPH_TYPE(iecho_resp) == ICMP_ECHO) {
                /* If ping self, stack will receive a ICMP_ECHO request message flowing a ICMP_ER reply message,
                    and we need reply only, do select again */
                goto DO_SELECT;
            }
        }
    }
 
    (void)lwip_close(sfd);
    (void)pbuf_free(pbuf_resp);
    return LOS_OK;
 
FAILURE:
    (void)lwip_close(sfd);
    if (pbuf_resp != NULL) {
        (void)pbuf_free(pbuf_resp);
    }
 
    return LOS_NOK;
}

函数调用图:

osShellTftp()

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

在文件 main.c 第 80 行定义.

{
    u32_t ulRemoteAddr = IPADDR_NONE;
    const u16_t usTftpServPort = 69;
    u8_t ucTftpGet = 0;
    s8_t *szLocalFileName = NULL;
    s8_t *szRemoteFileName = NULL;
    u32_t ret;
 
    int i = 1;
    if (argc < 1 || argv == NULL) {
        goto usage;
    }
 
    if (!tcpip_init_finish) {
        PRINTK("%s: tcpip_init have not been called\n", __FUNCTION__);
        return LOS_NOK;
    }
 
    while (i < argc) {
        if (strcmp(argv[i], "-p") == 0) {
            ucTftpGet = 0;
            i++;
            continue;
        }
 
        if (strcmp(argv[i], "-g") == 0) {
            ucTftpGet = 1;
            i++;
            continue;
        }
 
        if (strcmp(argv[i], "-l") == 0 && ((i + 1) < argc)) {
            szLocalFileName = (s8_t *)argv[i + 1];
            i += 2;
            continue;
        }
 
        if (strcmp(argv[i], "-r") == 0 && ((i + 1) < argc)) {
            szRemoteFileName = (s8_t *)argv[i + 1];
            i += 2;
            continue;
        }
 
        if ((i + 1) == argc) {
            ulRemoteAddr = inet_addr(argv[i]);
            break;
        }
 
        goto usage;
    }
 
    if (ulRemoteAddr == IPADDR_NONE || szLocalFileName == NULL || szRemoteFileName == NULL) {
        goto usage;
    }
 
    if (ucTftpGet) {
        ret = lwip_tftp_get_file_by_filename(ntohl(ulRemoteAddr), usTftpServPort,
                                             TRANSFER_MODE_BINARY, szRemoteFileName, szLocalFileName);
    } else {
        ret = lwip_tftp_put_file_by_filename(ntohl(ulRemoteAddr), usTftpServPort,
                                             TRANSFER_MODE_BINARY, szLocalFileName, szRemoteFileName);
    }
 
    LWIP_ASSERT("TFTP UNKNOW ERROR!", ret < ARRAY_SIZE(TftpError));
    PRINTK("%s", TftpError[ret]);
    if (ret) {
        return LOS_NOK;
    } else {
        return LOS_OK;
    }
usage:
    PRINTK("usage:\nTransfer a file from/to tftp server\n");
    PRINTK("tftp <-g/-p> -l FullPathLocalFile -r RemoteFile Host\n");
    return LOS_NOK;
}

函数调用图: