关于条件锁和互斥锁的问题

syoubin_sai

用多线程实现了一个ping程序。但发送线程与接收线程根本启动不了，怎么回事？
条件锁和互斥锁用的不对？请高手指点。

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <strings.h>
   
6. #include <errno.h>
   
7. #include <sys/socket.h>
   
8. #include <sys/time.h>
   
9. #include <signal.h>
   
10. #include <netinet/in.h>
    
11. #include <netinet/ip.h>
    
12. #include <netinet/ip_icmp.h>
    
13. #include <netdb.h>
    
14. #include <pthread.h>
    
15. #include <sys/types.h>
    
16. 
    
17. #define PACKET_SIZE 4096
    
18. #define RECV_TIME_OUT 10
    
19. 
    
20. char send_pkt[PACKET_SIZE];
    
21. char recv_pkt[PACKET_SIZE];
    
22. 
    
23. int n_send =0, n_recv = 0;
    
24. int sock_fd;
    
25. pid_t pid;
    
26. struct sockaddr_in dest_addr, recv_addr;
    
27. struct timeval tv_recv;
    
28. int timer = 0;
    
29. int send_tag = 0;
    
30. int recv_tag = 1;
    
31. pthread_mutex_t ping_lock = PTHREAD_MUTEX_INITIALIZER;
    
32. pthread_cond_t send_cond = PTHREAD_COND_INITIALIZER;
    
33. pthread_cond_t recv_cond = PTHREAD_COND_INITIALIZER;
    
34. 
    
35. void statistics(int sig_no);
    
36. unsigned short cal_cksum(unsigned short *addr, int len);
    
37. int pkt(int pkt_no);
    
38. void *recv_pkt_th(void *arg);
    
39. void *send_pkt_th(void *arg);
    
40. int unpkt(char *buf, int len);
    
41. void tv_sub(struct timeval *out, struct timeval *in);
    
42. 
    
43. void statistics(int signo)
    
44. {
    
45.         printf("\n------------PING statistics-----------\n");
    
46.         printf("%d packets transmitted, %d received, %%%d lost\n",
    
47.                  n_send, n_recv, (n_send - n_recv) / n_send * 100 );
    
48.         pthread_mutex_unlock(&ping_lock);
    
49.         pthread_cond_destroy(&send_cond);
    
50.         pthread_cond_destroy(&recv_cond);
    
51.         close(sock_fd);
    
52.         exit(1);
    
53. }
    
54. 
    
55. unsigned short cal_cksum(unsigned short *addr, int len)
    
56. {
    
57.         int nleft = len;
    
58.         int sum = 0;
    
59.         unsigned short *w = addr;
    
60.         unsigned short cksum = 0;
    
61.        
    
62.         while(nleft > 1)
    
63.         {
    
64.                 sum += *w++;
    
65.                 nleft -= 2;
    
66.         }
    
67.         if(nleft == 1)
    
68.         {
    
69.                 *(unsigned char *)(&cksum) = *(unsigned char *)w;
    
70.                 sum += cksum;
    
71.         }
    
72.         sum = (sum >> 16) + (sum & 0xffff);
    
73.         sum += (sum >> 16);
    
74.         cksum = ~sum;
    
75. 
    
76.         return cksum;
    
77. }
    
78. 
    
79. int pkt(int pkt_no)
    
80. {
    
81.         int i, pkt_sz;
    
82.         struct icmp *icmp;
    
83.         struct timeval *tval;
    
84.        
    
85.         icmp = (struct icmp *)send_pkt;
    
86.         icmp->icmp_type = ICMP_ECHO;
    
87.         icmp->icmp_code = 0;
    
88.         icmp->icmp_cksum = 0;
    
89.         icmp->icmp_seq = pkt_no;
    
90.         icmp->icmp_id = pid;
    
91.         pkt_sz = 64;
    
92.         tval = (struct timeval *)icmp->icmp_data;
    
93.         gettimeofday(tval, NULL);
    
94.         icmp->icmp_cksum = cal_cksum((unsigned short *)icmp, pkt_sz);
    
95. 
    
96.         return pkt_sz;
    
97. }
    
98. 
    
99. void *send_pkt_th(void *arg)
    
100. {
     
101.         int pkt_sz;
     
102. printf("D");
     
103.         while(1){
     
104.                 pthread_mutex_lock(&ping_lock);
     
105.                 n_send ++;
     
106.                 pkt_sz = pkt(n_send);
     
107.                 if(sendto(sock_fd, send_pkt, pkt_sz, 0, (struct sockaddr *)&dest_addr,
     
108.                      sizeof(dest_addr)) == -1){
     
109.                         perror("sendto error");
     
110.                         goto L_END;
     
111.                 }
     
112. //                sleep(1);
     
113.                 recv_tag = 0;
     
114.                 pthread_cond_signal(&recv_cond);
     
115. printf("C");
     
116.                 while(send_tag == 0){
     
117.                         pthread_cond_wait(&send_cond, &ping_lock);
     
118.                 }
     
119.                 send_tag = 0;
     
120.                 L_END:
     
121.                         pthread_mutex_unlock(&ping_lock);
     
122.         }
     
123. 
     
124.         return ((void *)0);
     
125. }
     
126. 
     
127. void *recv_pkt_th(void *arg)
     
