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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   1 K6 D0 a3 H# x/ P
3. #include <unistd.h>
   
4. #include <string.h>
   ! s! O( y" d& r  d" l) j
5. #include <sys/types.h>
   . M2 Z& k, P9 G$ }5 B
6. #include <sys/socket.h>
   ) ?) ?3 f4 B8 y
7. #include <netinet/in.h>
   
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   . b4 b/ y7 U6 m2 ~. t2 `+ j
10. #define PORT 4321   /* server port */
    
11. 
    
12. #define MAXDATASIZE 100
    % S/ |  I9 \$ H( A9 p
13. 
    # Q9 H$ u3 f# n' r2 L& O
14. int main(int argc, char *argv[])
    8 w! ~% I3 d% K7 V
15. {
    / Z1 R( h! f9 g5 [8 [/ |6 N) N
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 */
    8 o  E4 M2 a- E
19.     struct sockaddr_in server;
    8 H4 `! s4 E) l* a) h) d* o* h, a
20.    
    
21.     if (argc != 2)
    8 ~8 d6 u: L5 ?8 `' q# o. s7 S+ g- P
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    $ P+ i2 t# f* {5 H
24.         exit(1);
      D; w" u2 T- D  w5 m4 x7 s3 a
25.     }
    
26.    
      n2 Y6 b6 N  E! [5 e
27.     if((he=gethostbyname(argv[1]))==NULL)
    0 g' X  d7 K! Q$ ~) l1 ^
28.     {
    & X5 ?$ k' B/ e0 K9 M$ `
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    6 ?; O9 X7 s: E, b; A9 F
31.     }
    
