当前位置：文档库 › 实验六基于ICMP协议的ping程序设计实验

实验六基于ICMP协议的ping程序设计实验

一、实验目的

?分析ICMP协议报文，理解和掌握ICMP协议报文头各字段的含义和作用；

?熟悉原始套接字编程；了解网络结构与网络传输底层协议。

二、实验时数：4小时

三、实验环境

?连通的局域网络、若干PC机、Windows XP /2000等操作系统、Visual C等编

程软件等。

四、实验要求

?掌握ICMP协议报文格式和各字段含义；

?在WINDOWS环境下设计与实现基于ICMP协议的PING程序，该程序可以

用于测试网络连通性。具体要求如下：

在命令提示符下输入：

PING ***.***.***.***

其中***为目的主机的IP地址；不要求支持域名，对是否带有开关变量也

不做要求，当不带开关变量时，要求返回4次响应。

返回信息的格式：

REPL Y FROM ***.***.***.***

或

REQUEST TimeOut （无法PING通的情况）

五、实验原理

1、PING的工作原理

ping 程序是用来探测主机到主机之间是否可通信，如果不能ping到某台主机，表明不能和这台主机建立连接。ping 使用的是ICMP协议，它发送ICMP回送请求消息给目的主机。ICMP协议规定：目的主机必须返回ICMP回送应答消息给源主机。如果源主机在一定时间内收到应答，则认为主机可达。

ICMP协议通过IP协议发送的，IP协议是一种无连接的，不可靠的数据包协议。因此，保证数据送达的工作应该由其他的模块来完成。其中一个重要的模块就是ICMP(网络控制报文)协议。

当传送IP数据包发生错误，比如主机不可达，路由不可达等等，ICMP协议将会把错误信息封包，然后传送回给主机。给主机一个处理错误的机会，这也就是为什么说建立在IP层以上的协议是可能做到安全的原因。ICMP数据包由8bit的错误类型和8bit的代码和16bit的校验和组成。而前16bit就组成了ICMP所要传递的信息。

PING利用ICMP协议包来侦测另一个主机是否可达。其原理是用类型码为0的ICMP发请求，受到请求的主机则用类型码为8的ICMP回应。ping程序来计算间隔时间，并计算有多少个包被送达。用户就可以判断网络大致的情况。

2、RAW模式的SOCKET编程

PING程序是面向用户的应用程序，该程序使用ICMP的封装机制，通过IP协议来工作。为了实现直接对IP和ICMP包进行操作，实验中使用RAW模式的SOCKET 编程。

熟悉SOCKET的编程，包括基本的系统调用如SOCKET、BIND等。

3、ICMP协议

网络本身是不可靠的，在网络传输过程中，可能会发生许多突发事件并导致数据传输失败。位于网络层的IP协议是一个无连接的协议，它不会处理网络层传输中的故障，而位于网络层的ICMP协议却恰好弥补了IP的缺限，它使用IP协议进行信息传递，向数据包中的源端节点提供发生在网络层的错误信息反馈。

ICMP全称Internet Control Message Protocol，中文名为因特网控制报文协议，它的报头长8字节，结构如下图所示：

比特078 15 16比特31

ICMP提供多种类型的消息为源端节点提供网络层的故障信息反馈，它的报文类型

可以归纳为以下5个大类：

1)诊断报文（类型8，代码0；类型0，代码0）；

2)目的不可达报文（类型3，代码0-15）；

3)重定向报文（类型5，代码0-4）；

4)超时报文（类型11，代码0-1）；

5)信息报文（类型12-18）。

六、实验步骤及注意点

1)熟悉IP以及ICMP协议的工作机制；

2)熟悉RAW模式的SOCKET编程；

3)编写PING的实现程序；

4)在模拟实现环境下调试并运行自己编写的PING程序；

5)编译环境中需要包括SOCKET库WS2_32.lib。

七、实验报告要求

提交源程序，并撰写实验报告。

八、相关参考资料

1)Winsock Programmer's FAQ Examples: Ping: Raw Sockets Method，

https://www.wendangku.net/doc/a213654665.html,/wskfaq/examples/rawping.html；

2)透析ICMP协议: 协议原理，

https://www.wendangku.net/doc/a213654665.html,/view/e1e03836ee06eff9aef80722.html；

3)ping 原理与ICMP协议，

