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

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
# F2 f4 y. Y9 v1 i+ w8 l/ h* V9 ^（1）客户端程序，编写一个文件client.c，内容如下：
0 u1 c6 ?% n5 E# R3 o

1. #include <stdlib.h>
   4 O! q# c6 c# N. a% k% l
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <string.h>
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   8 l: ?. s6 y) S3 @. G- Z0 J
7. #include <netinet/in.h>
   2 F; u6 ]' X( f2 B7 Y+ B6 J4 c
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    8 K" C  `% u! V' V3 X8 F
12. #define MAXDATASIZE 100
    
13. 
    + g; G- |+ ~7 Z! M1 t) \7 b# E
14. int main(int argc, char *argv[])
    $ m, w* G3 X4 P
15. {
    
16.     int sockfd, num;    /* files descriptors */
    
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    ) l8 D$ Q8 Y, Y5 R4 y7 j
18.     struct hostent *he;    /* structure that will get information about remote host */
    ' C" Q+ e% v' h1 ]$ W
19.     struct sockaddr_in server;
    
20.    
    
21.     if (argc != 2)
    0 ]- r  c- P7 H, {2 R6 l
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    - G( w7 u: _7 k& b( H6 |
24.         exit(1);
    
25.     }
    
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    
29.         printf("gethostbyname() error\n");
    ; I. P5 }% D  _* u
30.         exit(1);
    
31.     }
    
32.    
    - h2 H, Z1 m7 q/ Q8 |2 `
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    " e$ [! V3 T, h0 G1 d+ Z
34.     {
    7 Y6 i: u- f- u  g# e; v
35.         printf("socket() error\n");
    8 |. M& a# D' @
36.         exit(1);
    # E0 \! w; J& E
37.     }
    
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    3 l1 n/ c/ B9 h3 o6 N+ @% C  ?
40.     server.sin_port = htons(PORT);
    % y$ R2 ^/ _, i2 S' [6 ]
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
      ^- z9 ~$ H: X" R( A5 X
44.         printf("connect() error\n");
    
45.         exit(1);
    $ A2 g2 p. D7 \1 w. R( X! Z
46.     }
    
47. 　　
    * ~. j  r- H/ ]: \4 {# d
48. 　　char str[] = "horst\n"
    1 j! E5 b& i/ a( r
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    * d4 Y3 n6 M2 ^7 l/ x9 Q* @+ Z* }; e
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    
56.         printf("recv() error\n");
    9 e# i6 A9 K" H8 P
57.         exit(1);
    
58.     }
    % R9 D! b' ^4 O* A3 \, [3 Z
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    ) R/ Q' |) Z; {9 c3 w0 k8 d+ z
61.     close(sockfd);
    
62.     return 0;
    
63. }

复制代码

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

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   , |* d  E, p* }* ^$ ~# p- K$ L5 ^
3. #include <stdio.h>
   7 t, B- {% a" y+ P, Z+ h9 l* s. r
4. #include <string.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>
   
10. 
    8 b, f( l5 R- D& q
11. #define PORT 4321
    7 G7 k; t: a6 @5 ]0 `- \7 S
12. 
    / m, j( u2 E" q# f$ O7 D# P7 Y
13. #define BACKLOG 1
    / F& _! y1 t. s; U: P8 {% `/ d9 T
14. #define MAXRECVLEN 1024
    
15. 
    
16. int main(int argc, char *argv[])
    * P* G% n+ p3 D; p0 R- ^
17. {
    4 `! \/ J: x' A5 }# e  S) N, e; }
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
      W- g1 Y4 o/ ^/ r7 Q5 u9 t* U
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    / s" q3 _. u3 o: J6 G
25.     {
    
26.         /* handle exception */
    & s3 f% ?. @. m7 e( k- \: W3 ~
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    
30. 
    
31.     /* set socket option */
    * `" K- ?# R( }9 P' o
32.     int opt = SO_REUSEADDR;
    ( t. ~  T& {. |, n- W. p
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    & W9 b5 f" ]! F+ ]$ j
35.     bzero(&server, sizeof(server));
    
36. 
    6 d" o" {$ n; E1 L. S
37.     server.sin_family = AF_INET;
      R, e/ M  s' ^
38.     server.sin_port = htons(PORT);
    ! D: `9 o& G+ I2 j
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    ) c9 S7 w4 X! S5 O
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    + `4 z9 T# W- R) w, ?: i* T
41.     {
      a. f) V: u  I' T6 j  N
42.         /* handle exception */
    * |3 F% X5 }& ?# ?: c
43.         perror("Bind() error.");
    
44.         exit(1);
    * e8 Z" [( X9 y; [5 B- [0 k/ f/ a
45.     }
    
46.    
    ) J! Q- I1 m" v5 n: K+ M% p* W
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    " I2 p- y# _3 D  E" @" E. h& l/ N
49.         perror("listen() error. \n");
    ( N* F& c* a) R. C
50.         exit(1);
    4 h, W$ g$ u' H$ n
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    , o) N7 V9 [9 h1 N
54.     while(1){
    ' O' L9 f" S7 E8 K- E, c( h- B: C
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    % i  t! c" X+ d; {
57.             perror("accept() error. \n");
    
58.             exit(1);
    
59.            }
    
60. 
    
61.         struct timeval tv;
    
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);
    
64.         
    
65.         int iret=-1;
    7 `3 j7 W& H; s
66.         while(1)
    % o1 ~0 c5 Y; c# {
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    
70.             {
    / d, @1 h/ X( s2 s) G7 A" x
71.                 printf("%s\n", buf);
    
72.             }else
    
73.             {
    
74.                 close(connectfd);
    
75.                 break;
    
76.             }
    # W* }/ W. n$ p
77.             /* print client's ip and port */
    7 W9 c" Z& S# Z- _9 B5 ?
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    5 g7 w2 D. K* P, [8 @. C7 z
79.         }
    8 k  n! `% p- p& `) e1 H9 a
80.     }
    - S. _/ }, p9 E
