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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <string.h>
     Y& E5 [  X2 d6 d0 R
5. #include <sys/types.h>
   # y/ H* x  ]" q) M  y$ J
6. #include <sys/socket.h>
   ' n: y1 X! Q7 F; a& ]
7. #include <netinet/in.h>
   
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   2 V. |4 o  R3 a3 p
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    * @) U  p3 g; c6 i, P- C
12. #define MAXDATASIZE 100
    ! P3 v: w& \) n- M) N* @" B0 n1 I
13. 
    6 z  L( w  O# Y2 k% S
14. int main(int argc, char *argv[])
    
15. {
    4 \& z9 R; _0 O& U5 k
16.     int sockfd, num;    /* files descriptors */
    
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.    
    3 J: c7 f3 t1 E" y
21.     if (argc != 2)
    $ I2 ?4 n* ^" F
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    # z* M9 @1 ]6 d7 S1 Z) f
25.     }
    5 U& e# r! f+ M' D
26.    
    ) J7 e6 d  T) K' ~" ~4 Q8 c
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    
29.         printf("gethostbyname() error\n");
    ' p0 z4 ~- M4 l% m5 v9 m+ i- |& Q
30.         exit(1);
    
31.     }
    
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    / ?6 s! @" _" ^. T7 U; ^- d
34.     {
    6 j/ m' ?. @( Z- d7 T. ^5 J6 F4 f
35.         printf("socket() error\n");
    
36.         exit(1);
    
37.     }
    
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)
    % W% a" i0 u& N' ]& c$ R
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
    8 A3 x2 Y0 f( Z+ n! ]8 e5 d  \
46.     }
    
47. 　　
      k5 l5 I, Z% p3 c! E4 @
48. 　　char str[] = "horst\n"
    % p8 |" U" K5 n0 o$ R
49. 
    ! b( ^6 D( |. c, W7 o9 S* s
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    " H: Y, _, d* _3 e( y
52.         exit(1);
    
53.     }
      g2 d& R) C! K) I' E
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    - n. z0 d/ S( y7 Y
56.         printf("recv() error\n");
    
57.         exit(1);
    % }5 O* z& J1 _+ L  V; R  X
58.     }
    
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    
62.     return 0;
    9 U+ C  Q* Q# \3 V- H# x* R/ |
63. }

复制代码

（2）服务器端，编写server.c，内容如下
! \3 Z) ?! y- m& |

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   2 a/ O3 Y# @* R) W. b4 n5 d4 H4 a
5. #include <unistd.h>
   