128. {
     
129.         int n, fromlen;
     
130.         fromlen = sizeof(recv_addr);
     
131. printf("A");
     
132.         while(1)
     
133.         {
     
134.                 pthread_mutex_lock(&ping_lock);
     
135. printf("B");
     
136.                 while(recv_tag == 1){
     
137.                         pthread_cond_wait(&recv_cond, &ping_lock);
     
138.                 }
     
139.                 recv_tag = 1;
     
140.                 if(n = recvfrom(sock_fd, recv_pkt, sizeof(recv_pkt), 0,
     
141.                      (struct sockaddr *)&recv_addr, &fromlen) == -1){
     
142.                         if(errno == EINTR){
     
143.                                 goto L_END;
     
144.                         }
     
145.                         perror("recvfrom error");
     
146.                         goto L_END;
     
147.                 }
     
148.                 gettimeofday(&tv_recv, NULL);
     
149.                 if(unpkt(recv_pkt, n) == -1){
     
150.                         goto L_END;
     
151.                 }
     
152.                 n_recv ++;
     
153.                 if(timer == RECV_TIME_OUT){
     
154.                         send_tag = 1;
     
155.                         timer = 0;
     
156.                         printf("From %s icmp_seq=%d Destination Host Unreachable",
     
157.                                 inet_ntoa(dest_addr.sin_addr), n_send);
     
158.                 }
     
159.                 if(send_tag == 1){
     
160.                         pthread_cond_signal(&send_cond);
     
161.                 }
     
162.                 L_END:
     
163.                         timer ++;
     
164.                         pthread_mutex_unlock(&ping_lock);
     
165.         }
     
166. 
     
167.         return ((void *)0);
     
168. }
     
169. 
     
170. int unpkt(char *buf, int len)
     
171. {
     
172.         int i, iphdrlen;
     
173.         struct ip *ip;
     
174.         struct icmp *icmp;
     
175.         struct timeval *tv_send;
     
176.         double rtt;
     
177. 
     
178.         ip = (struct ip *)buf;
     
179.         iphdrlen = ip->ip_hl << 2;
     
180.         icmp = (struct icmp *)(buf + iphdrlen);
     
181.         len -= iphdrlen;
     
182. 
     
183.         if(len < 8){
     
184.                 return -1;
     
185.         }
     
186.         if((icmp->icmp_type == ICMP_ECHOREPLY)
     
187.            && (icmp->icmp_id == pid)) {
     
188.                 tv_send = (struct timeval *)icmp->icmp_data;
     
189.                 tv_sub(&tv_recv, tv_send);
     
190.                 rtt = tv_recv.tv_sec * 1000 + tv_recv.tv_usec / 1000;
     
191.                 printf("%d byte from %s:icmp_seq = %u ttl = %d rtt = %.3f ms\n",
     
192.                 len, inet_ntoa(dest_addr.sin_addr), icmp->icmp_seq, ip->ip_ttl, rtt);
     
193.                 send_tag = 1;
     
194.         } else {
     
195.                 return -1;
     
196.         }
     
197. }
     
198. 
     
199. void tv_sub(struct timeval *out, struct timeval *in)
     
200. {
     
201.         if(out->tv_usec -= in->tv_usec){
     
202.                 --out->tv_sec;
     
203.                 out->tv_usec += 1000000;
     
204.         }
     
205.         out->tv_sec -= in->tv_sec;
     
206. }
     
207. 
     
208. int main(int argc, char *argv[ ])
     
209. {
     
210.         struct hostent *host;
     
211.         struct protoent *protocol;
     
212.         unsigned int inaddr = 0l;
     
213.         int waittime = 5;
     
214.         int size = 50 * 1024;
     
215.         pthread_t thread_id;
     
216.         pthread_attr_t attr;
     
217.         int retval;
     
218. 
     
219.         if(argc < 2) {
     
220.                 printf("usage:%s hostname/IP address\n", argv[0]);
     
221.                 exit(1);
     
222.         }
     
223.         if((protocol = getprotobyname("icmp")) == NULL ){
     
224.                 perror("getprotobyname");
     
225.                 exit(1);
     
226.         }
     
227.         if((sock_fd = socket(AF_INET, SOCK_RAW, protocol->p_proto)) == -1){
     
228.                 perror("socket error");
     
229.                 exit(1);
     
230.         }
     
231.         setuid(getuid());
     
232.         setsockopt(sock_fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
     
233.         bzero(&dest_addr, sizeof(dest_addr));
     
234.         dest_addr.sin_family = AF_INET;
     
235.         if((inaddr = inet_addr(argv[1])) == INADDR_NONE){
     
236.                 if((host = gethostbyname(argv[1])) == NULL){
     
237.                         perror("gethostbyname error");
     
238.                         exit(1);
     
239.                 }
     
240.                 memcpy((char *)&dest_addr.sin_addr, host->h_addr, host->h_length);
     
241.         } else{
     
242.                 memcpy((char *)&dest_addr, (char *)&inaddr, host->h_length);
     
243.         }
     
244. 
     
245.         pid = getpid();
     
246. printf("x");
     
247.         printf("PING %s(%s): %d bytes data in ICMP packets.\n", argv[1],
     
248.                 inet_ntoa(dest_addr.sin_addr), 56);
     
249. printf("0");
     
250.         (void)pthread_attr_init(&attr);
     
251.         (void)pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
     
252. printf("1");
     
253.         if((retval = pthread_create(&thread_id, &attr, send_pkt_th, NULL)) != 0){
     
254.                 perror("pthread_create error");
     
255.                 exit(1);
     
256.         }
     
257. 
     
258. printf("2");
     
259.         if((retval = pthread_create(&thread_id, &attr, recv_pkt_th, NULL)) != 0){
     
260.                 perror("pthread_create error");
     
261.                 exit(1);
     
262.         }
     
263.           signal(SIGTERM, statistics);
     
264.         signal(SIGINT, statistics);
     
265.         sleep(10);
     
266. 
     
267. printf("3");
     
268.         return 0;
     
269. }
     

复制代码

syoubin_sai