linux下ping编程

最新推荐文章于 2023-10-04 15:57:22 发布

汇聚的波浪

最新推荐文章于 2023-10-04 15:57:22 发布

阅读量492

点赞数

分类专栏：网络相关 linux

linux 同时被 2 个专栏收录

26 篇文章

订阅专栏

网络相关

23 篇文章

订阅专栏

本文深入解析了Ping命令的工作原理，从TCP/IP协议的角度出发，详细介绍了Ping如何利用ICMP报文进行主机间通信，以及如何测量往返时间等关键信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先来说说ping程序的原理吧，其实挺简单，就是一个主机系统向另外一个主机系统说：I love you(ICMP报文)，然后那个主机如果相信你或者说想和你通信，和你心知心，那它就把收到的I love you(ICMP)报文原样返回.好嘛,源主机收到这个回应后，就happy了，因为对方是和自己心连心的。如果对方没有收到这个消息，或者对你不感冒，不愿意理你，不回你这个报文，或者说些不知云是云雾是雾的话，对不起啦，感情是两个人的事情哦.

要想深刻了解，需有入目三分的实力，这个ping也一样，咱们先来看看它采用的TCP/IP协议，我刚说了，它发送的是ICMP回显请求，回答的是回显应答报文。谈起这个ICMP(Internet Control Message,网际控制报文协议)是为网关和目标主机而提供的一种差错控制机制，使它们在遇到差错时能把错误报告给报文源发方.是IP层的一个协议。但是由于差错报告在发送给报文源发方时可能也要经过若干子网，因此牵涉到路由选择等问题，所以ICMP报文需通过IP协议来发送。ICMP数据报的数据发送前需要两级封装：首先添加ICMP报头形成ICMP报文，再添加IP报头形成IP数据报。如下图所示：

IP报头

ICMP报头

ICMP数据报

由于IP层协议是一种点对点的协议，而非端对端的协议，它提供无连接的数据报服务，没有端口的概念，因此很少使用bind()和connect() 函数，若有使用也只是用于设置IP地址。发送数据使用sendto()函数，接收数据使用recvfrom()函数。

TCP/IP的经典大作《TCP/IP协议详解.卷一》清晰的告诉我，IP报头格式如下：

IP报头格式

详细的，小王那懒的人都知道翻翻上面提到的书，我也就不详细介绍了，我这里给出linux中的数据结构实现：

[cpp]view plaincopy
      
   
 <span style="font-size:18px;color:#3333ff;">struct ip  
   {  
 #if __BYTE_ORDER == __LITTLE_ENDIAN  
     unsigned int ip_hl:4;       /* header length */  
     unsigned int ip_v:4;        /* version */  
 #endif  
 #if __BYTE_ORDER == __BIG_ENDIAN  
     unsigned int ip_v:4;        /* version */  
     unsigned int ip_hl:4;       /* header length */  
 #endif  
     u_int8_t ip_tos;            /* type of service */  
     u_short ip_len;             /* total length */  
     u_short ip_id;              /* identification */  
     u_short ip_off;             /* fragment offset field */  
 #define IP_RF 0x8000            /* reserved fragment flag */  
 #define IP_DF 0x4000            /* dont fragment flag */  
 #define IP_MF 0x2000            /* more fragments flag */  
 #define IP_OFFMASK 0x1fff       /* mask for fragmenting bits */  
     u_int8_t ip_ttl;            /* time to live */  
     u_int8_t ip_p;              /* protocol */  
     u_short ip_sum;             /* checksum */  
     struct in_addr ip_src, ip_dst;  /* source and dest address */  
   };  
 </span>  

别看这多，其实ping程序用到的没几个：

(1)IP报头长度IHL（Internet Header Length）以4字节为一个单位来记录IP报头的长度，是上述IP数据结构的ip_hl变量。

(2)生存时间TTL（Time To Live）以秒为单位，指出IP数据报能在网络上停留的最长时间，其值由发送方设定，并在经过路由的每一个节点时减一，当该值为０时，数据报将被丢弃，是上述IP数据结构的ip_ttl变量。ICMP报文分为两种：查询报文和差错报文。每个ICMP报头均包含类型、编码和校验和这三项内容，其余选项则随ICMP的功能不同而不同。ICMP报文格式如下：

