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

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
* }  Q; R( o( V: A（1）客户端程序，编写一个文件client.c，内容如下：
6 ]/ Z: p, s( [0 v0 G; C

1. #include <stdlib.h>
   . E8 W$ N1 C5 F3 f7 u
2. #include <stdio.h>
   . [/ ?4 L& a" ?/ Z
3. #include <unistd.h>
   / K  ?0 u! j1 n0 u5 S$ @7 f
4. #include <string.h>
   % I; A2 q, K5 x" Q/ a1 I' T4 Y  v
5. #include <sys/types.h>
   , ]( H) v2 [9 g1 ?/ B, [
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   ( C% _! ?0 ^# A  s- T3 G6 {
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   2 @+ _& C* i- q, ^, A
10. #define PORT 4321   /* server port */
    
11. 
    
12. #define MAXDATASIZE 100
    : d: Q$ \6 G9 F+ L9 w4 Z7 V# P
13. 
    6 N) p+ {: t6 V& [6 b
14. int main(int argc, char *argv[])
    
15. {
      S2 _6 H& T) O0 W. @
16.     int sockfd, num;    /* files descriptors */
    ' i8 `$ @: ?4 {
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;
    
20.    
    
21.     if (argc != 2)
    1 [5 v7 b! @. o$ m  @
22.     {
    9 T$ w3 S6 [1 G# x* }5 g) {5 G
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    % b5 |! ^/ R6 `( b0 e( f3 F
25.     }
    4 q5 U' Y1 c9 H+ H! [6 ]2 _
26.    
    ; ]$ t) k' ?1 I) x: C
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    3 P8 P4 J5 o+ \: I
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    ; l+ [) {- k0 J! U
31.     }
    
32.    
    + k6 K& o/ T$ m8 |' p" J/ d
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    6 r% O  ?4 \5 ]# _( N; s5 @
34.     {
    ( D% V$ m. z- E9 Q8 `
35.         printf("socket() error\n");
    8 x; o& n. K3 t' Q
36.         exit(1);
    
37.     }
    
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    7 V0 N3 N& n- z
40.     server.sin_port = htons(PORT);
    + S" G: t0 S' j
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    
44.         printf("connect() error\n");
    + U# x* K; Y& I
45.         exit(1);
    ; T$ {5 P3 J# F2 [. P5 N
46.     }
    $ f2 n! }" ~  `, ?+ Q
47. 　　
    / ~6 w9 h8 c9 D' g# R9 b& t, n7 F: }1 f
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    $ n2 m5 _: [# x+ l3 Q  ^
51.         printf("send() error\n");
    " c/ p  L) E/ w
52.         exit(1);
    
53.     }
    / g2 i; _% l$ H
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    % o3 r( k+ e6 U5 k
55.     {
    ( |) K6 y& U- \$ K0 @
56.         printf("recv() error\n");
    
57.         exit(1);
    9 R* }7 c6 o) O% |5 Q$ m/ {
58.     }
    ) L6 X, g+ H/ f4 y
59.     buf[num-1]='\0';
    + ?5 y5 b$ }4 ?2 k( h( N5 J0 ?
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    1 E& I- y1 D& J$ h  b$ o
62.     return 0;
    ! O0 O" j8 w9 G8 L( [
63. }

复制代码

（2）服务器端，编写server.c，内容如下
" u0 o" l6 a8 F$ W

1. #include <sys/time.h>
   8 @. z9 {' s- |0 }( G& I; T
2. #include <stdlib.h>
   8 h1 E2 j( _; J' ]( e
3. #include <stdio.h>
   
4. #include <string.h>
   $ C' N+ g+ o8 N& m, t: L# n- u: Y/ w
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   1 l* r  P# j5 l( K, f
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   , e  h9 d- w* `( {% q2 r# ^% y1 E
10. 
    
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    - ?# G9 Y3 N% ~3 B- O, _, U
15. 
    # h' I- u/ B8 c- [* r
16. int main(int argc, char *argv[])
    
17. {
    
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    ) V# A4 z$ S* N3 P+ k6 C& g
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    9 a0 g4 U. [7 o3 h+ o: E
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
      a* b  O. ~# m3 C) s$ o
25.     {
    
26.         /* handle exception */
    6 [- \( N' D' q9 H
27.         perror("socket() error. Failed to initiate a socket");
    % x' \0 O/ v: }
28.         exit(1);
    
29.     }
    
30. 
    & O7 C1 \& A& l' o" r# U" h
31.     /* set socket option */
    ) Y' e0 f) D4 U
32.     int opt = SO_REUSEADDR;
    - w* w$ k5 {: A
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    8 \; l; B  Q5 Q4 f7 X- e1 ?2 A
34. 
    * g. @' F6 K9 f7 K, X& N1 g/ u8 ?
35.     bzero(&server, sizeof(server));
    
36. 
    4 k- v3 D  p1 F
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
    4 z3 L2 @0 ]' Y
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    
42.         /* handle exception */
      A9 K: M, t- e( {. {
43.         perror("Bind() error.");
    
44.         exit(1);
    8 O( M* S1 _+ Y
45.     }
    
46.    
    1 h: R# H4 W, `8 u  D6 S& [
47.     if(listen(listenfd, BACKLOG) == -1)
    - I: d* G4 ]  r. C0 y! @9 l
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
      m3 k# V5 S8 v3 ~
51.     }
    / b' d/ y8 {3 z9 z& X7 I
52. 
    
53.     addrlen = sizeof(client);
    
54.     while(1){
    7 m, [" O. q+ D, i) d
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    ! A+ m# D% {% Q* N
57.             perror("accept() error. \n");
    . w9 x0 V" V( T' I( T! z
58.             exit(1);
    
59.            }
    
60. 
    
61.         struct timeval tv;
    + Q2 d6 S! i, ]3 R/ f9 ^! @
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.         
    . d" H" Z- G) o$ e: |/ O
65.         int iret=-1;
    4 l$ R3 o( L6 m  L" g- k' A
66.         while(1)
    
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    
70.             {
    
71.                 printf("%s\n", buf);
    ) p2 Y+ u# O" ?4 m& ^
72.             }else
    
73.             {
    / h5 N. \' F: z! W
74.                 close(connectfd);
    # l5 o2 d2 ]9 o+ i
75.                 break;
    % v. z+ p2 T  ~0 l
76.             }
    + F. L* ^* G0 J3 ^. a5 R* ]8 D
77.             /* print client's ip and port */
    % H" W3 o& I1 F7 ~' n
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    
80.     }
    
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    8 Q- v  e0 f( k: L% E# G
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 r* {* P0 ?& p* T: W
2. 
   5 F8 A7 b: `) `& P5 m0 M
3. server message:horst

复制代码

0 k1 \) \+ ~% V6 C  t' J( I5 |( Z

服务器端：

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

; h" y: h9 {% S& k3 f) s4 X. X

5 Z" ]- ~' G% `

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
# s) s8 z$ A6 ?, T( m' d

1. /*client.c*/
   % d  H" g( J1 g6 J0 @) e
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   , T. Z' H# G, B; J- L  W. ]% h! ~
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   . t4 f+ x$ k3 ~2 {; W7 `5 {
7. #include<string.h>                             // for bzero  
   . O7 A7 i- x8 L' D1 v) u" ]# q* S
8. 
   : N; Y: M9 F, p/ v$ x  e
9. #define HELLO_WORLD_SERVER_PORT       6666  
   ) k$ q7 H# V* S4 w$ w1 t8 p, _% }8 M
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    
13. int main(int argc, char **argv)  
    
14. {  
    ! m7 m: `3 i8 p+ J5 ?
15.     if (argc != 2)  
    1 i  P3 ~6 C( i! I" L
16.     {  
    : J. C8 ?. r1 ?! m4 r6 |5 [
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    
19.     }  
    ( \& h  r8 W2 z/ }) F4 E' P3 t
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    0 `5 N9 ?' f0 D( N
22.     struct sockaddr_in client_addr;  
    # q" u' Z' B% Q# k
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表示自动获取本机地址  
    
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);  
    + n' i2 I. J1 c( D. W8 x
30.     if (client_socket < 0)  
    - a& d8 X9 v3 L; x7 f5 D
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    % V; i8 O3 _6 |
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    7 x0 M8 \8 n# N+ }' t
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    8 T# ?3 a0 R% ?: s+ ^# C+ u  T
40.         exit(1);  
    
41.     }  
    
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    ' m+ X9 r- Q6 s, P: Z* V
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    9 S. q5 m0 ^7 x% K- ?% \
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    ) S- A) x; |. M3 D
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    & z$ `( b9 l; F: _- o2 S
52.         exit(1);  
    $ a3 l/ Q" p1 a# A$ f0 M9 R
53.     }  
    
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    ) ^( r2 l1 B$ _6 u. N
56.     socklen_t server_addr_length = sizeof(server_addr);  
    
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    * K. c  c( l+ n
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    5 r5 W6 B* b: k. @: c7 \, v# R
62.         exit(1);  
    
63.     }  
    
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    & j7 {6 V1 X$ H6 `! u
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    , L. ]+ U5 a& q
69. 
    # Q  R2 V0 v. m' f1 x
70.     char buffer[BUFFER_SIZE];  
    % [4 l5 a# ?2 y+ R+ h; Q
71.     bzero(buffer, sizeof(buffer));  
    ) [! ^6 y4 U  E) a% |
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    * |9 E! B5 C6 }- D1 g! w
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    , d# X& L* G* M$ k1 p
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    . r; m" C# B# X0 N: J4 E
81.     }  
    ! r& V+ v# b% X) \! V
82. 
    & v) z3 Q6 w& L# W2 @0 m& E  }' b
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    ; g4 Q9 Z2 N5 q/ I+ D$ w
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    ( {/ S. N5 p% p$ h
88.         if (length < 0)  
    
89.         {  
    1 T' Q) D4 N8 r  u# R0 D
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    ; @- J% A' r/ p1 R4 ~  }7 m
91.             break;  
    % d% R% N+ M% ~
92.         }  
    8 v) b8 w" E) j9 H
93. 
    
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    7 R" K& z9 ~* [2 f5 ~# y
95.         if (write_length < length)  
    
96.         {  
    . c; s2 S5 ^0 N: L
97.             printf("File:\t%s Write Failed!\n", file_name);  
    ) U4 C2 ~+ I% c! X
98.             break;  
    % @. n+ p$ H; `7 ^' x  j" f
99.         }  
    $ i$ [; e* `3 I' c( |& U8 ~
100.         bzero(buffer, BUFFER_SIZE);  
     . L! J0 P7 F2 D: c- o+ }/ s
101.     }  
     ! {' `- B; F, ]0 B7 I) Q4 N
102. 
     + Q5 U4 j0 A- x: }7 ]" ~" U
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     - b0 i, @& R. d% E, b1 y6 y
104. 
     * ?& N* d( S' J! c  J: Y/ J7 a
105.     // 传输完毕，关闭socket   
     1 f. s, N) V4 c. l
106.     fclose(fp);  
     : n0 A5 }' W( m  G4 i1 j
107.     close(client_socket);  
     
108.     return 0;  
     
109. 
     % l( ?) b1 x* r( m& s6 C2 f
110. }  
     
111. 
     

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   
6. #include<stdlib.h>
   . [5 g6 r0 O! \; R* [! ?8 o
7. #include<string.h>
   4 w' i, k- V: g) C; U3 g6 Y
8. 
   ) M8 k! ?, j: m; _2 [% Z& J
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    : r9 ^( u( z% G1 i# q6 i5 s
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    8 D1 e# [  B' h8 {- p6 U7 C" _) |
14. int main(int argc, char **argv)
    
15. {
    ; ?4 Y; i) G) o7 b
16.     // set socket's address information
    # x8 e3 o$ f& n% }) W$ O* e
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    . e; ?/ i* F8 N7 p
19.     bzero(&server_addr, sizeof(server_addr));
    " p( L6 V3 e) X3 w
20.     server_addr.sin_family = AF_INET;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    . ~+ C4 p7 t; @) E8 b' ?" B0 A
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    , ]. R3 h8 U  y+ X1 s! ^
23. 
    
24.     // create a stream socket
    2 _. a. R" x7 G& `' t# K# }
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    
28.     {
    7 ]$ U) X3 i7 S0 T+ r
29.         printf("Create Socket Failed!\n");
    # Y+ H6 b/ b0 F* m( w) R
30.         exit(1);
    
31.     }
    
32. 
    
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);
    3 g/ \1 u5 C/ `
37.         exit(1);
    . P. M+ C1 J) C2 f- d% \
38.     }
    
39. 
    & |; L: ?" o& I  K$ d
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    7 C& A  x+ \* i* R
42.     {
    1 ^9 t4 h: I7 j, I1 n
43.         printf("Server Listen Failed!\n");
    " R$ [. C8 {* i# e6 j
44.         exit(1);
    
45.     }
    
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    4 R7 B; P) Z7 I* m+ ?9 S$ t! S# @
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    / V6 V% _( n2 \) }
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    ) W5 X0 }) `" k4 m4 c
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    3 x2 Y2 M5 X+ V8 v* o5 J
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    ' x  o. q# u5 h* T
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    * ^) p8 v5 o4 U. L0 R: P
61.         if (new_server_socket < 0)
    % J( Q! P" `" ~4 {; U& V8 F
62.         {
      C# y% ~( q% e% l" E8 Z4 Y, V) W
63.             printf("Server Accept Failed!\n");
    
64.             break;
    
65.         }
    ( N2 `  Q3 v& h  ]: u
66. 
    
67.         char buffer[BUFFER_SIZE];
    , O8 t# R$ M1 D
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    : ^. q' ?' o1 m* {# S
70.         if (length < 0)
    0 s& r* L+ p# ~, q9 V7 q
71.         {
    / q# r+ }8 j7 I, e& V& O9 l$ q
72.             printf("Server Recieve Data Failed!\n");
    * S- ~  W8 Z1 Q/ O
73.             break;
    . C8 @) H- e. I8 L
74.         }
    
75. 
    ! p! g. |& R) t& {- h# T9 B: ]
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
      e! C1 v( l+ O6 H. v4 W
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
      }6 @6 s) F' p+ V) M1 C
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    9 y: e9 ^( s8 Z" S. Z1 Q
80. 
    $ t4 X, x( q; C
81.         FILE *fp = fopen(file_name, "r");
    % v  F% N# K- [* ?: @7 z
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    - u* m, D7 }: u* U. [* K: a
85.         }
    1 h: _! ^/ D/ O5 ^2 e+ j
86.         else
    
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    ; `) k7 T2 E# _; ]9 {5 X
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    3 c/ n- E4 A) _& L; E* R
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    $ S* X3 R# V$ @( N! y! W* ]
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;
    
99.                 }
      q1 l& j6 P5 N, X
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     * h* x, K8 ^0 K" z5 {- m
102.             }
     ; g6 J+ V9 Z3 w
103.             fclose(fp);
     ' v0 Z! Z1 E+ j
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     
106. 
     
107.         close(new_server_socket);
     3 L8 y; ]7 a4 f. s
108.     }
     
109. 
     1 k2 N" a8 }: U2 q' b
110.     close(server_socket);
     
111. 
     + y" d& j- s9 j8 S8 E& l
112.     return 0;
     
113. }
     
114. 
     

复制代码

" [2 K4 P3 C5 n
& ^/ |9 l+ I. R( d
4 ]* y: d& t* Z" F$ z$ I