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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   ) e! g; z* ?, D
3. #include <unistd.h>
   
4. #include <string.h>
   2 Q% |1 A0 o* v: n$ c4 N" m
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   7 m2 `- m% t, N. N
7. #include <netinet/in.h>
   6 F1 O* H7 `1 g0 v3 [0 E. a
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    3 Z1 [# t9 h, j
12. #define MAXDATASIZE 100
    
13. 
    
14. int main(int argc, char *argv[])
    
15. {
    6 L' e6 S8 e9 p; K  b+ z) m- o, v
16.     int sockfd, num;    /* files descriptors */
    6 p. g, m; d) W0 u0 U( u* S! l
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)
    ' u2 n9 Y, i) U8 H, W' E- Z9 u: F
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    
25.     }
    ! r" l  r+ X- c# F
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    5 o) ]% s& U( H4 P$ T: Y
28.     {
    
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    
31.     }
    
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    " O$ p2 L9 H% g$ v1 u
34.     {
    
35.         printf("socket() error\n");
    2 H& x$ h" C- U! U4 F' R
36.         exit(1);
    9 Y, H$ T! {0 z3 ^" X0 ^
37.     }
    / E3 x1 q6 \/ u
38.     bzero(&server,sizeof(server));
    + X8 T4 b1 g% C2 A# t; P% t2 B  \
39.     server.sin_family = AF_INET;
    
40.     server.sin_port = htons(PORT);
    
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    ( G* x4 c0 r2 v. s6 t
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    7 x( W* n( }! ]# V6 X: O+ @
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    
47. 　　
    / `* \0 h: y) r8 E8 ?3 @
48. 　　char str[] = "horst\n"
    
49. 
      a! k4 W" ~5 B/ d  j2 I
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    ( m8 T8 Q, Q$ C7 z  S: y  k
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    
56.         printf("recv() error\n");
    7 }$ n) y7 N6 v) {# r4 Q
57.         exit(1);
    ( u3 `- p  `1 O: j
58.     }
    
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    4 Y7 W+ ~& k( @
61.     close(sockfd);
    : w  G0 H; r2 X8 ]3 z
62.     return 0;
    , Q2 G7 ?) ]& L' w! D- V
63. }

复制代码

（2）服务器端，编写server.c，内容如下
8 D+ ^- q, R! ?+ s* S1 i

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   % U, a: o5 K. p5 A. p; K( E2 H. c
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   % f0 P4 F$ t7 c. p( E
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    5 g5 b/ x; [+ ?/ |7 F4 Y
11. #define PORT 4321
    6 i3 j: ~( V% T& [
12. 
    ) Z  W  ^: W1 B) Z
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    $ K- J) r. r" w( x
16. int main(int argc, char *argv[])
    
17. {
    % D7 d4 i1 z& K, u( |7 V
18.     char buf[MAXRECVLEN];
    6 w- _+ ~! V5 _( O7 Q, b
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    1 X1 I6 `! L+ k2 E1 Z$ d+ m
23.     /* Create TCP socket */
    0 ^) w$ g( c0 @) `' |
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    0 W% t5 t1 r% ^+ H) I
25.     {
    
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    ; l% d1 _! O* X& f7 [
29.     }
    
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    : z  O7 s; O/ J
35.     bzero(&server, sizeof(server));
    ' n; ]! h( c; O: h0 u4 N
36. 
    
37.     server.sin_family = AF_INET;
    : t# Y& h, b3 {( a' l
38.     server.sin_port = htons(PORT);
    # @. E. W: l) }
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    . X* \) U* \% f  V) v: P, f6 P# l
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    7 G6 ^, [+ l- g5 N- e% Q  i
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    $ T: s5 Q8 r4 O: Q, j
45.     }
    - N; C: w% X# N4 Q
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    - ]( x% w; h6 g) t
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
    % t( ^! O4 g3 Z! h! Z/ @+ }
51.     }
    
52. 
    6 C! {6 E+ p) P
53.     addrlen = sizeof(client);
    7 J( Q8 u7 Z1 X" K) }
54.     while(1){
    ; e* [* u+ R4 P- w" N5 A" O
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    & E, J7 R, d# [% {
56.            {
    
57.             perror("accept() error. \n");
    
58.             exit(1);
    - A: A) R7 \+ b+ U8 v- [
59.            }
      Z/ i# E# \% B% _' n- j( P
60. 
    
61.         struct timeval tv;
    
62.         gettimeofday(&tv, NULL);
    + x" O7 ~& l% `1 Q+ c
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.         
    , H. j7 h% g9 k5 D7 d7 s- f
65.         int iret=-1;
    % k, B$ T/ {: \3 v1 A, b
66.         while(1)
    
67.         {
    6 r! {8 b; `; K+ t
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    8 n8 _  X9 l# _# ~
69.             if(iret>0)
    
70.             {
    
71.                 printf("%s\n", buf);
    
72.             }else
    
73.             {
    
74.                 close(connectfd);
    9 W- d2 }) \  c) ]
75.                 break;
    % s) P' v& I! T" G
76.             }
    8 @. p; P, B, x' R
77.             /* print client's ip and port */
    ! K& l5 M0 ?: n# W' ]- q7 f$ z
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    0 Y. V% F& j2 [3 W8 a" P$ q% A* B
79.         }
    
80.     }
    3 N7 v9 A* y- F# z$ y! b- t
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    
83. }

复制代码

  J  i( T6 k7 R% |  @& ?

（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

复制代码

服务器端：

1. $./server
     t+ _1 T; Z% g3 ?, z
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端口等待下一次连接。

, {& }0 q' V4 X7 b0 @


. B/ U& H' ~, w4 m2 L! q# x

admin

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

1. /*client.c*/
   ) j, F1 n3 @7 s
2. #include<netinet/in.h>                         // for sockaddr_in  
   " T; V+ z8 a( x2 v) U8 [1 L; A4 h4 f
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   0 W" n) ~/ \' z3 ^1 M2 T2 N
7. #include<string.h>                             // for bzero  
   
8. 
   2 \( D# y& {8 k: v. t% K9 Q& \
9. #define HELLO_WORLD_SERVER_PORT       6666  
   2 t! S1 i$ ^1 x9 x
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    " s& X: X! d$ p- n2 X! x
12. 
    ; p/ E+ I6 |  }" n% @' C6 m  V
13. int main(int argc, char **argv)  
    
14. {  
    
15.     if (argc != 2)  
    
16.     {  
    ; z- A7 x$ W; O8 X) H1 c4 Y  k
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    ) K5 _, u& e: g$ O9 ?5 \# p
18.         exit(1);  
    
19.     }  
    
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    ( z6 U1 z! R- C& C# ^
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    ; N7 o! `- ~7 Y5 z% g
24.     client_addr.sin_family = AF_INET; // internet协议族  
    & g! @* P7 t- O+ i1 l& R. Q! u
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    
27. 
    # ]9 S2 `6 w) I8 }+ ~% K
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    . A# v+ G5 u  ~8 K
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    6 F% ^8 m2 a- `% H- F1 p
30.     if (client_socket < 0)  
    6 @9 m. Q5 b8 y* o  }% i
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    . F2 }( r" U! L) s: n; ]/ v& E
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    4 f) V; N) {# p2 x
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    
41.     }  
    0 ]# D1 k8 h! D1 Y8 B
42. 
    " g0 v1 V" n7 ^$ R8 b7 ~, g
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    $ I- o/ F& _9 R4 g: U2 h7 k
44.     struct sockaddr_in  server_addr;  
    , E1 \) ?* }# V: B' C8 V  X/ x; E
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    % `# k# `0 n, i/ }- c" Z; P
50.     {  
    8 `  s4 B$ r' q$ \  f
51.         printf("Server IP Address Error!\n");  
    ( }+ Y" ~9 O. b- n7 _4 r
52.         exit(1);  
    5 g" b" F# ~3 B4 p& W1 B: T2 I
53.     }  
    
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
      H. u# D& a6 x( c: Y( }, @4 I; @
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    
60.     {  
    4 ?0 Q! o9 Q( d$ M6 v
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    " B0 S. d8 w1 K% m. i5 A, @* [
62.         exit(1);  
    ' N2 m; g- w2 d) {2 S# c- L
63.     }  
    & M9 k9 w4 `6 s) G: {5 b
64. 
    " ^4 @; L# T% H  p$ X' M
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    0 s/ k: g* L5 Z' }/ x" z; }
67.     printf("Please Input File Name On Server.\t");  
    ) U0 _  f' f& m
68.     scanf("%s", file_name);  
    
69. 
    
70.     char buffer[BUFFER_SIZE];  
    * [! }( u9 S0 U6 l$ T3 M% T
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    / N  J6 h% O  E' P
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    & o; n4 s; o4 M& B0 j
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    # P) Y: a  Z: [  U, z' \
77.     if (fp == NULL)  
    
78.     {  
    1 e5 k; ?1 Z" Q" l
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    ) ~- Q) a! W* Z
80.         exit(1);  
    , ?7 K5 l2 U9 ^0 s- G8 O
81.     }  
    8 l) _: U$ G% m. H1 s
82. 
    
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    + t: q: v) q8 I+ _3 F% Z
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    7 ?3 ^2 I2 d$ M% Y
88.         if (length < 0)  
    
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    % B* _2 `0 I5 G, L7 n9 V, V
91.             break;  
    0 P6 j0 f, n5 D5 i% t+ M
92.         }  
    ! f; h! t/ H/ f; |6 ]; I
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);  
    6 `) ?" m$ n, g: V$ F
98.             break;  
    
99.         }  
    " [* f$ L' b. r
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     " x: [$ n/ J, H( P7 ~
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     
107.     close(client_socket);  
     
