[已解决] ping程序的问题.

PCliangtao

在看UNP的时候,把书中的ping程序的例子的原理掌握之后,自己尝试写了一下.换汤不换药... 只不过纯粹只于IPv4打交道...
  不知道什么原理. 在发出echo的ICMP之后... 却一直阻塞在recvmsg调用上... 我用tcpdump看...的确发生了ICMP ECHO...
  还有奇怪的一点的所... ping  www.hao123.com能够正常工作... ping www.baidu.com www.goolge.com这样的时候就一直阻塞在recvmsg上...
接触网络变成不久... 希望有经验的兄弟们给瞧瞧... 多谢..

NB: 仔细想了一下... 估计是发送的ICMP 包被远端丢弃了...  仔细看了一下构造ICMP 头部的代码... 汗ing... 校验和的计算参数传错了...没有把ICMP头部算在内...修改了一下...
       就好了...
       可是还有一点奇怪的是... ICMP 对回送请求的应答应该是在内核里进行的吧...  但是为什么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. }
     

复制代码