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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   & w+ K5 g$ B' r# M: T* n
3. #include <unistd.h>
   
4. #include <string.h>
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   4 ^7 n3 O& Y" z
7. #include <netinet/in.h>
   * S: D' u+ k  h; A
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   2 o3 @( k& v$ T* R8 P" b& {0 H
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    ! |$ D2 J& @& j  u* `
12. #define MAXDATASIZE 100
    
13. 
    
14. int main(int argc, char *argv[])
    ! W2 [" {2 s* {
15. {
    
16.     int sockfd, num;    /* files descriptors */
    
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    ) j& U( @/ W5 v1 D. k  s6 A3 X+ f) Q
18.     struct hostent *he;    /* structure that will get information about remote host */
    
19.     struct sockaddr_in server;
    
20.    
    7 N- A" F/ O0 c7 ^( A1 R: E- i
21.     if (argc != 2)
    . k  \- C! x6 U1 S" o% r3 c& @: j
22.     {
    0 ~' G: R, ?: q  j% {3 o
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    7 }. S% B+ n6 J0 u
25.     }
    
26.    
    1 n" `* d6 ^$ W
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    , V0 b1 i- S9 L9 ?/ I
29.         printf("gethostbyname() error\n");
    7 N% D2 j& x" V( U6 |+ Z4 o
30.         exit(1);
    : S5 k3 @0 O- {1 [4 X9 D/ g
31.     }
    8 I$ W3 s; l% f
32.    
    0 Y- p% I2 j, ~. ^  \5 _
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    4 w% q, W6 \/ Q& a
34.     {
    
35.         printf("socket() error\n");
    
36.         exit(1);
    - x$ W4 D# Z6 I+ r/ r7 m! W1 K7 j& }
37.     }
    , X2 |: L; d5 ?. {) N
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    
40.     server.sin_port = htons(PORT);
    
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    1 a& E1 z9 g% o$ U
44.         printf("connect() error\n");
    3 ^! L; p$ s! J6 k# Y
45.         exit(1);
    
46.     }
    8 R+ z. f, e# W! u2 a
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    4 S% J! x% o! S
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    # v8 w  ~+ t4 Y" e9 T
51.         printf("send() error\n");
    ( N2 F6 t% s0 i, l1 R" X
52.         exit(1);
    
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    4 a" |0 Q6 t( T$ ~0 [) q# J
55.     {
    0 f  E/ N" R9 e3 R! E$ q5 `
56.         printf("recv() error\n");
    
57.         exit(1);
    " h& {  y; b7 z+ j
58.     }
    3 ^% x  }0 r, F# g+ d
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    , e% n. h1 Y. Q# k
61.     close(sockfd);
    + j1 R6 ?' z+ q, W
62.     return 0;
    
63. }

复制代码

（2）服务器端，编写server.c，内容如下
9 ~: u6 q- Z( L5 Q7 A

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   : U" t) I/ v- R! V  }
4. #include <string.h>
   - x/ E6 y3 p( o3 a/ H
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   # S# m5 v4 h3 G9 C  I/ {
10. 
    
11. #define PORT 4321
    : f" t9 B6 ?3 ?) p
12. 
    % y& G- ?/ p' F( f
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    9 N, ~4 O: `: m
15. 
    
16. int main(int argc, char *argv[])
    
17. {
    : \7 E, q  M* {# l- O
18.     char buf[MAXRECVLEN];
    ( l3 q  m) f! T; }' Z1 ]
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    ; ^  y$ t# L1 z% X% P
21.     struct sockaddr_in client; /* client's address information */
    ( ^3 E7 e4 x! w0 `& l1 a
22.     socklen_t addrlen;
    # |8 T8 ~' D8 b" b1 {+ I
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    " C' X- W0 {! S1 H
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    0 q; G! i  ?3 D; L# H/ j
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    / a1 s( W* s8 Z) f. J
34. 
    
35.     bzero(&server, sizeof(server));
    
36. 
    
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    1 o' R. t8 X& W' n$ _
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    $ i1 v  Q- J8 u) B8 e0 @1 u
41.     {
    2 R8 C. s' ~& J8 ?
42.         /* handle exception */
    " _1 i( r% A( B$ |4 H
43.         perror("Bind() error.");
    
44.         exit(1);
    
45.     }
    
46.    
    ; N* ~  T; K' O$ N7 [: K
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    3 I* p2 m! v. e& q& ?5 t$ C' }
49.         perror("listen() error. \n");
    2 N( `# W8 R9 _0 G# f
50.         exit(1);
    
51.     }
    
52. 
    / S3 [& T" O) a* @( ?; e' Z
53.     addrlen = sizeof(client);
    
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    ) s2 c6 g" i+ H" S9 Z6 L% ~0 i# j$ H; z
56.            {
    ' I5 M/ f; V; m3 p$ O3 d+ W: b; b( h
57.             perror("accept() error. \n");
    + `/ ^" |$ r6 o. I: r# O# L
58.             exit(1);
    . N- s% H5 V  ~% M* m
59.            }
    
60. 
    9 p  F% U) ], S; y
