[已解決] ping程序的問題.

PCliangtao

在看UNP的時候,把書中的ping程序的例子的原理掌握之后,自己嘗試寫了一下.換湯不換藥... 只不過純粹只于IPv4打交道...
  不知道什么原理. 在發(fā)出echo的ICMP之后... 卻一直阻塞在recvmsg調(diào)用上... 我用tcpdump看...的確發(fā)生了ICMP ECHO...
  還有奇怪的一點的所... ping  www.hao123.com能夠正常工作... ping www.baidu.com www.goolge.com這樣的時候就一直阻塞在recvmsg上...
接觸網(wǎng)絡(luò)變成不久... 希望有經(jīng)驗的兄弟們給瞧瞧... 多謝..

NB: 仔細想了一下... 估計是發(fā)送的ICMP 包被遠端丟棄了...  仔細看了一下構(gòu)造ICMP 頭部的代碼... 汗ing... 校驗和的計算參數(shù)傳錯了...沒有把ICMP頭部算在內(nèi)...修改了一下...
       就好了...
       可是還有一點奇怪的是... ICMP 對回送請求的應(yīng)答應(yīng)該是在內(nèi)核里進行的吧...  但是為什么www.hao123.com主機能夠接受錯誤的校驗和的ICMP ECHO請求包呢？
       翻一翻TCP／IP的源代碼去...

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <signal.h>
   
7. #include <errno.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. #include <netinet/ip.h>
    
11. #include <netinet/ip_icmp.h>
    
12. #include <netdb.h>
    
13. 
    
14. #define BUFSIZE 1024
    
15. /* need those global vars, for simplicity */
    
16. const char Usage[] = "Usage: ping [-v] host(hostname or hostIP)\n";
    
17. static int nsnd;
    
18. static int datalen;
    
19. static int sockfd;
    
20. static int verbose;
    
21. static pid_t pid;
    
22. static char sndbuf[BUFSIZE];
    
23. static struct sockaddr *rcvaddr;
    
24. static struct sockaddr *sndaddr;
    
25. static socklen_t addrlen;
    
26. /* some of the function prototypes */
    
27. static void send_echo_icmp(void);
    
28. static void recv_echoreply_icmp(char *, int, struct timeval *);
    
29. static void sig_alrm(int signo);
    
30. static char *show_addr_ip(struct sockaddr *, socklen_t len);
    
31. static inline u_int16_t ip_fast_csum(const void *, unsigned int);
    
32. 
    
33. static inline void err_quit(const char *str)
    
34. {
    
35.         perror(str);
    
36.         exit(-1);
    
37. }
    
38. static inline void err_sys(const char *str)
    
39. {
    
40.         perror(str);
    
41. }
    
42. 
    
43. int main(int argc, char *argv[])
    
