Ping程序设计

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

0. 设计框架

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

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

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

1. 实验须知

ICMP协议

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

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

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

2. 发送数据

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

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

1、 ICMP报文填充

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

各字段说明

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

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

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

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

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权限

运行结果

参考文献

[ 1 ] : Linux网络程序设计

前言

本实验主要是应用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));  //填充了一些废物
}

一、实验目的

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

四、实验结果