61.         struct timeval tv;
    
62.         gettimeofday(&tv, NULL);
    4 `7 H- s# O' Y8 z5 |
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);
    1 b" u( L1 {; y+ Z9 h% J0 q
64.         
    ' I/ p, {3 Y( P  U7 M" J& K$ {0 i  N7 v
65.         int iret=-1;
    
66.         while(1)
    4 v$ w7 I. j6 u$ T" p3 y( ?
67.         {
    ) v: x. f2 f% D; t9 q+ H9 T3 U
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    ! h+ B6 O6 m6 N4 m3 K
70.             {
    * [8 Y7 q4 v- L) k
71.                 printf("%s\n", buf);
    
72.             }else
    
73.             {
    4 M) r; {2 z( C7 C) C
74.                 close(connectfd);
    
75.                 break;
    
76.             }
    & y! I. D9 E2 s' H( J
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    9 u9 E! p  F8 _' x" X
79.         }
    
80.     }
    8 H' S; S% a. C& V6 j5 Z5 r$ V
81.     close(listenfd); /* close listenfd */
    & O/ {2 o4 w& u9 u
82.     return 0;
    ) n; A+ g7 d! O& V9 M3 h
83. }

复制代码

（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
   
2. 
   ) ^. e7 E, `* V+ @
3. server message:horst

复制代码

! i3 \6 h$ W) o9 r8 t& U

服务器端：

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端口等待下一次连接。

admin

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

1. /*client.c*/
   4 C: y- ]  @9 }
