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

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
$ }7 {& ]3 u8 k/ |$ \5 K（1）客户端程序，编写一个文件client.c，内容如下：

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   ' Z  z7 Y' ^3 X! f$ }
4. #include <string.h>
   - i* @3 F- ^' t. l! _5 @
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   % R' m8 x3 d; ]! c) s! Z8 H% ]
9. 
   
10. #define PORT 4321   /* server port */
    ) X- s0 M6 u- r' l) u2 r
11. 
    
12. #define MAXDATASIZE 100
    
13. 
    
14. int main(int argc, char *argv[])
    
15. {
    % a/ n& s2 N8 f; ?: g
16.     int sockfd, num;    /* files descriptors */
    3 B3 V- v  i# h# B
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    % f1 A( `" D1 i5 W
18.     struct hostent *he;    /* structure that will get information about remote host */
    
19.     struct sockaddr_in server;
    , o& j  ^! v1 Y! y
20.    
    
21.     if (argc != 2)
    
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    6 J' j$ b; o3 S  I$ H7 E* f  ?
24.         exit(1);
    
25.     }
    * l0 U# B$ L( v! u. F2 s4 n# f
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    $ P; H: C; o' f! y  R
28.     {
    
29.         printf("gethostbyname() error\n");
    8 o) C+ @8 m2 w2 W, r; @0 g/ @0 r
30.         exit(1);
    
31.     }
    
32.    
    ! [9 _" L0 ?- _) I6 h
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    0 U0 Q# q- c/ h+ L4 a% M# B/ H
34.     {
    
35.         printf("socket() error\n");
    + _( Q% F" ^- x/ D
36.         exit(1);
    8 I1 R1 J; L% x' z: j! D5 C
37.     }
    
38.     bzero(&server,sizeof(server));
    & h6 k$ V1 s# m2 l( Z( I
39.     server.sin_family = AF_INET;
    
40.     server.sin_port = htons(PORT);
    $ B8 T4 p' J" X
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    * `' h& Z) K0 g9 V/ J* w7 w' O/ ]1 z
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    
44.         printf("connect() error\n");
    0 N) V/ n$ n3 x4 \9 K2 D
45.         exit(1);
    ) B2 ?6 f; u# M
46.     }
    
47. 　　
    
48. 　　char str[] = "horst\n"
    + ?4 F' U) T* j; J* Q5 D0 @
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    3 c5 ^6 E5 v3 F. b
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    / ~5 o& W. x, ]7 R, f- U
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    / f" e/ I! h3 N0 ?5 Q) k8 @+ X* c
55.     {
    
56.         printf("recv() error\n");
    
57.         exit(1);
    
58.     }
    
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    9 K) ~  R0 s8 S& s1 n! h  Y$ a3 c
61.     close(sockfd);
    
62.     return 0;
    + c# z. S* I/ }& d9 n  n/ ]0 r
63. }

复制代码

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

1. #include <sys/time.h>
   $ a0 f- C& y$ }! N1 e, ~( ]
2. #include <stdlib.h>
   # S% M& g! w/ c  p! A9 R' M& v1 ]
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   0 h# f# m, B5 e2 D1 U, K" \
7. #include <sys/socket.h>
   / r$ |# Z/ t# ?1 e2 q9 y
8. #include <netinet/in.h>
   0 V" ]7 w$ k) F" J7 W6 u8 O  E
