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

admin

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

1. #include <stdlib.h>
   2 {, p/ ^$ N# I
2. #include <stdio.h>
   
3. #include <unistd.h>
   7 r6 G3 J: I" v) |" R# |9 G
4. #include <string.h>
   ; u$ g' b. U. W
5. #include <sys/types.h>
   6 P2 `6 {+ f; J4 p% L
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   1 ]9 v# H; J9 l# b# s7 S
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    
12. #define MAXDATASIZE 100
    ; W: W! O( w9 N5 A! {/ P
13. 
    
14. int main(int argc, char *argv[])
    
15. {
    ; ]: p5 D) u1 Z" [6 x
16.     int sockfd, num;    /* files descriptors */
    4 A9 l" E2 [# n0 c  q3 ]
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    
18.     struct hostent *he;    /* structure that will get information about remote host */
    
19.     struct sockaddr_in server;
    ' m' H) B" ?% x) }# Y5 Q0 u
20.    
    
21.     if (argc != 2)
    . D- Q2 P7 Y% k& N, q! e0 l, O( i
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    ' L7 K  v: `( c/ b1 T, T
24.         exit(1);
    
25.     }
    
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    1 e; ?2 a! I0 M6 V0 [3 Y
28.     {
    5 h& ~$ W) g1 C. J4 I" D
29.         printf("gethostbyname() error\n");
    % C2 M7 J) c2 G' ^8 {7 Q# k  F
30.         exit(1);
    
31.     }
    
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    5 J& O& |" M2 W6 |6 M* \4 e
34.     {
    3 |. b, W$ R/ o" m( o7 ]$ s: d
35.         printf("socket() error\n");
    6 t) {% Z8 s! T2 H: w
36.         exit(1);
    ) A9 H! ~) u9 Z  N: W
37.     }
    
38.     bzero(&server,sizeof(server));
      D7 x( _4 F1 X0 M# t
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)
    & k8 z. q! w# D; {6 A. h
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    2 f  j& X" y" w5 T$ z4 E6 I, `
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    8 Y9 g% u4 C1 I5 [
51.         printf("send() error\n");
    : d( z' l. M; {$ a6 A
52.         exit(1);
    3 d& r2 Z2 `( ~7 k
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    % F+ b, u. Q8 `3 M' R6 A
55.     {
    : \1 W4 K4 l; T! f0 M% Z
56.         printf("recv() error\n");
    ) x6 G" B# e; P5 e8 t4 H9 b4 r
57.         exit(1);
    / k+ T# r  P) J5 ^% ~9 a# f; F$ j
58.     }
    
59.     buf[num-1]='\0';
    # G; @( Z& G/ D9 `. P2 m
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    
62.     return 0;
    
63. }

复制代码

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

1. #include <sys/time.h>
   2 g2 s! i6 H7 @$ }% g$ P* T' j" ^
2. #include <stdlib.h>
   ) q2 B7 Z* C/ p! r: N- B8 q
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   ( _! s) D1 y4 ^7 m
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   * \3 W! T  k3 L" R& k, m* q
9. #include <arpa/inet.h>
   ; S: j$ p* e- k* m  ^1 z% t2 Q0 Q
10. 
    ; M' s8 R  u. E. j2 L9 P- q
11. #define PORT 4321
    3 L( t. t( U4 h7 |( P: A* f
12. 
    8 |. \) G7 |8 Q
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    
16. int main(int argc, char *argv[])
    1 f: r" T, q! s4 }$ |( v
17. {
    , w& l' K) I' L" e! E/ `' B
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    " k2 t  n4 ?; F" b% y3 O
21.     struct sockaddr_in client; /* client's address information */
    & s! G/ N5 b/ u, t9 I0 C7 |4 f6 x2 ]+ _
22.     socklen_t addrlen;
    & X2 U3 @  K9 I* b3 f. B
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    8 q+ G- I1 v5 B' \
26.         /* handle exception */
    " m/ j$ P& P4 L! e- R
27.         perror("socket() error. Failed to initiate a socket");
    # b# Q6 q- m" Q$ X8 h7 l
28.         exit(1);
    
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. 
    
37.     server.sin_family = AF_INET;
    ; H+ [& Q7 O3 O" u% O# F
38.     server.sin_port = htons(PORT);
    & n' {- n6 P9 Z! f( E0 G# `: K
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    , N7 m' w  w4 ]
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    6 `8 B/ m4 ~$ @9 [- e: f) k  u
41.     {
    
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    ; E% S& @) K, w7 y! m4 @9 N5 m
45.     }
    
46.    
    ' C# P7 V6 }/ q2 L; N) l) x8 E
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
    
51.     }
    0 u* h9 s3 ~& c9 p* }' i
52. 
    8 z; ]" e. a* W2 ^& g( |
53.     addrlen = sizeof(client);
    3 Q  v% G& X' v) r: L
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
      r+ B& b/ E4 N# N4 g
56.            {
    
57.             perror("accept() error. \n");
    2 I: _; C$ P1 I3 L: s+ ]
58.             exit(1);
    6 O' k, g; M: W1 W
59.            }
    
60. 
    9 }" u. U& g% I' [$ G! X; Y
61.         struct timeval tv;
    
62.         gettimeofday(&tv, NULL);
    " ^5 c( e2 S9 {" b
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 x( F) c$ |9 K8 t
64.         
    
65.         int iret=-1;
      o( g  k( ]$ w* }3 o7 G
66.         while(1)
    . s) E2 p  f9 d( g
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    
70.             {
    % Y( |5 b( P3 v# S8 `( Y2 X$ o
71.                 printf("%s\n", buf);
    
72.             }else
    
73.             {
    9 c6 \4 l& _2 ^$ g9 `7 T7 \. K
74.                 close(connectfd);
    
75.                 break;
    
76.             }
    % ^! p7 W1 K' n, A+ h* V0 {3 Y$ i
77.             /* print client's ip and port */
    - {/ {9 p, {" `. t1 A
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    : o/ I& _8 h/ Z& f. h! W7 I
80.     }
    , o) e" Y+ [3 w: p" U
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    1 g. ^3 |* j! Q
83. }

复制代码

: R; L% q: B- s) y5 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
   