https://www.wendangku.net/doc/a213654665.html,/_ioini/blog/item/a64de1a75d34eb91d1435811.html。

九、SOCKET编程基本知识

1、SOCKET规范概述

Windows Sockets规范以U.C. Berkeley大学BSD UNIX中流行的Socket接口为范例定义了一套Micorosoft Windows下网络编程接口。它不仅包含了人们所熟悉的Berkeley Socket风格的库函数；也包含了一组针对Windows的扩展库函数，以使程序员能充分地利用Windows消息驱动机制进行编程。

Windows Sockets规范本意在于提供给应用程序开发者一套简单的API，并让各家网络软件供应商共同遵守。此外，在一个特定版本Windows的基础上，Windows Sockets也定义了一个二进制接口（ABI），以此来保证应用Windows Sockets API的应用程序能够在任何网络软件供应商的符合Windows Sockets协议的实现上工作。因此这份规范定义了应用程序开发者能够使用，并且网络软件供应商能够实现的一套库函数调用和相关语义。

遵守这套Windows Sockets规范的网络软件，我们称之为Windows Sockets兼容的，而Windows Sockets兼容实现的提供者，我们称之为Windows Sockets提供者。一

个网络软件供应商必须百分之百地实现Windows Sockets规范才能做到现Windows Sockets兼容。

任何能够与Windows Sockets兼容实现协同工作的应用程序就被认为是具有Windows Sockets接口。我们称这种应用程序为Windows Sockets应用程序。

Windows Sockets规范定义并记录了如何使用API与Internet协议族（IPS，通常我们指的是TCP/IP）连接，尤其要指出的是所有的Windows Sockets实现都支持流套接口和数据报套接口.

应用程序调用Windows Sockets的API实现相互之间的通讯。Windows Sockets又利用下层的网络通讯协议功能和操作系统调用实现实际的通讯工作。

2、WINDOWS环境下SOCKET基本函数

（1）WSAStartup函数；

int WSAStartup(WORD wVersionRequested，LPWSADATA lpWSAData);

使用Socket的程序在使用Socket之前必须调用WSAStartup函数。该函数的第一个参数指明程序请求使用的Socket版本，其中高位字节指明副版本、低位字节指明主版本；操作系统利用第二个参数返回请求的Socket的版本信息。当一个应用程序调用WSAStartup函数时，操作系统根据请求的Socket版本来搜索相应的Socket库，然后绑定找到的Socket库到该应用程序中。以后应用程序就可以调用所请求的Socket库中的其它Socket函数了。该函数执行成功后返回0。

例：假如一个程序要使用2.1版本的Socket,那么程序代码如下wVersionRequested = MAKEWORD( 2, 1 );

err = WSAStartup( wVersionRequested, &wsaData );

（2）WSACleanup函数

int WSACleanup (void);

应用程序在完成对请求的Socket库的使用后，要调用WSACleanup函数来解

除与Socket库的绑定并且释放Socket库所占用的系统资源。

（3）socket函数

SOCKET socket( int af, int type, int protocol );

应用程序调用socket函数来创建一个能够进行网络通信的套接字。第一个

参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置PF_INET;第二个参数指定要创建的套接字类型，流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM；第三个参数指定应用程序所使用的通信协议。该函数如果调用成功就返回新创建的套接字的描述符，如果失败就返回INVALID_SOCKET。套接字描述符是一个整数类型的值。每个进程的进程空间里都有一个套接字描述符表，该表中存放着套接字描述符和套接字数据结构的对应关系。该表中有一个字段存放新创建的套接字的描述符，另一个字段存放套接字数据结构的地址，因此根据套接字描述符就可以找到其对应的套接字数据结构。每个进程在自己的进程空间里都有一个套接字描述符表但是套接字数据结构都是在操作系统的内核缓冲里。下面是一个创建流套接字的例子：

struct protoent *ppe;

ppe=getprotobyname("tcp");

SOCKET ListenSocket=socket(PF_INET,SOCK_STREAM,ppe->p_proto);

（4）closesocket函数

int closesocket( SOCKET s );

closesocket函数用来关闭一个描述符为s套接字。由于每个进程中都有