108.     return 0;  
     $ D. Q$ B: g! c' I7 G) }- Q
109. 
     
110. }  
     
111. 
     / R; h4 W9 C9 k3 @

复制代码

1. /*server.c*/
   - ?0 o% v% f( v6 P" x
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   - b3 O" P4 q  b' D( l# v
4. #include<sys/socket.h>
   ! ^7 b9 q3 z1 \  a" g' E
5. #include<stdio.h>
   7 x; [7 S3 D" f5 F) s( @& |1 m
6. #include<stdlib.h>
   ) e4 t; X4 D( a
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   ! z; m. q: k7 b# _7 O
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    : G5 E2 V2 b$ ~: n- s! i
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    
15. {
    - Q/ V5 O; s; L1 o8 v! x1 J1 l
16.     // set socket's address information
    
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    - Z8 u8 a) u9 T  U  Y2 i
19.     bzero(&server_addr, sizeof(server_addr));
    9 h6 c4 L' z) u0 }- s7 ~
20.     server_addr.sin_family = AF_INET;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    & o" d. y7 z8 n
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    
23. 
    : Y2 n! g4 H! t
24.     // create a stream socket
    + r, p7 O* K, J" ]( w
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    ) p' ~+ w! j$ v; @. Z
27.     if (server_socket < 0)
    
28.     {
    ' x/ l( y2 K5 n2 m0 l- {
29.         printf("Create Socket Failed!\n");
    2 A9 u+ J/ U3 r6 s' F1 P
30.         exit(1);
    ' D- s& E; @/ i. j' O8 q4 N# }
31.     }
    + O0 ]2 P( \5 v4 b! S3 h, r; q, V& F  s
32. 
    
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    8 L3 y2 i# Q8 |6 ^
35.     {
    , s, D  \) I2 l# j$ }
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    " U4 s9 y2 e$ y4 c* K4 i
38.     }
    - y+ B9 z8 N9 x! D/ [
39. 
    ) _: L$ l4 i0 \) U0 m