2. 
   
3. server message:horst

复制代码

; Z" N6 u+ t" k# q% T8 U" L$ Z  d

服务器端：

1. $./server
   # i/ W* ^+ i1 }5 D& @; _
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端口等待下一次连接。

/ E# P2 b7 \0 N2 R6 T! x: s8 J4 Z

8 A- m# D. l# c5 w, a
2 b' K: ^+ ?2 a. K$ g9 R

admin

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

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   $ g3 W* G) c5 H2 k3 j! }' }
6. #include<stdlib.h>                             // for exit  
   
7. #include<string.h>                             // for bzero  
   
8. 
   $ ~5 b8 L2 |- s, V
9. #define HELLO_WORLD_SERVER_PORT       6666  
   # O8 B& b8 y2 \
10. #define BUFFER_SIZE                   1024  
    4 r# U  X2 Z6 X; q- q9 H! I$ H
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    
13. int main(int argc, char **argv)  
    
14. {  
    / P9 |1 C# E# g; l4 m
15.     if (argc != 2)  
    
16.     {  
    " N, m* p) z; Z6 U, u
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
      f; _; v: V- t" r9 Z" V5 C
19.     }  
    9 Z# {* m: s7 c4 q6 n- \
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    4 m4 H, d% B' h4 r' T5 _
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, 让系统自动分配一个空闲端口  
    
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    & C" _# l% S, u% ]
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    & Q$ h% [; B( a% O! c
31.     {  
    ' T' }) j6 l) H* c1 O4 P2 G+ J
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    
34.     }  
    : a5 Q8 U$ K- R( I& j
35. 
    / T8 H- B% h6 q$ b# b  Y: _
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    
41.     }  
    & Q+ O* H. s6 h9 T
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    2 Y% K9 B6 D( D) n* l9 s1 }6 z5 B. R
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    ' {+ t7 D- _* x6 `( s
47. 
    : b3 ~% b; y( C  I  B% `
48.     // 服务器的IP地址来自程序的参数   
    ( X6 a5 d. B! v2 |6 @9 ]
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    / S5 U% i! K; M* l' B. E3 t4 W
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    
53.     }  
    
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    5 i, A( P0 |, Y6 [0 o9 u+ n6 h
57. 
    ( `5 E" u2 k! A1 o! q) ~
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    " Q! x% G" k/ @$ Q. T) v7 A
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);  
    
63.     }  
    
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    2 d- X$ T1 V" R! A+ T) F$ A
66.     bzero(file_name, sizeof(file_name));  
    
67.     printf("Please Input File Name On Server.\t");  
    ) w& M1 p+ g2 t& c" k9 k
68.     scanf("%s", file_name);  
    ' J" a" ~. a  j% p: p) ]
69. 
      j" P, b; z- k2 A5 o# n& b3 T
70.     char buffer[BUFFER_SIZE];  
    
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    9 f9 L2 E( ?& e5 O% L. _
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    2 h% U6 e) z( `7 I7 K! R+ ^8 N
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    # H9 ?, i( g: g% Y. A$ {
75. 
    / m$ F% E  \6 |, ?' j! @( x
76.     FILE *fp = fopen(file_name, "w");  
    ' n  S! N7 `! p& ]4 ~; [
77.     if (fp == NULL)  
    $ O4 N2 B# o. M! ]8 P; Z2 j
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    ( t6 t# c- @, {; y1 _" d
82. 
    * ^2 l4 g& g+ c9 c+ p
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    * Y$ ?9 l# l8 x1 |
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    
88.         if (length < 0)  
    2 X1 B6 ]8 q1 L, K! W
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    
92.         }  
    4 W1 c+ ~& }, ~* g4 C
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);  
    
98.             break;  
    
99.         }  
    ) O8 Y/ D" V: L3 R; ^" o
100.         bzero(buffer, BUFFER_SIZE);  
     , G1 K, g0 i0 K
