一个很实用的服务端和客户端进行TCP通信的实例

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
（1）客户端程序，编写一个文件client.c，内容如下：

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   $ P: Z; U+ h) Y) J$ N" U/ t4 _
4. #include <string.h>
   - g5 u7 t7 H, Y! H5 o* R
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   : }, q0 L! K0 N  R4 J
7. #include <netinet/in.h>
   / x' w2 n/ H+ s3 \* N
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   : O! O0 t1 d" v* p& Q
9. 
   % n% N; v+ W( S* h! L! b
10. #define PORT 4321   /* server port */
    
11. 
    * E6 @  @+ `( \, R) Z% O
12. #define MAXDATASIZE 100
    
13. 
    % G4 m; t# j) l8 G
14. int main(int argc, char *argv[])
    
15. {
    9 ^  ]" @: T  w, B
16.     int sockfd, num;    /* files descriptors */
    
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    4 f4 t& W; C: a  q" A8 w- n
18.     struct hostent *he;    /* structure that will get information about remote host */
    
19.     struct sockaddr_in server;
    - L3 Z0 Q+ x& b; \9 K/ Q: o, ~) y
20.    
    4 x4 |$ E8 \8 N
21.     if (argc != 2)
    $ o5 u+ w1 i- ^3 q+ j9 `0 J" H0 G
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    7 \" y8 h: U$ P- ?
24.         exit(1);
    
25.     }
    7 t( a2 Q  c- s$ s& b4 h
26.    
    2 _* }( E. V1 A) o" z) A# L7 B
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    + e6 f) k/ ~$ w, q% d' s
29.         printf("gethostbyname() error\n");
    4 x# ?* _! `4 D! ~; E/ {
30.         exit(1);
    
31.     }
    7 o4 L! R) X$ s" V
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    0 v4 P8 E. ]& N1 t# T" B
35.         printf("socket() error\n");
    / }  a7 U$ O5 e, n6 O! p& Z
36.         exit(1);
    
37.     }
    
38.     bzero(&server,sizeof(server));
    # }: J0 y; X2 A( [, @
39.     server.sin_family = AF_INET;
    
40.     server.sin_port = htons(PORT);
      E" g+ f% ^7 d( f
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    ; H) T! a0 `- ?" e0 ~# U
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    1 `! _1 U" W% Z! Z( J, V
43.     {
    " V+ w; v& c# o; T5 a5 M" p
44.         printf("connect() error\n");
    $ D: S7 N) S9 _, b& v4 }3 W# Z
45.         exit(1);
    