一个套接字描述符表，表中的每个套接字描述符都对应了一个位于操作系统缓冲区中的套接字数据结构，因此有可能有几个套接字描述符指向同一个套接字数据结构。套接字数据结构中专门有一个字段存放该结构的被引用次数，即有多少个套接字描述符指向该结构。当调用closesocket函数时，操作系统先检查套接字数据结构中的该字段的值，如果为1，就表明只有一个套接字描述符指向它，因此操作系统就先把s在套接字描述符表中对应的那条表项清除，并且释放s对应的套接字数据结构；如果该字段大于1，那么操作系统仅仅清除s在套接字描述符表中的对应表项，并且把s对应的套接字数据结构的引用次数减1。

closesocket函数如果执行成功就返回0，否则返回SOCKET_ERROR。

（5）send函数

int send( SOCKET s, const char FAR *buf, int len, int flags );

不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。该函数的第一个参数指定发送端套接字描述符；第二个参数指明一个存放应用程序要发送数据的缓冲区；第三个参数指明实际要发送的数据的字节数；第四个参数一般置0。这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲区的长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s 的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回SOCKET_ERROR）

注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send 的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

（6）recv函数

int recv( SOCKET s, char FAR *buf, int len, int flags );

不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数

据。该函数的第一个参数指定接收端套接字描述符；第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；第三个参数指明buf的长度；第四个参数一般置0。这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数

时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据copy到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。recv函数仅仅是copy数据，真正的接收数据是协议来完成的），recv函数返回其实际copy的字节数。如果recv 在copy时出错，那么它返回SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。

注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

（7）bind函数

int bind( SOCKET s, const struct sockaddr FAR *name, int namelen );

当创建了一个Socket以后，套接字数据结构中有一个默认的IP地址和默认的端口号。一个服务程序必须调用bind函数来给其绑定一个IP地址和一个特定的端口号。客户程序一般不必调用bind函数来为其Socket绑定IP地址和断口号。该函数的第一个参数指定待绑定的Socket描述符；第二个参数指定一个sockaddr结构，该结构是这样定义的：

struct sockaddr {

u_short sa_family;

char sa_data[14];

};

sa_family指定地址族，对于TCP/IP协议族的套接字，给其置AF_INET。当对TCP/IP协议族的套接字进行绑定时，我们通常使用另一个地址结构：

struct sockaddr_in {

short sin_family;

u_short sin_port;

struct in_addr sin_addr;

char sin_zero[8];

};

其中sin_family置AF_INET；sin_port指明端口号；sin_addr结构体中只有一个唯一的字段s_addr，表示IP地址，该字段是一个整数，一般用函数inet_addr（）把字符串形式的IP地址转换成unsigned long型的整数值后再置给s_addr。有的服务器是多宿主机，至少有两个网卡，那么运行在这样的服务器上的服务程序在为其Socket绑定IP 地址时可以把htonl(INADDR_ANY)置给s_addr，这样做的好处是不论哪个网段上的客户程序都能与该服务程序通信；如果只给运行在多宿主机上的服务程序的Socket绑定一个固定的IP地址，那么就只有与该IP地址处于同一个网段上的客户程序才能与该服务程序通信。我们用0来填充sin_zero数组，目的是让sockaddr_in结构的大小与sockaddr结构的大小一致。下面是一个bind函数调用的例子：

struct sockaddr_in saddr；

saddr.sin_family = AF_INET;

saddr.sin_port = htons(8888);

saddr.sin_addr.s_addr = htonl(INADDR_ANY);

bind(ListenSocket,(struct sockaddr *)&saddr,sizeof(saddr))；

（8）listen函数

int listen( SOCKET s, int backlog );

服务程序可以调用listen函数使其流套接字s处于监听状态。处于监听状态的流套接字s将维护一个客户连接请求队列，该队列最多容纳backlog个客户连接请求。

假如该函数执行成功，则返回0；如果执行失败，则返回SOCKET_ERROR。

（9）accept函数

SOCKET accept( SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen );

服务程序调用accept函数从处于监听状态的流套接字s的客户连接请求队列中取出排在最前的一个客户请求，并且创建一个新的套接字来与客户套接字创建连接通道，如果连接成功，就返回新创建的套接字的描述符，以后与客户套接字交换数据的是新创建的套接字；如果失败就返回INVALID_SOCKET。该函数的第一个参数指定处于监听状态的流套接字；操作系统利用第二个参数来返回新创建的套接字的地址结构；操作系统利用第三个参数来返回新创建的套接字的地址结构的长度。下面是一个调用accept的例子：

struct sockaddr_in ServerSocketAddr;

int addrlen;