101.     }  
     ' A% _) w" j0 U% @" e
102. 
     6 v- }& W  j6 V0 B4 k+ c! a- ^3 }
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     9 ~" M! d+ j7 t
106.     fclose(fp);  
     
107.     close(client_socket);  
     
108.     return 0;  
     
109. 
     ( B( g- e+ Y4 X! R, V6 _
110. }  
     ( I- @! e1 g* Y& P: X
111. 
     - ?+ t3 k" v1 s1 @+ a4 [

复制代码

1. /*server.c*/
   . K7 N1 A; Z  v) f  a
2. #include<netinet/in.h>
   % h; ~  `. ]" i1 K4 l' [
3. #include<sys/types.h>
   / @1 B0 Z& u# c
4. #include<sys/socket.h>
   ! l! Y3 \# u, b( J4 P* e* r
5. #include<stdio.h>
   
6. #include<stdlib.h>
   * m* D! E/ d3 w$ ~1 c, d
7. #include<string.h>
   / `! @; H9 A- @" q
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    5 b$ B5 P! S9 n7 F0 }
15. {
    
16.     // set socket's address information
    5 u$ Q8 \8 c3 G4 V0 P# S2 n" O
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    - E! y( }: H$ e  L) m" I1 Z
19.     bzero(&server_addr, sizeof(server_addr));
    7 l/ Z+ z6 G) N6 z
20.     server_addr.sin_family = AF_INET;
    ( G' Y& A" B. X
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代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    
28.     {
    ! J) Y) H6 Q5 L, N7 N
29.         printf("Create Socket Failed!\n");
    % A) C1 y4 D  {* @* g
30.         exit(1);
    6 ~& e) Y7 G5 O; E9 q) T( `, e
31.     }
    + G2 k5 @' C$ g, H) y
32. 
    " @* |* V4 s! H! {4 \9 o
33.     // 把socket和socket地址结构绑定
    
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);
    8 O# {+ ?' b# M9 c9 j$ Y
37.         exit(1);
    
38.     }
    
39. 
    8 m+ L- ]- x* s$ W7 ^
40.     // server_socket用于监听
    " l* ]  \$ ^6 u1 t' a) [
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    7 j8 _! m0 l/ c# ^( p
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    " r7 V/ @' v8 |5 |
45.     }
    
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    + ]! Y7 q- H$ G
49.     {
    / J6 p8 n8 f& P7 n1 l- M6 _
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    ! z+ i) I3 d9 ]& N4 |) ^' c
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    , }. X  _1 H/ {5 @
52.         struct sockaddr_in client_addr;
    : Z& G# T# Z* L( h1 r  O" b7 i
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    ; k: ]6 H; Z, E& h5 N! I
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    & x6 u3 a0 r8 s/ Y2 m
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    # b9 p+ h+ i" w5 L3 q% D8 N5 ~3 J
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    
61.         if (new_server_socket < 0)
    
62.         {
    
63.             printf("Server Accept Failed!\n");
    
64.             break;
    - p8 v- K# J$ h0 C+ p
65.         }
    
66. 
    9 S9 V8 I0 ]1 Q# |( D7 l$ s
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    / D) j% i; y1 w
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    
70.         if (length < 0)
    
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    , H  ?. Q/ c# ?& Z0 h6 ~( G4 T0 f
73.             break;
    
74.         }
    
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    / L4 [& f$ r: [$ p" e4 r6 D( g$ E
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    9 j1 ?; v' _- |* I9 H# R4 y
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    " @' ~/ \! U0 W4 w
80. 
    & v8 q5 V. x( P
81.         FILE *fp = fopen(file_name, "r");
    " v: c' f+ s) r
82.         if (fp == NULL)
    * \0 f/ Q9 _9 W% B8 t
83.         {
    5 F& f+ i( U! W$ o& {
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    # I2 B4 ~& O- h! ?1 ^
86.         else
    ! D. ]' T+ q- `# \, d  q0 T
87.         {
      d) P- A8 w! U" G8 m+ w
88.             bzero(buffer, BUFFER_SIZE);
    * \" ~, W7 O* {0 M5 h
89.             int file_block_length = 0;
    + m$ H1 u- P# s) y
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    0 C0 {1 R- X! E7 m
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    3 s' X, |: n- n9 {8 }
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
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;
    " n4 p6 S& Z5 U* W. H
99.                 }
    . P( G  u  N0 A  Y
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     9 U# A: G) @# g# Q* j2 |
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     & W3 B4 s# }0 p" e6 D% t
106. 
     
107.         close(new_server_socket);
     1 z. m! ]  A$ v2 a8 o
108.     }
     
109. 
     
110.     close(server_socket);
     ; Q6 l' T- h7 A0 ~; B- Z6 m* k
111. 
     2 L8 K5 t- \" W
112.     return 0;
     
113. }
     ) N# T4 V' @9 z9 W! ?, S3 q6 z9 e
114. 
     & D) o! k7 i: |

复制代码

; G2 O, e: z0 o  g' k