多clinet的C/S程序设计──样列代码

1. /* tcp_server.c*/
3. #include <stdio.h>
4. #include <sys/socket.h>
5. #include <arpa/inet.h>
6. #include <stdlib.h>
7. #include <string.h>
8. #include <unistd.h>
9. #include <netinet/in.h>
11. #define MAXPENDING 5 /* max client requests */
12. #define BUFFSIZE 32
14. int die(char *mess) {fprintf(stdout, mess); return 1;}
16. int handle_client(int sock) {
17.     char buffer[BUFFSIZE];
18.     int received = -1;
19.     
20.     /* Receive message */
21.     /*while (received <= 0)*/ {
22.         if ((received = recv(sock, buffer, BUFFSIZE, 0)) < 0) {
23.             die("Failed to receive initial bytes from client/n");
24.         }
25.     }
26.     buffer[received] = '/0';
28.     /* Send bytes and check for more incoming data in loop */
29.     while (received > 0) {
30.         fprintf(stdout, "Recieve: %s/n", buffer);
31.         /* Send back received data */
32.         if (send(sock, buffer, received, 0) != received) {
33.             die("Failed to send bytes to client/n");
34.         }
35.         
36.         /* Check for more data */
37.         if ((received = recv(sock, buffer, BUFFSIZE, 0)) < 0) {
38.             die("Failed to receive additional bytes from client/n");
39.         }
40.         buffer[received] = '/0';
41.     }
42.     
43.     return 0;
44. }
46. int tcp_server_4(short port)
47. {
48.     int server_sock,client_sock,maxfd;
49.     struct sockaddr_in server,client;
50.     int received = 0;
51.     fd_set fdR,fdR2;
52.     int ret = 0;
54.     /* create the tcp server socket */
55.     if ((server_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
56.         return die("Failed to create tcp server socket/n");
57.     }
59.     /* construct the server sockaddr_in struct */
60.     memset(&server, 0, sizeof(server));
61.     server.sin_family = AF_INET;   /* internet/IP */
62.     server.sin_addr.s_addr = htonl(INADDR_ANY);
63.     server.sin_port = htons(port);
65.     /* bind the server socket */
66.     if (bind(server_sock, (struct sockaddr *)(&server), sizeof(server)) < 0) {
67.         return die("Failed to bind the server socket./n");
68.     }
70.     /* listen on the server socket */
71.     if (listen(server_sock, MAXPENDING) < 0) {
72.         return die("Failed to listen on server socket/n");
73.     }
75.     /* initial fd sets */
76.     FD_ZERO(&fdR);
77.     FD_ZERO(&fdR2);
78.     /* add server sock to fd sets */
79.     FD_SET(server_sock, &fdR2);
80.     maxfd = server_sock;
82.     while (1) {
84.         /* use the two fd just to distinguish current fd sets 
85.          * and next time fd sets 
86.          */
87.         fdR = fdR2;
89.         /* block when have data come to a fd */
90.         fprintf(stdout, "Select intoi: fd [%d]/n", maxfd);
91.         ret = select(maxfd+1, &fdR, NULL,NULL,NULL);
92.         if (ret < 0) {
93.             return die(" select fail");
94.         }
95.         fprintf(stdout, "Select a fd/n");
97.         /* if have data come to server_sock , it is a client connect */
98.         if (FD_ISSET(server_sock, &fdR)) {
99.             int len = sizeof(client);
100.             client_sock = accept(server_sock, (struct sockaddr *)&client, &len);
101.             FD_SET(client_sock, &fdR2);
102.             if (maxfd < client_sock) {
103.                 maxfd = client_sock;
104.             }
105.         }
106.         else if (FD_ISSET(client_sock, &fdR)) {
107.            
108.             handle_client(client_sock);
109.             close(client_sock);
110.             FD_CLR(client_sock, &fdR2);
111.         }
112.     }
114.     return 0;
115. }
118. int tcp_server_3(short port)
119. {
120.     int server_sock,client_sock;
121.     struct sockaddr_in server,client;
122.     int received = 0;
123.  
124.     /* create the tcp server socket */
125.     if ((server_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
126.         return die("Failed to create tcp server socket/n");
127.     }
129.     /* construct the server sockaddr_in struct */
130.     memset(&server, 0, sizeof(server));
131.     server.sin_family = AF_INET;   /* internet/IP */
132.     server.sin_addr.s_addr = htonl(INADDR_ANY);
133.     server.sin_port = htons(port);
135.     /* bind the server socket */
136.     if (bind(server_sock, (struct sockaddr *)(&server), sizeof(server)) < 0) {
137.         return die("Failed to bind the server socket./n");
138.     }
139.     
140.     /* listen on the server socket */
141.     if (listen(server_sock, MAXPENDING) < 0) {
142.         return die("Failed to listen on server socket/n");
143.     }
145.     /* run until cancelled */
146.     while (1) {
147.         unsigned int clientlen = sizeof(client);
148.         pid_t pid;
150.         /* wait for client connection */
151.         if ((client_sock = accept(server_sock, (struct sockaddr *)&client, &clientlen)) < 0) {
152.             return die("Failed to accept client connection/n");
153.         }
154.         
155.         fprintf(stdout, "client connect ID:%d: %s/n", getpid(),inet_ntoa(client.sin_addr));
156.         pid = fork();
157.         if (0 == pid) {
158.             close(server_sock);
159.             handle_client(client_sock);
160.             fprintf(stdout, "I'am child , i will die./n");
161.             close(client_sock);
162.             return 0;
163.         } else {
164.             close(client_sock);
165.         }
166.     }
168.     return 0;
169. }
172. int tcp_server_2(short port)
173. {
174.     int server_sock,client_sock;
175.     struct sockaddr_in server,client;
176.     int received = 0;
177.  
178.     /* create the tcp server socket */
179.     if ((server_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
180.         return die("Failed to create tcp server socket/n");
181.     }
183.     /* construct the server sockaddr_in struct */
184.     memset(&server, 0, sizeof(server));
185.     server.sin_family = AF_INET;   /* internet/IP */
186.     server.sin_addr.s_addr = htonl(INADDR_ANY);
187.     server.sin_port = htons(port);
189.     /* bind the server socket */
190.     if (bind(server_sock, (struct sockaddr *)(&server), sizeof(server)) < 0) {
191.         return die("Failed to bind the server socket./n");
192.     }
193.     
194.     /* listen on the server socket */
195.     if (listen(server_sock, MAXPENDING) < 0) {
196.         return die("Failed to listen on server socket/n");
197.     }
199.     /* run until cancelled */
200.     while (1) {
201.         unsigned int clientlen = sizeof(client);
202.         pid_t pid;
203.         pid = fork();
204.         if (0 == pid) {
205.             /* wait for client connection */
206.             if ((client_sock = accept(server_sock, (struct sockaddr *)&client, &clientlen)) < 0) {
207.                 return die("Failed to accept client connection/n");
208.             }
209.             fprintf(stdout, "client connect at pid:%d, ID:%d: %s/n", pid,getpid(),inet_ntoa(client.sin_addr));
210.             handle_client(client_sock);
211.             close(client_sock);
212.             fprintf(stdout, "I'am child , i will die./n");
213.             return 0;
214.         }
215.     }
217.     return 0;
218. }
220. int tcp_server_1(short port)
221. {
222.     int server_sock,client_sock;
223.     struct sockaddr_in server,client;
224.     int received = 0;
225.  
226.     /* create the tcp server socket */
227.     if ((server_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
228.         return die("Failed to create tcp server socket/n");
229.     }
231.     /* construct the server sockaddr_in struct */
232.     memset(&server, 0, sizeof(server));
233.     server.sin_family = AF_INET;   /* internet/IP */
234.     server.sin_addr.s_addr = htonl(INADDR_ANY);
235.     server.sin_port = htons(port);
237.     /* bind the server socket */
238.     if (bind(server_sock, (struct sockaddr *)(&server), sizeof(server)) < 0) {
239.         return die("Failed to bind the server socket./n");
240.     }
242.     /* listen on the server socket */
243.     if (listen(server_sock, MAXPENDING) < 0) {
244.         return die("Failed to listen on server socket/n");
245.     }
247.     /* run until cancelled */
248.     while (1) {
249.         unsigned int clientlen = sizeof(client);
250.         /* wait for client connection */
251.         if ((client_sock = accept(server_sock, (struct sockaddr *)&client, &clientlen)) < 0) {
252.             return die("Failed to accept client connection/n");
253.         }
254.         fprintf(stdout, "client connect: %s/n", inet_ntoa(client.sin_addr));
255.         handle_client(client_sock);
257.         close(client_sock);
258.     }
260.     return 0;
261. }
263. int main(int argc, char *argv[])
264. {
265.     int sock;
266.    
267.     if (argc != 3)
268.     {
269.         fprintf(stderr, "USAGE: tcp_server_test <mode>  <Port>/n");
270.         return 1;
271.     }
272.     
273.     switch (argv[1][0]) {
274.         case '1':
275.             return tcp_server_1((short)atoi(argv[2]));
276.         case '2':
277.             return tcp_server_2((short)atoi(argv[2]));
278.          case '3':
279.             return tcp_server_3((short)atoi(argv[2]));
280.         case '4':
281.             return tcp_server_4((short)atoi(argv[2]));
282.         default:
283.             fprintf(stderr, "USAGE: tcp_server_test <mode>  <Port>/n"); 
284.     }
285.     return 0;
286. }
287. /*=====================================================*/
288. /* tcp_client */
289. #include <stdio.h>
290. #include <sys/socket.h>
291. #include <arpa/inet.h>
292. #include <stdlib.h>
293. #include <string.h>
294. #include <unistd.h>
295. #include <netinet/in.h>
297. #define BUFFSIZE 32
299. int die(char *mess) {fprintf(stdout, mess); return 1;}
301. int tcp_client_1(const char *ipaddr, short port, const char *message)
302. {
303.     int sock;
304.     struct sockaddr_in server;
305.     char buffer[BUFFSIZE];
306.     unsigned int len;
307.     int received = 0;
308.  
309.     /* create the tcp socket */
310.     if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
311.         die("Failed to create tcp socket/n");
312.     }
314.     /* construct the server sockaddr_in struct */
315.     memset(&server, 0, sizeof(server));
316.     server.sin_family = AF_INET;   /* internet/IP */
317.     server.sin_addr.s_addr = inet_addr(ipaddr);
318.     server.sin_port = htons(port);
320.     /* establish connection */
321.     if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
322.         die("Failed to connect with server/n");
323.     }
324.     
325.     /* send the word to the server */
326.     len = strlen(message);
327.     if (send(sock, message, len, 0) != len) {
328.         die("Mismatch in number of send bytes/n");
329.     }
330.     fprintf(stdout, "Success to send message[%s]./n", message);
331.     received = 0;
332.     while (received < len) {
333.         int bytes = 0;
334.         if ((bytes = recv(sock, buffer, BUFFSIZE-1, 0)) < 1) {
335.             die("Failed to receive bytes from server/n");
336.         }
338.         received += bytes;
339.         buffer[bytes] = '/0';
340.         fprintf(stdout, "Receive message[%s]./n", buffer);
341.     }
343.     fprintf(stdout, "/n");
344.     close(sock);
346.     return 0;
347. }
349. int main(int argc, char *argv[])
350. {
351.     int sock;
352.     int i = 0;
353.     char buffer[BUFFSIZE];
354.  
355.     if (argc != 4)
356.     {
357.         fprintf(stderr, "USAGE: tcp_client_test <Server IP> <Port> <message>/n");
358.         exit(1);
359.     }
360.     
361.     while (1) {
362.         memset(buffer, 0, sizeof(buffer)); 
363.         sprintf(buffer, "%s: %d", argv[3], i);
364.         tcp_client_1(argv[1], (short)atoi(argv[2]), buffer);
365.         i++;
366.         sleep(2);
367.     }
368. }

注释比较少，有什么地方不懂得，一起讨论。与代码对应的内容介绍可以参看这篇文章http://blog.csdn.net/mythfish/archive/2008/08/01/2753132.aspx