6. #include <sys/types.h>
   9 @0 V$ [6 [% b: A: A; _
7. #include <sys/socket.h>
   3 G: u! Z( A4 E: z
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    
11. #define PORT 4321
    7 o7 v- X# f# J4 c5 A: J
12. 
    
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    0 g2 O7 b$ R& R1 m0 p" h9 z
16. int main(int argc, char *argv[])
    : @8 O5 u8 R* k5 E
17. {
    
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    6 h# J% q. h* n
20.     struct sockaddr_in server; /* server's address information */
    ' Q0 f0 ^* I6 N4 H7 a7 X4 ^5 o* {
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    ! z8 y  _; m5 _) I1 c2 A( b: \3 l
23.     /* Create TCP socket */
    8 q# K* y- Z7 J" q! Z! L! W/ z5 _4 z
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
      P2 g) z& {( ^" a% g
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    
30. 
    # O* x/ i6 E. [/ l/ L
31.     /* set socket option */
    8 k/ _, |% e) r+ E$ g
32.     int opt = SO_REUSEADDR;
    ( H2 h9 w7 m, d) t2 V* F
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    - A* Q# A% K0 D
34. 
    ) W9 W" b* c) \% Q, O5 B  H
35.     bzero(&server, sizeof(server));
    8 ?/ B+ y9 h  W. |! v8 g" m& {7 ~
36. 
    
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    0 d- C( G0 H3 s4 y4 L4 q3 ~
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    8 Q$ D. N% i" ~+ a0 j
41.     {
    + V! h, r3 |# ~+ D1 R
42.         /* handle exception */
    ' {* ~& t/ C+ C# ^: G  Q/ p
43.         perror("Bind() error.");
    - x, _+ c; T2 X! X% y: h& A& G3 z+ C
44.         exit(1);
    # @; n. J0 ~) Y5 S3 q
45.     }
    8 U3 d% y/ _; v2 F
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
    
51.     }
    : A6 H: S- ~/ w' C$ n
52. 
    ! G$ c) u' E5 V
53.     addrlen = sizeof(client);
    4 D7 T( f4 v0 Y
54.     while(1){
      t( f, G) N$ V3 f2 K
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    ; G' n. \3 W9 f
56.            {
    ) p  Y/ ^- e3 X, O% d
57.             perror("accept() error. \n");
    
58.             exit(1);
    , p- h1 v# ~' v0 U, e3 R
59.            }
    1 J+ g0 q  @8 L/ o
60. 
    
61.         struct timeval tv;
    $ X4 R! K1 Z$ s+ j  y& m( t
62.         gettimeofday(&tv, NULL);
    1 n! k. U. r% |+ T
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);
    4 ]) j2 z0 Z3 p& ~. A$ R* H3 ~
64.         
    * v2 s; M4 J8 i, m# m
65.         int iret=-1;
    $ c9 w2 ~9 |6 @' H
66.         while(1)
    
67.         {
    ; s3 k+ f) k! I9 K/ m
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    ( S" J/ @+ T. V- y# {
70.             {
    
71.                 printf("%s\n", buf);
    , M: A2 P' J" p' m
72.             }else
    
73.             {
    
74.                 close(connectfd);
    6 v! c1 I5 b; r( f4 I; ^. _/ p
75.                 break;
    9 [/ d, e  k" ~' H+ A9 q
76.             }
    
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    1 T/ H0 ~+ c! O) B: r$ X, E
79.         }
    3 n7 C$ F9 n3 m5 b1 k' t$ p
80.     }
    # N) V' ^6 B  y: ]4 _6 S3 K! I% l
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    
83. }

复制代码

7 i$ `; h' `$ J& E

（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. 
   ( F! n, \. a% m5 @. m; m6 Z
3. server message:horst

复制代码

! K+ ^) B/ N3 U2 q

服务器端：

1. $./server
   : x, J0 }2 M1 c5 r9 s; a
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端口等待下一次连接。

, R1 d, _. y; e* H7 O
* w8 k9 R6 o1 ^7 P5 V

admin

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

1. /*client.c*/
   $ e: j! Z. Z5 Z) v2 a6 v
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   % p9 ~) T2 ^  i, [$ F+ O) i0 w
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   " s& F: D3 |" `
7. #include<string.h>                             // for bzero  
   
8. 
   6 ^- f: F8 [4 }
9. #define HELLO_WORLD_SERVER_PORT       6666  
   
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    ( y9 O* O* T- |4 o# r5 A1 J! e$ A
12. 
    
13. int main(int argc, char **argv)  
    . d5 z$ s" t2 ?
14. {  
    9 [* S8 p" H% }, D& b
15.     if (argc != 2)  
    . `) o+ q7 M8 H" S