9. #include <arpa/inet.h>
   6 S. I& q7 E. l( G0 w* U
10. 
    8 k6 {1 T- a2 c) f2 w
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    - q( `. U" U9 |/ L, z: Z' x" L  O
14. #define MAXRECVLEN 1024
    5 }- K; g4 A4 V1 J
15. 
    8 G/ Y& d# [/ Y
16. int main(int argc, char *argv[])
    
17. {
    & n% j& n5 f: F9 o  o8 H
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    6 E2 W- s7 Q3 f& C& h
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    5 u. _& u: o1 q1 P% _: c$ D/ B/ X
22.     socklen_t addrlen;
    , M! o. t% R: r; a4 b
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    - a4 a  j2 t& p3 d! A
26.         /* handle exception */
    6 V) e5 i* {+ Y6 x
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    0 o8 F8 q: A& S' m
30. 
    
31.     /* set socket option */
    6 M" P2 \! q0 o! c& o; Q& {1 d8 {  h
32.     int opt = SO_REUSEADDR;
    ' U# t5 z2 w0 y; @. \0 d
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    
35.     bzero(&server, sizeof(server));
    
36. 
    7 n! `- x( s0 s6 ^; v
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
      F3 n9 x% }0 I  C% K
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    1 m( I% m% H+ g3 z. q0 D  J0 t
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    9 ~+ j' B  ^+ f
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    + `7 g( I, M3 ^0 @$ ?' Q% Q4 ^5 i* t
45.     }
    % e- Y, y5 `# [9 m* W: I% y
46.    
    ) \! O5 D1 r* A( W7 r
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
    7 T9 _2 c/ J" F
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    0 |6 a: I* t8 R" J. w( L
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    - p  }5 t) H- u- n, {  R- ~5 n0 k+ ^
56.            {
    ; @% R# b/ ?4 \3 |+ E
57.             perror("accept() error. \n");
    ' h2 k/ P  o% }- W5 _
58.             exit(1);
    $ l6 g6 k: n5 E9 }
59.            }
    9 s- B1 H. ^% \: `
60. 
    ; J6 V' B; l5 I" z* Q
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.         
    : X  S( e3 q4 K; ]: \* Q
65.         int iret=-1;
    & k1 `" M+ n  L- P8 Z. j/ s2 w
66.         while(1)
    ( b& k1 P& {- g  b) F: i
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    . Z) b1 y4 a7 U
70.             {
    
71.                 printf("%s\n", buf);
    * r: [9 o5 [5 \2 k' _2 x
72.             }else
    0 ~! ^) b) X& T
73.             {
    ( d; \9 v3 H; O9 I' q
74.                 close(connectfd);
    
75.                 break;
      {: O, D7 T# o  q- E' T
76.             }
    
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    % M8 @5 c) _, u" q* K* B5 e$ o3 ?& g
79.         }
    , T  e; ^& L) @5 ]  w8 B
80.     }
    9 S/ o. L" }* W! Q. f" P- Q
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    - o  M$ o1 V* b  W' L0 }* i& J5 K
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. 
   
3. server message:horst

复制代码

( c: T$ q! z  w% ~- j4 G+ }/ e

服务器端：

1. $./server
   ) w. d" g/ Y% v' r. t/ E
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端口等待下一次连接。

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
! {# p6 z" c, k" F0 v8 b9 G# j5 ?

1. /*client.c*/
   3 J) N: d  A4 u/ H6 i" D. W- h+ Z
2. #include<netinet/in.h>                         // for sockaddr_in  
   4 L% Y1 T. o2 j* R! W8 A. T
3. #include<sys/types.h>                          // for socket  
   2 c6 a7 Q3 n+ P
4. #include<sys/socket.h>                         // for socket  
   & i1 Y) k4 H0 d" d" c
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   4 [* i$ |, r  p, m' L1 u5 ?
7. #include<string.h>                             // for bzero  
   ) P: w3 ?2 Z4 Y
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   8 S7 E: P% g# u* i1 t. K
10. #define BUFFER_SIZE                   1024  
    6 ?' B% i3 e. S) Q2 r
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    
13. int main(int argc, char **argv)  
    
