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

admin

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

1. #include <stdlib.h>
   8 g+ X4 L0 H) q' \+ R9 t
2. #include <stdio.h>
   ; J! H# v* |6 {9 k: c& q8 Q
3. #include <unistd.h>
   " _: x: @5 Y" T% x( I( C0 I
4. #include <string.h>
   
5. #include <sys/types.h>
   4 j7 {. P2 P% }$ z9 P8 u9 w
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   , r4 b. H  Y# t, r
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   7 D7 U7 M/ q8 a1 d7 W+ J3 j- Y
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    
12. #define MAXDATASIZE 100
    2 _: U6 b' w0 _$ m. K
13. 
    
14. int main(int argc, char *argv[])
    * M* \( o; o& Q, t: w
15. {
    + E/ V; B* @9 c& n& R- G
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.    
    
21.     if (argc != 2)
    
22.     {
    * N8 V1 [, Q9 a$ L
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    2 m1 D5 a4 u3 Z. U) W& R/ N
25.     }
    2 `; |7 r: L& @9 ]6 i
26.    
    ( F2 X9 d! W2 r1 Y! p2 g7 s( D3 B
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    3 G$ H) O: e1 G: @- Z% M
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    
31.     }
    
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    . Z' l6 ^7 d$ X! R: V1 N
34.     {
    
35.         printf("socket() error\n");
    
36.         exit(1);
    
37.     }
    
38.     bzero(&server,sizeof(server));
    & z7 t, R, o1 J' ^
39.     server.sin_family = AF_INET;
    / U$ x$ `" t7 s" s  V! P
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)
    . s0 I) J- s) ]& u5 L% S6 p
43.     {
    2 F9 Y4 \6 u" d2 l
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    
47. 　　
    , M5 v+ @( q" i  s: Z  v2 L$ i+ J
48. 　　char str[] = "horst\n"
    2 Y2 D# J) W* N& m
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    4 c, Z: h2 M7 |' d! {, d
51.         printf("send() error\n");
    ; o# w. U1 G0 t7 a/ ]) d% f, f
52.         exit(1);
    : Z8 w5 B  ?5 D( S# i4 i
53.     }
    ; \% ~9 g( }( v* M$ O
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    + ^: k+ u" L; B8 L
55.     {
    
56.         printf("recv() error\n");
    ) \/ W' F- Y2 s' D: C
57.         exit(1);
    
58.     }
    3 e* T: x0 ^* w1 f9 m/ L& i
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    , a$ A9 O8 v4 ~- n4 A) E; n7 N
61.     close(sockfd);
    ! d1 h/ |2 c. @6 B
62.     return 0;
    
63. }

复制代码

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

1. #include <sys/time.h>
   0 p8 v* T# m$ f) H* B  N4 a
2. #include <stdlib.h>
   8 P" R0 s- h, p! x" V