2. #include<netinet/in.h>                         // for sockaddr_in  
   % G6 x( ^- ^7 ^
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   . Z  u& b; P  Z
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   1 `; j0 G5 b9 s0 x8 Z: m* r, n1 d; x  [' U
7. #include<string.h>                             // for bzero  
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   
10. #define BUFFER_SIZE                   1024  
    & n, V8 ~" \( w+ y# v, a
11. #define FILE_NAME_MAX_SIZE            512  
    5 k- o* e0 _) d' k! G: t
12. 
    
13. int main(int argc, char **argv)  
    
14. {  
    % e' p* d6 Q% j, |0 W
15.     if (argc != 2)  
    
16.     {  
    & A0 J: ]: c" o9 U- P) z
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
      r" x9 L8 ^+ |( x3 w0 T; e
18.         exit(1);  
      W1 b8 l/ V$ g7 H
19.     }  
    
20. 
    * Z0 l5 s- U, U+ V  c
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    
24.     client_addr.sin_family = AF_INET; // internet协议族  
    
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    ) @! R: k# i  b7 j3 W
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    $ g4 c7 _8 b# y* E' m. `
30.     if (client_socket < 0)  
    . G6 Q; `& t5 t% _
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    0 P  a" R/ d9 m9 Q: R7 A
33.         exit(1);  
    * ?: o2 J' A% ?7 R
34.     }  
    5 v  M, x9 c: b' K) B9 }
35. 
    3 ?; C* I3 w; p; i7 O# n5 ?: u6 W
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    8 V+ S% W% R  _
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    , X0 M8 M2 h! A# s9 c9 I& I( L1 y
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    * ~4 T7 g; W5 \+ U
41.     }  
    
42. 
    * U) @8 n& O7 b6 _
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    1 m) y+ ^9 O0 M  a0 J, |" I
45.     bzero(&server_addr, sizeof(server_addr));  
    / W& Q  n! r" t1 O7 w# G
46.     server_addr.sin_family = AF_INET;  
    
47. 
    6 r9 I( x4 _0 z+ ?# |. n" y* M
48.     // 服务器的IP地址来自程序的参数   
    
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    $ j1 Z& [0 v" @1 K6 C) F
50.     {  
    7 i3 J! b& O# ^
51.         printf("Server IP Address Error!\n");  
    7 M* e! c; Y+ K( R
52.         exit(1);  
    
53.     }  
    
54. 
    2 C. \8 ]9 ~2 V0 |4 U: d$ t
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    7 I$ a; w8 P! O0 b" k/ ]" L1 c* o- f
56.     socklen_t server_addr_length = sizeof(server_addr);  
    4 f. D* ^) K6 l4 Q6 c
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    1 t8 B( `# V7 X- {" l9 b" I
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
      Y$ j8 Y5 v2 N1 \
60.     {  
    # g) F6 X8 ?8 j# q, ?
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    0 u! A$ w3 J; D+ g
62.         exit(1);  
    
63.     }  
    
64. 
    $ |# u( ^/ s% v
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    ( w. \5 T( w* @$ v! k* }" \8 D5 x* N% k
67.     printf("Please Input File Name On Server.\t");  
    * N: h$ ^8 B* ]3 {/ |5 C4 Z
68.     scanf("%s", file_name);  
    
69. 
    
70.     char buffer[BUFFER_SIZE];  
    # J; X3 u  n  q! W6 p  e2 ~
71.     bzero(buffer, sizeof(buffer));  
    
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);  
    ! G0 a1 z3 H" _8 u
75. 
    , K+ f) {1 r% z$ }3 D5 }
76.     FILE *fp = fopen(file_name, "w");  
    7 }% g* k2 I; k& B
77.     if (fp == NULL)  
    
78.     {  
    + y' x: q) f( N$ J
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    - x- H2 }4 i, |4 ]- r, B6 h$ G
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    " W0 ]; ]5 F0 o) Q7 F, R8 O' ~
87.     {  
    
88.         if (length < 0)  
    
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    " H/ O- J9 t  W* c: @. P/ j
92.         }  
    
