重写了unp 28章的ping， 通俗易懂， 新手，勿喷

madfrogme

一直在网上找ping的源代码，很不通俗易懂， 后来发现unp上28章就是，可是调试那个程序时候也是各种苦逼


于是就把书里的代码重新通俗的写了一遍，错误处理全部是用perror，和fprintf


所有代码集中到了一个文件里，也只有200行，初学，还望包涵，自己也学到了很多东西，


代码在github里， 可以加强的地方应该有很多，它只能ping一个主机，接下来的目标是fping，可以


同时ping多个主机， 不过fping里对时间的处理那一块好复杂，看晕了

编译之后要
$ sudo chown root a.out
$ sudo chmod u+s a.out
就可以创建raw socket了，而不要root权限了


git@github.com:ColdFreak/Ping.git

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <error.h>
   
4. #include <errno.h>
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <netdb.h>
   
8. #include <signal.h>
   
9. #include <strings.h> /* bzero() */
   
10. #include <string.h>
    
11. #include <arpa/inet.h> /* inet_ntop()*/
    
12. #include <netinet/ip_icmp.h> /* struct icmp */
    
13. #include <sys/time.h>
    
14. #include <netinet/in.h> /* struct sockaddr_in */
    
15. 
    
16. #define BUFSIZE        1500
    
17. 
    
18. char *host;
    
19. int sockfd;
    
20. pid_t pid;
    
21. int datalen = 56;
    
22. char sendbuf[BUFSIZE];
    
23. char h[128];
    
24. int nsent = 0;
    
25. 
    
26. struct addrinfo hints;
    
27. struct addrinfo *res;
    
28. struct sockaddr *sasend;
    
29. struct sockaddr *sarecv;
    
30. 
    
31. uint16_t in_cksum(uint16_t *addr, int len);
    
32. void sig_alrm(int signo);
    
33. void send_v4(void);
    
34. void readloop(void);
    
35. void tv_sub(struct timeval *out, struct timeval *in);
    
36. void proc_v4 (char *ptr, ssize_t len, struct msghdr *msg, struct timeval *tvrecv);
    
37. 
    
38. int main(int argc, char **argv) {
    
39.         struct icmp *icmp;
    
40.         struct sockaddr_in *sin;
    
41.         socklen_t salen;
    
42.         int n; /* getaddrinfo return value */
    
43.         char *buffer;
    
44. 
    
45.         if(argc != 2) {
    
46.                 perror("usage: ./ping <hostname>");
    
47.                 exit (1);
    
48.         }
    
49. 
    
50.         host = argv[1];
    
51.         pid = getpid() & 0xffff;
    
52.         signal(SIGALRM, sig_alrm);
    
53. 
    
54.         bzero(&hints, sizeof(struct addrinfo));
    
55.         hints.ai_flags = AI_CANONNAME;
    
56.         if( ( n = getaddrinfo(host, NULL, &hints, &res)) != 0) {
    
57.                 fprintf(stderr, "getaddrinfo: %s\n",gai_strerror(n));
    
58.                 exit (1);
    
59.         }
    
60.        
    
61.         sin = (struct sockaddr_in *)(res->ai_addr);       
    
62.         switch (sin->sin_family) {
    
63.                 case AF_INET:
    
64.                         if(inet_ntop(AF_INET,&(sin->sin_addr), h, 128) == NULL) {
    
65.                                 perror("inet_ntop");
    
66.                                 exit (1);
    
67.                         }
    
68.                         break;
    
69.                
    
70.                 default:
    
71.                         perror("Not IPv4 address");
    
72.                         exit (1);
    
73.         }
    
74.         printf("PING %s (%s): %d data bytes\n",res->ai_canonname ? res->ai_canonname:h, h, datalen);
    
75.         readloop();
    
76.         return 0;
    
77. }
    
78. 
    
79. uint16_t in_cksum(uint16_t *addr, int len) {
    
80.         int nleft = len;
    
81.         uint32_t sum = 0;
    
82.         uint16_t *w = addr;
    
83.         uint16_t answer = 0;
    
84. 
    
85.         while(nleft > 1) {
    
86.                 sum += *w++;
    
87.                 nleft -= 2;
    
88.         }
    
89.         if (nleft == 1) {
    
90.                 *(unsigned char *)(&answer) = *(unsigned char *)w;
    
91.                 sum += answer;
    
92.         }
    
93.         sum = (sum >> 16) + (sum & 0xffff);
    
94.         sum += (sum >> 16);
    
95.         answer = ~sum;
    
96.         return (answer);
    
97. }
    