32.    
    7 T6 [/ p7 x- d6 V+ [) P
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    
35.         printf("socket() error\n");
    
36.         exit(1);
    
37.     }
    ( |! Q7 A3 d; U2 b; g
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
      T+ K  V+ t  F" m  K; e0 R
40.     server.sin_port = htons(PORT);
    
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    7 w' d8 b' j1 L3 p
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    & e& ?! Y  n, u+ Z. n
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    3 {2 I! f- }6 b2 Y$ M& r8 Y* @
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    * H% K( N# a$ T5 [. B: R( a
55.     {
    
56.         printf("recv() error\n");
    
57.         exit(1);
    $ Z, D& D( i! }9 M) ~9 F3 w
58.     }
    
59.     buf[num-1]='\0';
    / e* h6 H9 Y1 ?$ `
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    : J: E0 y7 |, L, w6 w
62.     return 0;
    # j" n: ]- m( P) F  Y
63. }

复制代码

（2）服务器端，编写server.c，内容如下
- E! K5 ]6 r8 B" g/ V

1. #include <sys/time.h>
   $ H% Q/ G5 B. m* o' ]- u
2. #include <stdlib.h>
   " w- d# |. g0 N& _. T9 Y3 k6 j9 M& E
3. #include <stdio.h>
   . b5 `0 p  H7 q5 L. u* d  q
4. #include <string.h>
   0 u3 \% p8 x" {0 H! S$ P* \2 y, C
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   , E; j, }0 ^+ E/ h  v# ~) S
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    0 q; z0 {% ^9 _0 J* ^; C/ R" w
15. 
      T* c+ ^& e$ A+ t5 H# v# m* B8 F" a
16. int main(int argc, char *argv[])
    " |. u5 d* U. @2 J2 R4 N, o* J
17. {
    " @$ s+ r# @/ O$ Y' r
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 */
    2 C( a2 H! w+ x1 z" L+ q* T. D
22.     socklen_t addrlen;
    1 Y# J* {8 @& `0 y' q7 W. \( y
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    ( F0 v  E1 _' S( c' ?3 g
25.     {
    5 t4 i7 H% `5 C2 J5 b7 r4 e
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    % t1 N; e9 V8 t7 U: l6 B% u5 Z
29.     }
    
30. 
    
31.     /* set socket option */
    ' V( Z. T3 m. H
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    
35.     bzero(&server, sizeof(server));
    2 ~* @( Q# _. q2 r/ r
36. 
    : ^3 Z7 i# a. k# X8 E/ t
37.     server.sin_family = AF_INET;
    . |3 G3 Q# ^3 V5 m* G
38.     server.sin_port = htons(PORT);
    + C# j& [: o# K) n( t5 I* x
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    8 o1 }3 o( i' Y6 t
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    
42.         /* handle exception */
    + x( u+ @* R5 T9 `, j: ?# D
43.         perror("Bind() error.");
    9 v/ C* ?. l6 }
44.         exit(1);
    
45.     }
    5 C9 Y- A5 p$ C; Q$ k
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    + n+ i  H- g/ `
48.     {
    9 M1 U) `3 a7 i
49.         perror("listen() error. \n");
    1 e: k0 o$ x- J* L0 d
50.         exit(1);
    & m: D8 m# m1 h$ N. Y
51.     }
    5 W" g" U; @) ^: u& C' q& z# S
52. 
    
53.     addrlen = sizeof(client);
    3 Y/ J7 e, B) {
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    
57.             perror("accept() error. \n");
    & `! O$ I8 Z4 ]- {
58.             exit(1);
    
59.            }
    
60. 
    * I7 p+ G. f1 S0 K( s: a% ~
61.         struct timeval tv;
    
62.         gettimeofday(&tv, NULL);
    * T) f( {  q6 |6 E0 M6 x! g
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.         
    
65.         int iret=-1;
    
66.         while(1)
    
67.         {
    * m% ~1 l, L% o) ~; w+ }8 V
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    ' l2 R7 x" m& U
70.             {
    9 K. P; J* A: C! v1 S4 q: G- Z
71.                 printf("%s\n", buf);
    8 w0 p* Y8 g, x" M
72.             }else
    3 ]  q% Z, e' S* T: H
73.             {
    & {. a$ B3 h7 s1 p/ r
74.                 close(connectfd);
    8 F4 R3 d6 }9 Q: x4 Z4 m
75.                 break;
    " U. ^0 m6 a/ t! ]0 s% W0 f4 q' E
76.             }
    ; N7 _/ y' I% e3 \' V, f& h
77.             /* print client's ip and port */
    & ]' H# w9 \' {. q9 V
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    
80.     }
    
81.     close(listenfd); /* close listenfd */
    * M- l# U6 _$ O2 z6 |5 |* b
82.     return 0;
    
83. }

复制代码

  B8 y5 z& |0 H7 h9 m* w0 @6 f* N

（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. 
     d, u8 B9 F3 _
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端口等待下一次连接。

( q3 T, ~, K* N8 i7 X2 |
3 O: J' h4 _* f8 c7 g
# @; E4 U: ]- |* V
# v! D6 w+ n0 w( \

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
; w# q; ?. i4 O! K- P1 \2 u

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   . J6 _" V  D( v- [$ }1 v
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   8 ^6 k5 q5 _, c' M, H. C
6. #include<stdlib.h>                             // for exit  
   - Q5 ^* s. D) o$ m; Q- ^
7. #include<string.h>                             // for bzero  
   ' }, i* V7 C! D6 z1 R( G* ]
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   0 H; C3 K2 _+ N4 Z- Q& o
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    6 t/ R0 W6 A7 `8 p' c/ C
13. int main(int argc, char **argv)  
    6 D7 Z: s' l) I) v; L
14. {  
    
15.     if (argc != 2)  
    $ h' B: N: j: J1 }& |
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    6 Z% r$ u) l: [; w6 ?
18.         exit(1);  
    9 r, M4 @7 d- v0 Z
19.     }  
    5 @( k# Q0 o' ?) \/ G
20. 
    ) P) b% T5 n1 z3 B4 P6 H* N
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    7 ]$ x# f, w/ R
24.     client_addr.sin_family = AF_INET; // internet协议族  
    
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    - X- U' z1 X) b) R6 ]
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    2 q4 s* Q- {5 q) t2 @$ R6 ^7 d
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    ' O# X5 ~2 }4 a: c! o% ?; K
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    - ?5 c0 I! x4 Y3 L- ]
31.     {  
    0 M4 _& [8 k$ J
32.         printf("Create Socket Failed!\n");  
    ' n1 z" A8 s9 @! c" N& g+ t" M
33.         exit(1);  
    
34.     }  
    ' o# z& j( \2 x& J+ X; L5 O
35. 
    
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.     }  
    2 @9 h) U# u2 M* [2 ?
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    8 M" l, }9 V" b
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    $ \2 i- c% f3 v$ }3 d
47. 
    * m3 X. z- f6 b9 \, D8 [/ ~
48.     // 服务器的IP地址来自程序的参数   
    # z4 y2 B7 o6 d) Z5 Y" Q
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    + ~' v# l  C( [/ [! b) j
50.     {  
    6 K; T/ t% U% y# L/ Y
51.         printf("Server IP Address Error!\n");  
    . I" P6 r. T, r
52.         exit(1);  
    + ^$ O& K7 Y2 j6 h8 p
53.     }  
    ' {$ d! D5 ], ]* C0 t
54. 
    : @3 n, \! W& U3 Z" N1 B6 l
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    7 M. r% z8 ~5 v# m6 C" b9 P% U6 K* q
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)  
    
