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

admin

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

1. #include <stdlib.h>
   6 c& d0 u1 i& B( A
2. #include <stdio.h>
   
3. #include <unistd.h>
     s1 t8 I5 }) i& A! {
4. #include <string.h>
   0 |+ {/ W+ _) ~1 G
5. #include <sys/types.h>
   % x! e- o2 r: N
6. #include <sys/socket.h>
   ' c3 W$ ~: n9 t
7. #include <netinet/in.h>
   
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   6 j, p0 O7 q/ t; ^9 ]9 Y
9. 
   
10. #define PORT 4321   /* server port */
    / ~. s, b4 G6 w" A1 @
11. 
    
12. #define MAXDATASIZE 100
    ) S) A7 u) f* |# a$ s  s) e
13. 
    
14. int main(int argc, char *argv[])
    
15. {
    
16.     int sockfd, num;    /* files descriptors */
    
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    2 R) U$ m  v; f" X/ h
18.     struct hostent *he;    /* structure that will get information about remote host */
    ) S  Y0 K9 e$ M. K- O( a$ c
19.     struct sockaddr_in server;
    ( v$ v) F4 n/ p1 z7 X3 r
20.    
    1 `2 h' _. e/ C- x( j0 e6 F
21.     if (argc != 2)
    
22.     {
    ' M' h, H! ^1 [( \
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    2 \) [9 J- g) `; Z7 ^, C2 {7 F8 c
24.         exit(1);
    $ N; j0 T: \5 o( Z% I. q2 D
25.     }
    6 x7 R- ]- A* D4 w. S2 l
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
      n' M* S7 k9 Y* h
28.     {
    9 Z$ w/ X# f6 @$ ^
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    ! Y7 g! Y$ D- E7 B* s% l. `
31.     }
    . x5 k6 N4 j1 p  s
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    ' D6 i4 t) j2 b. B5 I% n
34.     {
    
35.         printf("socket() error\n");
    9 T1 i* M' V! [' U( J
36.         exit(1);
    & B! h) {1 K! }& d& r# X1 ^
37.     }
    
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    8 Q( [; a* b4 W
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)
    
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
    ! H' h5 E3 B4 L
46.     }
    
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    , k: Y& p5 P" F
51.         printf("send() error\n");
    / P2 I3 X" H$ a2 L$ D% w; \! z
52.         exit(1);
    
53.     }
    . X3 b) H0 {# C+ n
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    2 C2 G2 F8 B! \$ i7 T+ u
55.     {
    
56.         printf("recv() error\n");
    4 u8 Q4 B$ a; x1 c; N
57.         exit(1);
    
58.     }
    % Z0 d4 J1 X# r" W" }2 ?
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    2 w; @0 e) V! l6 x! Z
62.     return 0;
    % O+ k/ O+ }4 Z0 L+ Z+ i
63. }

复制代码

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

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   0 b; q6 X/ \; V  t
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   ( \/ E5 D7 k3 z
7. #include <sys/socket.h>
   : r! l) W( E; A  |
8. #include <netinet/in.h>
   4 v, k: v6 ~' H
9. #include <arpa/inet.h>
   
10. 
    
11. #define PORT 4321
    " j- g) C. p. Z7 q8 C+ B
12. 
    8 y  A# s! g! }+ Q
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    9 b- m+ i' l. C; t
16. int main(int argc, char *argv[])
    
17. {
    9 O' R! D. ]8 J  L0 N* j( M
18.     char buf[MAXRECVLEN];
    9 o% D; p8 ]( r- B0 I
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
      G- F6 \% F6 |8 p4 x2 t) }
22.     socklen_t addrlen;
    ' y2 d* m  L0 U. r! p& q6 Y
23.     /* Create TCP socket */
    ( j- Z* H) b8 m7 {: Y$ H( X$ g
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    
26.         /* handle exception */
    9 r) u$ C& i( V# K3 c
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    # [# T; c2 P( t: I7 c0 q) A
30. 
    
31.     /* set socket option */
    ! H& U# A$ I6 e6 c( x* y( ^
32.     int opt = SO_REUSEADDR;
    3 f- a3 l2 ]4 g4 S
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    8 U5 Y9 \# x/ Z9 X
35.     bzero(&server, sizeof(server));
    
36. 
    
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    % v! q; t7 S3 X# U8 @8 B
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    
42.         /* handle exception */
    
43.         perror("Bind() error.");
    7 z/ f) y8 x5 k2 w- A6 U
44.         exit(1);
    
45.     }
    ) N, @; T* m. F9 d0 b+ W
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    ; P! V3 n* z: c4 L: l
48.     {
    $ Z  z! w- q: j6 I
49.         perror("listen() error. \n");
    
50.         exit(1);
    
51.     }
    
52. 
    ( I) X6 u6 h* n( `
53.     addrlen = sizeof(client);
    
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    ( k( r) e# n+ R" R
56.            {
    2 V: ?- q, L$ W
57.             perror("accept() error. \n");
    
58.             exit(1);
    
59.            }
    ; d, l" }5 D( X. _; Z
60. 
    
61.         struct timeval tv;
    : K& z! P- d+ A9 j* w
62.         gettimeofday(&tv, NULL);
    - j8 ~7 c* ~" F
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.         {
    $ a6 W  g; ^0 `5 i' r+ Y' p0 H% ~
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    ) V0 R1 b: f0 t
69.             if(iret>0)
    
70.             {
    % {; W( d. ^5 m
71.                 printf("%s\n", buf);
    
72.             }else
    1 Y' ]; v% [- K8 I7 o% g. i
73.             {
    3 F+ M. Z( ~* V1 l/ }
74.                 close(connectfd);
    
75.                 break;
    : O0 W' M  v5 C4 G. l6 ~/ F1 E: l. O; G
76.             }
    
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    2 k! X/ |" E& B
79.         }
    % e1 `! s8 y6 d0 |; o7 \9 ?: z
80.     }
    
81.     close(listenfd); /* close listenfd */
    / V1 g/ g8 H% ?/ O2 g6 o$ [
82.     return 0;
    
83. }

复制代码

) I8 O. _- f) k0 @1 V# s3 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
   $ q2 B  J! [$ m
2. 
   ) D4 a  S+ B$ v$ r( W7 N9 d
3. server message:horst

复制代码

服务器端：

1. $./server
   2 i" @; ~$ @# l: x3 v8 V3 I. K. l' J! B
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端口等待下一次连接。

$ R' x; |. K( ]7 Y% E) B( N
8 z) ^+ h9 i( H
  J5 ^; x8 W7 _: t- R; Y

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
7 p3 z. v+ F( g( b- F& i$ h; w% L

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   : Y2 g; [5 Y' ^( y: j
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   % D* L# P; G6 t5 L1 ]
7. #include<string.h>                             // for bzero  
   
8. 
   0 {$ b$ C% j  J5 _/ w7 W0 h) F. U/ D
9. #define HELLO_WORLD_SERVER_PORT       6666  
   # [- ]: a; l7 M7 ?" ~
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    + L) V: J: b& B; G1 h8 }' _
12. 
    9 E/ t) K5 A' p
13. int main(int argc, char **argv)  
    
14. {  
    + U. h5 B) b8 s9 a
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    $ w& O9 [- _4 _9 U5 G1 \# h! {
19.     }  
    3 K5 u; y. h" }! }
20. 
      t2 M4 z) V, p( T) b2 y
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
      X8 Q1 c6 E+ ]" u$ L8 y/ {* r
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    
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, 让系统自动分配一个空闲端口  
    5 ~1 e3 {0 i7 t' {9 V
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    ) d& Q( c3 V$ H. n0 y
30.     if (client_socket < 0)  
    
31.     {  
    1 u( Q: n9 p7 m/ n5 G4 p
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    
34.     }  
    * S; u% U- l6 t
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    0 z, U/ ~0 }7 ^! W
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    . l% q4 M3 [/ _6 w7 P5 [1 {
38.     {  
    1 S7 Y: g1 b" F4 p
39.         printf("Client Bind Port Failed!\n");  
    + g3 K" b; @- Q/ y* P& h
40.         exit(1);  
    
41.     }  
    % u1 {% g# @& D
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    / G* _1 ?( J# y2 x2 u$ N# `- t
45.     bzero(&server_addr, sizeof(server_addr));  
    ' V6 {9 l7 ]7 \: a0 N; E
46.     server_addr.sin_family = AF_INET;  
    2 I4 G- ?# F6 [+ G
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    - J6 ~& r( h5 u
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    8 v  _" U  B# S. I: i) K
50.     {  
    6 a% a/ O3 e* {
51.         printf("Server IP Address Error!\n");  
    - S. Y# S; c1 b2 v! B2 [6 y/ h
52.         exit(1);  
    8 H# T% ?7 e2 e
53.     }  
    , N% [! Y, M" T" E9 ]; M* u. a
54. 
    ; _" ?) d1 X7 Z( v5 ^
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    7 C# T/ P4 P/ o0 m. P
56.     socklen_t server_addr_length = sizeof(server_addr);  
    3 r0 A! {* ?' y; s3 M/ U
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
      t5 l# N6 \7 q0 K
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    ' n( V+ ?' n; I* {7 s. ~
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    * h: m' r" k+ G' e
62.         exit(1);  
    ! C- p/ V- Q% z' {- S9 y. h+ ^
63.     }  
    ' `6 ~) H  ]# }/ ^
64. 
    * h% ^5 a  f& o! N
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    " U( ~$ e8 O5 e2 A* z0 l+ g4 [
66.     bzero(file_name, sizeof(file_name));  
    , J7 B4 m) }! x' ?8 h9 N5 z4 ?
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    
69. 
    " M9 d! P- j' A: T
70.     char buffer[BUFFER_SIZE];  
    $ ]# o1 V( A; O" X: I
71.     bzero(buffer, sizeof(buffer));  
    " v' I2 M' F9 h' N- A% _
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);  
    & a0 X* \( J8 @# Y2 C  t' _( J
75. 
    ! B) D4 ?) Q7 l; b/ c- x: t
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    8 n/ r0 t8 _  e6 C" |6 m5 c
78.     {  
    6 S1 E# d! K; M0 I
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    
82. 
    1 y* i3 K- E% R2 {. x
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    # S2 j+ [4 M' {& Z3 y% \+ t( j% I
87.     {  
    ( R$ X, }2 f% _4 V  B8 v% q
88.         if (length < 0)  
    
89.         {  
    
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)  
    2 `% v3 t7 P4 e: k
96.         {  
    1 |2 z; a8 W1 I  a" I! P
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    ( n! Y2 d  C5 a" R6 z& A) l
99.         }  
    6 ^0 b# P" e' o1 N, \2 G
100.         bzero(buffer, BUFFER_SIZE);  
     " W) R/ [$ a8 ~4 M1 ?
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     $ N- s& b1 u# r
104. 
     . ]& _6 A1 j, ~
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     
107.     close(client_socket);  
     
108.     return 0;  
     $ Y. t4 O) H/ o+ t! @4 V9 u
109. 
     # L6 ?4 z9 i' s
110. }  
     * }' Q, |8 t# ^- n- _
111. 
     

复制代码

1. /*server.c*/
   ; J) B1 ^" s, r4 U& P% F
2. #include<netinet/in.h>
   4 i( ~7 f/ D  C
3. #include<sys/types.h>
   4 e. g; A7 H4 Y% J) p& t
4. #include<sys/socket.h>
   / a; H$ v1 O, s9 t9 G
5. #include<stdio.h>
   % @6 h* @1 G( n2 i$ A
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   6 _' k; I: F5 K- E8 q  V6 R
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    9 F3 \  w( \  g. |! ?- h( f
12. #define FILE_NAME_MAX_SIZE         512
    . I9 l% G& A: o2 b' a: J
13. 
    , Z5 a. Y" b! p$ a2 i: N
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));
    
20.     server_addr.sin_family = AF_INET;
    0 d- H  C7 {0 D( |* w9 s
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    7 s! k; b9 S' v0 [( W; }+ c$ o
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    % ?/ s; @( G6 p1 g" p
23. 
    
24.     // create a stream socket
      N3 N3 S# R/ J! l/ G8 k$ Z
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    : W) u, w1 J" K# O. L
27.     if (server_socket < 0)
    
28.     {
    6 }6 }! @, n; D
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    
31.     }
    0 p2 B* U/ c2 N8 t* g+ ?
32. 
    4 M& \2 S3 J1 X/ y3 U& a/ ?+ h$ I. @
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    
35.     {
    ( s) [5 u0 V7 _$ \& ]
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    
38.     }
    
39. 
    % j* [  A- ^2 X! Y! a; ^
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    2 o8 ?) j( z4 E3 E0 z( j# ?; Q8 e3 \
43.         printf("Server Listen Failed!\n");
    - D8 G6 y' g9 ?/ g5 z# D+ f
44.         exit(1);
    
45.     }
    ) A' g0 r; L+ G  ~
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    # @4 L" {2 _& y% U# m- e3 x( T
48.     while(1)
    
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    . B4 _% ]% V. J. Y- K5 F
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    1 F+ E7 L! {6 X- S
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    3 _9 D& M. n+ e7 [
57.         // 用select()来实现超时检测
    8 |" ~& g) }1 d  T
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    * t. |3 J" {' ?% R
59.         // 这里的new_server_socket代表了这个通信通道
    ( n3 U2 b' _% J$ l$ K8 O  c
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    " ^. A9 T+ K0 f7 U
61.         if (new_server_socket < 0)
    
62.         {
    
63.             printf("Server Accept Failed!\n");
    : p; S/ k6 s3 y5 ~0 S9 L3 l+ c
64.             break;
    % V1 H8 A5 J6 _2 ~0 N/ p* k+ F; z
65.         }
    
66. 
    # V0 ^2 {0 f5 o$ P6 v! m9 l9 p
67.         char buffer[BUFFER_SIZE];
    9 k4 B1 U: E& [+ v% q1 J
68.         bzero(buffer, sizeof(buffer));
    2 i9 z  w" g2 L& u4 n# {
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    6 @) |# p; W2 Z% M' X+ P
70.         if (length < 0)
    0 c: p" e* @) S( A, T& w1 T
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    
73.             break;
    ! e; Q! W% H9 ]) i8 n, x; N
74.         }
    
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
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));
    . C8 Y# t% v3 }
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    0 l7 F( X2 W; J: \& k! y/ S
82.         if (fp == NULL)
    
83.         {
    / T" R) N3 Z. F- n' t
84.             printf("File:\t%s Not Found!\n", file_name);
    9 O. r7 o2 |: Q
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)
    9 S" r4 u$ a3 Z
91.             {
    ' W5 f% Q1 F; B$ _- v8 V
92.                 printf("file_block_length = %d\n", file_block_length);
    8 @1 ?, A' |, V2 V$ N, [
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    * o, E- G' ~; N$ j6 ]/ O; s  b5 b
98.                     break;
      Y& P+ L5 Z$ }9 D
99.                 }
    
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     ; G8 M; @" [  ]
102.             }
     - n# S+ y' ^$ h; u
103.             fclose(fp);
     6 m8 A0 K/ _( C
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     
106. 
       Y; p( d5 N1 U: d
107.         close(new_server_socket);
     
108.     }
     
109. 
     7 `/ X% Y' _% o! h6 v- O
110.     close(server_socket);
     8 ]% @0 |5 I# {1 U  t& m" }
111. 
     7 R+ ~3 w" u5 V2 {
112.     return 0;
     + `* U  Q  R9 g
113. }
     
114. 
     

复制代码

- n1 ?) q. p) M4 ~9 J
) C+ i) Z. O' K4 G
, x4 X; I+ E1 T
  p2 S& d/ W% ~- k& k  D1 {, c