16.     {  
    ( h" H9 b# S  Z
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    6 v4 @5 e  s0 K% O* S3 S& @! C$ J
18.         exit(1);  
    
19.     }  
    ; ~6 h+ x# r$ ?* _- N! j: ^
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    0 k( ?+ W5 _# Z/ h
22.     struct sockaddr_in client_addr;  
    + P/ M9 h( R8 e; s: i0 o% F: L
23.     bzero(&client_addr, sizeof(client_addr));  
    4 i" e2 ^4 e& U; A$ X' F6 D
24.     client_addr.sin_family = AF_INET; // internet协议族  
    
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    ) z1 o$ r1 t: e0 [( D
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    9 ]" ^7 W- F7 N) i2 P* C
27. 
    ) u- s; E, h3 v5 o4 a; S! _$ F) y/ c
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    ( k* k0 ?$ B; p# r& R
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    
31.     {  
    # `- s6 y  O3 F4 D! S! B
32.         printf("Create Socket Failed!\n");  
    , W! \& e5 q3 h! u' H6 Q2 }
33.         exit(1);  
    
34.     }  
    ; F4 f8 o# n, @6 W
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    % Z* n' H# Y" H# n! |
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    ( a+ w  q2 G& R, Z8 Q! X
38.     {  
    2 `$ ~% A! |+ ^
39.         printf("Client Bind Port Failed!\n");  
    ! \' o+ Z+ ~0 J5 N  L1 u" P3 I( G
40.         exit(1);  
    
41.     }  
    
42. 
    * }9 `3 A4 p8 b6 h8 c/ ]: T
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    . g" g$ O9 b$ w  h
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    
47. 
    & w* [2 Z" s4 d2 U$ I+ _$ Y
48.     // 服务器的IP地址来自程序的参数   
    8 ~( U; ?9 T) C& J% j9 \1 G
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    2 i+ j. T! N4 ^& Y) k
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    " r# S4 T$ e! C' N3 n
52.         exit(1);  
    
53.     }  
    
54. 
    ( X. L7 d8 c) N. ^9 K9 U
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    9 E6 a- y  T' o7 h$ ?! c
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    - F$ e* E4 B- t, J- t4 `9 J
60.     {  
    % d1 P9 h: g" e
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    3 A. a. a) r( F4 Q' U/ h4 K
62.         exit(1);  
    * i" w; ^( _# h8 t) c2 V% @
63.     }  
    
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    9 s$ E' D  X9 [# {1 r
67.     printf("Please Input File Name On Server.\t");  
    5 `4 m+ m0 g. M, n+ L
68.     scanf("%s", file_name);  
    
69. 
    
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));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    * y. O$ J5 ?& U# l$ g) e
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    ' u! a+ \9 X! V7 A3 \0 g
75. 
    9 U* V( g/ _7 w8 _" J! T+ D
76.     FILE *fp = fopen(file_name, "w");  
    " n: m5 N) s( @* e7 S' M/ e0 g3 Q
77.     if (fp == NULL)  
    9 ^7 T8 t3 F& H. T
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    $ p( L9 j! ]. f  T% X9 s" a
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    . D. G$ a$ f, s. Q) b4 g" E" p
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    3 \: d6 g8 S; O7 f7 {
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    , C* d  S1 q. l
87.     {  
    * V! r& ]8 u! K0 J" O; Y
88.         if (length < 0)  
    
89.         {  
    : e1 T7 b  J( d7 E4 T! w& R
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    $ }; s( h. |& ?/ T) Y6 n6 ]
91.             break;  
    
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;  
    2 {" Y1 ~, i5 \, v
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
       W3 c4 G- K* ^0 x" l) Z; x! h
102. 
     $ E& y1 O* H& u' t) Z# L
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     3 i. z8 q3 {* J8 Q
105.     // 传输完毕，关闭socket   
     3 T- O- z! h; C7 Y
106.     fclose(fp);  
     - S) R2 t& d! m9 b& \
107.     close(client_socket);  
     
108.     return 0;  
     
109. 
     5 [( _2 q( O' R% a9 p+ U1 P. P
110. }  
     
111. 
     

复制代码

1. /*server.c*/
   ( B2 J, _$ L: ~0 P
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   " w3 t: A' {' ^
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   % H: }. K- d7 u* @+ m" Y0 x
10. #define LENGTH_OF_LISTEN_QUEUE     20
    0 ]6 K! I: e9 E) P8 E) J
11. #define BUFFER_SIZE                1024
    + }" A, l( g4 u  K
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    1 q4 x. g) Q. A* h' G5 e) x, q
14. int main(int argc, char **argv)
    