44. {
    
45. 
    
46.         int c;
    
47.         char *host;
    
48.         char *hostip;
    
49.         char rcvbuf[BUFSIZE], ctlbuf[BUFSIZE];
    
50.         struct msghdr msg;
    
51.         struct iovec iov;
    
52.         struct timeval rcvtv;
    
53.         int size, n;
    
54.         struct addrinfo *ai, *saved_ai, hint;
    
55.        
    
56.         while((c = getopt(argc, argv, "v")) != -1) {
    
57.                 switch(c) {
    
58.                 case 'v':
    
59.                         verbose++;
    
60.                         break;
    
61.                 default:
    
62.                         printf("unrecognized option %c\n", c);
    
63.                         exit(-1);
    
64.                 }
    
65.         }
    
66.         if(optind !=  argc - 1) {
    
67.                 printf(Usage);
    
68.                 exit(-1);
    
69.         }
    
70.         host = argv[optind];
    
71.         datalen = 56;
    
72.         signal(SIGALRM, sig_alrm);
    
73.         pid = getpid() & 0xffff;
    
74.         bzero(&hint, sizeof(hint));
    
75.         hint.ai_flags = AI_CANONNAME;
    
76.         hint.ai_family = AF_INET;
    
77.         if(getaddrinfo(host, NULL, &hint, &ai) < 0)
    
78.                 err_quit("getaddrinfo error: ");
    
79.         saved_ai = ai;    /* don't need to do this actually */
    
80.         for(; ai; ai = ai->ai_next)
    
81.                 if(ai->ai_family == AF_INET)
    
82.                         break;
    
83.         if(!ai) {
    
84.                 printf("cann't get IPv4 addrinfo\n");
    
85.                 exit(-1);
    
86.         }
    
87.         hostip = show_addr_ip(ai->ai_addr, ai->ai_addrlen);
    
88.         printf("ping %s (%s): %d data bytes\n", ai->ai_canonname ? \
    
89.                 ai->ai_canonname : hostip, hostip, datalen);
    
90.         sndaddr = ai->ai_addr;
    
91.         addrlen = ai->ai_addrlen;
    
92.         rcvaddr = (struct sockaddr *) malloc(addrlen);
    
93.         if(!rcvaddr) {
    
94.                 printf("malloc failed, OOM\n");
    
95.                 exit(-1);
    
96.         }
    
97. 
    
98.         /* now we got all the information required, create the RAW socket and get started */
    
99.         sockfd = socket(sndaddr->sa_family, SOCK_RAW, IPPROTO_ICMP);
    
100.         if(sockfd < 0)
     
101.                 err_quit("create socket error: ");
     
102.         setuid(getuid()); /* only create RAW sock need privilege */
     
103. 
     
104.         size = 60 * 1024;
     
105.         setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
     
106.         sig_alrm(SIGALRM);
     
107.        
     
108.         iov.iov_base = rcvbuf;
     
109.         iov.iov_len = sizeof(rcvbuf);
     
110.         msg.msg_name = rcvaddr;
     
111.         msg.msg_namelen = addrlen;
     
112.         msg.msg_iov = &iov;
     
113.         msg.msg_iovlen = 1;
     
114.         msg.msg_control = ctlbuf;
     
115.         msg.msg_controllen = sizeof(ctlbuf);
     
116.         while(1) {
     
117.                 n = recvmsg(sockfd, &msg, 0);
     
118.                 if(n < 0) {
     
119.                         if(errno == EINTR)
     
120.                                 continue;
     
121.                         else {
     
122.                                 err_sys("recvmsg error:　");
     
123.                                 continue;
     
124.                         }
     
125.                 }
     
126.                 gettimeofday(&rcvtv, NULL);
     
127.         /*
     
128.          * what if this process is slower than recv...maybe we'll get corrupted
     
129.          * rcvtv .this should not be a problem, cause the internet is much much
     
130.          * slower, respectly.
     
131.          */
     
132.                 recv_echoreply_icmp(rcvbuf, n, &rcvtv);
     
133.         }
     
134. }
     
135. 
     
136. 
     
137. static void sig_alrm(int signo)
     
138. {
     
139.         send_echo_icmp();
     
140.         alarm(1);
     
141.         return;
     
142. }
     
143. 
     
144. 
     
145. /* send the icmp echo request */
     
146. static void send_echo_icmp()
     
147. {
     
148.         int len;
     
149.         struct icmp *icmp;
     
150.         icmp = (struct icmp *)sndbuf;
     
151.         /* build the icmp header */
     
152.         icmp->icmp_type = ICMP_ECHO;
     
153.         icmp->icmp_code = 0;
     
154.         icmp->icmp_id = pid;
     
155.         icmp->icmp_seq = ++nsnd;
     
156.         if(datalen & 3) {
     
157.                 fprintf(stderr, "datalen must be a multiple of 4!\n");
     
158.                 datalen = (datalen + 3) & (~3UL);
     
159.         }
     
160.         memset(icmp->icmp_data, 0xa5, datalen);
     
161.         gettimeofday((struct timeval *)icmp->icmp_data, NULL);
     
162.         len = 8 + datalen;
     
163.         icmp->icmp_cksum = 0;
     
164.         icmp->icmp_cksum = ip_fast_csum(icmp->icmp_data, len >> 2);
     
165.         if(sendto(sockfd, sndbuf, len, 0, sndaddr, addrlen) < 0)
     
166.                 if(errno != EINTR)
     
167.                         err_quit("sendto error: ");
     
168. }
     
169. 
     
170. static inline void cal_rtt(struct timeval *rcv, struct timeval *snd, double *rtt)
     
171. {
     
172.         if((rcv->tv_usec -= snd->tv_usec) < 0) {
     
173.                 rcv->tv_sec--;
     
174.                 rcv->tv_usec += 1000000;
     
175.         }
     
176.         rcv->tv_sec -= snd->tv_sec;
     
177.         *rtt = rcv->tv_sec * 1000.0+ rcv->tv_usec / 1000.0;
     
178. }
     
179. 
     