93. 
    
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);  
    & R( f- S9 g/ ^$ v( q+ {, U6 K
98.             break;  
    
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     $ u/ U! r% c* y1 p( F0 Q, Y
104. 
     4 O( Z" j- {' E! U0 a) y# V
105.     // 传输完毕，关闭socket   
     + n7 ~* h  L% v- j% D9 E  Z$ z
106.     fclose(fp);  
     
107.     close(client_socket);  
     8 ^( o! `$ R/ G: [9 [
108.     return 0;  
     
109. 
     ( L9 ?' x8 Z# w7 Z* M6 r
110. }  
     
111. 
     

复制代码

1. /*server.c*/
     H( ~" U5 `8 u
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   % R8 t9 H# _6 C8 q* b
5. #include<stdio.h>
   , X+ A+ ]! p: J8 P
6. #include<stdlib.h>
   + w- ?( Z- u& _
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    % }! U2 c( E& r2 \3 d$ V% L  _) L
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    $ w+ ^2 C6 m8 l! H
15. {
    
16.     // set socket's address information
    " p5 }& n0 t9 H- G8 l0 B
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    
19.     bzero(&server_addr, sizeof(server_addr));
    9 m( \. g+ a* v4 ]# p0 z" U: Z3 O
20.     server_addr.sin_family = AF_INET;
    " |3 j4 x! }+ K9 y, q" E+ b
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代表服务器向客户端提供服务的接口
    ' s, N! m- k$ Y9 F. z0 ~6 Q6 s- k4 F/ I
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    & ~; {5 G6 x4 W) z- k5 P
27.     if (server_socket < 0)
    
28.     {
    ) l2 R  D" K3 C7 I% ^
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    $ l$ G! A1 ]9 D+ [# b9 R
31.     }
    
32. 
    % O$ y& f/ i) N) p- _0 a4 C# G
33.     // 把socket和socket地址结构绑定
    6 I1 k9 K1 q# o1 \& f) B+ G+ h
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    4 d; U( W3 g: ^; a, Y4 m$ H
35.     {
    ' w3 F6 j# I6 C, L( Y
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    3 D/ }: t9 o; F$ I4 u
37.         exit(1);
    
38.     }
    - {2 K' x8 M- T" F, J) t
39. 
    ! t, r/ Q& g* Q& R
40.     // server_socket用于监听
    " n# ]# \! Y! ^1 l9 e) X$ z2 a
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    ; M6 M$ M. y0 R8 k' p; w6 z
42.     {
    
43.         printf("Server Listen Failed!\n");
    0 _$ L- \. V6 Q+ `& ]* [
44.         exit(1);
    
45.     }
    ) G7 ?( p" j! O# v! V1 i
46. 
    6 i$ e6 }7 Q* [. ]' ]1 S0 M
47.     // 服务器端一直运行用以持续为客户端提供服务
    & h: Z9 D$ M" ]5 H, H0 \) @
48.     while(1)
    # [. z9 |* S- Z% {/ Q9 }
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    , q: x+ S3 G* q$ y
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    + v* Z; U! b+ a8 F
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    5 j6 R, |/ v, J& Z: \+ O
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    3 P* u" Y8 q+ N1 x
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    $ E. C/ _1 N: T* E7 s
61.         if (new_server_socket < 0)
    
62.         {
    1 `3 M, p& t$ ^! A; A5 w. S
63.             printf("Server Accept Failed!\n");
    + Z* w) B) |$ o  L/ W2 d6 h
64.             break;
    3 K5 t, _2 I% ]6 |6 g) T: `
65.         }
    
66. 
    . Z) @- `3 ^7 M. O  n
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    
70.         if (length < 0)
    
71.         {
    . P5 a4 z' K# T0 ^+ g9 F
72.             printf("Server Recieve Data Failed!\n");
    
73.             break;
    
74.         }
    + J# E/ ]" X9 p8 {
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    ! r. S1 O. t7 J1 d* d
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    8 w) o: Y+ G; ~+ l
83.         {
    9 r9 J: W; u* c) N; ^
84.             printf("File:\t%s Not Found!\n", file_name);
    + O8 q& `/ N; T. t
85.         }
    
86.         else
    ! W! Z; z& o: f
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    + P, p+ c) ^" I6 i* e
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
    4 |! s: \" _* Z
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    & d7 w; C6 {/ A* h
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    ; T, y: S1 i6 Y0 `4 N1 w
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    ! {' o: O2 T" N& }  |
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    
99.                 }
    & ]1 Q7 C: k. j0 H0 J5 ?2 M
100. 
     , I! S- _6 L& y. h" x5 P1 g
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     
106. 
     
107.         close(new_server_socket);
     
108.     }
     5 o8 v, B% o. G8 d6 \* G
109. 
     1 e3 c, t8 a6 t: T
110.     close(server_socket);
     
111. 
     
112.     return 0;
     - X$ x- a, D: T/ z! B/ d
113. }
     $ }% T  G2 H' b
114. 
     3 |4 p) ]8 ^( m& ]7 k& q

复制代码

3 L& m; w7 D5 {- v) E7 M

. l# F5 A4 I: P# d! D; F