3. #include <stdio.h>
     f* E) l, r) ~( G. L& d- r7 M9 x
4. #include <string.h>
   2 v2 Y+ e0 g/ S$ ], W( {
5. #include <unistd.h>
   ( v/ P1 b5 L( b9 P
6. #include <sys/types.h>
   9 s9 n$ G7 }, K1 @
7. #include <sys/socket.h>
   & Q; x( g7 S- i* F
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    + F: q! |# W! g- P  \) f
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    7 N# Q" }# c0 D( S, F
16. int main(int argc, char *argv[])
    
17. {
    
18.     char buf[MAXRECVLEN];
    7 R; ~" Z2 k% n, \/ b
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
      q, E5 C5 @- a3 ]/ u% G5 n% ^% b
21.     struct sockaddr_in client; /* client's address information */
    - G1 Q: ?; Q$ r( B4 F6 ^
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    
26.         /* handle exception */
    " G5 B. F) A0 _8 L2 A/ C2 t
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    * i% T" o- i0 [5 o  R2 M
35.     bzero(&server, sizeof(server));
    * m6 M! E1 M" \% W- r9 B) M3 {1 A1 N
36. 
    
37.     server.sin_family = AF_INET;
    7 Q" P' t* ~' c1 W+ B- U. T
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    5 a8 x0 P' \& T& h* O
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    7 j0 `. h3 d/ G! ~1 A( f
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    + \# M* e$ E. \6 n. D
45.     }
    : W6 A3 ~! T( n! z% ]
46.    
    6 l$ O5 f! ~* l) m; b5 Q  g
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    
49.         perror("listen() error. \n");
    1 Z  x2 E* S) }6 {. K' [5 v5 o
50.         exit(1);
    0 Q5 c' E# y  y3 Z
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    
54.     while(1){
    4 e; t6 f1 T: {: p, w/ E$ b
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    # C$ z! _6 g2 t, v- ]* \
57.             perror("accept() error. \n");
    5 J4 W/ N9 w' n* N3 f1 J
58.             exit(1);
    
59.            }
    ! w& @, b8 X  |5 H) x$ O  M
60. 
    / R8 M% @; A6 q$ U5 g
61.         struct timeval tv;
    2 {  _! t( k$ Q4 x7 y5 h6 K
62.         gettimeofday(&tv, NULL);
    8 o2 e2 ], Y5 E/ |1 N  Y, n
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.         
    ! I2 _* G. _% x
65.         int iret=-1;
    , X: @0 z7 N+ }
66.         while(1)
    
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    - Y" ?: N' P+ H: U& e; g; x
69.             if(iret>0)
    
70.             {
    
71.                 printf("%s\n", buf);
    8 z0 V9 G( ?, D2 H6 _
72.             }else
    
73.             {
    . \/ e% O: i) m9 ^- i) _+ F
74.                 close(connectfd);
    + V! A/ E7 x: h1 G8 \
75.                 break;
      {8 D3 ~  O" k  S
76.             }
    
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    , Y3 H3 K% x6 [6 R0 E: l! K+ G
79.         }
    
80.     }
    
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    6 K$ g- H5 ~' u( j5 A
83. }

复制代码

# t3 B* Q* x0 T7 u# }7 Q3 a5 O6 n+ P

（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
   8 u6 C* ^+ e# k4 H; v) @$ W* i7 D
2. 
   8 r/ i$ Z) Z3 ]3 P1 O! h" h; {
3. server message:horst

复制代码

服务器端：

1. $./server
   # n7 M0 O( L" {$ T% o
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端口等待下一次连接。

6 l8 \( q4 t$ G1 G% x; Z

. n9 Y/ s0 s6 S0 R: l
+ Y- G, k8 \- m0 U! k7 V- W

admin

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

1. /*client.c*/
   5 C' E: W9 q' y# \( I* N1 O
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   " q1 w/ E- K% N6 Y
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   7 D! |6 C0 K# E! f2 o8 ]& {; W7 l# o% h
7. #include<string.h>                             // for bzero  
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
      g3 o1 ?) k. ~3 |
12. 
    
13. int main(int argc, char **argv)  
    
14. {  
    
15.     if (argc != 2)  
    , a+ Z0 I1 X2 `
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    : h2 v- R  ]9 C4 b7 X
18.         exit(1);  
    ' J4 E5 ~: {+ _7 K* b# m
19.     }  
    ) I  J* E7 W' P% m# z
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    * t2 h$ Q/ S  s. P  K! ?8 b
24.     client_addr.sin_family = AF_INET; // internet协议族  
    
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    ; X+ Z6 f3 z# J, I1 l" D, u
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    
27. 
    " p& {5 O8 y) d1 L% o
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    : L, W8 Y" b3 U7 L2 ], ?, T& J
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    % }/ R, M  x1 q* k6 F& Z* P
33.         exit(1);  
    # _$ _) f0 D& G+ ^$ c
34.     }  
    ( {# y: c4 j9 G+ e) ]& o! v  j
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    % W) a, T( m: Y  ~
38.     {  
    : G6 f' s/ |; z% Z! e
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    
41.     }  
    " h# u  Y7 R* Z6 g; }$ T. h+ u
42. 
    . \9 x  k, V  p! c
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    ; ~. H4 I- |8 I7 ]1 |9 @; q
46.     server_addr.sin_family = AF_INET;  
    " h3 F& f" `% }: [
47. 
    + N9 {6 N2 \- _6 _; t9 e
48.     // 服务器的IP地址来自程序的参数   
    ! J6 s+ j* Q; d& [) I) u# l" t
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    5 p& ]/ U- A8 G# ?6 y8 q3 k9 v) |' @6 _
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    : `: q  n6 a3 ^! Q" H! ^+ X
52.         exit(1);  
    ( ^  `4 l4 [' ^+ E1 {4 ~
53.     }  
    ! D: J( Q# r' _' @# j8 V; ]
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连接  
    8 D0 ]/ P+ K. P8 _! c. Z
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    ! Y" L# T* m, j1 s1 M4 s
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    4 ~$ k/ f5 d. Q. F0 g% F) D  R3 X
62.         exit(1);  
    ( @* {$ Z' d+ I
63.     }  
    
64. 
    ) ]: S7 m6 h% L8 z. e
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    0 P  i0 y- _3 V7 L; Q
66.     bzero(file_name, sizeof(file_name));  
    4 ~1 T. [% _/ o9 {! g8 Y
67.     printf("Please Input File Name On Server.\t");  
    9 H# T; U# {% s) D/ i7 B: A
68.     scanf("%s", file_name);  
    1 P) s/ Q  X% a) `
69. 
    2 O; h- @5 e* w* Z
70.     char buffer[BUFFER_SIZE];  
    7 s/ Y4 f& [) I' i
71.     bzero(buffer, sizeof(buffer));  
    . s; i7 B& k7 s, F
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    3 }, t) r* [2 |# d5 u- \/ x0 J9 z
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    ( f! s, E7 G& A$ C
77.     if (fp == NULL)  
    
78.     {  
    # ^$ B6 A4 y: D7 V
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    9 _, X0 S( C, H: }4 J
80.         exit(1);  
    
81.     }  
    3 c* g, d, m/ ]/ H
82. 
    % ^0 ~; B! ?8 Q3 f* C7 F
83.     // 从服务器端接收数据到buffer中   
    8 \' ^) j. P. w' G
84.     bzero(buffer, sizeof(buffer));  
    4 q" c  p: Q9 L; n5 J
85.     int length = 0;  
    - I  C7 K$ G+ C2 o  N: D1 C
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    & Y# Y$ L* a- q* q
87.     {  
    * a5 l1 }, v9 P* x6 G) u6 ~; F