40.     // server_socket用于监听
    . R6 _0 t! Q' F+ x$ l; h
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    ; y9 C/ S8 @7 d$ D9 ?
42.     {
    9 y9 Q1 x# Z5 ^
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    , j3 B* E# A# \  O
45.     }
    % V+ n% c- U; x  n
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
      {* ^' s* O, P- z, S4 R5 R
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    9 A! i$ G* M& J, m" U+ j' ^5 R
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    # u; O8 U# f: P) b# t' c$ }# |* l
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    . ^0 \" c& `0 [1 J% a3 [! a- }7 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);
    # ~0 ?' X( O5 r  ?9 @0 C0 D
61.         if (new_server_socket < 0)
    
62.         {
    
63.             printf("Server Accept Failed!\n");
    7 g! X* F' R5 [
64.             break;
    
65.         }
    
66. 
    8 c% {! U) C* R) X$ s' g$ g" w% ^
67.         char buffer[BUFFER_SIZE];
    , b. a6 e7 s/ ?1 x- S
68.         bzero(buffer, sizeof(buffer));
    % T% o- y- i5 o( r% q
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    0 P, H9 ?2 K7 }+ ~5 j# ?) k* _
70.         if (length < 0)
    
71.         {
    5 e% _( R' M: X" }% Z
72.             printf("Server Recieve Data Failed!\n");
    $ y6 f+ S0 m$ b: r& B
73.             break;
    
74.         }
    , n7 A2 z, F0 @9 [$ n3 W/ I
75. 
    . X9 E+ }2 ~" y) J
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    ' e1 g# g/ v7 n! b: N1 c
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.         {
    9 `( o+ H) ]& `' Q. j- o
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    9 e! s, u5 t6 o/ G
86.         else
    
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    . T- B' d. e8 m0 M
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    + X; Z0 J6 Y7 M  N, r" s7 h
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    % @8 U2 ^/ X* r: c0 w
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    # a& R- [; J4 F1 ~( o
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    ! |6 q1 V! a' e, k4 y
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    2 e5 Q% n7 E6 A$ L/ @& C3 a
98.                     break;
    4 L5 [) Q" t2 y4 m, w
99.                 }
    
100. 
     % r( ?. y7 M3 F' f( m
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     - N% ~0 N5 ]* V+ I# S9 R
105.         }
     " @1 w  }6 ^* c$ h
106. 
     
107.         close(new_server_socket);
     
108.     }
     / u1 R& B5 o+ \# q
109. 
     - m! k% Y: u/ I8 }, j! D+ d
110.     close(server_socket);
     
111. 
     
112.     return 0;
     , w4 P) T( p. \) d* G1 I; H( @
113. }
     
114. 
     

复制代码

( M' X4 C0 U) }% E" A% K
* l8 B' |- Z+ O, M/ B; U; k' N4 D