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

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
9 J( _1 I9 M7 O( w) i/ v+ C（1）客户端程序，编写一个文件client.c，内容如下：
' F# u# R: y( @0 B% Q3 o9 F8 @

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   . u$ [+ V6 }6 q& t
4. #include <string.h>
   
5. #include <sys/types.h>
   " f( e- N0 g1 t; e
6. #include <sys/socket.h>
   % j# I& g5 U+ V6 K. i7 s7 a
7. #include <netinet/in.h>
   6 g# s" J" d$ i+ Z
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    
12. #define MAXDATASIZE 100
    
13. 
    8 V8 F5 u% i3 \) [
14. int main(int argc, char *argv[])
    
15. {
    # ~0 u( s( N# F. e: @7 ]9 P0 h
16.     int sockfd, num;    /* files descriptors */
    
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    6 N" w8 @" i& Z) j+ W7 t6 F9 j
18.     struct hostent *he;    /* structure that will get information about remote host */
      W' n( j2 T" H4 ^) _1 t
19.     struct sockaddr_in server;
    - B2 _3 x% E: F( ]" I5 Q& m* {
20.    
    1 y5 S. b7 ?) I* x
21.     if (argc != 2)
    
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    * e6 I/ ~1 `% |, o
24.         exit(1);
    
25.     }
    ) p# y7 _% j3 X# q8 o0 r& L
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    " [# O- x3 U& e$ p& C
29.         printf("gethostbyname() error\n");
    + b, a. z3 J7 F- k- j* }
30.         exit(1);
    
31.     }
    
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    
35.         printf("socket() error\n");
    
36.         exit(1);
    
37.     }
    
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    7 o2 \: ?! F6 A4 i$ x! i
40.     server.sin_port = htons(PORT);
    / r- _( L4 d$ F' j4 A
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    9 S( J/ l6 ?0 s2 K6 P2 W  C
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    / x) |' Z9 K3 ?
44.         printf("connect() error\n");
    4 {; q2 b' h, K, ]$ p4 r1 u4 y
45.         exit(1);
    
46.     }
    8 d" }) u) |/ k) h: O# i. F+ T0 q
47. 　　
    
48. 　　char str[] = "horst\n"
    7 g; ^. M4 W2 K
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    2 x  k. J- G* P
51.         printf("send() error\n");
    / W  K8 l* H- t+ v" y6 Q
52.         exit(1);
    
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    
56.         printf("recv() error\n");
    5 C% A* x8 Y3 ~+ G; r
57.         exit(1);
    ! J$ K; f- l; j
58.     }
    
59.     buf[num-1]='\0';
    ; }8 Y. ?: u5 x  g! L8 ]4 h
60.     printf("server message: %s\n",buf);
    , M! ]( {1 U4 r& r. U* q  z
61.     close(sockfd);
    
62.     return 0;
    
63. }

复制代码

（2）服务器端，编写server.c，内容如下
! T1 }; z' e) r  N5 ]( r

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   - ~9 I. U$ `9 G5 W, r+ p
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   , z- {, Y0 e" T6 |
7. #include <sys/socket.h>
   ; [2 _3 g; Z$ u0 V
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    . a; I$ D) k: X0 K: C& H$ [! X
11. #define PORT 4321
    : }3 D( V$ m  X5 H8 d$ q7 T0 k
12. 
    $ a( x2 H" L: q+ G  Y" b& I
13. #define BACKLOG 1
    4 I: Q9 h" x7 H& S; t  |; \, f3 ~
14. #define MAXRECVLEN 1024
    # x. W7 A. k* n0 G
15. 
    
16. int main(int argc, char *argv[])
    
17. {
    ( I9 m0 c5 r7 s8 W3 ?9 @
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 */
    $ |9 z6 t9 f6 C7 ~/ R
22.     socklen_t addrlen;
    , g" ^- M/ a4 L) C3 x, Z
23.     /* Create TCP socket */
    , X9 i- c2 {- U
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    ' |. }! k* [% A3 }' l8 s* W  X
25.     {
    9 @8 L8 G9 f# T: H# ^
26.         /* handle exception */
    9 V! j: b8 x- v: ~9 \, Z& J, |3 a
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    
30. 
    
31.     /* set socket option */
    ) u! T. v# G& M
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    + D2 _1 }! F. U
35.     bzero(&server, sizeof(server));
    , E8 h1 r- H5 ~8 n: f5 n
36. 
    ) b" K6 m9 H! f. w& d9 e
37.     server.sin_family = AF_INET;
    & I! g& R6 z. H- H2 h9 V* Y
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    # ~& e7 n6 U) a
41.     {
    & U3 h8 g+ t1 C5 c( m
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    
45.     }
    
46.    
      i8 o% \8 j! f( Q
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
    ) e9 r" ?( b5 q3 ~! S/ ]: J2 y
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    : {+ F" L. M4 F5 U! r
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    
57.             perror("accept() error. \n");
    
58.             exit(1);
    , H# G( A5 e4 X
59.            }
    6 x7 s/ C, e* v9 c! R$ u- b
60. 
    ! y( a$ a2 m! C' X3 R2 T
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);
    2 }+ |  U. Z1 n: a
64.         
    ' V+ ]6 r2 i; l2 M0 e& [3 d* l
65.         int iret=-1;
    
66.         while(1)
    
67.         {
    ! @5 h+ S  [/ N
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    8 g6 X2 ^, n  D" y9 X% O" t4 L- `* N
69.             if(iret>0)
    ; Q( B! _! W; N% I" I. [
70.             {
    
71.                 printf("%s\n", buf);
    
72.             }else
    
73.             {
    
74.                 close(connectfd);
    . N! |; b( u& b: }
75.                 break;
    
76.             }
    
77.             /* print client's ip and port */
    # \/ I& u: ]* X5 B& h3 E
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    - z: i+ J! ?) I- r- n1 `3 J. }  a7 c& U
80.     }
    
81.     close(listenfd); /* close listenfd */
    1 c1 a  x) k- d7 |8 b1 D
82.     return 0;
    
83. }

复制代码

. k' X; D) [1 v/ D( u

（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
     p1 v% z$ p$ H0 s& b# O, R/ Q6 _
2. 
   
3. server message:horst

复制代码

服务器端：

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

- t  }7 E4 I: ^, O! r( o# G
8 ^3 p. D/ Q0 T/ h

admin

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

1. /*client.c*/
   & I% V% j4 }. j8 s! `( d# Z' y
2. #include<netinet/in.h>                         // for sockaddr_in  
   / d8 U7 g/ o* n  F- S2 n
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   ) O- J$ _4 ^- `7 F/ ^7 l
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   6 o1 u) j3 M! Q+ n' `+ G$ x
7. #include<string.h>                             // for bzero  
   + W: F2 z* \9 s
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   
10. #define BUFFER_SIZE                   1024  
    & O9 R: u- @. v& v+ `* r
11. #define FILE_NAME_MAX_SIZE            512  
    ; U. v+ i' W, t
12. 
    6 C* Z: O3 a- H9 c' a  e8 S2 X
13. int main(int argc, char **argv)  
    
14. {  
    
15.     if (argc != 2)  
    & s8 [, L' w5 H2 t% v. P
16.     {  
    7 e2 ~3 i" M0 T: U
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    
19.     }  
    * l4 V% U/ y$ x- T7 F8 @' h( |% I
20. 
    
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协议族  
    : P/ }$ b# J- _) F6 B" C
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    + _% Y! M3 F- A6 u
27. 
    ' C! J# U0 z6 L& y% }" C, G. S
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    8 ^8 h; B$ x5 j7 t! d4 f* U
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    - x# R  Y, i: M  M- ^$ i. B% b5 ?
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    ) e# i. z# I0 {7 n8 }
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    - _" g! n; L" t# o
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    2 i) H+ P& H( ?& q! J+ I( j# ]+ @
39.         printf("Client Bind Port Failed!\n");  
    9 K7 \" m+ {6 a  ^
40.         exit(1);  
    ( R" g8 `% W2 s( ?" n0 S1 Q
41.     }  
    
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    . ]8 p! ^' V! B9 h# N5 E& |* R
44.     struct sockaddr_in  server_addr;  
    5 s0 z+ a( x$ V' o
45.     bzero(&server_addr, sizeof(server_addr));  
    0 o' E+ s, F& p" g$ l+ d: h% @% m
46.     server_addr.sin_family = AF_INET;  
    
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    # C& i5 ^) K% \0 c: N1 o9 f- B6 m
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    ) L# W# s! j: n7 J; o" _# E
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    * g* A% L% Y3 s2 t6 Q6 a
53.     }  
    
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    
57. 
    + j( X0 b* x, ]
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    - S/ ?7 k# U/ e9 k) r1 D
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    . c( I( N6 m9 z
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    ( i9 i9 U0 \/ r! p
63.     }  
    
64. 
    ! P2 K& }  W  n3 Q+ o- ]$ `
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    % {% J* f' J% R
66.     bzero(file_name, sizeof(file_name));  
    0 y* n0 |/ ^- M1 c
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    - y; d" O7 P( w, d7 [
69. 
    
70.     char buffer[BUFFER_SIZE];  
    + G/ e2 g6 `5 d
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    ' N6 O' Z$ e9 G3 L1 u7 ?4 @
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    + v. F) A6 o  G& t
76.     FILE *fp = fopen(file_name, "w");  
    % S5 y! n/ A3 L& F5 R, |9 J2 X* A" v
