精华内容
下载资源
问答
  • Ping程序设计实现
    千次阅读
    2021-11-14 11:15:43

    由于IP层的协议是一种点对点的协议,而非端对端的协议,它提供无连接的数据报服务,没有端口的概念,因此很少使用bind()和connect()函数,如果用的话也仅是用于设置IP地址。用socket函数生成原始套接字后,即可用sendto()或sendmsg()函数发送数据和用函数recvfrom()或recvmsg()接收数据。

    ping程序发ICMP响应请求给某一主机,该主机返回一个ICMP响应应答,程序收到应答则显示结果.为了完成这个功能,首先应创建协议为ICMP的原始套接字以接收/发送ICMP包,然后需要构造ICMP包,通过原始套接字发送给对方主机.

    #include <stdio.h> 
    #include <stdlib.h> 
    #include <winsock.h> 
    #include<conio.h> 
    #pragma comment(lib, "ws2_32.lib")// 导入库文件 
    #define ICMP_ECHOREPLY 0 //ICMP 回应答复 
    #define ICMP_ECHOREQ 8 //ICMP 回应请求 
    #define REQ_DATASIZE 32 // 请求数据报大小
    #include <iostream>
    using namespace std; 
    
    //定义 IP 首部格式
    typedef struct IPHeader 
    { 
        u_char VIHL; // 版本和首部长度 
        u_char ToS; //服务类型 
        u_short TotalLen; // 总长度 
        u_short ID; // 标识号 
        u_short Frag_Flags; //片偏移量 
        u_char TTL; // 生存时间 
        u_char Protocol; // 协议 
        u_short Checksum; //首部校验和
        struct in_addr SrcIP; // 源 IP 地址 
        struct in_addr DestIP; // 目的地址
    }IPHDR, *PIPHDR; 
    
    //定义 ICMP 首部格式
    typedef struct ICMPHeader 
    { 
        u_char Type; //类型 
        u_char Code; //代码 
        u_short Checksum; //首部校验和 
        u_short ID; // 标识 
        u_short Seq; //序列号
        char Data; //数据
    }ICMPHDR, *PICMPHDR; 
    
    //定义 ICMP 回应请求
    typedef struct ECHOREQUEST 
    { 
        ICMPHDR icmpHdr; 
        DWORD dwTime; 
        char cData[REQ_DATASIZE]; 
    }ECHOREQUEST, *PECHOREQUEST; 
    
    //定义 ICMP 回应答复
    typedef struct ECHOREPLY 
    { 
        IPHDR ipHdr; 
        ECHOREQUEST echoRequest; 
        char cFiller[256]; 
    }ECHOREPLY,*PECHOREPLY;
    
    //计算校验和
    u_short checksum(u_short *buffer, int len) 
    { 
        register int nleft = len; 
        register u_short *w = buffer; 
        register u_short answer; 
        register int sum = 0; 
        //使用 32 位累加器 ,进行 16 位的反馈计算
        while ( nleft > 1 ) 
        { 
            sum += *w++; 
            nleft -= 2; 
        } 
        //补全奇数位
        if ( nleft == 1 ) 
        { 
            u_short u = 0; 
            *(u_char *)(&u) = *(u_char*)w; 
            sum += u; 
        }
        //将反馈的 16 位从高位移到低位
        sum = (sum >> 16) + (sum & 0xffff); 
        sum += (sum >> 16); 
        answer = ~sum; 
        return (answer); 
    } 
    
    //发送回应请求函数
    int SendEchoRequest(SOCKET s, struct sockaddr_in *lpstToAddr) 
    { 
        static ECHOREQUEST echoReq; 
        static int nId = 1; 
        static int nSeq = 1; 
        int nRet; 
        //填充回应请求消息
        echoReq.icmpHdr.Type = ICMP_ECHOREQ; 
        echoReq.icmpHdr.Code = 0; 
        echoReq.icmpHdr.Checksum = 0; 
        echoReq.icmpHdr.ID = nId++; 
        echoReq.icmpHdr.Seq = nSeq++; 
        //填充要发送的数据
        for (nRet = 0; nRet < REQ_DATASIZE; nRet++) 
        { 
            echoReq.cData[nRet] = '1' + nRet; 
        } 
        //存储发送的时间
        echoReq.dwTime = GetTickCount(); 
        //计算回应请求的校验和
        echoReq.icmpHdr.Checksum = checksum((u_short*)&echoReq, sizeof(ECHOREQUEST)); 
        //发送回应请求
        nRet = sendto(s,(LPSTR)&echoReq,sizeof(ECHOREQUEST),0,(struct sockaddr*)lpstToAddr,sizeof(SOCKADDR_IN)); 
        if (nRet == SOCKET_ERROR) 
        { 
            printf("send to() error:%d\n", WSAGetLastError()); 
        } 
        return (nRet); 
    } 
    
    //接收应答回复并进行解析
    DWORD RecvEchoReply(SOCKET s, LPSOCKADDR_IN lpsaFrom, u_char *pTTL) 
    { 
        ECHOREPLY echoReply; 
        int nRet; 
        int nAddrLen = sizeof(struct sockaddr_in); 
        //接收应答回复
        nRet = recvfrom(s,(LPSTR)&echoReply,sizeof(ECHOREPLY),0,(LPSOCKADDR)lpsaFrom,&nAddrLen); 
        //检验接收结果
        if (nRet == SOCKET_ERROR) 
        { 
            printf("recvfrom() error:%d\n",WSAGetLastError()); 
        } 
        //记录返回的 TTL 
        *pTTL = echoReply.ipHdr.TTL; 
        //返回应答时间
        return(echoReply.echoRequest.dwTime); 
    } 
    
    //等待回应答复 ,使用 select 模型
    int WaitForEchoReply(SOCKET s) 
    {
        struct timeval timeout;
        fd_set readfds;
        readfds.fd_count = 1;
        readfds.fd_array[0] = s;
        timeout.tv_sec = 1;
        timeout.tv_usec = 0;
        return(select(1, &readfds, NULL, NULL, &timeout));
    } 
    
    //PING 功能实现
    void Ping(char *pstrHost,bool logic) 
    { 
        char c; 
        SOCKET rawSocket; 
        LPHOSTENT lpHost; 
        struct sockaddr_in destIP; 
        struct sockaddr_in srcIP; 
        DWORD dwTimeSent; 
        DWORD dwElapsed; 
        u_char cTTL; 
        int nLoop,k=4; 
        int nRet,minimum=100000,maximum=0,average=0; 
        int sent=4,reveived=0,lost=0; 
        //创建原始套接字 ,ICMP 类型
        rawSocket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
        // 第二个注释函数 socket 
        if (rawSocket == SOCKET_ERROR) 
        { 
            printf("socket() error:%d\n", WSAGetLastError()); 
            return; 
        } 
        //检测目标主机
        lpHost = gethostbyname(pstrHost); 
        if (lpHost==NULL) 
        { 
            printf("Host not found:%s\n", pstrHost); 
            return; 
        } 
        //设置目标机地址 
        destIP.sin_addr.s_addr = *((u_long FAR*)(lpHost->h_addr)); // 设置目标 IP 
        destIP.sin_family = AF_INET; //地址规格
        destIP.sin_port = 0; 
        //提示开始进行 PING 
        printf("\nPinging %s [%s] with %d bytes of data:\n",pstrHost,inet_ntoa(destIP.sin_addr),REQ_DATASIZE);
        //发起多次 PING 测试
        for (nLoop=0; nLoop<k; nLoop++){ 
            if (logic) k=k+1; 
            //发送 ICMP 回应请求 
            SendEchoRequest(rawSocket, &destIP); 
            //等待回复的数据
            nRet = WaitForEchoReply(rawSocket); 
            if(nRet == SOCKET_ERROR) 
            { 
                printf("select() error:%d\n", WSAGetLastError()); 
                break; 
            } 
            if (!nRet) 
            { 
                lost++; 
                printf("\nRequest time out."); 
                continue; 
            } 
            //接收回复
            dwTimeSent = RecvEchoReply(rawSocket, &srcIP, &cTTL); 
            reveived++; 
            //计算花费的时间
            dwElapsed = GetTickCount() - dwTimeSent; 
            if(dwElapsed > maximum) maximum=dwElapsed; 
            if(dwElapsed < minimum) minimum=dwElapsed; 
            average+=dwElapsed; 
            printf("\nReply from %s: bytes = %d time = %ldms TTL = %d", 
                inet_ntoa(srcIP.sin_addr),REQ_DATASIZE,dwElapsed,cTTL); 
            if(_kbhit()) /* Use _getch to throw key away. */ 
            { 
                if ((c=_getch())==0x2) //crrl -b 
                break; 
            } else 
            Sleep(1000); 
        } 
        printf("\n\n"); 
        printf("Ping statistics for %s:\n",inet_ntoa(srcIP.sin_addr)); 
        printf(" Packets: Sent = %d, Received = %d, Lost = %d (%.f%% loss),\n", 
            sent,reveived,lost,(float)(lost*1.0/sent)*100); 
        if(lost==0) 
        { 
            printf("Approximate round trip times in milli-seconds:\n"); 
            printf(" Minimum = %dms, Maximum = %dms, Average = %dms\n",minimum,maximum,average/sent); 
        } 
        printf("\n\n"); 
        nRet = closesocket(rawSocket); 
        if (nRet == SOCKET_ERROR) 
        { 
            printf("closesocket() error:%d\n", WSAGetLastError()); 
        } 
    } 
    
    //主程序
    void main() 
    { 
        printf("Welcome to the Ping Test\n"); 
        while(1) 
        { 
            WSADATA wsd;// 检测输入的参数 
            //初始化 Winsock 
            if(WSAStartup(MAKEWORD(1, 1), &wsd) != 0){// 第一个函数说明 WSAStartup() 
                printf(" 加载 Winsock 失败 !\n"); 
            } 
            char opt1[100]; 
            char *ptr=opt1; 
            bool log=false; 
            printf("Ping "); 
            cin.getline(opt1,100,'\n');//ping 的地址 字符串
            if(strstr(opt1, "-t")!=NULL) 
            { 
                log=true; 
                strncpy(ptr,opt1+0,strlen(opt1)-3);// 把原字符串的最后三位截取 
                ptr[strlen(opt1)-2]=0; 
                //printf("%s", ptr); 
            } 
            //开始 PING 
            Ping(ptr,log); 
            //程序释放 Winsock 资源
            WSACleanup(); 
        } 
    } 
    

    实现效果:
    在这里插入图片描述

    更多相关内容
  • 计算机网络课程设计,利用socket套接字编写出ping程序,测试本局域网的当前所有机器是否在线
  • 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数据结构主函数流程...

    Ping程序设计


    github: https://github.com/zhaojunchen/Linux-Network/tree/master/ping

    0. 设计框架

    ping程序一般按照下图的框架进行设计。主要分为

    1. 发送数据
    2. 接收数据
    3. 计算时间差

    发送数据对组织好的数据进行发送,接收数据从网络上接收数据并判断其合法性,例如判断是否本进程发出的报文等,计算时间差反应网络的延时。

    image-20200519210917147

    1. 实验须知

    ICMP协议

    ICMP协议消息类型有很多种、常见的有如下的几种:

    ICMP消息类型用途说明
    回显请求Ping工具通过发送ICMP回显消息检查特定节点的IPv4连接以排查网络问题。类型值为0
    回显应答节点发送回显答复消息响应ICMP回显消息。类型值为8
    重定向路由器发送“重定向”消息,告诉发送主机到目标IPv4地址更好的路由。类型值为5
    源抑制路由器发送“源结束”消息,告诉发送主机它们的IPv4数据报将被丢弃——因为路由器上发生了拥塞。于是,发送主机将以较低的频度发送数据报。类型值为4
    超时这个消息有两种用途。第一,当超过IP生存期时向发送系统发出错误信息。第二,如果分段的IP数据报没有在某种期限内重新组合,这个消息将通知发送系统。类型值为11
    无法到达目标路由器和目标主机发送“无法到达目标”消息,通知发送主机它们的数据无法传送。类型值为3

    其中ping发送数据的时候类型为 回显请求 接收数据的时候类型为 回显应答

    2. 发送数据

    发送数据对组织好的数据进行发送、送达到目标主机。

    具体包含以下的几个部分:

    1、 ICMP报文填充

    ICMP报头的格式设置如下所示:

    image-20200519211520398

    各字段说明

    • 类型:占一字节,标识ICMP报文的类型,目前已定义了14种,从类型值来看ICMP报文可以分为两大类。第一类是取值为1~127的差错报文,第2类是取值128以上的信息报文。
    • 代码:占一字节,标识对应ICMP报文的代码。它与类型字段一起共同标识了ICMP报文的详细类型。
    • 校验和:这是对包括ICMP报文数据部分在内的整个ICMP数据报的校验和(数据部分和报头部分),以检验报文在传输过程中是否出现了差错。其计算方法与在我们介绍IP报头中的校验和计算方法是一样的。
    • 标识:占两字节,用于标识本ICMP进程,但仅适用于回显请求和应答ICMP报文,对于目标不可达ICMP报文和超时ICMP报文等,该字段的值为0。

    ping程序请求远程主机所使用的ICMP的类型为回显请求

    回显请求的报文格式如下:

    image-20200519212611266

    就是上面所说的头部(没有选型字段)+ 数据部分

    ICMP回显请求报文的数据填充就是根据上图的格式填写正确的内容

    报文填充如下:

    报头部分

    • ICMP回显请求的类型为8,即 ICMP ECHO。
    • ICMP回显请求的代码值为0。
    • ICMP回显请求的校验和后面会讲到
    • ICMP回显请求的序列号是一个16位的值,通常由一个递增的值生成。
    • ICMP回显请求的ID用于区别,通常用进程的PID填充进行ICMP头部校验
    • ICMP回显请求头部的选项部分未设置

    数据部分

    • ICMP回显的数据部分可以任意设置,但是以太网包的总长度不能小于以太网的最小值,即总长度不能小于46.由于IP头部为20字节,ICMP头部为8个字节,以太网头部占用14个字节,因此ICMP回显包的最小值为46-20-8-14=4个字节。 本程序中ICMP的报文长度设置为64(8字节头部+其余56字节的 任意数据)
    /**
     **设置ICMP报文
     * @param icmph 发送的报文
     * @param seq   序列号(依次递增)
     * @param tv    时间戳信息
     * @param length icmp报文(头部+数据部分)总长度  程序中设置为64  
     */
    static void icmp_pack(struct icmp *icmph, int seq, struct timeval *tv, int length) {
        unsigned char i = 0;
        /*设置ICMP的报头*/
        // 请求类型
        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*/
        
        // 设置ICMP的数据部分
        // length-8 = 56字节的数据部分填充
        for (i = 0; i < length - 8; i++)
            icmph->icmp_data[i] = i;
        /*计算校验和*/
        icmph->icmp_cksum = icmp_cksum((unsigned char *) icmph, length);
    }
    

    2、 ICMP校验

    由于ICMP必须使用原始套接字进行设计,要手动设置ICMP的头部校验和。这是对包括ICMP报文数据部分在内的整个ICMP数据报的校验和(数据部分和报头部分),以检验报文在传输过程中是否出现了差错。

    // 使用校验的部分:(icmp报文填充的时候)
    /*计算校验和*/
        icmph->icmp_cksum = icmp_cksum((unsigned char *) icmph, length);
    
    
    /**
    CRC16校验和计算icmp_cksum
    参数:
    	data:数据  注意的是ICMP校验包含了头部和数据部分  程序的ICMP总长度为64字节
    	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;                            /*返回取反值*/
    }
    

    3、 发送ICMP报文

    发送报文函数是一个线程,每隔1s向目的主机发送一个ICMP回显请求报文,它在整个程序处于激活状态( alive为1)时一直发送报文(alive是一个全局变量)

    发送报文的逻辑如下:

    1. 获得当前的时间值,按照序列号 packet_send将ICMP报文打包到缓冲区 send buff中后,发送到目的地址。发送成功后,记录发送报文的状态
      • 序号seq为 packet_send
      • 标志fag为1,表示已经发送但是没有收到响应
      • 发送时间为之前获得的时间
    2. 每次发送成功后序号值会增加1,即 packet send++。
    3. 在线程开始进入主循环 while( alive)之前,将整个程序的开始发送时间记录下来,用于在程序退出的时候进行全局统计,即 gettimeofday(& ctv begin,NULL),将时间保存在变量 tv_begin中。
    /*发送ICMP回显请求包*/
    static void *icmp_send(void *argv) {
        /*保存程序开始发送数据的时间*/
        gettimeofday(&tv_begin, NULL);
        while (alive) {
            int size = 0;
            struct timeval tv;
            gettimeofday(&tv, NULL);            /*当前包的发送时间*/
            /*在发送包状态数组中找一个空闲位置*/
            
            // 寻找一个pingm_pakcet结构、记录当前ping包的时间戳信息和序列号等信息
            pingm_pakcet *packet = icmp_findpacket(-1);
            if (packet) {
            	// 设置序列号
                packet->seq = packet_send;        /*设置seq*/
                packet->flag = 1;                /*已经使用*/
                // 记录当前ping包的开始时间  结束时间在接收部分处理
                gettimeofday(&packet->tv_begin, NULL);    /*发送时间*/
            }
            // 填充报文数据到发送缓冲区  icmp_pack填充 ICMP响应请求的报头和数据部分
            icmp_pack((struct icmp *) send_buff, packet_send, &tv, 64);
            
            // 原始套接字 发送 到目标主机
            // rawsock:ICMP的原始套接字
            // send_buff ICMP报文 
            // 64 是报文的长度 dest是服务器地址
            size = sendto(rawsock, send_buff, 64, 0,        /*发送给目的地址*/
                          (struct sockaddr *) &dest, sizeof(dest));
            if (size < 0) {
                perror("sendto error");
                continue;
            }
            // packet_send就是发送的序列号
            packet_send++;                    /*计数增加*/
            /*每隔1s,发送一个ICMP回显请求包*/
            sleep(1);
        }
    }
    

    备注

    1. 在C语言中可以使用函数gettimeofday()函数来得到精确时间。它的精度可以达到微妙,是C标准库的函数. gettimeofday()会把目前的时间用timeval 结构体返回,当地时区的信息则放到tz所指的结构中

    2. timeval 结构体如下

      struct timeval
      {
        __time_t tv_sec;    /* Seconds.  */
        __suseconds_t tv_usec;   /* Microseconds.  */
      };
      #endif
      

    3. 接收数据

    1、 剥离ICMP接收报文头部

    函数 icmp_unpack处理来自目标地址的响应应答 icmp_unpack会剥离应答内容IP头部,分析ICMP头部的值。判断是否为正确的ICMP报文,并打印结果。

    参数buf为剥去了以太网部分数据的IP数据报文,len为数据长度。可以利用IP头部的参数快速地跳到ICMP报文部分,IP结构的iph标识I头部的长度,由于ih标识的是4字节单位,所以需要乘以4来获得IMP段的地址。

    获得ICMP数据段后,判断其类型是否为 ICMP ECHOREPLY,并核实其标识是否为本进程的PID。由于需要判断数据报文的往返时间,在本程序中需要先查找这个包发送时的时间,与当前时间进行计算后,可以得出本地主机与目标主机之间网络ICMP回显报文的差值!

    /*解压接收到的包,并打印信息*/
    static int icmp_unpack(char *buf, int len) {
        int iphdrlen;
        struct ip *ip = NULL;
        struct icmp *icmp = NULL;
        int rtt;
    
        ip = (struct ip *) buf;                    /*IP头部*/
        iphdrlen = ip->ip_hl * 4;                    /*IP头部长度*/
        // icmp指向ICMP报文的起始地址
        icmp = (struct icmp *) (buf + iphdrlen);        /*ICMP段的地址*/
        len -= iphdrlen;
        // len是ICMP报文的长度
        /*判断长度是否为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_internel, tv_recv, tv_send;
            /*在发送表格中查找已经发送的包,按照seq*/
            // 已经使用的ping包(flag =1 存在seq)会被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);        /*读取此时间,计算时间差*/
            // timeval 时间差计算
            tv_internel = icmp_tvsub(tv_recv, tv_send);
            // timeval 得到rtt往返时间
            rtt = tv_internel.tv_sec * 1000 + tv_internel.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);
    		// 统计受到响应的ping包
            packet_recv++;                        /*接收包数量加1*/
        } else {
            return -1;
        }
        return 0;
    }
    
    // 附上时间计算函数
    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值,从usec域借位*/
        if (tv.tv_usec < 0) {
            tv.tv_sec--;
            tv.tv_usec += 1000000;
        }
    
        return tv;
    }
    

    2、 接收报文

    与发送函数一样,接收报文也用一个线程实现,使用 select轮询等待报文到来。当接收到一个报文后,使用函数 icmp _npack(来解包和查找报文之前发送时的记录,获取发送时间,计算收发差值并打印信息)
    (1)接收成功后将合法的报文记录重置为没有使用,fag为0
    (2)接收报文数量增加1。
    (3)为了防止丢包, select的轮询时间设置的比较短。

    接收来自目标地址的响应数据、并且将其送入imcp_packet解包

    /*接收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 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;
            }
    
        }
    }
    

    4. 主程序流程

    ping程序的实现使用了两个线程,一个线程 icmp sendo用于发送请求,另一个线程icmp recv用于接收远程主机的响应。当变量 alive为0时,两个线程退出。

    Ping数据结构

    程序使用类型为结构 struct ping_packet的变量 pingpacket用于保存发送数据报文的状态。

    • tv_begin用于保存发送的时间。
    • ty_end用于保存数据报文接收到的时间。
    • seq是序列号,用于标识报文,作为索引。
    • flag用于表示本单元的状态,表示数据报文已经发送,但是没有收到回应包;0表示已经接收到回应报文,这个单元可以再次用于标识发送的报文。
    typedef struct pingm_pakcet {
        struct timeval tv_begin;    /*发送的时间*/
        struct timeval tv_end;        /*接收到的时间*/
        short seq;                    /*序列号*/
        int flag;        /*1,表示已经发送但没有接收到回应包0,表示接收到回应包*/
    } pingm_pakcet;
    
    

    主函数流程

    0.ICMP协议类型设置

     struct protoent *protocol = NULL;
     char protoname[] = "icmp";
     /*获取协议类型ICMP*/
     protocol = getprotobyname(protoname);
    

    1.初始化ICMP的raw sock

     /*socket初始化*/
        rawsock = socket(AF_INET, SOCK_RAW, protocol->p_proto);
    

    2.系列全局变量初始化(不多赘述)

    /*复制目的地址字符串*/
        memcpy(dest_str, argv[1], strlen(argv[1]) + 1);
        memset(pingpacket, 0, sizeof(pingm_pakcet) * 128);
        /*为了与其他进程的ping程序区别,加入pid*/
        pid = getuid();
        /*增大接收缓冲区,防止接收的包被覆盖*/
        setsockopt(rawsock, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
        bzero(&dest, sizeof(dest));
    

    3.目的IP地址解析(域名或者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);
        } else        /*为IP地址字符串*/
        {
            memcpy((char *) &dest.sin_addr, &inaddr, sizeof(inaddr));
        }
        /*打印提示*/
        inaddr = dest.sin_addr.s_addr;
    

    4.开启发送线程和接收线程

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

    5.清理并打印统计结果

    /*清理并打印统计结果  程序使用SIGINT退出子线程、控制权转到主线程*/
    close(rawsock);
    icmp_statistics();
    

    注意点

    在主程序中需要注意如下几点:

    • 使用 getprotobyname函数获得icmp对应的ICMP协议值。对输入的目的主机地址兼容域名和IP地址,使用 gethostbynameo函数来获得DNS对应的IP地址, inet addo函数获得字符串类型的P地址对应的整型值。
    • 为了防止远程主机发送过大的包或者本地来不及接收现象的发生, setsockopt( rawsock、 SOL SOCKET、 SO RCVBUF、&size、 sizeof(size)函数将 socket的接收缓冲区设置为128K
    • 对信号 SIGINT进行了截取、设置alive为0 让子线程主动退出,用以来结束函数
    • 建立两个线程 icmp_sendo和 icmp_recv进行接收和发送,然后主程序等待两个线程结束。
    • ICMP原始报文发送需要root权限

    运行结果

    image-20200519224549793

    参考文献

    [ 1 ] : Linux网络程序设计

    展开全文
  • PING程序是我们使用的比较多的用于测试网络连通性的程序。...课程设计中选取PING程序设计,其目的是希望同学们通过PING程序设计,能初步掌握TCP/IP网络协议的基本实现方法,对网络的实现机制有进一步的认识。
  • ping程序设计

    2012-02-15 12:26:29
    ping程序设计,用C语言编写代码实现ping程序
  • Tracert Ping Windows

    前言

    本实验主要是应用ICMP报文实现Tracert和Ping功能,主要用的是Windows中的库,所以程序只能在Windows下运行。
    在博客结束的地方,附上C/C++的Tracert源码和Ping源码,两个源码来自指导书和网络。
    我的程序也改编自这两个源码

    白嫖容易,创作不易,本文原创,转载请注明!!!
    源码和可运行程序:
    链接:https://pan.baidu.com/s/1A9KctmpP2JJgyW2wLrehIg
    提取码:Lin2

    计算机网络课程设计:
    计算机网络课程设计之网络聊天程序的设计与实现
    计算机网络课程设计之Tracert与Ping程序设计与实现
    计算机网络课程设计之基于 IP 多播的网络会议程序
    计算机网络课程设计之网络嗅探器的设计与实现
    计算机网络课程设计之电子邮件客户端程序设计与实现
    计算机网络课程设计之TELNET 终端设计与实现
    计算机网络课程设计之网络代理服务器的设计与实现
    计算机网络课程设计之简单 Web Server 程序的设计与实现

    Qt入门系列:
    Qt学习之C++基础
    Qt学习之Qt安装
    Qt学习之Qt基础入门(上)
    Qt学习之Qt基础入门(中)
    Qt学习之Qt基础入门(下)

    创作不易,整个课程设计程序3000多行代码,所有实验都写在了一个程序中,时间有限,能力不足,转载望注明!!!
    本文链接
    个人博客:https://ronglin.fun/archives/266
    PDF链接:见博客网站
    CSDN: https://blog.csdn.net/RongLin02/article/details/122510039

    实验题目

    Tracert 与 Ping 程序设计与实现

    实验目的

    了解 Tracert 程序的实现原理
    了解 Ping 程序的实现原理
    参照附录,了解 Tracert 程序的实现原理,并调试通过。然后参考 Tracert 程序和教材 4.4.2 节,编写一个 Ping 程序,并能测试本局域网的所有机器是否在线,例如 QuickPing 程序。

    总体设计

    (含背景知识或基本原理与算法、或模块介绍、设计步骤等)
    先简单的说一下原理,就是不论是Tracert还是Ping,都是利用了IPPROTO_ICMP类型的数据报,格式如下:

    //SOCK_RAW表示原始套接字,即不是TCP也不是UDP
    SOCKET sockRaw=WSASocket(AF_INET,SOCK_RAW,IPPROTO_ICMP,NULL,0,WSA_FLAG_OVERLAPPED);
    

    然后通过修改其中的部分数据来实现对应的功能

    Tracert

    Tracert的主要功能就是获取数据报所经过的路由器线路
    Tracert的基本原理如下,构造一个数据报,将它的初始TTL值设置为1,这样的话,主机将数据发出到第一个路由器1号,然后这个路由器1号将TTL-1,TTL=0,然后路由器1号就把数据报丢弃了,然后向源主机发送一个ICMP时间超过差错报告报文。然后主机就通过解析回传的数据就知道了路由器1号的信息。然后再构造一个数据报,,将它的TTL值设置为2,这样数据就如此流向,主机->路由器1号->路由器2号,然后路由器2号把数据丢弃,发送差错报告,主机就是知道了路由器2号的信息。如此往复直到数据到达了目的主机。
    在我的程序设计中,用一个单独的线程完成Tracert功能,同时在线程中的run()方法中构造套接字,创建连接,得到结果,分析结果,直到到达目的地址。用单独的线程主要是因为在反复发送接收数据时需要较长的时间。
    同时根据指导书上的Tracert源代码构造以下方法

    //对数据包进行解码
    bool MyTracert::DecodeIcmpResponse(char * pBuf,int iPacketSize,DECODE_RESULT &DecodeResult,BYTE ICMP_ECHO_REPLY,BYTE ICMP_TIMEOUT)
    //计算校验和
    USHORT MyTracert::checksum(USHORT *pBuf,int iSize)
    

    同时还有若干槽函数和setter getter方法就不贴出来了

    Ping

    ping的原理也是利用ICMP数据报文,主要就是检测连通性
    PING的源码我是从网上找的MSDN的源码,思路如下:
    初始化WSADATA ->构造ICMP数据报->创建原始套接字 ->设置发送/接受超时时间 -> 用sendto发送ICMP报文->用recvfrom接受返回的数据 -> 分析数据 ->将结果返回给前端界面

    主要设计的方法如下:

        //填充ICMP数据报
        void fill_icmp_data(char *, int);
        //计算校验和
        USHORT checksum(USHORT *, int);
        //解析返回的数据报
        bool decode_resp(char *,int,struct sockaddr_in *);
    

    详细设计

    (含主要的数据结构、程序流程图、关键代码等)
    在这里插入图片描述

    Tracert

    界面上图左侧
    这个主要是要用到3个参数,第一个是要Tracert的IP地址和域名,第二个是要设置的超时时间,第三个是设置转发的节点

    IP地址和域名

    这个是根据用户输入,然后用Windows API提供的方法解析ip和域名,部分代码如下:

    bool MyTracert::isLegalIP(QString ip)
    {
        WSADATA* wsa =(WSADATA*) malloc(sizeof(WSADATA));
        WSAStartup(MAKEWORD(2,2),wsa);
        bool flag = true;
        //得到 IP 地址
        u_long ulDestIP=inet_addr(ip.toUtf8().data());
        //转换不成功时按域名解析
        if(ulDestIP==INADDR_NONE)
        {
            hostent * pHostent=gethostbyname(ip.toUtf8().data());
            if(!pHostent)
            {
                flag = false;
            }
        }
        free(wsa);
        return flag;
    }
    

    通过此方法就知道了用户输入的ip是否合法

    超时时间

    超时时间主要是用在创建套接字的时候,在Windows API中用法如下,其中变量iTimeout(:int)就是设置超时时间

        //接收超时 (用于任意类型、任意状态套接口的设置选项值)
        setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char *)&iTimeout,sizeof(iTimeout));
        //发送超时
        setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char *)&iTimeout,sizeof(iTimeout));
    

    当接收时间/发送时间超过设定的值的时候,就会出现错误WSAGetLastError()==WSAETIMEDOUT

    转发节点个数

    这个比较简单了,就是设置最大跳站数,就是最多允许查看的转发的路由器的节点数量

    int DEF_MAX_HOP=30; //最大跳站数
    

    然后点击开始就启动线程,然后将结果通过槽函数返回给前端界面

    Ping

    界面上图右侧
    这个主要是要用到4个参数,第一个是IP地址的开始值,第二个是IP地址结束值,第三个是设置超时时间,第四个设置ping的次数

    IP范围

    范围就是从开始到结束,同时只允许用户修改点分十进制的最后一部分,同时需要在前端界面中判断用户输入的是否正确,就是开始值<=结束值,同时根据用户输入的范围,构造出来一个IPList,然后传到MyPing类中。

    超时时间

    原理同Tracert

    ping次数

    这个就是对同一个ip地址发送ICMP数据报的次数,发送一次解析一次,如果解析成功(Ping通),返回结果,如果解析失败(无数据/超时/无法解析),则再次发送数据报。

    同时以上也写在了一个子线程中,以防长时间导致前端界面无响应。

    实验结果与分析

    结果如下:
    在这里插入图片描述

    同时启动两个功能
    左侧开始输出结果,因为超时时间问题,返回的结果都是超时
    右侧根据输入开始ping每一个结果然后输出结果
    在这里插入图片描述
    运行结果如上
    左侧经过17跳之后成功的到达,并且显示的域名对应的ip地址
    右侧从IP:39.101.201.10 到IP:39.101.201.30然后分别输出结果
    通过用cmd的Tracert指令和Ping指令检验,结果正确

    小结与心得体会

    对ICMP有了更深入的理解,同时常用的ping功能也知道了它的实现原理,获益匪浅,对计算机网络中网络层有了更深入的认识。
    =w=

    Tracert源码

    #include <iostream>
    #include <winsock2.h>
    #include <ws2tcpip.h>
    using namespace std;
    #pragma comment(lib, "Ws2_32.lib")
    //IP 报头
    typedef struct
    {
        unsigned char hdr_len:4; //4 位头部长度
        unsigned char version:4; //4 位版本号
        unsigned char tos; //8 位服务类型
        unsigned short total_len; //16 位总长度
        unsigned short identifier; //16 位标识符
        unsigned short frag_and_flags; //3 位标志加 13 位片偏移
        unsigned char ttl; //8 位生存时间
        unsigned char protocol; //8 位上层协议号
        unsigned short checksum; //16 位校验和
        unsigned long sourceIP; //32 位源 IP 地址
        unsigned long destIP; //32 位目的 IP 地址
    } IP_HEADER;
    //ICMP 报头
    typedef struct
    {
        BYTE type; //8 位类型字段
        BYTE code; //8 位代码字段
        USHORT cksum; //16 位校验和
        USHORT id; //16 位标识符
        USHORT seq; //16 位序列号
    } ICMP_HEADER;
    //报文解码结构
    typedef struct
    {
        USHORT usSeqNo; //序列号
        DWORD dwRoundTripTime; //往返时间
        in_addr dwIPaddr; //返回报文的 IP 地址
    } DECODE_RESULT;
    //计算网际校验和函数
    USHORT checksum(USHORT *pBuf,int iSize)
    {
        unsigned long cksum=0;
        while(iSize>1)
        {
            cksum+=*pBuf++;
            iSize-=sizeof(USHORT);
        }
        if(iSize)
        {
            cksum+=*(UCHAR *)pBuf;
        }
        cksum=(cksum>>16)+(cksum&0xffff);
        cksum+=(cksum>>16);
        return (USHORT)(~cksum);
    }
    //对数据包进行解码
    BOOL DecodeIcmpResponse(char * pBuf,int iPacketSize,DECODE_RESULT &DecodeResult,BYTE ICMP_ECHO_REPLY,BYTE ICMP_TIMEOUT)
    {
    //检查数据报大小的合法性
        IP_HEADER* pIpHdr = (IP_HEADER*)pBuf;
        int iIpHdrLen = pIpHdr->hdr_len * 4;
        if (iPacketSize < (int)(iIpHdrLen+sizeof(ICMP_HEADER)))
            return FALSE;
    //根据 ICMP 报文类型提取 ID 字段和序列号字段
        ICMP_HEADER *pIcmpHdr=(ICMP_HEADER *)(pBuf+iIpHdrLen);
        USHORT usID,usSquNo;
        if(pIcmpHdr->type==ICMP_ECHO_REPLY) //ICMP 回显应答报文
        {
            usID=pIcmpHdr->id; //报文 ID
            usSquNo=pIcmpHdr->seq; //报文序列号
        }
        else if(pIcmpHdr->type==ICMP_TIMEOUT)//ICMP 超时差错报文
        {
            char * pInnerIpHdr=pBuf+iIpHdrLen+sizeof(ICMP_HEADER); //载荷中的 IP 头
            int iInnerIPHdrLen=((IP_HEADER *)pInnerIpHdr)->hdr_len*4; //载荷中的 IP 头长
            ICMP_HEADER * pInnerIcmpHdr=(ICMP_HEADER *)(pInnerIpHdr+iInnerIPHdrLen);//载荷中的 ICMP 头
            usID=pInnerIcmpHdr->id; //报文 ID
            usSquNo=pInnerIcmpHdr->seq; //序列号
        }
        else
        {
            return false;
        }
    //检查 ID 和序列号以确定收到期待数据报
        if(usID!=(USHORT)GetCurrentProcessId()||usSquNo!=DecodeResult.usSeqNo)
        {
            return false;
        }
    //记录 IP 地址并计算往返时间
        DecodeResult.dwIPaddr.s_addr=pIpHdr->sourceIP;
        DecodeResult.dwRoundTripTime=GetTickCount()-DecodeResult.dwRoundTripTime;
    //处理正确收到的 ICMP 数据报
        if (pIcmpHdr->type == ICMP_ECHO_REPLY ||pIcmpHdr->type == ICMP_TIMEOUT)
        {
    //输出往返时间信息
            if(DecodeResult.dwRoundTripTime)
                cout<<" "<<DecodeResult.dwRoundTripTime<<"ms"<<flush;
            else
                cout<<" "<<"<1ms"<<flush;
        }
        return true;
    }
    int main()
    {
    //初始化 Windows sockets 网络环境
        WSADATA wsa;
        WSAStartup(MAKEWORD(2,2),&wsa);
        char IpAddress[255];
        cout<<"请输入一个 IP 地址或域名:";
        cin>>IpAddress;
    //得到 IP 地址
        u_long ulDestIP=inet_addr(IpAddress);
    //转换不成功时按域名解析
        if(ulDestIP==INADDR_NONE)
        {
            hostent * pHostent=gethostbyname(IpAddress);
            if(pHostent)
            {
                ulDestIP=(*(in_addr*)pHostent->h_addr).s_addr;
            }
            else
            {
                cout<<"输入的 IP 地址或域名无效!"<<endl;
                WSACleanup();
                return 0;
            }
        }
        cout<<"Tracing route to "<<IpAddress<<" with a maximum of 30 hops.\n"<<endl;
    //填充目地端 socket 地址
        sockaddr_in destSockAddr;
        ZeroMemory(&destSockAddr,sizeof(sockaddr_in));
        destSockAddr.sin_family=AF_INET; //地址族 使用 IPv4 进行通信
        destSockAddr.sin_addr.s_addr=ulDestIP; // 32位的IP地址
    //创建原始套接字 详细说明:https://www.cnblogs.com/hgwang/p/6118634.html
        SOCKET sockRaw=WSASocket(AF_INET,SOCK_RAW,IPPROTO_ICMP,NULL,0,
                                 WSA_FLAG_OVERLAPPED); //SOCK_RAW表示原始套接字,即不是TCP也不是UDP
    //超时时间
        int iTimeout=3000;
    //接收超时 (用于任意类型、任意状态套接口的设置选项值)
        setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char *)&iTimeout,sizeof(iTimeout));
    //发送超时
        setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char *)&iTimeout,sizeof(iTimeout));
    //构造 ICMP 回显请求消息,并以 TTL 递增的顺序发送报文
    //ICMP 类型字段
        const BYTE ICMP_ECHO_REQUEST=8; //请求回显
        const BYTE ICMP_ECHO_REPLY=0; //回显应答
        const BYTE ICMP_TIMEOUT=11; //传输超时
    //其他常量定义
        const int DEF_ICMP_DATA_SIZE=32; //ICMP 报文默认数据字段长度
        const int MAX_ICMP_PACKET_SIZE=1024;//ICMP 报文最大长度(包括报头)
        const DWORD DEF_ICMP_TIMEOUT=3000; //回显应答超时时间
        const int DEF_MAX_HOP=30; //最大跳站数
    //填充 ICMP 报文中每次发送时不变的字段
        char IcmpSendBuf[sizeof(ICMP_HEADER)+DEF_ICMP_DATA_SIZE];//发送缓冲区
        memset(IcmpSendBuf, 0, sizeof(IcmpSendBuf)); //初始化发送缓冲区
        char IcmpRecvBuf[MAX_ICMP_PACKET_SIZE]; //接收缓冲区
        memset(IcmpRecvBuf, 0, sizeof(IcmpRecvBuf)); //初始化接收缓冲区
        ICMP_HEADER * pIcmpHeader=(ICMP_HEADER*)IcmpSendBuf;
        pIcmpHeader->type=ICMP_ECHO_REQUEST; //类型为请求回显
        pIcmpHeader->code=0; //代码字段为 0
        pIcmpHeader->id=(USHORT)GetCurrentProcessId(); //ID 字段为当前进程号
        memset(IcmpSendBuf+sizeof(ICMP_HEADER),'E',DEF_ICMP_DATA_SIZE);//数据字段
        USHORT usSeqNo=0; //ICMP 报文序列号
        int iTTL=1; //TTL 初始值为 1
        BOOL bReachDestHost=FALSE; //循环退出标志
        int iMaxHot=DEF_MAX_HOP; //循环的最大次数
        DECODE_RESULT DecodeResult; //传递给报文解码函数的结构化参数
        while(!bReachDestHost&&iMaxHot--)
        {
    //设置 IP 报头的 TTL 字段
            setsockopt(sockRaw,IPPROTO_IP,IP_TTL,(char *)&iTTL,sizeof(iTTL));
            cout<<iTTL<<flush; //输出当前序号
    //填充 ICMP 报文中每次发送变化的字段
            ((ICMP_HEADER *)IcmpSendBuf)->cksum=0; //校验和先置为 0
            ((ICMP_HEADER *)IcmpSendBuf)->seq=htons(usSeqNo++); //填充序列号
            ((ICMP_HEADER *)IcmpSendBuf)->cksum=checksum((USHORT *)IcmpSendBuf,
                                                sizeof(ICMP_HEADER)+DEF_ICMP_DATA_SIZE); //计算校验和
    //记录序列号和当前时间
            DecodeResult.usSeqNo=((ICMP_HEADER*)IcmpSendBuf)->seq; //当前序号
            DecodeResult.dwRoundTripTime=GetTickCount(); //当前时间
    //发送 TCP 回显请求信息
            sendto(sockRaw,IcmpSendBuf,sizeof(IcmpSendBuf),0,(sockaddr*)&destSockAddr,sizeof(destSockAddr));
    //接收 ICMP 差错报文并进行解析处理
            sockaddr_in from; //对端 socket 地址
            int iFromLen=sizeof(from); //地址结构大小
            int iReadDataLen; //接收数据长度
            while(1)
            {
    //接收数据
                iReadDataLen=recvfrom(sockRaw,IcmpRecvBuf,MAX_ICMP_PACKET_SIZE,0,(sockaddr*)&from,&iFromLen);
                if(iReadDataLen!=SOCKET_ERROR)//有数据到达
                {
    //对数据包进行解码
                    if(DecodeIcmpResponse(IcmpRecvBuf,iReadDataLen,DecodeResult,ICMP_ECHO_REPLY,ICMP_TIMEOUT))
                    {
    //到达目的地,退出循环
                        if(DecodeResult.dwIPaddr.s_addr==destSockAddr.sin_addr.s_addr)
                            bReachDestHost=true;
    //输出 IP 地址
                        cout<<'\t'<<inet_ntoa(DecodeResult.dwIPaddr)<<endl;
                        break;
                    }
                }
                else if(WSAGetLastError()==WSAETIMEDOUT) //接收超时,输出*号
                {
                    cout<<" *"<<'\t'<<"Request timed out."<<endl;
                    break;
                }
                else
                {
                    break;
                }
            }
            iTTL++; //递增 TTL 值
        }
        return 0;
    }
    
    

    Ping源码

    /******************************************************************************\
    * ping.c - Simple ping utility using SOCK_RAW
    *
    * This is a part of the Microsoft Source Code Samples.
    * Copyright 1996-1997 Microsoft Corporation.
    * All rights reserved.
    * This source code is only intended as a supplement to
    * Microsoft Development Tools and/or WinHelp documentation.
    * See these sources for detailed information regarding the
    * Microsoft samples programs.
    \******************************************************************************/
    
    #define WIN32_LEAN_AND_MEAN
    #include <winsock2.h>
    #include <stdio.h>
    #include <stdlib.h>
    #pragma comment(lib,"ws2_32.lib")
    
    #define ICMP_ECHO 8
    #define ICMP_ECHOREPLY 0
    
    #define ICMP_MIN 8                                           // minimum 8 byte icmp packet (just header)
    
    /* The IP header */
    typedef struct iphdr
    {
        unsigned int h_len:4; // length of the header
        unsigned int version:4; // Version of IP
        unsigned char tos; // Type of service
        unsigned short total_len; // total length of the packet
        unsigned short ident; // unique identifier
        unsigned short frag_and_flags; // flags
        unsigned char ttl;
        unsigned char proto; // protocol (TCP, UDP etc)
        unsigned short checksum; // IP checksum
        unsigned int sourceIP;
        unsigned int destIP;
    } IpHeader;
    
    //
    // ICMP header
    //
    typedef struct _ihdr
    {
        BYTE i_type;     //消息类型
        BYTE i_code;     //代码  /* type sub code */
        USHORT i_cksum;  //校验和
        USHORT i_id;     //ID号
        USHORT i_seq;    //序列号
        ULONG timestamp; //时间戳  /* This is not the std header, but we reserve space for time */
    } IcmpHeader;        //ICMP报文  包括报头和数据
    
    #define STATUS_FAILED 0xFFFF
    #define DEF_PACKET_SIZE 32
    #define MAX_PACKET 1024
    
    #define xmalloc(s) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(s))
    #define xfree(p) HeapFree (GetProcessHeap(),0,(p))
    
    void fill_icmp_data(char *, int);
    USHORT checksum(USHORT *, int);
    void decode_resp(char *,int,struct sockaddr_in *);
    
    int main(int argc, char **argv)
    {
        WSADATA wsaData;
        SOCKET sockRaw;
        struct sockaddr_in dest;
        struct hostent * hp;
        int bread,datasize;
        int timeout = 1000;
        char *dest_ip;
        char *icmp_data;
        char *recvbuf;
        unsigned int addr=0;
        USHORT seq_no = 0;
        struct sockaddr_in from;
        int fromlen = sizeof(from);
    
        if (WSAStartup(MAKEWORD(2,1),&wsaData) != 0)
        {
            fprintf(stderr,"WSAStartup failed: %d\n",GetLastError());
            ExitProcess(STATUS_FAILED);
        }
    
        /*
        为了使用发送接收超时设置(即设置SO_RCVTIMEO, SO_SNDTIMEO),
        //    必须将标志位设为WSA_FLAG_OVERLAPPED !
        */
        sockRaw = WSASocket (AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,WSA_FLAG_OVERLAPPED);                    //建立一个原始套接字
        //sockRaw = WSASocket (AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,0);
    
        if (sockRaw == INVALID_SOCKET)
        {
            fprintf(stderr,"WSASocket() failed: %d\n",WSAGetLastError());
            ExitProcess(STATUS_FAILED);
        }
    
        timeout = 1000;   //设置接收超时时间
        bread = setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char*)&timeout, sizeof(timeout)); //RECVTIMEO是接收超时时间
        if(bread == SOCKET_ERROR)
        {
            fprintf(stderr,"failed to set recv timeout: %d\n",WSAGetLastError());
            ExitProcess(STATUS_FAILED);
        }
    
        timeout = 1000;   //设置发送超时时间
        bread = setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char*)&timeout, sizeof(timeout)); //SNDTIMEO是发送超时时间
        if(bread == SOCKET_ERROR)
        {
            fprintf(stderr,"failed to set send timeout: %d\n",WSAGetLastError());
            ExitProcess(STATUS_FAILED);
        }
        memset(&dest,0,sizeof(dest));            //目标地址清零
    
        hp = gethostbyname("www.baidu.com");      //通过域名或者主机名获取IP地址
        if (!hp)  //失败返回NULL
        {
            ExitProcess(STATUS_FAILED);
        }
        else
        {
            addr = inet_addr("14.215.177.37");    //www.baidu.com的ip地址
        }
    
        if ((!hp) && (addr == INADDR_NONE))        //既不是域名也不是点分十进制的IP地址
        {
            ExitProcess(STATUS_FAILED);
        }
    
        if (hp != NULL)                           //获取的是域名
            memcpy(&(dest.sin_addr),hp->h_addr,hp->h_length);   //从hostent得到的对方ip地址
        else
            dest.sin_addr.s_addr = addr;
    
        if (hp)
            dest.sin_family = hp->h_addrtype;    //sin_family不是一定只能填AF_INET吗?
        else
            dest.sin_family = AF_INET;
    
            addr = inet_addr("39.101.201.13");
        dest.sin_addr.s_addr = addr;
            //addr = inet_addr("14.215.177.37");
    
        dest_ip = inet_ntoa(dest.sin_addr);        //目标IP地址
    
        datasize = DEF_PACKET_SIZE;             //ICMP包数据大小设定为32
    
        datasize += sizeof(IcmpHeader);         //另外加上ICMP包的包头 其实包头占12个字节
    
        icmp_data = (char *)xmalloc(MAX_PACKET);//发送icmp_data数据包内存
        recvbuf = (char *)xmalloc(MAX_PACKET);  //存放接收到的数据
    
        if (!icmp_data)                         //分配内存
        {
            ExitProcess(STATUS_FAILED);
        }
    
        memset(icmp_data,0,MAX_PACKET);
        fill_icmp_data(icmp_data,datasize);         //只填充了ICMP包
    
        fprintf(stdout,"\nPinging %s ....\n\n",dest_ip);
    
        while(1)
        {
            int bwrote;
    
            ((IcmpHeader*)icmp_data)->i_cksum = 0;
            ((IcmpHeader*)icmp_data)->timestamp = GetTickCount(); //时间戳
    
            ((IcmpHeader*)icmp_data)->i_seq = seq_no++;           //ICMP的序列号
            ((IcmpHeader*)icmp_data)->i_cksum = checksum((USHORT*)icmp_data, datasize);   //icmp校验位
    
            //下面这个函数的问题是 发送数据只是ICMP数据包,而接收到的数据时包含ip头的 也就是发送和接收不对等
            //问题是sockRaw 设定了协议为 IPPROTO_ICMP
            bwrote = sendto(sockRaw,icmp_data,datasize,0,(struct sockaddr*)&dest, sizeof(dest));
            if (bwrote == SOCKET_ERROR)
            {
                if (WSAGetLastError() == WSAETIMEDOUT)     //发送时间超时
                {
                    printf("timed out\n");
                    continue;
                }
    
                fprintf(stderr,"sendto failed: %d\n",WSAGetLastError());
                ExitProcess(STATUS_FAILED);
            }
    
            if (bwrote < datasize )
            {
                fprintf(stdout,"Wrote %d bytes\n",bwrote);
            }
    
            bread = recvfrom(sockRaw,recvbuf,MAX_PACKET,0,(struct sockaddr*)&from, &fromlen);
            if (bread == SOCKET_ERROR)
            {
                if (WSAGetLastError() == WSAETIMEDOUT)
                {
                    printf("timed out\n");
                    continue;
                }
                fprintf(stderr,"recvfrom failed: %d\n",WSAGetLastError());
                ExitProcess(STATUS_FAILED);
            }
            decode_resp(recvbuf,bread,&from);
    
            Sleep(1000);
        }
    
        WSACleanup();
        system("pause");
    
        return 0;
    }
    
    /*
    The response is an IP packet. We must decode the IP header to locate
    the ICMP data
    */
    void decode_resp(char *buf, int bytes,struct sockaddr_in *from)
    {
        IpHeader *iphdr;
        IcmpHeader *icmphdr;
        unsigned short iphdrlen;
    
        iphdr = (IpHeader *)buf;      //接收到的数据就是原始的IP数据报
    
        iphdrlen = iphdr->h_len * 4 ; // number of 32-bit words *4 = bytes
    
        if (bytes < iphdrlen + ICMP_MIN)
        {
            printf("Too few bytes from %s\n",inet_ntoa(from->sin_addr));
        }
    
        icmphdr = (IcmpHeader*)(buf + iphdrlen);
    
        if(icmphdr->i_type == 3)
        {
            printf("network unreachable -- Response from %s.\n",inet_ntoa(from->sin_addr));
            return ;
        }
    
        if (icmphdr->i_id != (USHORT)GetCurrentProcessId())
        {
            fprintf(stderr,"someone else's packet!\n");
            return ;
        }
        printf("%d bytes from %s:",bytes, inet_ntoa(from->sin_addr));
        printf(" icmp_seq = %d ",icmphdr->i_seq);
        printf(" time: %d ms ",GetTickCount()-icmphdr->timestamp);
        printf(" ttl: %d",iphdr->ttl);
        printf("\n");
    }
    
    //完成ICMP的校验
    USHORT checksum(USHORT *buffer, int size)
    {
        unsigned long cksum=0;
    
        while(size >1)
        {
            cksum+=*buffer++;
            size -=sizeof(USHORT);
        }
    
        if(size )
        {
            cksum += *(UCHAR*)buffer;
        }
    
        cksum = (cksum >> 16) + (cksum & 0xffff);
        cksum += (cksum >>16);
        return (USHORT)(~cksum);
    }
    
    /*
    Helper function to fill in various stuff in our ICMP request.
    */
    void fill_icmp_data(char * icmp_data, int datasize)
    {
    
        IcmpHeader *icmp_hdr;
        char *datapart;
    
        icmp_hdr = (IcmpHeader*)icmp_data;
    
        icmp_hdr->i_type = ICMP_ECHO;                   //ICMP_ECHO要求收到包的主机回复此ICMP包
        icmp_hdr->i_code = 0;
        icmp_hdr->i_id = (USHORT)GetCurrentProcessId(); //id填当前进程的id
        icmp_hdr->i_cksum = 0;
        icmp_hdr->i_seq = 0;
    
        datapart = icmp_data + sizeof(IcmpHeader);
        //
        // Place some junk in the buffer.
        //
        memset(datapart,'E', datasize - sizeof(IcmpHeader));  //填充了一些废物
    }
    
    
    展开全文
  • ping程序设计.zip

    2022-03-03 01:32:46
    ping程序设计.zip
  • ping程序设计.pdf

    2021-10-31 22:29:11
    ping程序设计.pdf
  • Ping程序设计(c语言课程设计).pdf
  • 计算机网络——Tracert与Ping程序设计与实现一、实验目的二、总体设计1. 基本原理2. 设计步骤三、详细设计1. 程序流程图2. 实验代码四、实验结果 一、实验目的 了解Tracert程序的实现原理,并调试通过。 二、总体...

    一、实验目的

    了解Tracert程序的实现原理,并调试通过。

    二、总体设计

    1. 基本原理

    tracert(跟踪路由)是路由跟踪实用程序,用于确定IP数据包访问目标所采取的路径。tracert 有一个固定的时间等待响应(ICMP TTL到期消息)。如果这个时间过了,它将打印出一系列的*号表明:在这个路径上,这个设备不能在给定的时间内发出ICMP TTL到期消息的响应。然后,Tracert给TTL记数器加1,继续进行。

    2. 设计步骤

    (1)加载套接字,创建套接字库;
    使用Socket的程序在使用Socket之前必须调用WSAStartup函数,以后应用程序就可以调用所请求的Socket库中的其他Socket函数了。
    (2)用inet_addr()将输入的点分十进制的IP地址转换为无符号长整型数,转换不成功时,按域名解析得到IP地址;
    gethostbyname()是查找主机名最基本的函数,如果调用成功,就返回一个指向hosten结构的指针,该结构中含有对应于给定主机名的主机名字和地址信息,用来承接域名解析的结构。
    (3)设置发送接收超时时间,即请求超时,设置接收、发送超时的套接字;
    (4)构造ICMP回显请求消息,并以TTL递增顺序发送报文,填充ICMP报文中每次发送时不变的字段,构造ICMP头;
    (5)设置IP报头的TTL字段,填充ICMP报文中每次发送变化的字段,记录序列号和当前时间;
    (6)指定对方信息,发送TCP回显请求信息;
    sendto()函数利用数据表的方式进行数据传输,指定哪个socket发送给对方
    (7)接收ICMP差错报文并进行解析:如果有数据到达,解析数据包,如果到达目的地址,输出IP地址;如果没有数据到达,输出接收超时,递增TTL值,TTL增为最大时,若还没有到达目的地址,退出循环,输出目的地址不在线;
    recvform()利用数据报方式进行数据传输,当recvfrom()返回时,(sockaddr*)&from包含实际存入from中的数据字节数。Recvfrom函数返回接收到的字节数或当出现错误时返回-1,并置相应的errno。
    (8)重复(2)-(7),实现查找一个范围内的IP地址。

    三、详细设计

    1. 程序流程图

    在这里插入图片描述

    2. 实验代码

    #include <iostream>
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #include <stdlib.h>
    #include <sstream>
    using namespace std;
    #pragma comment(lib, "Ws2_32.lib")
    const int ipAddressSize = 14;
    //int count11=0;
    //IP 报头
    typedef struct
    {
        unsigned char hdr_len : 4; //4 位头部长度
        unsigned char version : 4; //4 位版本号
        unsigned char tos; //8 位服务类型
        unsigned short total_len; //16 位总长度: 和头部长度一起就能区分 头 主体数据了
        unsigned short identifier; //16 位标识符: 作用是分片后的重组
        unsigned short frag_and_flags; //3 位标志加 13 位片偏移: 标志:MF 1是否还有分配 0 没有分片了
        //                         DF 0 可以分片
        // 片偏移:分片后的相对于原来的偏移
        unsigned char ttl; //8 位生存时间
        unsigned char protocol; //8 位上层协议号: 指出是何种协议
        unsigned short checksum; //16 位校验和: 检验是否出错
        unsigned long sourceIP; //32 位源 IP 地址
        unsigned long destIP; //32 位目的 IP 地址
    } IP_HEADER;
    //ICMP 报头,一共八个字节,前四个字节为:类型(1字节)、代码(1字节)和检验和(2字节)。后四个字节取决于类型
    typedef struct
    {
        BYTE type; //8 位类型字段:标识ICMP的作用
        BYTE code; //8 位代码字段
        USHORT cksum; //16 位校验和
        USHORT id; //16 位标识符
        USHORT seq; //16 位序列号
    } ICMP_HEADER;
    
    //报文解码结构
    //接收到的数据缓存是字符数组char bufRev[],因此需要通过特定的解析(也就是拆成一段一段的)获取想要的信息
    //把信息封装到结构体中,就比较方便的得到序列号、往返时间和目的IP了。
    typedef struct
    {
        USHORT usSeqNo; //序列号
        DWORD dwRoundTripTime; //往返时间
        in_addr dwIPaddr; //返回报文的 IP 地址
    } DECODE_RESULT;
    //计算网际校验和函数
    USHORT checksum(USHORT *pBuf, int iSize)
    {
        unsigned long cksum = 0;
        while (iSize > 1)
        {
            cksum += *pBuf++;
            iSize -= sizeof(USHORT);
        }
        if (iSize)
        {
            cksum += *(UCHAR *)pBuf;
        }
        cksum = (cksum >> 16) + (cksum & 0xffff);
        cksum += (cksum >> 16);
        return (USHORT)(~cksum);
    }
    //对数据包进行解码
    // 1)接收到的Buf 2)接收到的数据长度 3)解析结果封装到Decode 4)ICMP回显类型 5)TIMEOUT时间
    BOOL DecodeIcmpResponse2(char * pBuf, int iPacketSize, DECODE_RESULT &DecodeResult, BYTE
                             ICMP_ECHO_REPLY, BYTE ICMP_TIMEOUT)
    {
        //查找数据报大小合法性
        //pBuf的首地址,就是IP报的首地址
        IP_HEADER *pIpHdr = (IP_HEADER*)pBuf;
        int iIpHdrLen = pIpHdr->hdr_len * 4;
        if(iPacketSize < (int)(iIpHdrLen + sizeof(ICMP_HEADER)))
            return FALSE;
        // 根据 ICMP 报文类型提取 ID 字段和序列号字段
        //ICMP字段包含在 IP数据段的起始位置,因此扣掉IP头,得到的就是ICMP头
        ICMP_HEADER *pIcmpHdr = (ICMP_HEADER *)(pBuf + iIpHdrLen);
    
        USHORT usID, usSquNo;
        if (pIcmpHdr->type == ICMP_ECHO_REPLY) // ICMP 回显应答报文
        {
            usID = pIcmpHdr->id;//报文 ID
            usSquNo = pIcmpHdr->seq;//报文序列号
        }
        else if (pIcmpHdr->type == ICMP_TIMEOUT)//ICMP超时差错报文
        {
            // 如果是TIMEOUT ,那么在ICMP数据包中,会夹带一个IP报(荷载IP)
            char * pInnerIpHdr = pBuf + iIpHdrLen + sizeof(ICMP_HEADER); // 荷载中的 IP 的头
            int iInnerIPHdrLen = ((IP_HEADER*)pInnerIpHdr)->hdr_len * 4;// 荷载中的IP 头长度
            ICMP_HEADER * pInnerIcmpHdr = (ICMP_HEADER*)(pInnerIpHdr + iInnerIPHdrLen); //荷载中的ICMP头
            usID = pInnerIcmpHdr->id;// 报文ID
            usSquNo = pInnerIcmpHdr->seq; // 序列号
        }
        else
        {
            return false;
        }
    
        // 检查 ID 和序列号以确定收到期待数据报
        if (usID != (USHORT)GetCurrentProcessId() || usSquNo != DecodeResult.usSeqNo)
        {
            return false;
        }
        // 记录 IP 地址并计算往返时间
        DecodeResult.dwIPaddr.S_un.S_addr = pIpHdr->sourceIP;
        DecodeResult.dwRoundTripTime = GetTickCount() - DecodeResult.dwRoundTripTime;
        //处理正确收到的 ICMP 数据包
        if (pIcmpHdr->type == ICMP_ECHO_REPLY || pIcmpHdr->type == ICMP_TIMEOUT)
        {
            // 输出往返时间信息
            if (DecodeResult.dwRoundTripTime)
                cout << " " << DecodeResult.dwRoundTripTime << "ms" << flush;
            else
                cout << " " << "<1ms" << flush;
        }
        return true;
    }
    
    
    char * findNextIp(char * nowIp);
    
    int main()
    {
        //初始化 Windows sockets 网络环境
        WSADATA wsa;//存储被WSAStartup函数调用后返回的Windows Sockets数据
        //使用Socket的程序在使用Socket之前必须调用WSAStartup函数,以后应用程序就可以调用所请求的Socket库中的其他Socket函数了
        WSAStartup(MAKEWORD(2, 2), &wsa);//进行相应的socket库绑定
        cout << "请输入你要查找的起始IP:" << endl;
        char IpAddressBeg[ipAddressSize]; // 255.255.255.255
        cin >> IpAddressBeg;
        cout << "请输入你要查找的终止IP:" << endl;
        char IpAddressEnd[ipAddressSize]; // 255.255.255.255
        cin >> IpAddressEnd;
        char nextIpAddress[17];
        strcpy(nextIpAddress, IpAddressBeg);
        while (strcmp(nextIpAddress, IpAddressEnd) != 0)
        {
            // 执行,单线程执行,实现后改成多线程
            //得到IP地址
            u_long ulDestIP = inet_addr(nextIpAddress);//inet_addr()的功能是将一个点分十进制的IP转换成一个无符号长整型数
            //转换不成功时按域名解析
            if (ulDestIP == INADDR_NONE)
            {
                //gethostbyname()是查找主机名最基本的函数
                //如果调用成功,就返回一个指向hosten结构的指针
                //该结构中含有对应于给定主机名的主机名字和地址信息,用来承接域名解析的结构
                hostent * pHostent = gethostbyname(nextIpAddress);
                if (pHostent)//调用成功
                {
                    //得到IP地址
                    //套了两层,IP和ICMP,ICMP是套在IP里面的
                    //h_addr返回主机IP地址
                    //in_addr返回报文的IP地址
                    //sin_addr.s_addr指向IP地址
                    ulDestIP = (*(in_addr*)pHostent->h_addr).s_addr;
                }
                else
                {
                    cout << "输入的 IP 地址或域名无效!" << endl;
                    WSACleanup();//解除与Socket库的绑定并且释放Socket库所占用的系统资源
                    return 0;
                }
            }
            // 填充目的 sockaddr_in
            sockaddr_in destSockAddr;//sockaddr_in是Internet环境下套接字的地址形式
            //将指定的内存块清零,使用结构前清零,而不让结构体的成员数值具有不确定性,是一个好的编程习惯
            ZeroMemory(&destSockAddr, sizeof(sockaddr_in));
            destSockAddr.sin_family = AF_INET;//指代协议簇,在socket编程中只能是AF_INET
            destSockAddr.sin_addr.S_un.S_addr = ulDestIP;//按照网络字节顺序存储IP地址
            //创建原始套接字
            //WSASocket()的发送操作和接收操作都可以被重叠使用。接收函数可以被多次调用,发出接收缓冲区,准备接收到来的数据。发送函数也可以被多次调用,组成一个发送缓冲区队列
            //如无错误发生,返回新套接口的描述字,否则的话,返回INVALID_SOCKET
            //AF_INET为地址簇描述,SOCK_RAW为新套接口的类型描述,SOCK_RAW为原始套接字,可处理PING报文等
            //IPPROTO_ICMP为套接口使用的协议,为ICMP;NULL是一个指向PROTOCOL_INFO结构的指针,该结构定义所创建套接口的特性
            //0为套接口的描述字;WSA_FLAG_OVERLAPPED为套接口属性描述,WSA_FLAG_OVERLAPPED表示要使用重叠模型
            SOCKET sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,
                                       WSA_FLAG_OVERLAPPED);
            // 设置发送接收超时时间,即请求超时
            //比如请求B站的一个视频,他超过一个时间没回我,我就认为超时了
            //超时时间是可能变化的,这个超时时间用来存储在不同的变量,它刚好在一个变量而已
            int iTimeout = 500;//如果没超过超时时间就会一直等着,超过超时时间就不等了
            //接收超时
            //sockRaw为将要被设置或者获取选项的套接字;SOL_SOCKET为在套接字级别上设置选项;SO_RCVTIMEO设置接收超时时间
            //(char*)&iTimeout指向存放选项值的缓冲区;sizeof(iTimeout)为缓冲区的长度
            setsockopt(sockRaw, SOL_SOCKET, SO_RCVTIMEO, (char *)&iTimeout, sizeof(iTimeout));
            //发送超时
            //sockRaw为将要被设置或者获取选项的套接字;SOL_SOCKET为在套接字级别上设置选项;SO_SNDTIMEO设置发送超时时间
            //(char*)&iTimeout指向存放选项值的缓冲区;sizeof(iTimeout)为缓冲区的长度
            setsockopt(sockRaw, SOL_SOCKET, SO_SNDTIMEO, (char *)&iTimeout, sizeof(iTimeout));
            // 构造 ICMP 回显请求消息, 并以TTL 递增顺序发送报文
            // ICMP 类型字段
            //采用const修饰变量,功能是对变量声明为只读特性,并保护变量值以防被修改
            const BYTE ICMP_ECHO_REQUEST = 8;//请求回显
            const BYTE ICMP_ECHO_REPLY = 0;//回显应答
            //其他常量定义
            const int DEF_ICMP_DATA_SIZE = 32; // ICMP 报文默认数据字段长度
            const int MAX_ICMP_PACKET_SIZE = 1024;//ICMP 报文最大长度(加上报头)
            const DWORD DEF_ICMP_TIMEOUT = 500;// 回显应答超时时间
            const int DEF_MAX_HOP = 20; // 最大跳站数
            // 填充 ICMP 报文中每次发送时不变的字段
            char IcmpSendBuf[sizeof(ICMP_HEADER) + DEF_ICMP_DATA_SIZE];// 发送缓冲区
            memset(IcmpSendBuf, 0, sizeof(IcmpSendBuf));//初始化发送缓冲区
            char IcmpRecvBuf[MAX_ICMP_PACKET_SIZE]; // 接收缓冲区
            memset(IcmpRecvBuf, 0, sizeof(IcmpRecvBuf)); //初始化接收缓冲区
            // 构造ICMP头
            ICMP_HEADER * pIcmpHeader = (ICMP_HEADER*)IcmpSendBuf;
            pIcmpHeader->type = ICMP_ECHO_REQUEST; // 类型为请求回显
            pIcmpHeader->code = 0;//代码字段为0
            pIcmpHeader->id = (USHORT)GetCurrentProcessId();// ID字段为当前进程号
            memset(IcmpSendBuf + sizeof(ICMP_HEADER), 'E', DEF_ICMP_DATA_SIZE);//数据字段
            USHORT usSeqNo = 0; // ICMP 报文序列号
            int iTTL = 1; // TTL初始化值为1
            BOOL bReachDestHost = FALSE; // 循环退出标志
            int iMaxHot = DEF_MAX_HOP; // 最大循环数
            DECODE_RESULT DecodeResult;// 传递给报文解码函数的结构化参数
            //int count11=0;
            while (!bReachDestHost && iMaxHot--)
            {
                bReachDestHost = FALSE;
                // 设置 IP 报头的 TTL 字段
                //sockRaw为将要被设置或者获取选项的套接字;IPPROTO_IP为套接口使用的协议,为IP;IP_TTL为设置IP报头的TTL字段
                //(char*)&iTTL指向存放选项值的缓冲区;sizeof(iTTL)为缓冲区的长度
                setsockopt(sockRaw, IPPROTO_IP, IP_TTL, (char *)&iTTL, sizeof(iTTL));
                cout << iTTL << flush; // 输出当前序号,flush的作用是刷新缓冲区
                // 填充 ICMP报文中每次发送变化的字段
                ((ICMP_HEADER *)IcmpSendBuf)->cksum = 0;//校验和为0
                ((ICMP_HEADER *)IcmpSendBuf)->seq = htons(usSeqNo++);// 填充序列号
                ((ICMP_HEADER *)IcmpSendBuf)->cksum = checksum((USHORT *)IcmpSendBuf,
                                                      sizeof(ICMP_HEADER) + DEF_ICMP_DATA_SIZE); //计算校验和
    
                // 记录序列号和当前时间
                DecodeResult.usSeqNo = ((ICMP_HEADER*)IcmpSendBuf)->seq;//当前序号
                DecodeResult.dwRoundTripTime = GetTickCount();// 当前时间
    
                // 指定对方信息
                // 发送 TCP 回显请求信息
                //sendto()利用数据报的方式进行数据传输
                // 1)指定哪个Socket发给对方 2)发送的数据 3)flag 4)目的地址  5)目的地址的sockaddr_in结构
                sendto(sockRaw, IcmpSendBuf, sizeof(IcmpSendBuf), 0, (sockaddr*)&destSockAddr, sizeof(destSockAddr));
    
                //接收 ICMP 差错报文并进行解析
                sockaddr_in from; // 对端 socket地址,对方的
                int iFromLen = sizeof(from);//地址结构大小
                int iReadDataLen;// 接收数据长度
    
                // 接收正常的话,这个循环只会执行一次
                while (true)
                {
                    //接收数据
                    //recvfrom()利用数据报方式进行数据传输
                    //当recvfrom()返回时,(sockaddr*)&from包含实际存入from中的数据字节数。
                    //Recvfrom()函数返回接收到的字节数或当出现错误时返回-1,并置相应的errno。
                    iReadDataLen = recvfrom(sockRaw, IcmpRecvBuf, MAX_ICMP_PACKET_SIZE, 0, (sockaddr*)&from, &
                                            iFromLen);
    
                    if (iReadDataLen != SOCKET_ERROR) // 有数据到达
                    {
                        //解析数据包
                        // 1)接收到的Buf 2)接收到的数据长度 3)解析结果封装到Decode 4)ICMP回显类型 5)TIMEOUT时间
                        if (DecodeIcmpResponse2(IcmpRecvBuf, iReadDataLen, DecodeResult, ICMP_ECHO_REPLY, DEF_ICMP_TIMEOUT))
                        {
                            // 到达目的地,退出循环
                            //返回报文的IP地址等于输入的IP地址
                            if (DecodeResult.dwIPaddr.S_un.S_addr == destSockAddr.sin_addr.S_un.S_addr)
                            {
                                bReachDestHost = true;
                                // 输出 IP 地址
                                //inet_ntoa()功能是将网络地址转换成“.”点隔的字符串格式。
                                cout << '\t' << inet_ntoa(DecodeResult.dwIPaddr) << endl;
                                strcpy(nextIpAddress, inet_ntoa(DecodeResult.dwIPaddr));
                                break;
                            }
    
                        }
    
                    }
                    //WSAGetLastError()当一特定的Sockets API函数指出一个错误已经发生,该函数就应调用来获得对应的错误代码。
                    //WSAETIMEDOUT在尝试连接超时,而不建立连接。
                    else if (WSAGetLastError() == WSAETIMEDOUT) //接收超时,输出*号
                    {
                        cout << " *" << '\t' << "Request timed out." << endl;
                        break;
                    }
                    else
                    {
                        break;
                    }
                }
                iTTL++;//递增TTL值
            }
    
            cout << "查找: " << nextIpAddress << "结果为 ->" << (bReachDestHost ? "在线" : "不在线") << endl;
            //if nextIpAddress ==bReachDestHost;
            // 向下推
            strcpy(nextIpAddress, findNextIp(nextIpAddress));
        }
        return 0;
    }
    
    char * findNextIp(char * nowIp)
    {
        char nextIpAddress[ipAddressSize];
        char z[4][4];
        int idxIp = 0, idxj = 0;
        for (int i = 0; i < strlen(nowIp); i++)
        {
            if (nowIp[i] == '.')
            {
                z[idxIp][idxj] = '\0';
    
                idxIp++;
                idxj = 0;
    
                continue;
    
            }
            z[idxIp][idxj++] = nowIp[i];
        }
        z[idxIp][idxj] = '\0';
    
        //for (int i = 0; i < 4; i++)
        //{
        //	puts(z[i]);
        //}
        //cout << endl;
    
        for (int i = 3; i >= 0; i--)
        {
            if (strcmp("254", z[i]) == 0)
            {
                strcpy(z[i], "1"); // 这里让ip 1-254
            }
            else
            {
                int x;
                x = atoi(z[i]) + 1;
                //stringstream ss;
                //ss << x;
                //string z[i] = ss.str();
                itoa(x,z[i],10); // 第三个参数是 int的进制
    
                break;
            }
        }
    
    
        char retIp[ipAddressSize];
        strcpy(retIp, z[0]);
        char c[2] = ".";
        for (int i = 1; i < 4; i++)
        {
            strcat(retIp, c);
            strcat(retIp, z[i]);
        }
        /*cout << retIp << endl;*/
    
        return retIp;
    }
    
    

    四、实验结果

    在这里插入图片描述

    展开全文
  • ping程序设计(2).pdf

    2021-10-30 17:26:19
    ping程序设计(2).pdf
  • 计算机网络实验设计-Tracert 与Ping 程序设计与实现

    千次阅读 多人点赞 2019-12-28 18:11:08
    Tracert 与Ping 程序设计与实现 二.设计内容 参照附录 2,了解 Tracert 程序的实现原理,并调试通过。然后参考 Tracert 程序和教材 4.4.2 节,编写一个 Ping 程序,并能测试本局域网的所有机器是否在线。 三.设计...
  • PING程序设计

    2013-01-10 13:09:46
    基于网络应用实现PING程序 用于简单的学习交流 头文件需要自己添加
  • ping程序设计C代码

    2012-09-20 10:29:54
    c语言写的ping程序 学习网络的好文档
  • 计算机网络实验之Ping程序设计实现分析.doc
  • 广东工业大学网络课程设计ping程序设计和实现 1.已知参数:目的节点IP地址或主机名 2.设计要求:通过原始套接字编程,实现Ping的基本功能 2.1初始化Windows Sockets网络环境; 2.2解析命令行参数,构造目的端socket...
  • 计算机网络课程设计之Tracert与Ping 程序设计与实现

    千次阅读 多人点赞 2018-12-28 15:49:45
    二、实验部分:Tracert 与 Ping 程序设计与实现 参照附录 2,了解 Tracert 程序的实现原理,并调试通过。然后参考 Tracert 程序和教材 4.4.2 节, 编写一个 Ping 程序,并能测试本局域网的所有机器是否在线 ,运行...
  • 计算机网络课设,分享给大家,基于Socket的PING程序设计,谢谢
  • 计算机网络ping程序设计 目 录 一、《计算机网络》实验教学大纲 4 1.1 学时安排 4 1.2 实验内容 4 1.3 试验要求 5 1.4 验收 5 二、实验一:PING程序设计(必做实验) 5 2.1 实验目的 5 2.2 实验内容 6 2.3 ...
  • 简单ping程序设计

    2010-10-10 11:09:24
    本程序是模仿windows的ping程序设计的,输入IP地址或域名,可以获得ICMP包到达目标主机的时延,和丢包率,以此判断通信是否良好。支持-t参数,实现无限ping。文件包含源码和可执行文件

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,879
精华内容 19,551
关键字:

ping程序设计