81.     close(listenfd); /* close listenfd */
    + A, m( S1 |4 L9 Y
82.     return 0;
    
83. }

复制代码

1 g6 C7 D$ N) H( N- F

（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
   , P' L$ b; ^) _: h$ K4 s
2. 
   
3. server message:horst

复制代码

服务器端：

1. $./server
   # ]; s1 S) s2 c. M3 d9 Y
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端口等待下一次连接。

5 m: D5 k% T) {' L' ]: u8 p
- t- K9 {6 U/ ~6 N8 k4 e

3 T: J  w% a* k

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
* a- D4 A5 `& [& w" r7 Y, ^3 j

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   # h: E! ]/ U9 \2 x5 V$ ]' g. [
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   ' |0 e! s6 j$ w. B% E0 A
6. #include<stdlib.h>                             // for exit  
   
7. #include<string.h>                             // for bzero  
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   5 {5 s' Y4 M' o0 E6 |5 d% |# I
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    & _0 u+ p! A( m8 ?& x% R- D
13. int main(int argc, char **argv)  
    
14. {  
    ( o# L3 _7 T6 ^: B5 m5 S
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    $ }4 z4 z4 p3 o
18.         exit(1);  
    . J8 e- j5 f7 Q, F
19.     }  
    
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    * V( U6 }' Y/ r3 O
23.     bzero(&client_addr, sizeof(client_addr));  
      S- f/ a* X; }7 K# R: z! ~
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, 让系统自动分配一个空闲端口  
    7 D- N4 q6 l. d8 D$ [7 m( R
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    " L; @8 f7 A+ L! N1 z# P) r
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    & @1 k: H# C5 T4 n  r3 }! D
30.     if (client_socket < 0)  
    4 ^! n( E5 i2 k( j. d. c2 E
31.     {  
    1 g# v1 l2 y1 O* M+ U
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    * S5 Y/ x# G4 G& v/ ]3 J
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    % h. Y& J" F* z8 p3 N% e4 J
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    ) O8 q8 l& T* i% A2 U" R. }  T
40.         exit(1);  
    
41.     }  
    
42. 
    
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;  
    7 Y. A0 [% t6 z6 `; s; Z* |
47. 
    
48.     // 服务器的IP地址来自程序的参数   
      e: F# _6 h  {6 e" t4 i; |
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    # P, C' C* {2 ^) o, E. T/ [: @
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    
53.     }  
    8 G4 f3 m; C0 I3 T3 G6 W5 n5 ]% L' ]
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    6 f8 O% u  n1 \, @
56.     socklen_t server_addr_length = sizeof(server_addr);  
    ! {8 m3 u) u' g9 N4 O7 L& ]
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    ' c5 h3 Z- b% P
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    * F. u) z4 d% A
63.     }  
    
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    - T, n' q  k  w8 c2 U8 j
66.     bzero(file_name, sizeof(file_name));  
    
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    : T- N( x, Q3 k7 v/ ^( f( L
69. 
    
70.     char buffer[BUFFER_SIZE];  
      `% b, N0 Q( A' Y3 @! R
71.     bzero(buffer, sizeof(buffer));  
    & g1 Z, G6 Q. k6 q
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    1 ?: q) M) h1 Q
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    0 {& T, h& o+ J6 j% D8 i
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    ' w6 H8 K: e% [+ U
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    6 N- \( u/ G9 x8 o7 w9 g
84.     bzero(buffer, sizeof(buffer));  
    ! c8 ^; }* @( J4 K5 D1 w
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    & O* t# V) l" A4 G5 |. ?. R$ R& ^
87.     {  
    
88.         if (length < 0)  
    
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    
92.         }  
    
93. 
    
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    + d& K& ]* F. C7 B5 v
95.         if (write_length < length)  
    
96.         {  
    ' |. {8 A# I& S4 M8 r8 ~) k/ q  m
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    # ?( O3 y5 ~- [1 O/ R9 g1 @
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     ( P5 G  t* \' [) Z* Q. ]
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     # I6 ]' H+ A0 ^- {; B7 ~( H8 Q
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     
107.     close(client_socket);  
     6 h$ E' W% C, u/ ]
108.     return 0;  
     
109. 
     " ]  N% s; b. ^& ?( ]
110. }  
     
111. 
     ; p: x/ m: j5 ^# c8 N

复制代码

1. /*server.c*/
   - n7 {: j: x4 W' Q& f0 H
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   4 }- I5 G2 J& c% S, l  g3 i  `! i( v
5. #include<stdio.h>
   & d4 Y4 V" f1 r6 ?
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   : v; U( L- [1 z" H
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    9 s3 q! V+ i' L. {. ]8 j
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    ) U3 @# h; Z* ?& R
14. int main(int argc, char **argv)
    
15. {
    
16.     // set socket's address information
    * c0 e( a% h( n( [
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    " U4 _: ?! ]& G( \: g2 Y' ^
18.     struct sockaddr_in   server_addr;
    3 |) w' i2 H# T6 O9 \( C- M0 \
19.     bzero(&server_addr, sizeof(server_addr));
    / L9 X# W% F9 Z- u; h9 c
20.     server_addr.sin_family = AF_INET;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    7 M, {2 W) A- w& n$ l
23. 
    & O# O# }& Q8 W4 K$ Y/ U2 ~) A. m
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    " K& v8 J. u4 B+ B, h/ K& w4 i! }
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    
31.     }
    
32. 
    
33.     // 把socket和socket地址结构绑定
    3 l! i, d+ J# g7 B3 V" f; y# l' x
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    " }, y( S) A( c+ C7 i
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    % z+ d% c  c1 n- g- p! y8 T
38.     }
    - M' D  f* A% H- c
39. 
    ; b) [; Y7 q& p$ t# S% j2 k
40.     // server_socket用于监听
    5 w; s" K' v3 p4 m& ?
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    
43.         printf("Server Listen Failed!\n");
    ( {4 [, X, o' n3 P" r  r
44.         exit(1);
    ( b6 M# C" ^+ t5 e
45.     }
    
46. 
    6 A0 J+ R0 e5 S1 R
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    , b& x3 J( `9 d8 M5 K
49.     {
    - _2 y! H6 \( B$ \0 u
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    8 G; j* w/ c9 e) ?6 p( L
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    # b* ~9 f' e7 p9 l; O
54. 
    7 n* o) B7 ^  W& N$ |4 D: P
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    0 ~9 B. G5 s7 f. S7 ?# x7 t* P
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    # k$ B6 n0 U! t
59.         // 这里的new_server_socket代表了这个通信通道
    7 i& p% x- u/ E6 Q0 s6 Y
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    ; v7 n3 |/ p9 T$ j  A
61.         if (new_server_socket < 0)
    ; I2 X7 u8 d$ ?/ L4 s- {
62.         {
    4 ~3 k+ K, R+ {" @
63.             printf("Server Accept Failed!\n");
    ( S+ [4 Y- D/ W7 ]' v/ o1 Q) K2 p
64.             break;
    4 _( j  L8 ~7 C- E% ?4 i  |8 R
65.         }
    " F, B, n) a3 J- c3 s% n
66. 
    ( [3 u0 i8 v8 C: [* c
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    8 T# x2 I& Y# [- ]
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    ' \" w1 c5 I. G& W& L
70.         if (length < 0)
    - r/ T" w: k! W; U+ V5 r6 N- `
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    
73.             break;
    * i  a3 f/ q/ ]
74.         }
    
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    # T: a# J4 M( t3 j. b
78.         strncpy(file_name, buffer,
    , _! K9 N4 e- r: x/ R% j3 C
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    - z' F2 }# T) [6 l- u) y
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    9 r2 {. ?& M5 z" `. y6 o
86.         else
    2 ], O# d: O, W7 J* d/ d9 D% g) ^* _
87.         {
    / `% ^7 b8 K3 F$ C( O
88.             bzero(buffer, BUFFER_SIZE);
    9 C% j+ F0 T  q1 N7 p- s* ~7 p
89.             int file_block_length = 0;
    0 u  h2 W7 c  Y" S; _8 `
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    : q+ R' Y! `0 H
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    % \( H7 ]8 H; D2 }# R+ B6 ]
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    ! X' i  L2 X( K: K) U( G
99.                 }
    # J. n6 c8 H/ D- Y5 W, j
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     8 B; I9 k% l- a1 M0 e4 W' M9 S
105.         }
     " \* D, x. t. ^& g; {/ o' @
106. 
     
107.         close(new_server_socket);
     ' d/ v; Z- B% e) ?& R6 v; ?
108.     }
     3 x; t' j  g% c# x
109. 
     + Z; I& a2 p- {! b; m& `
110.     close(server_socket);
     
111. 
     
112.     return 0;
     
113. }
     , j: ^9 l9 A$ u
114. 
     2 O) A8 \& E! ~

复制代码

, Z, A: a8 F2 G& a
+ i8 W; D7 H6 r% u/ |