精华内容
下载资源
问答
  • uboot-ping代码学习笔记

    2013-10-28 14:44:08
    uboot-ping代码学习笔记 2011-02-20, root 最近这两天学习了uboot的ping源代码,现在做一下笔记。  uboot :v1.1.6    uboot从start.s启动后会跳转到lib_arm/board.c里的start_armboot函数,从这以后都 ...
    uboot-ping代码学习笔记
    

    2011-02-20, root

    最近这两天学习了uboot的ping源代码,现在做一下笔记。

        uboot :v1.1.6

     

        uboot从start.s启动后会跳转到lib_arm/board.c里的start_armboot函数,从这以后都

             是C语言代码。start_armboot做了一些初始化化然后在死循环里调用main_loop函数 :

         /* main_loop() can return to retry autoboot, if so just run it again. */

         for (;;) {

         main_loop ();

         }

    main_loop是在;common/main.c中定义的,下面是从串中读取命令然后执行的一部分代码:

    for (;;) {

     

    len = readline (CFG_PROMPT); //从串口读入命令

    flag = 0; /* assume no special flags for now */

    if (len > 0)

    strcpy (lastcommand, console_buffer);

    else if (len == 0)

    flag |= CMD_FLAG_REPEAT;

    }

    if (len == -1)

    puts ("<INTERRUPT>/n");

    else

    rc = run_command (lastcommand, flag); // 执行命令

    if (rc <= 0) {

    /* invalid command or not repeatable, forget it */

    lastcommand[0] = 0;

    }

    }

    run_command首先调用find_command在命令列表里查找到输入的命令:

    /* Look up command in command table */

    if ((cmdtp = find_cmd(argv[0])) == NULL) {

    printf ("Unknown command '%s' - try 'help'/n", argv[0]);

    rc = -1; /* give up after bad command */

    continue;

    }

        find_cmd返回的是cmd_tbl_t类型,cmd_tbl_t里有命令对应的执行函数,再调用具体的

              执行函数来执行命令具体的操作:

       /* OK - call function to do the command */

       if ((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0) {

       rc = -1;

       }

     

     

        uboot所有的命令都定义在commom目录下,ping命令在cmd_net.c文件里定义,定义如下:    

     

        U_BOOT_CMD(

         ping, 2, 1, do_ping,

         "ping/t- send ICMP ECHO_REQUEST to network host/n",

         "pingAddress/n"

        );  

    U_BOOT_CMD定义如下:

    /*

    * Monitor Command

    *

    * All commands use a common argument format:

    *

    * void function (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); 

    */

     

    struct cmd_tbl_s {

    char *name; // Command Name

    int maxargs; // maximum number of arguments

    int repeatable; // autorepeat allowed?

    // Implementation function

    int (*cmd)(struct cmd_tbl_s *, int, int, char *[]);

    char *usage; // Usage message (short)

    #ifdef CFG_LONGHELP

    char *help; // Help  message (long)

    #endif

    #ifdef CONFIG_AUTO_COMPLETE

    // do auto completion on the arguments 

    int (*complete)(int argc, char *argv[], char last_char, int maxv, char *cmdv[]);

    #endif

    };

     

    typedef struct cmd_tbl_s cmd_tbl_t;

     

    #define Struct_Section  __attribute__ ((unused,section (".u_boot_cmd")))

     

    #define U_BOOT_CMD(name,maxargs,rep,cmd,usage,help) /

    cmd_tbl_t __u_boot_cmd_##name Struct_Section = {#name, maxargs, rep, cmd, usage}

    ping命令定义的展开:

     

    cmd_tbl_t __u_boot_cmd_ping __attribute__ ((unused, section (".u_boot_cmd"))) = {

    "ping", // name

    2,      // maxargs

    1, // repeatable

    do_ping,// (*cmd)(struct cmd_tbl_s *, int, int, char *[]);

    "ping/t- send ICMP ECHO_REQUEST to network host/n", // *usage

    "pingAddress/n", // *help

    }

    从这里可以看出,ping命令其实是调用的do_ping函数来实行具体的ping操作,do_ping的定义如下:

    int do_ping (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])

    {

    if (argc < 2)

    return -1;

     

    NetPingIP = string_to_ip(argv[1]);

    if (NetPingIP == 0) {

    printf ("Usage:/n%s/n", cmdtp->usage);

    return -1;

    }

     

    if (NetLoop(PING) < 0) {

    printf("ping failed; host %s is not alive/n", argv[1]);

    return 1;

    }

     

    printf("host %s is alive/n", argv[1]);

     

    return 0;

    }

    执行ping命令:

    EmbedSky> ping 192.168.1.1

    dm9000 i/o: 0x20000300, id: 0x90000a46

    MAC: 0a:1b:2c:3d:4e:5f

    ping failed; host 192.168.1.1 is not alive

    do_ping首先将192.168.1.1存在NetPingIP变量里边,然后调用NetLoop函数,如果执行成功

    显示:

    host 192.168.1.1 is alive

    如果不成功显示:

    host 192.168.1.1 is not alive

    然后 退出。

    NetLoop主要的工作是打包各命令对应的数据包,通过eth_send函数发送数据包,然后在死循

    环里调用eth_rx来接收一个完整的ethernet帧,eth_rx收到的帧会传给NetRecive函数分析处

    理。

    对于ping命令,NetLoop调用PingStart

    static void PingStart(void)

    {

    #if defined(CONFIG_NET_MULTI)

    printf ("Using %s device/n", eth_get_name());

    #endif /* CONFIG_NET_MULTI */

    NetSetTimeout (10 * CFG_HZ, PingTimeout);

    NetSetHandler (PingHandler);

    PingSend();

    }

    PingStart首先设置接收到Ping数据包后调用的处理函数,然后调用PingSeng

    发送ICMP数据包。

    NetReceive处理接收到的ICMP数据包最后会调用PingHandler函数来结束Ping

    操作,PingHandler只是将NetState改为NETLOOP_SUCCESS,在NetLoop里会一直

    检测NetState的状态(刚进入NetLoop函数的时候NetState为NETLOOP_CONTINUE),

    如果为 NETLOOP_SUCCESS 或NETLOOP_FAIL则NetLoop就会退出:

    switch (NetState) {

    case NETLOOP_RESTART:

    #ifdef CONFIG_NET_MULTI

    NetRestarted = 1;

    #endif

    goto restart;

    case NETLOOP_SUCCESS:

    if (NetBootFileXferSize > 0) {

    char buf[10];

    printf("Bytes transferred = %ld (%lx hex)/n",

    NetBootFileXferSize,

    NetBootFileXferSize);

    sprintf(buf, "%lx", NetBootFileXferSize);

    setenv("filesize", buf);

    sprintf(buf, "%lX", (unsigned long)load_addr);

    setenv("fileaddr", buf);

    }

    eth_halt();

    return NetBootFileXferSize;

    case NETLOOP_FAIL:

    return (-1);

    }

    PingHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len)

    {

    IPaddr_t tmp;

    volatile IP_t *ip = (volatile IP_t *)pkt;

    tmp = NetReadIP((void *)&ip->ip_src);

    if (tmp != NetPingIP)

    return;

    NetState = NETLOOP_SUCCESS;

    }

    int PingSend(void)

    {

    static uchar mac[6];

    volatile IP_t *ip;

    volatile ushort *s;

    uchar *pkt;

     

    /* XXX always send arp request */

     

    memcpy(mac, NetEtherNullAddr, 6);

     

    #ifdef ET_DEBUG

    printf("sending ARP for %08lx/n", NetPingIP);

    #endif

     

    NetArpWaitPacketIP = NetPingIP;

    NetArpWaitPacketMAC = mac;

     

    pkt = NetArpWaitTxPacket;

    pkt += NetSetEther(pkt, mac, PROT_IP);

     

    ip = (volatile IP_t *)pkt;

     

    /*

    * Construct an IP and ICMP header.  (need to set no fragment bit - XXX)

    */

    ip->ip_hl_v  = 0x45; /* IP_HDR_SIZE / 4 (not including UDP) */

    ip->ip_tos   = 0;

    ip->ip_len   = htons(IP_HDR_SIZE_NO_UDP + 8);

    ip->ip_id    = htons(NetIPID++);

    ip->ip_off   = htons(0x4000); /* No fragmentation */

    ip->ip_ttl   = 255;

    ip->ip_p     = IPPROTO_ICMP; /* ICMP */

    ip->ip_sum   = 0;

    NetCopyIP((void*)&ip->ip_src, &NetOurIP); /* already in network byte order */

    NetCopyIP((void*)&ip->ip_dst, &NetPingIP);   /* - "" - */

    ip->ip_sum   = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);

     

    s = &ip->udp_src; /* ICMP starts here */

    s[0] = htons(0x0800); /* echo-request, code */

    s[1] = 0; /* checksum */

    s[2] = 0; /* identifier */

    s[3] = htons(PingSeqNo++); /* sequence number */

    s[1] = ~NetCksum((uchar *)s, 8/2);

     

    /* size of the waiting packet */

    NetArpWaitTxPacketSize = (pkt - NetArpWaitTxPacket) + IP_HDR_SIZE_NO_UDP + 8;

     

    /* and do the ARP request */

    NetArpWaitTry = 1;

    NetArpWaitTimerStart = get_timer(0);

    ArpRequest();

    return 1; /* waiting */

    }

    PingSend调用NetSetEther封装ethernet帧的头部,NetSetEther参数:

    mac    :为目的host的mac,在这里全为0,因为我们只知道目的主机的ip,

                  现在还不知道它的mac地址

    PROT_IP: 说明该ethernet帧里封装的是IP包。ethernet帧分三种类型,根据

    ethernet的type来判断是哪种类型。

    ethernet帧的封装:

     

    |destination addr| source addr |type| data |crc|

    6         6       2 46-1500  4 bytes

    type:

    PROT_IP 0x0800 /* IP protocol */

    PROT_ARP 0x0806 /* IP ARP protocol */

    PROT_RARP 0x8035 /* IP ARP protocol */

    PingSend再将IP包封装成ICMP包:

    ip->ip_p     = IPPROTO_ICMP; /* ICMP */

    IP包跟ethernet帧一样,也是复用的数据包,所有IP头部用1字节的proto标示来说明

    IP包是哪类:

    IPPROTO_ICMP 1 /* Internet Control Message Protocol */

    IPPROTO_UDP 17 /* User Datagram Protocol */

    IPPROTO_TCP 6 /* Transmission Control Protocol */

    IPPROTO_IGMP 2 /* Internet Group Message Protocol */

    ICMP将该ICMP包类型设置为echo request:

    s[0] = htons(0x0800); /* echo-request, code */

    封装完IP包和ICMP包后,没有立即将该ethernet帧发出去,因为现在我们只知道目的主机的

    IP地址,并不知道它的ethernet地址,所以先调用ArpRequest函数取得目的主机的ethernet

    地址,再ping封装的ethernet帧发送出去。

    ArpRequest函数将ethernet帧封装为ARP request帧,然后广播该帧。

    void ArpRequest (void)

    {

    int i;

    volatile uchar *pkt;

    ARP_t *arp;

     

    #ifdef ET_DEBUG

    printf ("ARP broadcast %d/n", NetArpWaitTry);

    #endif

    pkt = NetTxPacket;

     

    pkt += NetSetEther (pkt, NetBcastAddr, PROT_ARP); // PORT_ARP说明该

     // 帧为ARP帧

     

    arp = (ARP_t *) pkt;

     

    arp->ar_hrd = htons (ARP_ETHER);// 物理地址类型,在此为ethernet地址

    arp->ar_pro = htons (PROT_IP);  // 逻辑地址类型,在此为IP地址

    arp->ar_hln = 6; // 物理地址类型的长度

    arp->ar_pln = 4; // 逻辑地址类型的长度

    arp->ar_op = htons (ARPOP_REQUEST);

     

    memcpy (&arp->ar_data[0], NetOurEther, 6); /* source ET addr */

    NetWriteIP ((uchar *) & arp->ar_data[6], NetOurIP); /* source IP addr */

    for (i = 10; i < 16; ++i) {

    arp->ar_data[i] = 0; /* dest ET addr = 0 */ //广播该帧

    }

     

    if ((NetArpWaitPacketIP & NetOurSubnetMask) !=

       (NetOurIP & NetOurSubnetMask)) {

    if (NetOurGatewayIP == 0) {

    puts ("## Warning: gatewayip needed but not set/n");

    NetArpWaitReplyIP = NetArpWaitPacketIP;

    } else {

    NetArpWaitReplyIP = NetOurGatewayIP;

    }

    } else {

    NetArpWaitReplyIP = NetArpWaitPacketIP;

    }

     

    NetWriteIP ((uchar *) & arp->ar_data[16], NetArpWaitReplyIP); /* dest ip addr */

    (void) eth_send (NetTxPacket, (pkt - NetTxPacket) + ARP_HDR_SIZE); //通过底层硬件发送该ethernet帧

    }

    接收ARP Replay帧和icmp echo replay帧是在NetLoop里的eth_rx进行的,eth_rx收到一个完整的帧后将该帧

    传送给NetReceive处理。

    NetReceive处理ARP Replay帧:

    case ARPOP_REPLY: /* arp reply */

    /* are we waiting for a reply */

    if (!NetArpWaitPacketIP || !NetArpWaitPacketMAC)

    break;

     

     

    tmp = NetReadIP(&arp->ar_data[6]);

     

    /* matched waiting packet's address */

    if (tmp == NetArpWaitReplyIP) {

     

    /* save address for later use */

    memcpy(NetArpWaitPacketMAC, &arp->ar_data[0], 6);

     

    /* modify header, and transmit it */

    // 将返回的目标主机的mac地址放入PingSend封装的ethernet帧,然后发送该ping帧

    memcpy(((Ethernet_t *)NetArpWaitTxPacket)->et_dest, NetArpWaitPacketMAC, 6);

    (void) eth_send(NetArpWaitTxPacket, NetArpWaitTxPacketSize);

     

    /* no arp request pending now */

    NetArpWaitPacketIP = 0;

    NetArpWaitTxPacketSize = 0;

    NetArpWaitPacketMAC = NULL;

     

    }

    return;

    NetReceive处理icmp echo replay帧:

    case ICMP_ECHO_REPLY:

    /*

    * IP header OK.  Pass the packet to the current handler.

    */

    /* XXX point to ip packet */

    (*packetHandler)((uchar *)ip, 0, 0, 0);

    return;

    只是调用PingHandler函数将NetState设置为NETLOOP_SUCCESS,结束NetLoop循环,

    打印ping结果,然后退出do_ping函数。

    展开全文
  • 内容索引:VB源码,系统...程序特点:Ping通就停了,不会一直Ping;不过有个选项可以一直Ping,鼠标点选就可以了,其实很简单的应用,不过用可视化的形式展现则有利于大家更进一步了解Ping的机制,对学习VB有一定帮助。
  • ping的实现和代码分析

    千次阅读 2018-04-11 09:25:03
    ping的实现和代码分析一.介绍 ping命令是用来查看网络上另一个主机系统的网络连接是否正常的一个工具。ping命令的工作原理是:向网络上的另一个主机系统发送ICMP报文,如果指定系统得到了报文,它将把报文一模一样地...
    ping的实现和代码分析
    一.介绍     
    ping命令是用来查看网络上另一个主机系统的网络连接是否正常的一个工具。ping命令的工作原理是:

    向网络上的另一个主机系统发送ICMP报文,如果指定系统得到了报文,它将把报文一模一样地传回给发送者,这有点象潜水艇声纳系统中使用的发声装置。 例如,在Linux终端上执行ping如下:


    二.分析

    由上面的执行结果可以看到,ping命令执行后显示出被测试系统主机名和相应IP地址、返回给当前主机的ICMP报文顺序号、ttl生存时间和往返时间rtt(单位是毫秒,即千分之一秒)。要写一个模拟ping命令,这些信息有启示作用。要真正了解ping命令实现原理,就要了解ping命令所使用到的TCP/IP协议。 ICMP(Internet Control Message,网际控制报文协议)是为网关和目标主机而提供的一种差错控制机制,使它们在遇到差错时能把错误报告给报文源发方。ICMP协议是IP层的一个协议,但是由于差错报告在发送给报文源发方时可能也要经过若干子网,因此牵涉到路由选择等问题,所以ICMP报文需通过IP协议来发送。ICMP数据报的数据发送前需要两级封装:首先添加ICMP报头形成ICMP报文,再添加IP报头形成IP数据报。由于IP层协议是一种点对点的协议,而非端对端的协议,它提供无连接的数据报服务,没有端口的概念,因此很少使用bind()和connect()函数,若有使用也只是用于设置IP地址。明白了工作原理,我们就可以写我们自己的ping命令:myping:

    代码1:

    /*     
    
     *    名称:     myping 
    *     程序应用:  ping命令是向目的主机发送ICMP报文,检验本地主机和远程的目的主机是否连接 
    *      
     *  
    */     /*ICMP必须使用原始套接字进行设计,要手动设置IP的头部和ICMP的头部并行校验*/  
    /***********主函数********************************************* 
    myping.c*/  
    #include <sys/socket.h>  
    #include <netinet/in.h>  
    #include <netinet/ip.h>  
    #include <netinet/ip_icmp.h>  
    #include <unistd.h>  
    #include <signal.h>  
    #include <arpa/inet.h>  
    #include <errno.h>  
    #include <sys/time.h>  
    #include <stdio.h>  
    #include <string.h> /* bzero */  
    #include <netdb.h>  
    #include <pthread.h>  
    //保存发送包的状态值  
    typedef struct pingm_pakcet{  
        struct timeval tv_begin;     //发送时间  
        struct timeval tv_end;       //接收到的时间  
        short seq;                   //序列号  
        int flag;          //1,表示已经发送但是没有接收到回应,0,表示接收到回应  
    }pingm_pakcet;  
    static pingm_pakcet *icmp_findpacket(int seq);  
    static unsigned short icmp_cksum(unsigned char *data, int len);  
    static struct timeval icmp_tvsub(struct timeval end, struct timeval begin);  
    static void icmp_statistics(void);  
    static void icmp_pack(struct icmp *icmph, int seq, struct timeval *tv,int length);  
    static int icmp_unpack(char *buf,int len);  
    static void *icmp_recv(void *argv);  
    static void icmp_sigint(int signo);  
    static void icmp_usage();    
    static pingm_pakcet pingpacket[128];  
    #define K 1024  
    #define BUFFERSIZE 72                            //发送缓冲区的大小  
    static unsigned char send_buff[BUFFERSIZE];        
    static unsigned char recv_buff[2*K];             //防止接收溢出,设置大一些  
    static struct sockaddr_in dest;                  //目的地址  
    static int rawsock = 0;                          //发送和接收线程需要的socket描述符  
    static pid_t pid;                                //进程PID  
    static int alive = 0;                            //是否接收到退出信号  
    static short packet_send = 0;                    //已经发送的数据包数量  
    static short packet_recv = 0;                    //已经接收的数据包数量  
    static char dest_str[80];                        //目的主机字符串  
    static struct timeval tv_begin, tv_end, tv_interval;  
    
    2.计算发送和接收的时间
    static void icmp_usage()  
    {  
        //ping加IP地址或者域名  
        printf("ping aaa.bbb.ccc.ddd\n");  
    }  
    /*终端信号处理函数SIGINT*/  
    static void icmp_sigint(int signo)  
    {  
        alive = 0;  
        gettimeofday(&tv_end,NULL);  
        tv_interval = icmp_tvsub(tv_end, tv_begin);    
        return;  
    } 
     
    3.统计数据结果
    /*统计数据结果函数****************************************** 
    打印全部ICMP发送的接收统计结果*/  
    static void icmp_statistics(void)  
     {  
       long time = (tv_interval.tv_sec * 1000) + (tv_interval.tv_usec/1000);  
       printf("--- %s ping statistics ---\n", dest_str);  
       printf("%d packets transmitted, %d received, %d%c packet loss, time %ld ms\n",   
           packet_send,packet_recv,(packet_send-packet_recv)*100/packet_send,'%',time);  
    }  
     /*************查找数组中的标识函数*********************** 
     查找合适的包的位置 
    当seq为1时,表示查找空包 
    其他值表示查找seq对应的包*/  
     static pingm_pakcet *icmp_findpacket(int seq)  
     {  
        int i;  
        pingm_pakcet *found = NULL;  
        //查找包的位置  
        if(seq == -1){  
           for(i=0;i<128;i++){  
                if(pingpacket[i].flag == 0){  
                  found = &pingpacket[i];  
                   break;  
                }  
            }  
        }  
        else if(seq >= 0){  
            for(i =0 ;i< 128;i++){  
                if(pingpacket[i].seq == seq){  
                    found = &pingpacket[i];  
                    break;  
                }  
            }  
        }  
        return found;  
     } 
     
    4.校验和函数
    /*************校验和函数***************************** 
    TCP/IP协议栈使用的校验算法是比较经典的,对16位的数据进行累加计算,并返回计算结果, 
     
    CRC16校验和计算icmp_cksum 
    参数: 
        data:数据 
           len:数据长度 
    返回值: 
        计算结果,short类型 
    */  
    static unsigned short icmp_cksum(unsigned char *data, int len)  
    {  
        int sum = 0;   //计算结果  
        int odd = len & 0x01;  //是否为奇数  
        /*将数据按照2字节为单位累加起来*/  
        while(len & 0xfffe){  
            sum += *(unsigned short*)data;  
            data += 2;  
            len -= 2;  
        }  
        /*判断是否为奇数个数据,若ICMP报头为奇数个字节,会剩下最后一个字节*/  
        if(odd){  
            unsigned short tmp = ((*data)<<8)&0xff00;  
           sum += tmp;  
        }  
        sum = (sum >> 16) + (sum & 0xffff);   //高地位相加  
        sum += (sum >> 16);                    //将溢出位加入  
      
        return ~sum;                           //返回取反值  
    } 
     
    5.ICMP头部校验打包和拆包
    /**********进行ICMP头部校验********************/  
    //设置ICMP报头  
    static void icmp_pack(struct icmp *icmph, int seq, struct timeval *tv, int length)  
    {  
        unsigned char i = 0;  
        //设置报头  
        icmph->icmp_type = ICMP_ECHO;   //ICMP回显请求  
        icmph->icmp_code = 0;           //code的值为0  
        icmph->icmp_cksum = 0;          //先将cksum的值填为0,便于以后的cksum计算  
        icmph->icmp_seq = seq;          //本报的序列号  
        icmph->icmp_id = pid & 0xffff;  //填写PID  
        for(i=0; i< length; i++)  
            icmph->icmp_data[i] = i;   //计算校验和  
        icmph->icmp_cksum = icmp_cksum((unsigned char*)icmph, length);  
    }  
      
    /*解压接收到的包,并打印信息*/  
    static int icmp_unpack(char *buf, int len)  
    {  
        int i,iphdrlen;  
        struct ip *ip = NULL;  
        struct icmp *icmp = NULL;  
        int rtt;  
      
        ip = (struct ip *)buf;            //IP报头  
        iphdrlen = ip->ip_hl * 4;         //IP头部长度  
        icmp = (struct icmp *)(buf+iphdrlen);  //ICMP段的地址  
        len -= iphdrlen;  
        //判断长度是否为ICMP包  
        if(len < 8){  
            printf("ICMP packets\'s length is less than 8\n");  
            return -1;  
        }  
        //ICMP类型为ICMP_ECHOREPLY并且为本进程的PID  
        if((icmp->icmp_type == ICMP_ECHOREPLY) && (icmp->icmp_id == pid)){  
            struct timeval tv_interval,tv_recv,tv_send;  
            //在发送表格中查找已经发送的包,按照seq  
            pingm_pakcet *packet = icmp_findpacket(icmp->icmp_seq);  
            if(packet == NULL)  
                return -1;  
            packet->flag = 0;          //取消标志  
            tv_send = packet->tv_begin;  //获取本包的发送时间  
      
            gettimeofday(&tv_recv,NULL);  //读取此时间,计算时间差  
            tv_interval = icmp_tvsub(tv_recv,tv_send);  
           rtt = tv_interval.tv_sec * 1000 + tv_interval.tv_usec/1000;  
            /*打印结果包含 
              ICMP段的长度 
              源IP地址 
              包的序列号 
              TTL 
              时间差 
            */  
            printf("%d byte from %s: icmp_seq=%u ttl=%d rtt=%d ms\n",   
                len,inet_ntoa(ip->ip_src),icmp->icmp_seq,ip->ip_ttl,rtt);  
            packet_recv ++;              //接收包数量加1  
        }  
        else {  
            return -1;  
        }  
    }
      
    6.计算时间差函数
    /************计算时间差time_sub************************ 
    参数: 
        end:接收到时间 
        begin:开始发送的时间 
    返回值: 
        使用的时间 
    */  
    static struct timeval icmp_tvsub(struct timeval end, struct timeval begin)  
    {  
        struct timeval tv;  
        //计算差值  
        tv.tv_sec = end.tv_sec - begin.tv_sec;  
        tv.tv_usec = end.tv_usec - begin.tv_usec;  
        //如果接收的时间的usec值小于发送时的usec,从uesc域借位  
        if(tv.tv_usec < 0){  
            tv.tv_sec --;  
            tv.tv_usec += 1000000;  
        }  
      
        return tv;  
    } 
     
    7.发送报文函数
    //**********发送报文***************************  
    static void *icmp_send(void *argv)  
    {  
        //保存程序开始发送数据的时间  
        gettimeofday(&tv_begin, NULL);  
        while(alive){  
            int size = 0;  
            struct timeval tv;  
            gettimeofday(&tv, NULL);     //当前包的发送时间  
            //在发送包状态数组中找到一个空闲位置  
            pingm_pakcet *packet = icmp_findpacket(-1);  
            if(packet){  
                packet->seq = packet_send;  
                packet->flag = 1;  
                gettimeofday(&packet->tv_begin,NULL);  
            }  
            icmp_pack((struct icmp *)send_buff,packet_send,&tv, 64);  
            //打包数据  
            size = sendto(rawsock, send_buff,64,0,(struct sockaddr *)&dest, sizeof(dest));  
            if(size < 0){  
                perror("sendto error");  
                continue;  
            }  
           packet_send ++;  
           //每隔1s发送一个ICMP回显请求包  
            sleep(1);  
        }  
    }
      
    8.接收目的主机的回复函数
    /***********接收ping目的主机的回复*********** / 
    static void *icmp_recv(void *argv)  
    {  
        //轮询等待时间  
        struct timeval tv;  
        tv.tv_usec = 200;  
        tv.tv_sec = 0;  
        fd_set readfd;  
        //当没有信号发出一直接收数据  
        while(alive){  
           int ret = 0;  
            FD_ZERO(&readfd);  
            FD_SET(rawsock,&readfd);  
            ret = select(rawsock+1,&readfd,NULL,NULL,&tv);  
            switch(ret)  
            {  
                case -1:  
                    //错误发生  
                    break;  
                case 0:  
                    //超时  
                    break;  
                default :  
                    {  
                        //收到一个包  
                        int fromlen = 0;  
                        struct sockaddr from;  
                        //接收数据  
                        int size = recv(rawsock,recv_buff,sizeof(recv_buff),0);  
                        if(errno == EINTR){  
                            perror("recvfrom error");  
                            continue;  
                        }  
                                            //解包  
                        ret = icmp_unpack(recv_buff,size);  
                        if(ret == 1){  
                           continue;  
                        }  
                   }  
                    break;  
            }  
        }  
    } 
     
    9.设置ICMP头部(程序中不需要,这里只是作为了解)
    /**********设置ICMP发送报文的头部********************************* 
       回显请求的ICMP报文 
       */  
    /*struct icmp 
    { 
        u_int8_t icmp_type;   //消息类型 
        u_int8_t icmp_code;   //消息类型的子码 
        u_int16_t icmp_cksum;   //校验和 
        union 
        { 
            struct ih_idseq    //显示数据报 
            { 
                u_int16_t icd_id;  //数据报ID 
                u_int16_t icd_seq;  //数据报的序号 
            }ih_idseq;   
        }icmp_hun; 
    #define icmp_id icmp_hun.ih_idseq.icd_id; 
    #define icmp_seq icmp_hun.ih_idseq.icd_seq; 
        union 
        { 
            u_int8_t id_data[1];    //数据 
        }icmp_dun; 
    #define icmp_data icmp_dun.id_data; 
    }; */
      
    10.主函数
    //主程序  
    int main(int argc, char const *argv[])  
    {  
        struct hostent *host = NULL;  
        struct protoent *protocol = NULL;  
        char protoname[] = "icmp";  
        unsigned long inaddr = 1;  
        int size = 128*K;  
      
        if(argc < 2)                     //参数是否数量正确  
        {  
            icmp_usage();  
            return -1;  
        }  
                                              //获取协议类型  
        protocol = getprotobyname(protoname);  
        if(protocol == NULL)  
        {  
            perror("getprotobyname()");  
            return -1;  
        }  
                                              //复制目的地址字符串  
        memcpy(dest_str, argv[1],strlen(argv[1])+1);  
        memset(pingpacket, 0, sizeof(pingm_pakcet) * 128);  
                                               //socket初始化  
       rawsock = socket(AF_INET, SOCK_RAW, protocol->p_proto);  
        if(rawsock < 0){  
            perror("socket");  
           return -1;  
        }  
      
        pid = getuid();                       //为与其他线程区别,加入pid  
                                              //增大接收缓冲区,防止接收包被覆盖  
        setsockopt(rawsock, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));  
        bzero(&dest, sizeof(dest));  
                                              //获取目的地址的IP地址  
        dest.sin_family = AF_INET;  
                                              //输入的目的地址为字符串IP地址  
        inaddr = inet_addr(argv[1]);  
        if(inaddr == INADDR_NONE){             //输入的是DNS地址  
           host = gethostbyname(argv[1]);  
            if(host == NULL){  
                perror("gethostbyname");  
                return -1;  
            }  
                                                //将地址复制到dest  
           memcpy((char *)&dest.sin_addr, host->h_addr, host->h_length);  
        }                                       //IP地址字符串  
        else {  
           memcpy((char *)&dest.sin_addr, &inaddr,sizeof(inaddr));  
        }  
                                               //打印提示  
        inaddr = dest.sin_addr.s_addr;  
        printf("PING %s (%ld.%ld.%ld.%ld) 56(84) bytes of data.\n",   
            dest_str,(inaddr&0x000000ff)>>0,(inaddr&0x0000ff00)>>8,(inaddr&0x00ff0000)>>16,(inaddr&0xff000000)>>24);  
                                               //截取信号SIGINT,将icmp_sigint挂接上  
        signal(SIGINT,icmp_sigint);  
      
        /*发送数据并接收回应 
        建立两个线程,一个用于发数据,另一个用于接收响应数据,主程序等待两个线程运行完毕后再进行 
        下一步,最后对结果进行统计并打印 
        */  
        alive = 1;                                     //初始化可运行  
        pthread_t send_id, recv_id;                    //建立两个线程,用于发送和接收  
        int err = 0;  
        err = pthread_create(&send_id, NULL, icmp_send, NULL); //发送  
        if(err <  0){  
            return -1;  
        }  
        err = pthread_create(&recv_id, NULL, icmp_recv, NULL); //接收  
        if(err < 0){  
            return -1;  
        }  
                                      //等待线程结束  
        pthread_join(send_id, NULL);  
        pthread_join(recv_id, NULL);  
                                      //清理并打印统计结果  
        close(rawsock);  
        icmp_statistics();  
        return 0;  
    } 
    三.程序运行方法
    由于在程序中用到了<pthread.h>多线程,所以在编译时要加上-lpthread,并且想要运行的话要在root权限下,一般的用户是没有权限的此程序编译方法为:
    gcc -o myping myping.c -lpthread 
    ./myping www.baidu.com

    结果为:


    代码2:

    #include "stdafx.h"
    #include<stdio.h>
    #include<windows.h>
    #include<process.h>
    
    #pragma comment( lib, "ws2_32.lib" )
    
    #define SEND_SIZE 32 
    #define PACKET_SIZE 4096
    #define ICMP_ECHO 8
    #define ICMP_ECHOREPLY 0
    
    struct icmp
    {
    	unsigned char icmp_type;
    	unsigned char icmp_code;
    	unsigned short icmp_cksum;
    	unsigned short icmp_id;
    	unsigned short icmp_seq;
    	unsigned long icmp_data; 
    };
    
    struct ip
    {
    	unsigned char ip_hl:4;      
    	unsigned char ip_v:4;       
    	unsigned char ip_tos;          
    	unsigned short ip_len;        
    	unsigned short ip_id;         
    	unsigned short ip_off;        
    	unsigned char ip_ttl;          
    	unsigned char ip_p;         
    	unsigned short ip_sum;        
    	unsigned long ip_src;
    	unsigned long ip_dst; 
    };
    
    /*unsigned */char sendpacket[PACKET_SIZE];
    /*unsigned */char recvpacket[PACKET_SIZE];
    struct sockaddr_in dest_addr;
    struct sockaddr_in from_addr;
    int sockfd;
    int pid;
    
    unsigned short cal_chksum(unsigned short *addr,int len);
    int pack(int pack_no);
    int unpack(/*unsigned*/ char *buf,int len);
    void send_packet(void);
    void recv_packet(void);
    
    void main(int argc,char *argv[])
    {      
    	struct hostent *host;
    	struct protoent *protocol;
    	WSADATA wsaData;
    	int timeout=1000;
    	int SEND_COUNT=4;
    	int i;
    	char* par_host = "www.baidu.com";
    
    /*
    	par_host=argv[argc-1];
    	switch(argc)
    	{
    	case 2: break;
    	case 3: if(strcmp(argv[1],"-t")==0)
    			{
    				SEND_COUNT=10000;
    				break;
    			}
    			//fall through
    	default:
    		printf("usage: %s [-t] Host name or IP address\n",argv[0]);
    		exit(1);       
    	}*/
    
    
    	if(WSAStartup(0x1010,&wsaData)!=0)
    	{
    		printf("wsastartup error\n");
    		exit(1);
    	}
    	if( (protocol=getprotobyname("icmp") )==NULL)
    	{
    		printf("getprotobyname error\n");
    		exit(1);
    	}
    	if( (sockfd=socket(AF_INET,SOCK_RAW,protocol->p_proto) )<0)
    	{  
    		printf("socket error\n");
    		exit(1);
    	}
    	if(setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,(char*)&timeout,sizeof(timeout))<0) 
    		fprintf(stderr,"failed to set recv timeout: %d\n",WSAGetLastError());
    	if(setsockopt(sockfd,SOL_SOCKET,SO_SNDTIMEO,(char*)&timeout,sizeof(timeout))<0)
    		fprintf(stderr,"failed to set send timeout: %d\n",WSAGetLastError());       
    
    	memset(&dest_addr,0,sizeof(dest_addr));
    	dest_addr.sin_family=AF_INET;
    	if(host=gethostbyname(par_host) )
    	{
    		memcpy( (char *)&dest_addr.sin_addr,host->h_addr,host->h_length);
    		//resolve address to hostname
    		if(host=gethostbyaddr(host->h_addr,4,PF_INET))
    			par_host=host->h_name;
    	}
    	else if( dest_addr.sin_addr.s_addr=inet_addr(par_host)==INADDR_NONE)
    	{
    		printf("Unkown host %s\n",par_host);
    		exit(1);
    	}
    
    
    	pid = _getpid();
    	printf("Pinging %s [%s]: with %d bytes of data:\n\n",par_host,inet_ntoa(dest_addr.sin_addr),SEND_SIZE);                   
    	for(i=0;i<SEND_COUNT;i++)                       
    	{
    		send_packet();
    		recv_packet();
    		Sleep(1000);
    	}
    }
    
    //this algorithm is referenced from other's
    unsigned short cal_chksum(unsigned short *addr,int len)d
    //打包
    int pack(int pack_no)
    {      
    	int packsize;
    	struct icmp *icmp;
    
    	packsize=8+SEND_SIZE;
    	icmp=(struct icmp*)sendpacket;
    	icmp->icmp_type=ICMP_ECHO;
    	icmp->icmp_code=0;
    	icmp->icmp_cksum=0;
    	icmp->icmp_seq=pack_no;
    	icmp->icmp_id=pid;
    	icmp->icmp_data=GetTickCount();
    	icmp->icmp_cksum=cal_chksum( (unsigned short *)icmp,packsize); /*校验算法*/
    	return packsize;
    }
    
    //解包
    int unpack(/*unsigned*/ char *buf,int len)
    {     
    	struct ip *ip;
    	struct icmp *icmp;
    	double rtt;
    	int iphdrlen;
    
    	ip=(struct ip *)buf;
    	iphdrlen=ip->ip_hl*4;   
    	icmp=(struct icmp *)(buf+iphdrlen);          
    	if( (icmp->icmp_type==ICMP_ECHOREPLY) && (icmp->icmp_id==pid) )
    	{
    		len=len-iphdrlen-8;  
    		rtt=GetTickCount()-icmp->icmp_data; 
    		printf("Reply from %s: bytes=%d time=%.0fms TTL=%d icmp_seq=%u\n",            
    			inet_ntoa(from_addr.sin_addr),
    			len,
    			rtt,
    			ip->ip_ttl,
    			icmp->icmp_seq);
    		return 1;
    	}
    	return 0;
    }
    
    //发送
    void send_packet()
    {  
    	int packetsize;
    	static int pack_no=0;
    
    	packetsize=pack(pack_no++);
    	if( sendto(sockfd,sendpacket,packetsize,0,(struct sockaddr *)&dest_addr,sizeof(dest_addr) )<0  )
    		printf("Destination host unreachable.\n");
    	// printf("send NO %d\n",pack_no-1);
    }
    
    //接收
    void recv_packet()
    {   
    	int n,fromlen;
    	int success;
    
    	fromlen=sizeof(from_addr);
    	do
    	{
    		if( (n=recvfrom(sockfd,recvpacket,sizeof(recvpacket),0,(struct sockaddr *)&from_addr,&fromlen)) >=0)
    			success=unpack(recvpacket,n);
    		else if (WSAGetLastError() == WSAETIMEDOUT)
    		{
    			printf("Request timed out.\n");
    			return;
    		}
    	}while(!success);
    
    }

    gcc -o myping myping.c -lpthread 
    ./myping www.baidu.com

    gcc -o myping myping.c -lpthread 
    ./myping www.baidu.com

    展开全文
  • 1.java代码实现ping命令 <1> 使用InetAddress类的getByName(ip)方法 int timeOut = 3000; boolean status = true; try { status = InetAddress.getByName(main_router_ip).isReachable(timeOut); if ...

    1.java代码实现ping命令
    <1> 使用InetAddress类的getByName(ip)方法

            int timeOut = 3000;
            boolean status = true;
            try {
                    status = InetAddress.getByName(main_router_ip).isReachable(timeOut);
                    if (status) {
    //                    ping成功
                    }
            } catch (Exception e) {
                e.printStackTrace();
            }
    

    <2>调用cmd执行命令(ping ip 和 ping ip -t都可使用,其他cmd可执行的命令也可以使用并且可以打印输出的文字)

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    public class Test3 {
        public static void main(String[] args) throws Exception {
            Runtime runtime = Runtime.getRuntime(); // 获取当前程序的运行进对象
            Process process = null; //声明处理类对象
            String line = null; //返回行信息
            InputStream is = null; //输入流
            InputStreamReader isr = null;// 字节流
            BufferedReader br = null;
            String ip = "127.0.0.1";
            int requestNum = 0;
            int a= 0;
            boolean res = false;// 结果
            try {
                process = runtime.exec("ping " + ip + " -t"); // PING ip -t(会一直发)
                //process = runtime.exec("ping " + ip); // PING ip (注意ping只发四个请求)
                is = process.getInputStream(); // 实例化输入流
                isr = new InputStreamReader(is);// 把输入流转换成字节流
                br = new BufferedReader(isr);// 从字节中读取文本
                while ((line = br.readLine()) != null) {
                    System.out.println(br.readLine());
                    System.out.println(a++);
                    if (line.contains("TTL")) {
                        requestNum++;
                        if (requestNum == 30) {
                            res = true;
                            break;
                        }
    
                    }
                }
                is.close();
                isr.close();
                br.close();
                System.out.println(res);
                if (res) {
                    System.out.println("ping通  ...");
    
                } else {
                    System.out.println("ping不通...");
                }
            } catch (IOException e) {
                System.out.println(e);
                runtime.exit(1);
            }
        }
    }
    
    

    代码实现的结果:

    在这里插入图片描述
    cmd中执行的结果:
    在这里插入图片描述

    展开全文
  • LoRa终端节点开发之旅④ - - LoRa驱动_PingPong代码分析4.1 前言4.2 PingPong Project Structure4.3 重点函数分析 4.1 前言 回顾上一集, 4.2 PingPong Project Structure 4.3 重点函数分析 ...

    4.1 前言

    你好! 欢迎来到【LoRa终端节点开发之旅④ - - LoRa驱动_PingPong代码分析】!回顾上一集,相信你已经有了一套可编译的LoRa工程PingPong代码!接下来,为了让工程看的更加方便,把工程里面带减号的文件删掉,这样显得更方便些

    4.2 PingPong Project Structure

    关于PingPong代码,分为以下几个部分


    在这里插入图片描述

    4.2.1 Doc

    readme文件,里面包含了该工程的功能,使用方法,部分文件说明等等

    4.2.2 Drivers/BSP/Components

    SX127x/SX126x的驱动程序;如<SX1276.c>:里面主要是包含了LoRa芯片参数设置的一些内容,包括初始化,工作模式,频率,扩频因子等等…(LoRa参数具体含义说明,将于下一篇博客介绍)

    4.2.3 Drivers/BSP/stm32l0xx_nucleo

    关于stm32l0xx_nucleo非LoRa相关的一些功能,如ADC、LED等等 ;就算把这个文件及文件夹删掉,工程仍可用,编译没问题

    4.2.4 Drivers/BSP/sx1276mb1mas

    SX127x/SX126x的驱动程序;如<sx1276mb1mas.c>:里面主要是关于LoRa IO功能及射频相关的函数定义;

    4.2.5 Drivers/CMSIS…Drivers/MDK-ARM

    system_stm32l0xx.c、startup_stm32l053xx.s:有经验的STM32大佬一看就知道这是STM32官方系统文件及汇编底层驱动文件;

    4.2.6 Drivers/STM32L0xx_HAL_Driver

    STM32 HAL库文件,STM32用起来方便,美滋滋!!!

    4.2.7 Project/PingPong

    包含了main函数之外,还包含了STM32一些功能的用法,如串口,SPI的初始化等等,都是用到4.2.6里面的HAL库…

    4.3 几个函数分析

    4.3.1 Radio.Init( &RadioEvents );

    Radio.Init( &RadioEvents );
    

    LoRa 芯片时间初始化,作用体现在while(1)循环里面,LoRa工作状态包含:发送完成、接收完成、发送超时、接收超时、接收错误。

    4.3.2 Radio.SetChannel( RF_FREQUENCY );

    Radio.SetChannel( RF_FREQUENCY );
    

    设置LoRa芯片工作频率,EU869:欧洲国家868Mhz

    4.3.3Radio.SetTxConfig(…)/Radio.SetRxConfig(…);

    Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                                   LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                                   true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );
    
    Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                                   0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
    

    发送/接收配置,走到底层你可以看到对应的函数原型及描述

    void    ( *SetTxConfig )( RadioModems_t modem, int8_t power, uint32_t fdev,
                              uint32_t bandwidth, uint32_t datarate,
                              uint8_t coderate, uint16_t preambleLen,
                              bool fixLen, bool crcOn, bool freqHopOn,
                              uint8_t hopPeriod, bool iqInverted, uint32_t timeout );
    

    mode:工作模式,LoRa芯片可工作在FSK模式/LoRa模式;
    power:LoRa工作功率
    fdev:FSK模式下设置,不考虑使用
    bandwidth:带宽-125K、250K、500K
    datarate:扩频因子
    coderate: 编码率
    preambleLen:前导码长度
    fixLen:数据包长度是否固定
    crcOn:是否启动CRC校验
    freqHopOn:调频使能开关
    hopPeriod:若启动调频,调频周期确定
    iqInverted:反转IQ信号(笔者也没搞过呀)
    timeout:设置超时时间(一般是接收超时时间)

    4.3.4Radio.Rx( RX_TIMEOUT_VALUE );

    Radio.Rx( RX_TIMEOUT_VALUE );
    

    Rx接收超时时间,一旦经过了这个时间接收不到数据,就产生接收超时中断,无法接收;
    将RX_TIMEOUT_VALUE 设置成0,就不会产生接收超时,一直等待接收!

    展开全文
  • 在我配置好了pom.xml和启动类注解以后发现ping:一直都是空的 即使根据网上的方法访问了以后刷新也还是空的 但是用下面的代码是可以监控到数据的 @RequestMapping(value = "/dept/get/{id}", method = RequestMethod....
  • Python 如何 ping

    万次阅读 2020-10-10 19:38:10
    背景 最近需要监测一个服务器的运行状态。...ping 的原理就是发送一份 ICMP 回显请求报文给目标主机,并等待目标主机返回ICMP回显应答。 如果想要自己写,可以自己控制发报文,这里推荐一篇博客大家可以自行
  • 先介绍下,菜鸟我做的一个程序是[color=#FF0000]利用timer每700毫秒去群ping IP地址(一直ping),[/color]然后把状态放置在datagridview中显示出来,,现在出现的问题是,,但程序是在ping的次数为20次以下就不会...
  • 一、 报错信息 向 GitHub 提交代码 , 经常出现提交连接超时 , ping 一下 , 发现 ping 不通 , 请求超时 ; C:\Users\octop>ping github.com 正在 Ping github.com [13.250.177.223] 具有 32 字节的数据: 请求超时。 ...
  • 118 printf("PING is (%d.%d.%d.%d) 56(84) bytes of data.\n",dest_str,(inaddr&0x000000FF)>>0,(inaddr&0x0000FF00)>>8,(inaddr&0x00FF0000)>>1 6,(inaddr&0xFF000000)>>24); 119  120 //截取信号SIDINT,将...
  • Ping程序设计

    2020-05-19 23:51:39
    Ping程序设计 文章目录Ping程序设计0. 设计框架1. 实验须知ICMP协议2. 发送数据1、 ICMP报文填充2、 ICMP校验3、 发送ICMP报文3. 接收数据1、 剥离ICMP接收报文头部2、 接收报文4. 主程序流程Ping数据结构主函数流程...
  • Linux ping命令

    千次阅读 2019-03-22 19:03:00
    ping 是常用的网络命令,主要通过 ICMP 协议进行网络探测,测试网络中主机的通信情况。 ping 命令的基本信息如下。 命令名称:ping。 英文原意:send ICMP ECHO_REQUEST to network hosts。 所在路径:/bin/ping。 ...
  • 用Python实现PING

    千次阅读 2019-07-16 21:02:10
    PING 概述 ping属于一个通信协议,是TCP/IP协议的一部分。利用“ping”命令可以检查网络是否连通,可以很好地分析和判定网络故障。 PING ,用于测试网络连接量的程序。Ping发送一个ICMP(Internet Control Messages ...
  • Java实现ping ip

    千次阅读 2018-04-24 20:45:44
    Java实现ping功能的三种方法检测设备的运行状态,有的是使用ping的方式来检测的。所以需要使用java来实现ping功能。为了使用java来实现ping的功能,有人推荐使用java的 Runtime.exec()方法来直接调用系统的Ping命令,也...
  • 粗略实现Ping程序

    千次阅读 2016-11-17 21:29:25
    最近一直在看《TCP/IP详解》这本书,也许因为我不是计算机专业的缘故,总感觉看了跟没看一样,想着写写博客,能加深印象,结果简直是尴尬。所以想着不如自己动手来实现一个Ping程序,当是学习学习吧,几年以前用...
  • VC封装Ping命令的实现

    千次阅读 2016-07-22 23:31:11
    本文给出了网络编程中封装ping命令的一种实现方式,能够在程序启动后一直ping目标网络。
  • ping的shell脚本

    2019-01-10 10:29:38
    之前一直在找ping的shell脚本,现在将ping的shell脚本编写出来,以便接下来的时候找不到,又没有办法进行处理。废话不多说,奉上代码: #!/bin/bash#ping host ip for hostip in {10..25}; do ip="192.168.0.$hostip...
  • ping命令
  • VB编写的窗体式Ping工具,可设置持续PING或PING通即停。...不过有个选项可以一直Ping,鼠标点选就可以了,其实很简单的应用,不过用可视化的形式展现则有利于大家更进一步了解Ping的机制,对学习VB有一定帮助。
  • zhangping

    千次阅读 2013-09-17 18:46:53
    项目名称:差旅eTravel国际机票割接项目 开发周期:2013/02-2013/10 开发技术:struts 1+ EJB + jQuery + mybatis3 +...开发环境:RSA7, Oracle11g,CC (ClearCase)代码库管理 项目描述:
  • Android中的ping网络实现

    万次阅读 2016-02-23 16:20:02
    android中判断是否联网的那个方法在某些情况下是不可靠的,其实最可靠的就是ping当前的网络例如ping百度看下能不能ping通,能就代表网络正常,不能就表示网络不正常,以下就是ping代码实现:public static boolean...
  • Windows中的ping命令

    千次阅读 2020-05-06 14:50:11
    在网络中 ping 是一个十分强大的 TCP/IP 工具,它的作用主要为: 1、时间属性用来检测网络的连通情况和分析网络速度 ,时间值越小说明你连接这个地址速度越快。 2、根据域名得到服务器 IP, Ping www.baidu.com...
  • ICMP报文和ping命令

    万次阅读 2017-04-17 22:05:34
    一、ping 的原理  ping程序是用来探测主机到主机之间是否可通信,如果不能ping到某台主机,表明不能和这台主机建立连接。ping使用的是ICMP协议,它发送icmp回送请求消息给目的主机。ICMP协议规定:目的主机必须...
  • Python实现ping指定IP

    万次阅读 2016-05-10 17:13:03
    代码: import osimport sysiplist = list()ip = '192.168.1.11'# ip = '172.24.186.191'ip = 'www.baidu.com'backinfo =  os.system('ping -c 1 -w 1 %s'%ip) # 实现pingIP地址的功能,-c1指发送报文一次,-w1...
  • QT实现ping功能

    千次阅读 2020-12-11 14:41:44
    QT实现ping功能 1.问题描述: 界面点击“建立连接”按钮实现测试主机和目的主机的通信链路是否正常。 2.解决思路: "建立连接"按钮响应槽函数,槽函数实现ping操作,返回ping通的结果。 3.解决方法: 方法(1) ...
  • 参数可以对命令的功能进行扩展,ping命令的参数比较多,常用的主要有以下几个: (1)pingIP地址–t 连续不停对IP地址发送ICMP数据包,直到被用户以Ctrl+C中断。 如:ping192.168.1.1-t (2)pingIP地址–n 自由指定...
  • ping命令详解

    2014-06-02 17:27:53
    PING (Packet Internet Grope),因特网包探索器,用于测试网络连接量的程序。Ping发送一个ICMP回声请求消息给目的地并报告是否收到所希望的ICMP回声应答。 它是用来检查网络是否通畅或者网络连接速度的命令。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,812
精华内容 11,524
热门标签
关键字:

一直ping的代码