60.     {  
    % U& q9 L7 {$ R
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    ! c! W( l' P6 R
63.     }  
    
64. 
    " [! g" D# p* W2 J5 h# t
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    1 |- k8 q; ~2 `' F% Y* w
66.     bzero(file_name, sizeof(file_name));  
    " }- |( d5 x' c' X
67.     printf("Please Input File Name On Server.\t");  
    3 {' o0 G0 L2 i# D& B; c
68.     scanf("%s", file_name);  
    
69. 
    $ X( e3 W3 _0 M6 i, _6 J6 T7 H: i
70.     char buffer[BUFFER_SIZE];  
    ) @; {4 H6 \; x% a+ P6 {# C% e! V
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    " q# L0 t8 @$ C' g# y
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    . O7 ?" o3 v' C* g3 m  k
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    ( U2 z7 C, g5 w% M* r5 H2 J
75. 
    , V& D, v8 L3 ]0 `3 U+ z. @
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    
78.     {  
    . j  M; B1 ?3 m# W% H6 w
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    : H2 v3 H4 b6 g
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    1 i* z* D- }' t! `$ g9 L
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
      H+ A& D+ W7 d" u$ L7 X  @) b
87.     {  
    
88.         if (length < 0)  
    . O+ D9 K( A. {- b# K' G
89.         {  
    , M3 y4 n1 D5 @
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    * C$ c; W; ^/ b, X# b' S
91.             break;  
    
92.         }  
    9 ~, `% _& _  E: B
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;  
    6 ^3 {& Q9 P. |( k
99.         }  
    5 w' z% i% }* ?+ D" f$ x
100.         bzero(buffer, BUFFER_SIZE);  
     1 {* B/ [; X. S  O) m
101.     }  
     
102. 
     $ Z1 P7 J8 W$ M, {% N7 x
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     & V7 `. U+ L/ K9 F% N4 m* s
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     
107.     close(client_socket);  
     9 s4 Z9 Q+ P& }1 x0 T& ~
108.     return 0;  
     
109. 
     * A8 c$ L  X7 U$ y) ?
110. }  
       |8 y! e$ D" d) s- Y
111. 
     , Q5 c9 o* x# i6 K( Y$ C' N6 w

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   + |, W' o) @8 {5 p- o* }' R
3. #include<sys/types.h>
   $ T  Q! t) v+ j
4. #include<sys/socket.h>
   + d6 C% d9 V. u& s; A. O8 |
5. #include<stdio.h>
   / u9 _9 A7 _9 n0 o6 g- ~5 }