addrlen=sizeof(ServerSocketAddr);

ServerSocket=accept(ListenSocket,(struct sockaddr *)&ServerSocketAddr,&addrlen);

（10）connect函数

int connect( SOCKET s, const struct sockaddr FAR *name, int namelen );

客户程序调用connect函数来使客户Socket s与监听于name所指定的计算机的特定端口上的服务Socket进行连接。如果连接成功，connect返回0；如果失败则返回SOCKET_ERROR。下面是一个例子：

struct sockaddr_in daddr;

memset((void *)&daddr,0,sizeof(daddr));

daddr.sin_family=AF_INET;

daddr.sin_port=htons(8888);

daddr.sin_addr.s_addr=inet_addr("133.197.22.4");

connect(ClientSocket,(struct sockaddr *)&daddr,sizeof(daddr))；

3、RAW模式的SOCKET编程

Windows Sockets 是一个编程接口，它是在加州大学伯克利分校开发的套接字接口的基础上定义的。它包括了一组扩展件，以充分利用Microsoft Windows 消息驱动的特点。规范的1.1版是在1993 年 1 月发行的，2.2.0 版在1996 年 5 月发行。Windows 2000 支持Winsock 2.2 版。在Winsock2中，支持多个传输协议的原始套接字，重叠I/O模型、服务质量控制等。

这里介绍Windows Sockets的一些关于原始套接字(Raw Socket)的编程。同Winsock 1相比，最明显的就是支持了Raw Socket套接字类型，通过原始套接字，我们可以更加自如地控制Windows下的多种协议，而且能够对网络底层的传输机制进行控制。

（1）创建一个原始套接字，并设置IP头选项。

SOCKET sock;

sock = socket(AF_INET,SOCK_RAW,IPPROTO_IP);

或者：

s = WSASoccket(AF_INET,SOCK_RAW,IPPROTO_IP,NULL,0,WSA_FLAG_ OVERLAPPED);

这里，我们设置了SOCK_RAW标志，表示我们声明的是一个原始套接字类型。

创建原始套接字后，IP头就会包含在接收的数据中，如果我们设定IP_HDRINCL 选项，那么，就需要自己来构造IP头。

注意，如果设置IP_HDRINCL 选项，那么必须具有administrator权限，要不就必须修改注册表：

HKEY_LOCAL_MACHINESystemCurrentControlSetServicesAfdParameter

修改键：DisableRawSecurity（类型为DWORD），把值修改为1。如果没有，就添加。

BOOL blnFlag=TRUE;

setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&blnFlag, sizeof(blnFlag);

对于原始套接字在接收数据报的时候，要注意这么几点：

如果接收的数据报中协议类型和定义的原始套接字匹配，那么，接收的所有数据就拷贝到套接字中。

如果绑定了本地地址，那么只有接收数据IP头中对应的远端地址匹配，接收的数据就拷贝到套接字中。

如果定义的是外部地址，比如使用connect()，那么，只有接收数据IP头中对应的源地址匹配，接收的数据就拷贝到套接字中。

（2）构造IP头和TCP头

这里，提供IP头和TCP头的结构：

// Standard TCP flags

#define URG 0x20

#define ACK 0x10

#define PSH 0x08

#define RST 0x04

#define SYN 0x02

#define FIN 0x01

typedef struct _iphdr //定义IP首部

{

unsigned char h_lenver; //4位首部长度+4位IP版本号

unsigned char tos; //8位服务类型TOS

unsigned short total_len; //16位总长度（字节）

unsigned short ident; //16位标识

unsigned short frag_and_flags; //3位标志位

unsigned char ttl; //8位生存时间TTL

unsigned char proto; //8位协议(TCP, UDP 或其他)

unsigned short checksum; //16位IP首部校验和

unsigned int sourceIP; //32位源IP地址

unsigned int destIP; //32位目的IP地址

}IP_HEADER;

typedef struct psd_hdr //定义TCP伪首部

{

unsigned long saddr; //源地址

unsigned long daddr; //目的地址

char mbz;

char ptcl; //协议类型

unsigned short tcpl; //TCP长度

}PSD_HEADER;

typedef struct _tcphdr //定义TCP首部