180. static void recv_echoreply_icmp(char *rcvbuf, int len, struct timeval *rcv_tv)
     
181. {
     
182.         int iplen, icmplen;
     
183.         double rtt;
     
184.         struct ip *ip;
     
185.         struct icmp *icmp;
     
186.         struct timeval *snd_tv;
     
187.         ip = (struct ip *)rcvbuf;
     
188.         iplen = ip->ip_hl << 2;
     
189.         if(ip->ip_p != IPPROTO_ICMP)
     
190.                 goto ignore;
     
191.         icmp = (struct icmp *)(rcvbuf + iplen);
     
192.         icmplen = len - iplen;
     
193.         if(icmplen < 8)
     
194.                 goto ignore;
     
195.         if(icmp->icmp_type == ICMP_ECHOREPLY) {
     
196.                 if(icmp->icmp_id != pid)
     
197.                         goto ignore;
     
198.                 if(icmplen < 8+sizeof(struct timeval))
     
199.                         goto ignore;
     
200.                 snd_tv = (struct timeval *)icmp->icmp_data;
     
201.                 cal_rtt(rcv_tv, snd_tv, &rtt);
     
202. 
     
203.                 printf("%d bytes from %s: seq=%d, ttl=%d, rtt=%.3f ms\n", \
     
204.                 icmplen, show_addr_ip(rcvaddr, addrlen), icmp->icmp_seq, \
     
205.                         ip->ip_ttl, rtt);
     
206.         } else if(verbose) {
     
207.                 printf("%d bytes from %s: type=%d, code=%d\n", icmplen, \
     
208.                 show_addr_ip(rcvaddr, addrlen), icmp->icmp_type,\
     
209.                  icmp->icmp_code);
     
210.         }
     
211. ignore:
     
212.         return;       
     
213. }
     
214. 
     
215. /* it's not safe, though */
     
216. static char *show_addr_ip(struct sockaddr *sa, socklen_t len)
     
217. {
     
218.         static char ipbuf[INET6_ADDRSTRLEN];
     
219.         switch(sa->sa_family) {
     
220.         case AF_INET: {
     
221.                 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
     
222.                 if(len < sizeof(struct sockaddr_in))
     
223.                         return NULL;
     
224.                 if(inet_ntop(AF_INET, &sin->sin_addr, ipbuf,\
     
225.                                                  INET6_ADDRSTRLEN) < 0)
     
226.                         return NULL;
     
227.                 return ipbuf;
     
228.                 break;
     
229.                 }
     
230.         default:
     
231.                 printf("don't support other addr type\n");
     
232.                 return NULL;
     
233.         }
     
234. }
     
235. 
     
236. /*
     
237. *        This is a version of ip_compute_csum() optimized for IP headers,
     
238. *        which always checksum on 4 octet boundaries.
     
239. *
     
240. *        By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
     
241. *        Arnt Gulbrandsen.
     
242. */
     
243. static inline u_int16_t ip_fast_csum(const void *iph, unsigned int ihl)
     
244. {
     
245.         unsigned int sum;
     
246. 
     
247.         asm volatile("movl (%1), %0        ;\n"
     
248.                      "subl $4, %2        ;\n"
     
249.                      "jbe 2f                ;\n"
     
250.                      "addl 4(%1), %0        ;\n"
     
251.                      "adcl 8(%1), %0        ;\n"
     
252.                      "adcl 12(%1), %0;\n"
     
253.                      "1:        adcl 16(%1), %0        ;\n"
     
254.                      "lea 4(%1), %1        ;\n"
     
255.                      "decl %2        ;\n"
     
256.                      "jne 1b                ;\n"
     
257.                      "adcl $0, %0        ;\n"
     
258.                      "movl %0, %2        ;\n"
     
259.                      "shrl $16, %0        ;\n"
     
260.                      "addw %w2, %w0        ;\n"
     
261.                      "adcl $0, %0        ;\n"
     
262.                      "notl %0        ;\n"
     
263.                      "2:                ;\n"
     
264.         /* Since the input registers which are loaded with iph and ihl
     
265.            are modified, we must also specify them as outputs, or gcc
     
266.            will assume they contain their original values. */
     
267.                      : "=r" (sum), "=r" (iph), "=r" (ihl)
     
268.                      : "1" (iph), "2" (ihl)
     
269.                      : "memory");
     
270.         return (u_int16_t)sum;
     
271. }
     

復(fù)制代碼