88.         if (length < 0)  
    
89.         {  
    4 x. F4 X3 f3 u( B4 ^
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    
92.         }  
    
93. 
    
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    
95.         if (write_length < length)  
    
96.         {  
    - C0 w1 _9 ]) x/ q8 Q/ u- a4 e
97.             printf("File:\t%s Write Failed!\n", file_name);  
    6 [% d; ?& G" I+ V
98.             break;  
    
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     ) X4 `/ Q% ]; G& R) I
101.     }  
     1 c  o, u: x3 h/ @5 f
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     
107.     close(client_socket);  
     
108.     return 0;  
     
109. 
     6 I# a7 E, w" y0 w. z
110. }  
     
111. 
       I; m8 _! ~% O- X4 _& g

复制代码

1. /*server.c*/
   & V1 O2 M; R, j% }7 ]+ \, v+ @
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   4 M- g# k' X$ H& j
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   - U5 T/ o3 G1 d6 l! [
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    ) h- b% B4 K/ `2 B, y
12. #define FILE_NAME_MAX_SIZE         512
    ! S! U% m& x! [6 B" q7 \) f
13. 
    
14. int main(int argc, char **argv)
    
15. {
    
16.     // set socket's address information
    9 W% O6 R7 Q) M
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    - S9 q1 P" @( e5 _
18.     struct sockaddr_in   server_addr;
    
19.     bzero(&server_addr, sizeof(server_addr));
    
20.     server_addr.sin_family = AF_INET;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    - B; g5 R4 ~0 o' O& q3 c4 E
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    ; r8 ]% w6 c% Q4 ?% T' E: D" i
23. 
    / B& ?. ?/ _  b2 c- W6 z
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    0 B  f# v- }3 h, }3 J
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    * ~) Y: m" o5 d! E6 j' T: I
30.         exit(1);
      ?9 I! w0 H+ l6 V