{

USHORT th_sport; //16位源端口

USHORT th_dport; //16位目的端口

unsigned int th_seq; //32位序列号

unsigned int th_ack; //32位确认号

unsigned char th_lenres; //4位首部长度/6位保留字

unsigned char th_flag; //6位标志位

USHORT th_win; //16位窗口大小

USHORT th_sum; //16位校验和

USHORT th_urp; //16位紧急数据偏移量

}TCP_HEADER;

TCP伪首部并不是真正存在的，只是用于计算检验和。校验和函数：

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

}

当需要自己填充IP头部和TCP头部的时候，就同时需要自己计算他们的检验和。

（3）发送原始套接字数据报

填充这些头部稍微麻烦点，发送就相对简单多了。只需要使用sendto()就OK。

sendto(sock,(char*)&tcpHeader,sizeof(tcpHeader),0,(sockaddr*)&addr_in,sizeof(addr_ in));

（4）接收数据

和发送原始套接字数据相比，接收就比较麻烦了。因为在WIN我们不能用recv()来接收raw socket上的数据，这是因为，所有的IP包都是先递交给系统核心，然

后再传输到用户程序，当发送一个raws socket包的时候（比如syn），核心并不知道，也没有这个数据被发送或者连接建立的记录，因此，当远端主机回应的时候，系统核心就把这些包都全部丢掉，从而到不了应用程序上。所以，就不能简单地使用接收函数来接收这些数据报。要达到接收数据的目的，就必须采用嗅探，接收所有通过的数据包，然后进行筛选，留下符合我们需要的。可以再定义一个原始套接字，用来完成接收数据的任务，需要设置SIO_RCVALL，表示接收所有的数据。

十、模拟Ping程序的源代码参考（Linux环境下）

#include

#define PACKET_SIZE 4096

#define MAX_W AIT_TIME 5

#define MAX_NO_PACKETS 3

char sendpacket[PACKET_SIZE];

char recvpacket[PACKET_SIZE];

int sockfd,datalen=56;

int nsend=0,nreceived=0;

struct sockaddr_in dest_addr;

pid_t pid;

struct sockaddr_in from;

struct timeval tvrecv;

void statistics(int signo);

unsigned short cal_chksum(unsigned short *addr,int len);

int pack(int pack_no);

void send_packet(void);

void recv_packet(void);

int unpack(char *buf,int len);

void tv_sub(struct timeval *out,struct timeval *in);

void statistics(int signo)

{ printf("\n--------------------PING statistics-------------------\n");

printf("%d packets transmitted, %d received , %%%d lost\n",nsend,nreceived,

(nsend-nreceived)/nsend*100);

close(sockfd);

exit(1);

}

/*校验和算法*/

unsigned short cal_chksum(unsigned short *addr,int len)

{ int nleft=len;

int sum=0;

unsigned short *w=addr;

unsigned short answer=0;

/*把ICMP报头二进制数据以2字节为单位累加起来*/

while(nleft>1)

{ sum+=*w++;

nleft-=2;

}

/*若ICMP报头为奇数个字节，会剩下最后一字节。把最后一个字节视为一个2字节数据的高字节，这个2字节数据的低字节为0，继续累加*/

if( nleft==1)

{ *(unsigned char *)(&answer)=*(unsigned char *)w;

sum+=answer;

}

sum=(sum>>16)+(sum&0xffff);

sum+=(sum>>16);

answer=~sum;

return answer;

}

/*设置ICMP报头*/

int pack(int pack_no)

{ int i,packsize;

struct icmp *icmp;

struct timeval *tval;

icmp=(struct icmp*)sendpacket;

icmp->icmp_type=ICMP_ECHO;

icmp->icmp_code=0;

icmp->icmp_cksum=0;

icmp->icmp_seq=pack_no;

icmp->icmp_id=pid;

packsize=8+datalen;

tval= (struct timeval *)icmp->icmp_data;

gettimeofday(tval,NULL); /*记录发送时间*/

icmp->icmp_cksum=cal_chksum( (unsigned short *)icmp,packsize); /*校验算法*/ return packsize;

}

/*发送三个ICMP报文*/

void send_packet()