46.     }
    ( F; g( j/ I5 t' U
47. 　　
    
48. 　　char str[] = "horst\n"
    ' }+ c+ b/ ~# B0 m8 }* b* s
49. 
    8 h; W6 n0 W! A1 g0 H- c: V7 c. y
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    ' T; O- @) ^& h, a2 h- C+ c! x
52.         exit(1);
    2 K6 ?' s4 {0 X
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    ' |7 z. x8 F1 Y) j* n: a
55.     {
    5 o6 T8 h, u% P- Z& v5 ^; p3 \6 t
56.         printf("recv() error\n");
    $ _$ D0 F4 o! D9 `6 @, \
57.         exit(1);
      O/ E' \  o# ]8 e
58.     }
    
59.     buf[num-1]='\0';
    - \9 _* `  D+ A: i
60.     printf("server message: %s\n",buf);
    7 p: ^' F4 [" ]# V, h; z5 t
61.     close(sockfd);
    ' I9 `8 p- Y8 f' H% O
62.     return 0;
    6 l( t* L9 e0 I6 V6 _
63. }

复制代码

（2）服务器端，编写server.c，内容如下

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   4 }& i' y* f' x2 j
7. #include <sys/socket.h>
   8 k& O& A, |+ t9 z- ?" f' }2 ?% p
8. #include <netinet/in.h>
   # m" v- X# M- T# M, `
9. #include <arpa/inet.h>
   
10. 
    
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    + _; ^: t$ f, a8 b# ~9 R% Q
14. #define MAXRECVLEN 1024
    5 \# z0 T6 W  D$ Q
15. 
    % c" r& `; H# j* M
16. int main(int argc, char *argv[])
    
17. {
      F3 ]2 X7 ~" ~1 R7 u9 N
18.     char buf[MAXRECVLEN];
    , H4 p5 x5 f8 o9 W, i9 x
19.     int listenfd, connectfd;   /* socket descriptors */
    8 Q4 c5 T9 u% U: Z
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    0 _9 q8 f% u4 o  M
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    % W6 w. o  E' |2 d2 L
25.     {
    : ?/ H( |0 P/ ?7 `9 q% s4 I
26.         /* handle exception */
    9 ]( V( t: p, Z( ?8 O
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    + e% X. w5 s  z2 [/ [( Y( F
29.     }
    
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    
35.     bzero(&server, sizeof(server));
    
36. 
    . X4 w% a7 A$ \
37.     server.sin_family = AF_INET;
    3 U- u7 U) h+ S0 ?! k. |+ r; }
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    , s5 A6 l/ L+ w! ^& B
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    % R2 Q" }  J! J
41.     {
    
42.         /* handle exception */
    ( y8 B6 |7 G! @& X+ ^3 D0 v
43.         perror("Bind() error.");
    
44.         exit(1);
    . }9 q3 ^7 }9 k5 {3 y2 p
45.     }
    0 L7 k# v* G8 i1 J: E2 ]9 O/ A
46.    
    * t8 _$ U: E' z  J
47.     if(listen(listenfd, BACKLOG) == -1)
    $ E; z2 E; W! w$ D
48.     {
    
49.         perror("listen() error. \n");
    - a4 }% J' |3 x1 l, D( X! F, Q
50.         exit(1);
    : n# g* K- ]1 r7 F9 P7 X: t' x
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    ' S, L3 a! V7 B/ Z* j* S
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    
57.             perror("accept() error. \n");
    
58.             exit(1);
    
59.            }
    
60. 
    % D8 t) n9 L1 M% i
61.         struct timeval tv;
    5 _" N3 U: K& E) N% Y3 `" z
62.         gettimeofday(&tv, NULL);
    
63.            printf("You got a connection from client's ip %s, port %d at time %ld.%ld\n",inet_ntoa(client.sin_addr),htons(client.sin_port), tv.tv_sec,tv.tv_usec);
    * y& ^2 D: Z2 L3 _
64.         
    
65.         int iret=-1;
    
66.         while(1)
    # O( H" g1 n, _* Y1 `
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    4 ^5 B8 D6 m) G5 Y; y9 R# }
69.             if(iret>0)
    
70.             {
    1 z2 H, H9 @2 J8 X6 y
71.                 printf("%s\n", buf);
    0 l2 y& i! k( v6 `
72.             }else
    
73.             {
    
74.                 close(connectfd);
    3 _5 _! R1 K/ g7 X, Y+ @# [( i
75.                 break;
    # h" T! C6 ~# L' g
76.             }
    
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    
80.     }
    
81.     close(listenfd); /* close listenfd */
    ! j0 C2 d2 {! j) h' p: l
82.     return 0;
    
83. }

复制代码

' D/ Q' Z, e3 D* k% e0 n2 j

（3）编译运行

以上两个程序放在同一个目录下，比如 /home/horstxu/Cprog/tcpCSmodel

命令行进入该目录 $ cd /home/horstxu/Cprog/tcpCSmodel

命令行执行 $ gcc -o client client.c ，可以编译出客户端程序。

命令行执行 $ gcc -o server server.c，可以编译出服务端程序。

命令行执行 $ ./server，启动server程序。

这时你可能需要重新打开一个命令行窗口，到刚才的目录下，执行 $ ./client 127.0.0.1，启动客户端程序，就可以看到结果了。

客户端：

1. $ ./client 127.0.0.1
   ; B* X, z  Y5 F1 G3 I! H
2. 
   
3. server message:horst

复制代码

# v& _, k$ ?8 K/ j: \& q3 W- G5 w& C

服务器端：

1. $./server
   
2. you got a connection from client`s ip 127.0.0.1, port 60865 at time 1418281267.643428

复制代码

本程序客户端会自动退出，服务器不会，因此如果想停掉服务器程序，直接在命令行界面按键盘Ctrl+C停止。

程序实现的功能很简单，就是服务器监听4321端口，客户端与之建立TCP连接后，再发送字符串“horst\n”到服务端，服务端打印出来，然后再把字符串传回给客户端，客户端再打印出来。然后客户端关闭连接退出，而服务端继续监听4321端口等待下一次连接。

" r6 `2 |6 B- G- ]8 h- F* o' [

' _; Q' `  k  e  }
4 R* _* e4 \( ~& d- i

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   , P/ Z. w- Y8 Z) H8 d
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   0 q  ]3 V$ H! S; i* r
7. #include<string.h>                             // for bzero  
   + H, z7 j1 {) S4 g. ]
8. 
   9 \1 t8 ^$ \' {5 l0 N- b# ]
9. #define HELLO_WORLD_SERVER_PORT       6666  
   ' F% N( V- H" o& B% N+ Q6 p
10. #define BUFFER_SIZE                   1024  
    ! T+ v8 r8 v: w9 q4 @3 Z6 k0 G
11. #define FILE_NAME_MAX_SIZE            512  
    , `4 m+ k( y7 u0 \, W
12. 
    
13. int main(int argc, char **argv)  
    
14. {  
    
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    
19.     }  
    + {8 n$ Z2 P+ z( G& v
20. 
    + o% t* q: k0 j% D' l; c
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    6 I5 U, N+ A5 q  a- }. w% y7 V
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    , W9 o- t  O  q! h5 e) ]& W: F/ d
24.     client_addr.sin_family = AF_INET; // internet协议族  
    
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    1 @4 m4 l7 @# a- k
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    # z  M/ I  Z/ l0 v* k+ M9 e
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    , X& }: O: {, |) {- Y1 j
30.     if (client_socket < 0)  
    ( G4 r; P9 Z" r2 y' Y! l
31.     {  
    ( i: f1 `# E+ o1 F, l+ Q
32.         printf("Create Socket Failed!\n");  
    ' M# o3 Y' |  I, F% y. W
33.         exit(1);  
    
34.     }  
    0 ~4 W2 E: x+ J; l! h' I
35. 
    7 k# H5 V# Z+ _+ W
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    " x4 ~3 r* ?' E: k
38.     {  
    5 ~* Q: q; d7 b  r, U
39.         printf("Client Bind Port Failed!\n");  
    7 T/ Q6 g2 P8 b# _! W6 ^
40.         exit(1);  
    $ R; n$ t4 X( b& S" A# b% q
41.     }  
    
42. 
    : K( ~; Z  Z& i0 B. D
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    2 o, w5 ^; g. j5 K' z
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    ) V1 ?6 `3 e2 @1 V9 q; b$ G9 e# ]
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    ; G( t9 h' i) a" W) S! E, r3 ]
53.     }  
    * a# ]( D- e6 c1 \+ k. K1 k2 W5 |
54. 
    8 Y7 H5 ?; x) b  q" ^6 l
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    # l1 c, m1 ]% d, _) I$ W' _0 A- U
56.     socklen_t server_addr_length = sizeof(server_addr);  
    * R0 b( r" V6 t
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    0 y: w$ a2 [( h% p- c& H
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    
60.     {  
    # w. y/ R% _& F4 j
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    0 U1 Q: h$ Q' P! H2 c8 r
63.     }  
    % |) b, ?1 t- W; X; }& N2 ~0 z
64. 
    4 Z% M  f5 f$ ^( ?( J* o
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    ' }6 g% I1 j! W
66.     bzero(file_name, sizeof(file_name));  
    1 }# v) D4 S  V
67.     printf("Please Input File Name On Server.\t");  
    + x+ f& k+ R; o' b: c6 ~4 S$ ~4 f$ G
68.     scanf("%s", file_name);  
    
69. 
    8 W0 T4 ]( |  `, z8 v
70.     char buffer[BUFFER_SIZE];  
    1 g4 T3 E# p1 ?
71.     bzero(buffer, sizeof(buffer));  
    ) A) y* _/ v- A! u; C
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    / y& [" U0 U3 p; W6 y3 y0 G2 ~
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    
78.     {  
      Z6 v& x4 B  c
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    , z& D* K% A% G! K7 x
81.     }  
    
82. 
    , V3 E. U& d. `9 b: _3 Y+ H. j1 }
83.     // 从服务器端接收数据到buffer中   
    , ]4 r4 }" o2 Y" B0 V& G( ], \* h; O
84.     bzero(buffer, sizeof(buffer));  
    . L% [( y' [8 b
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    ( A% f- B3 l! F( e7 }9 I) O/ F
87.     {  
    
88.         if (length < 0)  
    
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    : r  P! s: ~3 p) |0 I. L# k7 e  g
92.         }  
    3 B1 p' D& S+ X# v7 f. v8 \! I
93. 
    # C6 ]0 Q- R1 Q. G& a4 t
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    
95.         if (write_length < length)  
    
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    7 d" ]" m7 n+ j* g& ^
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     4 a8 F+ k6 V6 ^" Q6 K  J9 {
102. 
     8 n5 V( w2 A* a
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     : N! d! [, J6 k5 r; e1 X
107.     close(client_socket);  
     / H, X" c5 u6 ^3 w9 n
108.     return 0;  
     
109. 
     + {8 p( y' Z+ U; x
110. }  
     
111. 
     

复制代码

1. /*server.c*/
   + s" K7 U% ?3 R: }6 M( N
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   3 c  g% l1 q. Q3 A2 n
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   % b. s2 b7 I/ n4 c! `4 @1 N
6. #include<stdlib.h>
   ! E# @! C* J9 a5 s" O! s. D% ]
7. #include<string.h>
   1 V# j% U, G; T- I" T1 w! _
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   % w- A& W! N8 w2 O5 k
10. #define LENGTH_OF_LISTEN_QUEUE     20
    ) w- f) V" a: Q' Q9 a. G8 ?* e5 Z- i6 y. u
11. #define BUFFER_SIZE                1024
    2 Y! r2 s, v$ n: G8 K
12. #define FILE_NAME_MAX_SIZE         512
    / S, l1 G0 t) f4 f+ H- c+ V7 G
13. 
    
14. int main(int argc, char **argv)
    ! D7 S2 b, g: d. Y' l, x
15. {
    
16.     // set socket's address information
    
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    ! F% H7 t$ u- J% j
18.     struct sockaddr_in   server_addr;
    & O9 q8 g$ d: P1 \4 n% ?# X
19.     bzero(&server_addr, sizeof(server_addr));
    ( }! |) `6 \, g5 m( \
20.     server_addr.sin_family = AF_INET;
    4 x* e5 q( o3 N( y4 I8 i
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    
23. 
    
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
      F1 ~( I+ m0 P4 f: T8 u
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    ' o4 V! N: e# c  f; s$ Q  E9 ]: k4 E
27.     if (server_socket < 0)
    
28.     {
    * w! {, G) ^) y1 c6 X; m$ E
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    
31.     }
    
32. 
    7 K+ Y3 P4 i3 u0 f
33.     // 把socket和socket地址结构绑定
    4 O" z# b; v! x- E. a  i9 D5 D$ }
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    $ p8 [) T2 D( W% d  m
37.         exit(1);
    ( z' _) F! L) y. [! S# Z
38.     }
    3 ?3 ?% r# j+ z0 j$ R0 S$ u/ i
39. 
    + l7 d% [% D1 h: e3 C% B
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    9 y! i& l( {* F5 j5 B
43.         printf("Server Listen Failed!\n");
    + ~$ @% K% z0 m. b! B
44.         exit(1);
    
45.     }
    
46. 
    7 ~0 J2 l3 B3 W& u* M/ @3 s5 F7 ^
47.     // 服务器端一直运行用以持续为客户端提供服务
    ; b* H! n7 ^# X* ^6 a% _/ ~
48.     while(1)
    
49.     {
      q5 {  m, P6 ?0 \# G
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    ' y6 @0 \( M6 i& ]' h
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    " D5 E( {. Y; ^0 b+ p
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    ! |1 `" X/ l3 ~$ B/ }- Q
61.         if (new_server_socket < 0)
    3 k0 ]" L2 t& z, P0 S# |* y
62.         {
    
63.             printf("Server Accept Failed!\n");
    " U3 I- J9 ?  ~/ U- Z/ n- V
64.             break;
    7 G0 S2 V! }" U2 L3 w
65.         }
    ( \9 S/ u0 T- X2 i- t
66. 
    
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    " T( Z8 }* ^/ y: b3 H
70.         if (length < 0)
    
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    1 C- I" ?6 F- x+ I7 Z9 ]3 C
73.             break;
    
74.         }
    ! j+ u# ^+ U' I5 f& M, O* L
75. 
    # _, Z8 t8 R+ d
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    % m# }( F2 A% o2 i1 |# k) l0 H$ S( I: _
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    ; m  Q9 s; I8 o
80. 
    3 ?9 B* u( _6 b9 S" u
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    7 x# B( }1 G' Q/ c
83.         {
    % Q; s/ x" B! J& w  m' P8 r  J
84.             printf("File:\t%s Not Found!\n", file_name);
    # E4 A5 M4 V) v8 j4 I6 \
85.         }
    
86.         else
    
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    0 m8 U" G5 K, |$ N2 Y
89.             int file_block_length = 0;
    9 T! K+ q2 b+ m4 c  _, [% ~
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    ' b$ e/ ?: m& i% X8 u) S
91.             {
    9 w. ^/ L6 j- P5 N8 p( |
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    & h2 P4 X  N1 K2 M) n
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    ' O5 g- c  |. {% M0 {5 _( a8 G2 F
96.                 {
    # K# ]- J$ u' b  N4 B" t3 O
97.                     printf("Send File:\t%s Failed!\n", file_name);
    . S9 |! u+ C$ f
98.                     break;
    
99.                 }
    
100. 
     / Y8 f8 H/ H  ?* C; p
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     6 V" K: n. V" I( Y3 j' y4 l5 n
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     
106. 
     1 ~+ g/ Z6 v1 F
107.         close(new_server_socket);
     
108.     }
     0 n4 ?# Q, {8 V5 ^1 g+ k
109. 
     
110.     close(server_socket);
     - Y' g3 Y, c/ M
111. 
     9 z; |& [$ D  Q5 X: O1 k
112.     return 0;
     1 b' E/ Z/ w/ B2 U! O5 Z: n
113. }
     9 a: |( [  N$ I1 T
114. 
     

复制代码