31.     }
      R- I8 I4 B! q# m
32. 
    0 y' w$ i# ?. U
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    ' X" ?9 t1 k( S0 y/ \
35.     {
    8 ]& [: h! n/ a5 d6 b
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    6 O% ~+ I: F' Q7 j2 `5 B% Z
38.     }
    6 H* p6 _0 {1 }+ a" `2 V- L
39. 
    
40.     // server_socket用于监听
    7 M- _6 @3 n, `: P! A6 ^7 B
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    $ V6 `: @( z" s# X2 E3 E
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    / l" @) T$ y. D
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    $ ]) _2 Q3 w, C/ k7 {
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    ; E  g$ i! b1 V2 q
61.         if (new_server_socket < 0)
    7 {- p9 w  e7 ]$ P4 R7 I3 q" _2 J3 P  P
62.         {
    
63.             printf("Server Accept Failed!\n");
    
64.             break;
    
65.         }
    ! t# ]+ M* n+ d2 q3 b5 X
66. 
    
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    
70.         if (length < 0)
    
71.         {
    1 `6 H- k' {4 c$ i: y; X. o: k
72.             printf("Server Recieve Data Failed!\n");
    
73.             break;
    
74.         }
    
75. 
    + `7 [7 y! L) ]; u+ o( ]+ z
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    * t- V/ V" J  L- y+ F5 J8 Z
77.         bzero(file_name, sizeof(file_name));
    4 M# G; |3 B& {' Y" N$ O8 i
78.         strncpy(file_name, buffer,
    
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    & f6 V5 W4 q/ D1 O8 v+ l; R( S
80. 
    " x/ z% p: @! R) y0 E% J
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    / R: _! N* S  W$ W$ i8 E' ]0 Y
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    
86.         else
    # J1 i; W" S* B  B, ?; K- h
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    & L' p* h1 \' R# }) l
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
    + l! h. M* c/ n! i% y8 h
92.                 printf("file_block_length = %d\n", file_block_length);
    ( F2 U) J4 X: k- K$ h6 g
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    1 c$ T( M8 ?- W8 \1 B7 O
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    5 O1 c) [+ ^# p5 Y4 B
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    
99.                 }
    + V; Q$ C2 V7 ]$ M+ f  w
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     - f/ Y3 X: q  q8 S' Z
102.             }
     & Y% ~" L+ y7 w1 F, U
103.             fclose(fp);
     9 y' l( ^# P! \7 T' n+ E. C
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     9 e0 P, r( R1 a& R
105.         }
     . j1 r6 V' y, ~! i2 Y
106. 
     
107.         close(new_server_socket);
     
108.     }
     * C" b$ N  T( E" P6 h
109. 
     ; G$ t4 D! Z8 z. C, U4 r
110.     close(server_socket);
     * b0 A# Y% H$ E; s4 M
111. 
     
112.     return 0;
     ) ?( P: ?1 _6 G8 j- f0 N' |
113. }
     6 ]8 Y8 S+ G0 D- K* @
114. 
     6 {( {. Z" U! ], `9 d" v

复制代码

8 x$ K, \. b% d& l6 W0 K# W! }

2 E3 o, i& N( k$ s4 B
% ?3 r' _: A! r0 A! I6 @! ~( `