14. {  
    % |% @' m+ }" D* o. T
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    % O+ F7 g* J, F/ A
19.     }  
    4 e" G4 c, v' ?: [8 ?
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    # b5 |* p$ I- n! @( _: [
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    % a5 T2 L: ?  }! ?' H
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, 让系统自动分配一个空闲端口  
    ( p# l* L. |8 L# b. ?
27. 
    1 f% T) C9 g4 Q% K8 Q- v% d
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    $ j0 d) O" k- l' _% }
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    4 q$ q. E$ e+ Z0 s9 w  X
30.     if (client_socket < 0)  
    3 @) g! R$ Z/ H* ^; w( t
31.     {  
    - V) z. m' t2 _
32.         printf("Create Socket Failed!\n");  
      q$ {; u& D4 D
33.         exit(1);  
    
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    * ?  X3 l- M1 r; c! V
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    . e. |; k% _$ K& P( W
38.     {  
    ) {9 a+ i( ?. s' ~$ O
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    0 E: {. Z  |* ^9 m. N$ d- Y! w& o; C
41.     }  
    
42. 
    % B7 h5 y2 Y, S; B
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    ' Y0 Z1 C! w. L2 F
45.     bzero(&server_addr, sizeof(server_addr));  
    # t/ t, Z3 X# q6 Z* o
46.     server_addr.sin_family = AF_INET;  
    3 h2 G/ [; Y2 k# w, ?
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    8 }$ g1 x9 G/ p! X: [+ [' e
51.         printf("Server IP Address Error!\n");  
    2 }; T* u% Y& N( \, i% s9 A' }
52.         exit(1);  
    ; W: w( [2 U! U! q4 K1 T
53.     }  
    
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    1 g+ Q/ h7 d" M4 d
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    % ?0 a' w$ ^! }0 s+ ~
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    + k" d9 ]) a+ x7 {( D$ |5 p* X
63.     }  
    ; w/ G) `5 g& _; d$ K+ T
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    * Y' a+ N& c0 n! v+ w
66.     bzero(file_name, sizeof(file_name));  
    
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    4 D& I& K5 z2 v$ K' Q
69. 
    
70.     char buffer[BUFFER_SIZE];  
    1 P$ ]% ]5 F' P, \+ x0 f: g
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    $ j. t7 y% v$ T9 Q; ?! _9 L: A
75. 
    + {( A( w: k1 Q. J2 o, R3 r0 `% t
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    ! D, ]. Z1 w/ P0 k, F1 t
78.     {  
    ; k( |$ s: r; E; x0 }1 i' X
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    ( p; j; _5 Q5 y
80.         exit(1);  
    
81.     }  
    3 J6 `4 ?1 X" J/ S% S3 ]
82. 
    ! K1 d7 J2 ~6 w0 W7 h! K
83.     // 从服务器端接收数据到buffer中   
    ! g6 e+ Q! B# d
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    ! W; D0 I0 Z1 f3 @5 S* _
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    3 G& v- I1 `5 i- E# x
87.     {  
    - f* }7 o( @% _( O. f' O
88.         if (length < 0)  
    5 J5 }* y* m7 z/ D
89.         {  
    8 D" b% b1 d/ [! X! H7 d& W
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    ( |2 N0 }# }2 |! f8 V  V
92.         }  
    
93. 
    + }# R$ q8 W* E/ l; j  t% h1 ?; @$ l! @/ w
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    ' _4 C; T! _7 F+ n+ d1 S) Y
95.         if (write_length < length)  
    ! L! h. e8 @8 C; \5 {- q" q. A! t+ f
96.         {  
    ( g4 F2 r  y! q7 P
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    . b! y6 ~6 z' f7 ]2 S4 j) }1 f% F
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     % q0 s& x; y3 H' F4 K  d! O
101.     }  
     
102. 
     5 S2 G% ]' m0 x. G: o( S
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     1 Y' y5 z, S1 u0 l; F+ I
104. 
     + j: Y) c  b( f) N) j% z
105.     // 传输完毕，关闭socket   
     9 j/ D* p' v+ M5 G0 S
106.     fclose(fp);  
     ( C5 f, L4 H& t! X
107.     close(client_socket);  
     % C0 [) V5 Q8 {  N' q* a0 n
108.     return 0;  
     
109. 
     
110. }  
     / a% a8 r$ d2 I
111. 
     , p; B4 W. v* K6 T" A4 o

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
     ^: ~& K# F2 c/ ~* @
3. #include<sys/types.h>
   8 \# y( f5 i2 `/ L5 O% K% c
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   0 _5 a0 Z' D! M6 Y2 b/ [  f
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    % ]8 f% H( y# m" y3 m5 v7 z+ J
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;
    
19.     bzero(&server_addr, sizeof(server_addr));
    : i% Q! `; p* V+ r0 a# G7 C
20.     server_addr.sin_family = AF_INET;
    - d: L8 L/ n# z7 V1 s1 {  \
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    7 O7 {- L6 z) u6 b6 o+ p
23. 
    3 Z; |4 n  J# X( s) H
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    & D: R6 F. o1 P4 @6 ~' [
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    ) @+ h+ _3 g+ r, Y: y/ A4 W  A1 I
30.         exit(1);
    % J; D5 V; c* k9 Y: }! }4 W
31.     }
    ) h& `6 ]" Q4 M% m+ t: J5 \
32. 
    + l- ~- ]+ i0 T( }8 n3 {0 K
33.     // 把socket和socket地址结构绑定
    6 K& G  F9 D; t3 {) v
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    3 ?0 q+ B- c5 I" Y  \3 v
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    + `: g2 n, |' t* Y
38.     }
    # \9 f& }/ d6 Y& Q
39. 
    
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    8 v9 h4 f- _8 M8 [
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    3 q5 g/ \$ v3 h* `" k! @* M
48.     while(1)
    
49.     {
    * i. ?8 p% _2 w
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    ' V) |1 R% z; P
52.         struct sockaddr_in client_addr;
    & v" U1 ]" w, k( ^# `9 U: j3 c
53.         socklen_t          length = sizeof(client_addr);
    7 {3 T8 f: ~: F6 T) P+ G3 b
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    : I$ K2 C5 z/ R4 g" g; w
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    
61.         if (new_server_socket < 0)
    
62.         {
    ' F6 f9 ^4 I8 K# |' T
63.             printf("Server Accept Failed!\n");
    . d; _7 a1 B+ @( G7 {$ k# \( t4 K2 I
64.             break;
    
65.         }
    
66. 
    % X* `- h/ q' k
67.         char buffer[BUFFER_SIZE];
    2 t+ |$ E8 ~% k2 e+ F
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    
70.         if (length < 0)
    8 p: X6 B: f4 g% r0 S8 L9 u
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    $ p- A* f  W* e- g
73.             break;
    
74.         }
    
75. 
    ! m8 Y/ ^( d; f+ P* e/ W8 B% k
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    ! z1 K1 @: d. I+ Z( c
78.         strncpy(file_name, buffer,
    
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    
83.         {
    $ k7 Z& l& n1 R5 _  w0 u+ \
84.             printf("File:\t%s Not Found!\n", file_name);
      W% U3 a& h+ G/ l2 P  g# ?
85.         }
    0 p  i  K6 v0 r2 i
86.         else
    
87.         {
    + @* B1 t! {- l/ |: p' W
88.             bzero(buffer, BUFFER_SIZE);
    # w: h0 P3 H9 N) V3 u
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
      s2 P9 y, _* Y7 P
91.             {
    & D8 b& o  @; V# @
92.                 printf("file_block_length = %d\n", file_block_length);
    6 z- x" {* y# l, y
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    & `% x1 [# C# R* V
96.                 {
    . U3 _$ O4 |4 @! d% f
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    
99.                 }
    ! D. v6 u2 G0 }8 F8 j1 ?
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     
106. 
     , B1 o3 `4 {+ H2 {
107.         close(new_server_socket);
     , r4 g: o( t* P; G! K. W3 D& f6 a* H/ }' N
108.     }
     / y" F1 E4 P) w8 f6 j
109. 
     , F2 Q* m# Z9 U2 j/ [2 L
110.     close(server_socket);
     
111. 
     - q  `  q) P4 j, ?/ Q
112.     return 0;
     
113. }
     
114. 
     2 i$ j6 N' b, Z; w& L4 o" K

复制代码

* ]$ k  }1 M; T* t! U  Q