77.     if (fp == NULL)  
    
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    . G9 A3 J% [. ]9 @: ]. R
85.     int length = 0;  
    5 U/ w6 e! |$ y! M9 f+ O+ h
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    3 E! U1 F' H8 h: P! N3 C5 g& K$ \
88.         if (length < 0)  
    8 Y7 l* K9 X0 e. g4 S
89.         {  
    7 m; y6 V1 {# F8 Q4 f3 ^
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    , r, R; X' c6 M2 [. v: ?. `
91.             break;  
    ) x% u* o( [7 _3 O1 u  f8 q2 b; ^; U
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);  
    
98.             break;  
    ( u- X( C7 v5 q  n, Z9 r
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     , @7 t' o2 g$ i# f9 ^: ]6 y+ K# S0 v; }
104. 
     ) a% |4 l( K/ @7 X1 v$ B
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     + W* b& A* k0 v- J0 J- h  K
107.     close(client_socket);  
     % G; b1 N9 ]( I, l) b; ]
108.     return 0;  
     
109. 
       w# A% d+ q( r
110. }  
     
111. 
     1 {3 c4 C2 k# U6 v" n  U) A

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   , L: i  a& L) z9 |" _2 O" I6 E2 Q
4. #include<sys/socket.h>
   ! U( k# Z) Q3 a6 @7 |, E
5. #include<stdio.h>
   
6. #include<stdlib.h>
   & ?7 y8 [2 i/ \/ A& }
7. #include<string.h>
   $ A) }! N8 U6 f' }  c$ p# q