15. {
    
16.     // set socket's address information
    5 `# S" r/ x" ^% M" [4 w
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    + K+ \3 G* |' E: T8 ?
18.     struct sockaddr_in   server_addr;
    / B& ^( Q4 ^  r) A$ d& U
19.     bzero(&server_addr, sizeof(server_addr));
    8 V; ?+ S3 G* y% R* n* x; V
20.     server_addr.sin_family = AF_INET;
    ! d4 e; ?- C: K
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    / z8 H$ y8 R  I! H1 s
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    
23. 
    
24.     // create a stream socket
    # m7 F, A. F4 @9 a4 b
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    ) u  L! e3 P3 [& V' {
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    
31.     }
    9 j& W3 J" r$ R7 N3 {7 d! g
32. 
    
33.     // 把socket和socket地址结构绑定
    5 r* M. T1 w6 y( q  R/ d
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    & C8 d& V6 a" t6 S
35.     {
    4 @! ]3 f, \' Y5 e
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    3 l# S# w( x+ H& k
37.         exit(1);
    
38.     }
    
39. 
    
40.     // server_socket用于监听
    % |6 A2 u. D8 }1 j
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    4 u8 y' N4 U" b" r
42.     {
    
43.         printf("Server Listen Failed!\n");
    ' @6 i+ x& s, L% {
44.         exit(1);
    " ?0 O$ X% i8 a7 q! u+ t
45.     }
    ; V9 H  o& W" v+ R7 x. F) }# t
46. 
    & ?* C# \' k2 W5 `% j- _- C% B
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    
49.     {
    - S- D3 g5 c" _5 Y. F2 L4 w* E
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    * R, y3 j+ @" s
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    * u7 W9 y0 z+ T/ q5 R
52.         struct sockaddr_in client_addr;
    9 D8 V* d* J1 U# c6 W6 p  }
53.         socklen_t          length = sizeof(client_addr);
    2 e/ N4 _# G9 H9 q5 l
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    3 f! W, a1 y8 ?. A# ~
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    9 {3 |8 X% l) O0 r) i2 l
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    8 E. X( L' P, |6 C4 ]
59.         // 这里的new_server_socket代表了这个通信通道
    
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");
    : h5 N! V! V/ E, r0 s, D7 k) B
64.             break;
    
65.         }
    " \8 _8 Y) j8 @7 N
66. 
    
67.         char buffer[BUFFER_SIZE];
    0 A  I4 F9 N- L; p# }
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    9 q" O4 x% ^# k* ^) @' G
70.         if (length < 0)
    * U: I3 @, ?- J
71.         {
    : @' k" m* f2 _1 y' g6 A% ~( _9 h
72.             printf("Server Recieve Data Failed!\n");
    
73.             break;
    : [3 O- q. M2 w, t  Y0 _( L0 e
74.         }
    - u. c# H' b* G0 D
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    4 G2 b* ?2 f1 {( G6 j
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    3 p2 R+ l  f& T; u- c/ Y
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    & P3 M/ N4 K# B* I. `
85.         }
    
86.         else
    ) t# ]: z' [1 z) J" ~$ o! L
87.         {
    , j+ q. ~: u0 i' f. h( p& e6 o
88.             bzero(buffer, BUFFER_SIZE);
    / K7 [6 e$ p6 \  I! Z
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    ) R& ]& Q3 y# V1 Y9 s) d: j
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    3 X2 N7 w+ @3 `
93. 
    8 s2 M1 l8 U7 k: l
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    , r# X0 |/ D9 W0 k
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    2 U; Q) Z8 s# C$ q0 f! e5 B
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    
99.                 }
    4 {' ]0 S+ H% a# J% G
100. 
     7 M, s3 y  ^: h2 d0 W
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     9 s% p+ Y  f8 l% c9 a
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     , e1 [) @, R4 W  M5 s  c+ i
105.         }
     9 w- g0 u6 x/ ^, h! R2 k1 {# p6 h
106. 
     6 g, [3 G; C" l% a, o2 H- v: R! V
107.         close(new_server_socket);
     
108.     }
     , w/ ]3 |* V6 Y% [- t
109. 
     3 D5 D3 R3 X+ ?- ]" D
110.     close(server_socket);
     
111. 
     
112.     return 0;
     
113. }
     
114. 
     . e" O& B" e% y+ @

复制代码

2 y* x+ S! m3 I/ `3 I: b# E
5 ~) [, @! p* e$ F0 I+ ~
6 i3 _' v, X- a: A3 |