6. #include<stdlib.h>
   / S5 ]7 e. c4 T# |6 \1 Q: ?, U4 ?+ W# t
7. #include<string.h>
   
8. 
   & k) O7 H$ m& U* C
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    ) }2 r/ {; ]' M' T* U
11. #define BUFFER_SIZE                1024
    " O7 X: x, u" O; B- c6 c
12. #define FILE_NAME_MAX_SIZE         512
    ; _) {1 T9 N& \! R
13. 
    
14. int main(int argc, char **argv)
    , Y$ O7 w2 Q- J5 p
15. {
    / Z  I7 l) n) f# h8 F
16.     // set socket's address information
    , }/ g& V. @2 v3 X8 l
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    2 ]) X; j; n. w5 c  X' Y
19.     bzero(&server_addr, sizeof(server_addr));
    
20.     server_addr.sin_family = AF_INET;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    . m1 e6 d- I) V# J
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    
23. 
    
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    1 P( U5 K) C7 W
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);
    , n$ @2 i4 [0 R2 n% @
31.     }
    4 p, w: X/ H- ~( l( [# l
32. 
    
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    1 z  y, v5 W, r
35.     {
    / [4 H( Z7 c$ ^7 g# E
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    5 T5 ]& c  T; R3 V5 j0 v# @* ]
38.     }
    
39. 
    
40.     // server_socket用于监听
      E. w% X6 Z9 Y0 P1 V' P$ a. S
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
      A. A1 t8 E3 w- k/ h3 w
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    
46. 
    ) N6 E0 O8 s) g) X8 l% ?; [- e
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    1 M. ]7 M6 i0 Q# {6 U
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    ( h: Z. ~% `% @1 \' o9 t. f
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    ' c5 h$ H( [$ g8 U, j! f# v' N
52.         struct sockaddr_in client_addr;
    + G& k5 _8 E! T  t  ~
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    5 S! I, T& x, m& r
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    $ s4 ~2 S- w; L% L0 _
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    ' e" a( l  f$ M1 V% o
61.         if (new_server_socket < 0)
    
62.         {
    - Z7 |8 q$ X8 a% W0 g
63.             printf("Server Accept Failed!\n");
    $ T: e0 V2 x5 M  R
64.             break;
      s3 v8 P5 ?( v% h, f8 W: ^
65.         }
    
66. 
    + E$ V" A- r6 F
67.         char buffer[BUFFER_SIZE];
    + f7 }% ?* l( M0 q; E
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    % {0 W3 \& i3 q
70.         if (length < 0)
    
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    9 V* ?# }7 h; _
73.             break;
    : I" R+ J& I& a3 r* k& X' ^
74.         }
    
75. 
    # g. {1 S0 D" P5 R8 X) \! V6 m
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    ) g9 @# P0 k. T8 o5 F+ e6 [
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    - D4 E, X: x* A( k; V9 w
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    2 ], Y) f8 ~0 a' {& \  t  P3 b& C
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    8 p' l8 N: j: x7 n/ t' I
82.         if (fp == NULL)
    ) u' |9 Y: ?& k8 e
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    
86.         else
    
87.         {
    
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.             {
    2 ^3 @& F1 k3 S* w" C! \7 t
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    6 t1 C+ r% r: m
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    5 n* F+ D7 j/ y. ?8 i
99.                 }
    , B' M+ u* f' U
100. 
       a* K) i( Y9 P7 e# t- u: {! h4 m
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     9 f7 H# j6 m' ]& e$ q9 s
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     * y0 b7 @2 m" Y8 ?+ y/ T3 q; Z0 ]
106. 
     
107.         close(new_server_socket);
     3 w! B) M" X7 X, p- w; G
108.     }
     
109. 
     
110.     close(server_socket);
     
111. 
     
112.     return 0;
     
113. }
     2 ?0 m6 L  b# @% v) Z
114. 
     

复制代码

, A. c! X& D8 C- ?