ICMP

Ping命令只使用众多ICMP报文中的两种："请求回送'(ICMP_ECHO)和"请求回应'(ICMP_ECHOREPLY)。在Linux中定义如下：

#define ICMP_ECHO   0 #define ICMP_ECHOREPLY  8

在Linux中ICMP数据结构(<netinet/ip_icmp.h>)定义如下：

 linux中ICMP数据结构struct icmp 
{ 
  u_int8_t  icmp_type;  /* type of message, see below */ 
  u_int8_t  icmp_code;  /* type sub code */ 
  u_int16_t icmp_cksum; /* ones complement checksum of struct */ 
  union 
  { 
    u_char ih_pptr;     /* ICMP_PARAMPROB */ 
    struct in_addr ih_gwaddr;   /* gateway address */ 
    struct ih_idseq     /* echo datagram */ 
    { 
      u_int16_t icd_id; 
      u_int16_t icd_seq; 
    } ih_idseq; 
    u_int32_t ih_void; 
 
    /* ICMP_UNREACH_NEEDFRAG -- Path MTU Discovery (RFC1191) */ 
    struct ih_pmtu 
    { 
      u_int16_t ipm_void; 
      u_int16_t ipm_nextmtu; 
    } ih_pmtu; 
 
    struct ih_rtradv 
    { 
      u_int8_t irt_num_addrs; 
      u_int8_t irt_wpa; 
      u_int16_t irt_lifetime; 
    } ih_rtradv; 
  } icmp_hun; 
#define icmp_pptr   icmp_hun.ih_pptr 
#define icmp_gwaddr icmp_hun.ih_gwaddr 
#define icmp_id     icmp_hun.ih_idseq.icd_id 
#define icmp_seq        icmp_hun.ih_idseq.icd_seq 
#define icmp_void   icmp_hun.ih_void 
#define icmp_pmvoid icmp_hun.ih_pmtu.ipm_void 
#define icmp_nextmtu    icmp_hun.ih_pmtu.ipm_nextmtu 
#define icmp_num_addrs  icmp_hun.ih_rtradv.irt_num_addrs 
#define icmp_wpa    icmp_hun.ih_rtradv.irt_wpa 
#define icmp_lifetime   icmp_hun.ih_rtradv.irt_lifetime 
  union 
  { 
    struct 
    { 
      u_int32_t its_otime; 
      u_int32_t its_rtime; 
      u_int32_t its_ttime; 
    } id_ts; 
    struct 
    { 
      struct ip idi_ip; 
      /* options and then 64 bits of data */ 
    } id_ip; 
    struct icmp_ra_addr id_radv; 
    u_int32_t   id_mask; 
    u_int8_t    id_data[1]; 
  } icmp_dun; 
#define icmp_otime  icmp_dun.id_ts.its_otime 
#define icmp_rtime  icmp_dun.id_ts.its_rtime 
#define icmp_ttime  icmp_dun.id_ts.its_ttime 
#define icmp_ip     icmp_dun.id_ip.idi_ip 
#define icmp_radv   icmp_dun.id_radv 
#define icmp_mask   icmp_dun.id_mask 
#define icmp_data   icmp_dun.id_data

Ping命令中需要显示的信息，包括icmp_seq和ttl都已有实现的办法，但还缺rtt往返时间。为了实现这一功能，可利用ICMP数据报携带一个时间戳。使用以下函数生成时间戳：

 #include  
int gettimeofday(struct timeval *tp,void *tzp) 
其中timeval结构如下： 
  struct timeval{ 
   long tv_sec; 
   long tv_usec; 
}

在发送和接收报文时由gettimeofday分别生成两个timeval结构，两者之差即为往返时间,即 ICMP报文发送与接收的时间差，而timeval结构由ICMP数据报携带,

tzp指针表示时区，一般都不使用，赋NULL值。系统自带的ping命令当它接送完所有ICMP报文后，会对所有发送和所有接收的ICMP报文进行统计，从而计算ICMP报文丢失的比率。为达此目的，定义两个全局变量：接收计数器和发送计数器，用于记录ICMP报文接受和发送数目。丢失数目=发送总数-接收总数，丢失比率=丢失数目/发送总数。现给出模拟Ping程序功能的代码如下：

 /******************************************************** 
 *  IP报头格式数据结构定义在<netinet/ip.h>中    * 
 *  ICMP数据结构定义在<netinet/ip_icmp.h>中     * 
 *  套接字地址数据结构定义在<netinet/in.h>中 * 
 ********************************************************/ 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <signal.h> 
#include <arpa/inet.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <unistd.h> 
#include <netinet/in.h> 
#include <netinet/ip.h> 
#include <netinet/ip_icmp.h> 
#include <netdb.h> 
#include <setjmp.h> 
#include <errno.h> 
 
#define PACKET_SIZE 4096 
#define MAX_WAIT_TIME   5 
#define MAX_NO_PACKETS  10000 
 
 
char *addr[]; 
char sendpacket[PACKET_SIZE]; 
char recvpacket[PACKET_SIZE]; 
int sockfd,datalen = 56; 
int nsend = 0, nreceived = 0; 
double temp_rtt[MAX_NO_PACKETS]; 
double all_time = 0; 
double min = 0; 
double max = 0; 
double avg = 0; 
double mdev = 0; 
 
struct sockaddr_in dest_addr; 
struct sockaddr_in from; 
struct timeval tvrecv; 
pid_t pid; 
 
void statistics(int sig); 
void send_packet(void); 
void recv_packet(void); 
void computer_rtt(void); 
void tv_sub(struct timeval *out,struct timeval *in); 
int pack(int pack_no); 
int unpack(char *buf,int len); 
unsigned short cal_checksum(unsigned short *addr,int len); 
 
/*计算rtt最小、大值，平均值，算术平均数差*/ 
void computer_rtt() 
{ 
    double sum_avg = 0; 
    int i; 
    min = max = temp_rtt[0]; 
    avg = all_time/nreceived; 
 
    for(i=0; i<nreceived; i++){ 
        if(temp_rtt[i] < min) 
            min = temp_rtt[i]; 
        else if(temp_rtt[i] > max) 
            max = temp_rtt[i]; 
 
        if((temp_rtt[i]-avg) < 0) 
            sum_avg += avg - temp_rtt[i]; 
        else 
            sum_avg += temp_rtt[i] - avg;  
        } 
    mdev = sum_avg/nreceived; 
} 
 
/****统计数据函数****/ 
void statistics(int sig) 
{ 
    computer_rtt();     //计算rtt 
    printf("\n------ %s ping statistics ------\n",addr[0]); 
    printf("%d packets transmitted,%d received,%d%% packet loss,time %.f ms\n", 
        nsend,nreceived,(nsend-nreceived)/nsend*100,all_time); 
    printf("rtt min/avg/max/mdev = %.3f/%.3f/%.3f/%.3f ms\n", 
        min,avg,max,mdev); 
    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 check_sum = 0; 
 
    while(nleft>1)      //ICMP包头以字（2字节）为单位累加 
    { 
        sum += *w++; 
        nleft -= 2; 
    } 
 
    if(nleft == 1)      //ICMP为奇数字节时，转换最后一个字节，继续累加 
    { 
        *(unsigned char *)(&check_sum) = *(unsigned char *)w; 
        sum += check_sum; 
    } 
    sum = (sum >> 16) + (sum & 0xFFFF); 
    sum += (sum >> 16); 
    check_sum = ~sum;   //取反得到校验和 
    return check_sum; 
} 
 
/*设置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_ECHO类型的类型号为0 
    icmp->icmp_code = 0; 
    icmp->icmp_cksum = 0; 
    icmp->icmp_seq = pack_no;   //发送的数据报编号 
    icmp->icmp_id = pid; 
 
    packsize = 8 + datalen;     //数据报大小为64字节 
    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; 
    if(nsend < MAX_NO_PACKETS) 
    { 
        nsend++; 
        packpacketsize = pack(nsend);   //设置ICMP报头 
        //发送数据报 
        if(sendto(sockfd,sendpacket,packetsize,0, 
            (struct sockaddr *)&dest_addr,sizeof(dest_addr)) < 0) 
        { 
            perror("sendto error"); 
        } 
    } 
 
} 
 
 
/****接受所有ICMP报文****/ 
void recv_packet() 
{ 
    int n,fromlen; 
    extern int error; 
    fromlen = sizeof(from); 
    if(nreceived < nsend) 
    {    
        //接收数据报 
        if((n = recvfrom(sockfd,recvpacket,sizeof(recvpacket),0, 
            (struct sockaddr *)&from,&fromlen)) < 0) 
        { 
            perror("recvfrom error"); 
        } 
        gettimeofday(&tvrecv,NULL);     //记录接收时间 
        unpack(recvpacket,n);       //剥去ICMP报头 
        nreceived++; 
    } 
} 
 
 
/******剥去ICMP报头******/ 
int unpack(char *buf,int len) 
{ 
    int i; 
    int iphdrlen;       //ip头长度 
    struct ip *ip; 
    struct icmp *icmp; 
    struct timeval *tvsend; 
    double rtt; 
 
 
    ip = (struct ip *)buf; 
    ipiphdrlen = ip->ip_hl << 2;  //求IP报文头长度，即IP报头长度乘4 
    icmp = (struct icmp *)(buf + iphdrlen); //越过IP头，指向ICMP报头 
    len -= iphdrlen;    //ICMP报头及数据报的总长度 
    if(len < 8)     //小于ICMP报头的长度则不合理 
    { 
        printf("ICMP packet\'s length is less than 8\n"); 
        return -1; 
    } 
    //确保所接收的是所发的ICMP的回应 
    if((icmp->icmp_type == ICMP_ECHOREPLY) && (icmp->icmp_id == pid)) 
    { 
        tvsend = (struct timeval *)icmp->icmp_data; 
        tv_sub(&tvrecv,tvsend); //接收和发送的时间差 
        //以毫秒为单位计算rtt 
        rtt = tvrecv.tv_sec*1000 + tvrecv.tv_usec/1000; 
        temp_rtt[nreceived] = rtt; 
        all_time += rtt;    //总时间 
        //显示相关的信息 
        printf("%d bytes from %s: icmp_seq=%u ttl=%d time=%.1f ms\n", 
                len,inet_ntoa(from.sin_addr), 
                icmp->icmp_seq,ip->ip_ttl,rtt); 
    } 
    else return -1; 
} 
 
 
//两个timeval相减 
void tv_sub(struct timeval *recvtime,struct timeval *sendtime) 
{ 
    long sec = recvtime->tv_sec - sendtime->tv_sec; 
    long usec = recvtime->tv_usec - sendtime->tv_usec; 
    if(usec >= 0){ 
        recvtime->tv_sec = sec; 
        recvtime->tv_usec = usec; 
    }else{ 
        recvtime->tv_sec = sec - 1; 
        recvtime->tv_usec = -usec; 
    } 
} 
 
/*主函数*/ 
main(int argc,char *argv[]) 
{ 
    struct hostent *host; 
    struct protoent *protocol; 
    unsigned long inaddr = 0; 
//  int waittime = MAX_WAIT_TIME; 
    int size = 50 * 1024; 
    addr[0] = argv[1]; 
    //参数小于两个 
    if(argc < 2)         
    { 
        printf("usage:%s hostname/IP address\n",argv[0]); 
        exit(1); 
    } 
    //不是ICMP协议 
    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;     //套接字域是AF_INET(网络套接字) 
 
    //判断主机名是否是IP地址 
    if(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 地址 
        dest_addr.sin_addr.s_addr = inet_addr(argv[1]); 
    } 
    pid = getpid(); 
    printf("PING %s(%s):%d bytes of data.\n",argv[1], 
            inet_ntoa(dest_addr.sin_addr),datalen); 
 
    //当按下ctrl+c时发出中断信号，并开始执行统计函数 
    signal(SIGINT,statistics);   
    while(nsend < MAX_NO_PACKETS){ 
        sleep(1);       //每隔一秒发送一个ICMP报文 
        send_packet();      //发送ICMP报文 
        recv_packet();      //接收ICMP报文 
    } 
    return 0; 
}