{ int packetsize;

while( nsend

{ nsend++;

packetsize=pack(nsend); /*设置ICMP报头*/

if( sendto(sockfd,sendpacket,packetsize,0,

(struct sockaddr *)&dest_addr,sizeof(dest_addr) <0

{ perror("sendto error");

continue;

}

sleep(1); /*每隔一秒发送一个ICMP报文*/

}

/*接收所有ICMP报文*/

void recv_packet()

{ int n,fromlen;

extern int errno;

signal(SIGALRM,statistics);

fromlen=sizeof(from);

while( nreceived

{ alarm(MAX_W AIT_TIME);

if( (n=recvfrom(sockfd,recvpacket,sizeof(recvpacket),0,

(struct sockaddr *)&from,&fromlen)) <0)

{ if(errno==EINTR)continue;

perror("recvfrom error");

continue;

}

gettimeofday(&tvrecv,NULL); /*记录接收时间*/

if(unpack(recvpacket,n)==-1)continue;

nreceived++;

}

/*剥去ICMP报头*/

int unpack(char *buf,int len)

{ int i,iphdrlen;

struct ip *ip;

struct icmp *icmp;

struct timeval *tvsend;

double rtt;

ip=(struct ip *)buf;

iphdrlen=ip->ip_hl<<2; /*求ip报头长度,即ip报头的长度标志乘4*/ icmp=(struct icmp *)(buf+iphdrlen); /*越过ip报头,指向ICMP报头*/ len-=iphdrlen; /*ICMP报头及ICMP数据报的总长度*/

if( len< /*小于ICMP报头长度则不合理*/

{ printf("ICMP packets\'s length is less than 8\n");

return -1;

}

/*确保所接收的是我所发的的ICMP的回应*/

if( (icmp->icmp_type==ICMP_ECHOREPL Y) && (icmp->icmp_id==pid) { tvsend=(struct timeval *)icmp->icmp_data;

tv_sub(&tvrecv,tvsend); /*接收和发送的时间差*/

rtt=https://www.wendangku.net/doc/a213654665.html,_sec*1000+https://www.wendangku.net/doc/a213654665.html,_usec/1000; /*以毫秒为单位计算rtt*/ /*显示相关信息*/

printf("%d byte from %s: icmp_seq=%u ttl=%d rtt=%.3f ms\n",

len,

inet_ntoa(from.sin_addr),

icmp->icmp_seq,

ip->ip_ttl,

rtt);

}

else return -1;

}

main(int argc,char *argv[])

{ struct hostent *host;

struct protoent *protocol;

unsigned long inaddr=0l;

int waittime=MAX_W AIT_TIME;

int size=50*1024;

if(argc<2)

{ printf("usage:%s hostname/IP address\n",argv[0]);

exit(1);

}

if( (protocol=getprotobyname("icmp") ==NULL)

{ perror("getprotobyname");

exit(1);

}

/*生成使用ICMP的原始套接字,这种套接字只有root才能生成*/

if( (sockfd=socket(AF_INET,SOCK_RAW,protocol->p_proto) <0) { perror("socket error");

exit(1);

}

/* 回收root权限,设置当前用户权限*/

setuid(getuid());

/*扩大套接字接收缓冲区到50K这样做主要为了减小接收缓冲区溢出的的可能性,若无意中ping一个广播地址或多播地址,将会引来大量应答*/

setsockopt(sockfd,SOL_SOCKET,SO_RCVBUF,&size,sizeof(size) ; bzero(&dest_addr,sizeof(dest_addr));

dest_addr.sin_family=AF_INET;

/*判断是主机名还是ip地址*/

if( inaddr=inet_addr(argv[1])==INADDR_NONE)

{ if((host=gethostbyname(argv[1]) ==NULL) /*是主机名*/

{ perror("gethostbyname error");

exit(1);

}

memcpy( (char *)&dest_addr.sin_addr,host->h_addr,host->h_length);

}

else /*是ip地址*/

memcpy( (char *)&dest_addr,(char *)&inaddr,host->h_length);

/*获取main的进程id,用于设置ICMP的标志符*/

pid=getpid();

printf("PING %s(%s): %d bytes data in ICMP packets.\n",argv[1],

inet_ntoa(dest_addr.sin_addr),datalen);

send_packet(); /*发送所有ICMP报文*/

recv_packet(); /*接收所有ICMP报文*/

statistics(SIGALRM); /*进行统计*/

return 0;

}

/*两个timeval结构相减*/

void tv_sub(struct timeval *out,struct timeval *in)

{ if( (out->tv_usec-=in->tv_usec)<0) { --out->tv_sec;

out->tv_usec+=1000000;

}

out->tv_sec-=in->tv_sec;

}

实验六 基于ICMP协议的ping程序设计实验

实验六基于ICMP协议的ping程序设计实验