8. 
   . d( j8 E$ d4 b5 L) A' ]; C: G1 l* p
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   # I, i! C/ f$ @. S& a
10. #define LENGTH_OF_LISTEN_QUEUE     20
    & G% R1 ?8 {% f" i3 L2 D9 |  D
11. #define BUFFER_SIZE                1024
    3 d% f& l5 K" O: J9 s$ ^# o9 Q
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    
15. {
    
16.     // set socket's address information
    
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    3 f# S$ e/ O; m! k
19.     bzero(&server_addr, sizeof(server_addr));
    * w9 [3 u/ D& z% x# u) u1 ~
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);
    " x- g# {/ i0 m* g
23. 
    
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    % {6 \7 H+ t6 }8 G2 y! ]5 ?; a
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    / p2 G; B4 x9 J( {
27.     if (server_socket < 0)
    
28.     {
    & z4 A: m7 G4 `0 I2 n
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    / j6 L0 C3 y1 P3 t, {
31.     }
    ) T7 e1 {0 H2 M
32. 
    : J+ o0 d1 r# A) b
33.     // 把socket和socket地址结构绑定
    0 [% ^. G3 @3 P+ p- e
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    4 W: ^! `) u& ^+ \: [7 k9 A
35.     {
    * x1 s1 E6 d& Y, H7 o$ R
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    . `% E# q3 V3 w' Q2 c
38.     }
    
39. 
    
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    + q  M- I5 y4 _) E2 }5 b1 n
42.     {
    - ^5 A9 W& n# }1 m) U5 y& P& i( R
43.         printf("Server Listen Failed!\n");
    7 f  x+ ~/ a7 I" {! T
44.         exit(1);
    2 g" Y; r+ I" d8 `( h  F/ g
45.     }
    3 \# V- p6 `0 \( X. `
46. 
    - z# n/ W; B; K/ p# d  o* s0 x& b7 f
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    / ~! J: z6 j, {
54. 
    ; \' A0 ~9 x" d+ T/ t
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    * @6 z( S8 j5 c1 J8 a& i3 e" O- z
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    6 A6 [4 w; r2 q! g, p
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    " M1 x% t. m, q( I+ d$ i
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    4 w! O7 H' X+ q: v$ E2 ]0 G
61.         if (new_server_socket < 0)
    
62.         {
    " s" Y/ g9 M3 F2 X
63.             printf("Server Accept Failed!\n");
    
64.             break;
    ! }- D' O4 k0 o- u8 Y9 y2 p
65.         }
    / r4 |, v2 g4 j8 x! E, p& f! r
66. 
    & ^  P; o# A+ X5 w& B: ^
67.         char buffer[BUFFER_SIZE];
    ) \/ U) T2 I3 N" [+ m
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    $ w( E( @' P- l9 d, W; I
70.         if (length < 0)
    
71.         {
    ' ?1 |# O  h6 j* n7 a! k4 j! j* S% C2 u" \
72.             printf("Server Recieve Data Failed!\n");
      g" V- s- }  T/ d; |- z
73.             break;
    
74.         }
    
75. 
    4 ~$ b8 |% c. K; w$ S
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    ! i& n: z1 r" e! _* l, L! k
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    5 ]7 _% J+ }2 o
80. 
    % a7 Z0 n: V0 k; c$ U4 Q2 X
81.         FILE *fp = fopen(file_name, "r");
    % \2 ^9 D2 K. J7 _  E. k
82.         if (fp == NULL)
    
83.         {
    % x7 d2 c! b1 }1 y' {$ M3 m
84.             printf("File:\t%s Not Found!\n", file_name);
    ' g1 {/ R7 s+ K3 ], A2 f8 ^: q
85.         }
    4 d" }! O$ S; o* q
86.         else
    
87.         {
      w9 t- L0 n; E
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    + r- _4 F% B, Z1 m5 k
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    * a2 e6 C- V! N' E1 ?, D* w
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    4 m: t) L" \9 }& B
97.                     printf("Send File:\t%s Failed!\n", file_name);
    + U) N* |% Q" O: Z* H
98.                     break;
    " H/ I, T' W0 r2 z! Y( C
99.                 }
    
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     . o- r4 o5 W: l$ n. U, a3 C, y
105.         }
     
106. 
     6 r/ @! r6 k5 ^6 A9 v1 D" r
107.         close(new_server_socket);
     
108.     }
     % X3 f/ {" c5 p$ J/ H* Q' S
109. 
     4 f- F( E7 f2 Z) F4 K; o
110.     close(server_socket);
     ( N% c6 N! K0 ?3 }( @$ y  d# F9 J0 @8 f
111. 
     ' N. R% D  h, ]$ R
112.     return 0;
     5 t; P8 _" e  C" f
113. }
     4 g0 i+ T3 Z4 z) t% K
114. 
     

复制代码

6 H% I1 x2 e0 w% h8 P
/ ~1 x$ t7 p3 E& ^/ B
$ V8 o  G: F' |6 q1 P4 ?