98. void send_v4(void) {
    
99.         struct icmp *icmp;
    
100.         int len;
     
101.         socklen_t salen;
     
102.         icmp = (struct icmp *)sendbuf;
     
103.         icmp->icmp_type = ICMP_ECHO;
     
104.         icmp->icmp_code = 0;
     
105.         icmp->icmp_seq = nsent++;
     
106.         icmp->icmp_id = pid;
     
107.         memset(icmp->icmp_data,0, datalen);
     
108.         if(gettimeofday((struct timeval *)icmp->icmp_data, NULL) < 0) {
     
109.                 perror("gettimeofday");
     
110.                 exit (1);
     
111.         }
     
112.         len = 8 + datalen;
     
113.         icmp->icmp_cksum = 0;
     
114.         icmp->icmp_cksum = in_cksum((u_short *)icmp,len);
     
115. 
     
116.         sasend = res->ai_addr;
     
117.         salen = res->ai_addrlen;
     
118.         if(sendto(sockfd, sendbuf, len, 0, sasend, salen) != len) {
     
119.                 perror("sendto");
     
120.                 exit(1);
     
121.         }
     
122. }
     
123. void readloop(void) {
     
124.         ssize_t n;
     
125.         int size;
     
126.         char recvbuf[BUFSIZE];
     
127.         char controlbuf[BUFSIZE];
     
128.         struct msghdr msg;
     
129.         struct iovec iov;
     
130.         struct timeval tval;
     
131.        
     
132. 
     
133.         // create socket from here
     
134.         if(res->ai_family == AF_INET) {
     
135.                 if((sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) {
     
136.                         perror("socket");
     
137.                         exit(1);
     
138.                 }
     
139.         }
     
140.         else {
     
141.                 fprintf(stderr,"unknown address family %d", res->ai_family);
     
142.                 exit (1);
     
143.         }
     
144.         setuid(getuid());
     
145.        
     
146.         size = 60 * 1024;
     
147.         setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
     
148.         sig_alrm(SIGALRM); /* send the first packet */
     
149. 
     
150.         iov.iov_base = recvbuf;
     
151.         iov.iov_len = sizeof(recvbuf);
     
152.         msg.msg_name = sarecv;
     
153.         msg.msg_iov = &iov;
     
154.         msg.msg_iovlen = 1;
     
155.         msg.msg_control = controlbuf;
     
156. 
     
157.         for( ; ; ) {/* now receive message after sending packet */
     
158.                 n = recvmsg(sockfd, &msg, 0);
     
159.                 if( n < 0) {
     
160.                         if(errno == EINTR )
     
161.                                 continue;
     
162.                         else {
     
163.                                 perror("recvmsg");
     
164.                                 exit(1);
     
165.                         }
     
166.                 }
     
167.                 if(gettimeofday(&tval, NULL) < 0) {
     
168.                         perror("gettimeofday");
     
169.                         exit (1);
     
170.                 }
     
171.                 proc_v4(recvbuf, n, &msg, &tval);
     
172.         }
     
173. }
     
174. 
     
175. void sig_alrm(int signo) {
     
176.         send_v4();
     
177.         alarm(1);
     
178.         return ;
     
179. }
     
180. 
     
181. 
     
182. void proc_v4 (char *ptr, ssize_t len, struct msghdr *msg, struct timeval *tvrecv) {
     
183.         int hlenl, icmplen;
     
184.         struct ip *ip;
     
185.         struct icmp *icmp;
     
186.         struct timeval *tvsend;
     
187.         double rtt;
     
188. 
     
189.         ip = (struct ip*)ptr;
     
190.         /* only check two fields of ip header, length and protocol */
     
191.         hlenl = ip->ip_hl << 2; /* length of ip header */
     
192.         if(ip->ip_p != IPPROTO_ICMP )
     
193.                 return;                /*second, check protocol */
     
194.         icmp = (struct icmp *)(ptr + hlenl); /* start of icmp header */
     
195.         if((icmplen = len - hlenl) < 8)
     
196.                 return ;
     
197.         if(icmp->icmp_type == ICMP_ECHOREPLY) {
     
198.                 if(icmp->icmp_id != pid)
     
199.                         return;
     
200.                 if(icmplen < 16)
     
201.                         return;
     
202.                 tvsend = (struct timeval *)icmp->icmp_data;
     
203.                 tv_sub(tvrecv,tvsend);
     
204.                 rtt = tvrecv->tv_sec * 1000.0 + tvrecv->tv_usec/1000.0;
     
205.                 printf("%d bytes from %s: seq=%u, ttl=%d, rtt=%.3f ms\n",icmplen, h, icmp->icmp_seq, ip->ip_ttl, rtt);
     
206.                
     
207.         }
     
208. }
     
209. 
     
210. void tv_sub(struct timeval *out, struct timeval *in) {
     
211.         if((out->tv_usec -= in->tv_usec) < 0) {
     
212.                 --out->tv_sec;
     
213.                 out->tv_usec += 100000;
     
214.         }
     
215.         out->tv_sec -= in->tv_sec;
     
216. }       

复制代码