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

admin

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

1. #include <stdlib.h>
   4 V. n1 |8 E" N
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <string.h>
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   1 b5 D- y9 n/ r! o/ W( t) t
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   
10. #define PORT 4321   /* server port */
    5 u% _! J& F3 q: B
11. 
    $ }! G' m, w9 z  }0 O% y0 {
12. #define MAXDATASIZE 100
    
13. 
    1 H' l* Z" C/ E, P3 D* T
14. int main(int argc, char *argv[])
    
15. {
    / i% q% ]9 j8 H# ~8 Z8 P
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.    
    2 C5 M, C5 s7 G3 x/ d
21.     if (argc != 2)
    & f  K" {, H: W$ W
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    : N! l5 B, E  V0 _, x+ Q
24.         exit(1);
    
25.     }
    $ `: {6 R5 w9 u# q8 g
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    ) j! h' B8 V/ n4 r
28.     {
    1 K3 J3 W# C/ i0 v$ L3 t/ o& A& l
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    ) X% W. o5 T: c5 d! A2 Q
31.     }
    ) `5 ^+ \- j) f7 |4 w- f+ A/ s" X0 N
32.    
    & `: e5 z9 O2 i8 P6 O: f; z5 @: x
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    4 b- _- B* e" k8 N7 F3 E
34.     {
    
35.         printf("socket() error\n");
    1 e8 |" O: H% G# C- }0 i
36.         exit(1);
    
37.     }
    
38.     bzero(&server,sizeof(server));
    5 D# {6 a% X" h% S
39.     server.sin_family = AF_INET;
    
40.     server.sin_port = htons(PORT);
    
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    / S/ t# G2 I/ S$ K6 Z
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    7 g, Q- S, F) H  D
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    ( [- y8 O  A" S) P) Y
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    : t- ?7 r/ C" I) O9 V7 H6 H
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    ! ]0 j' D$ b; R+ B% f6 {
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    : |- a, E* n0 d/ r  L/ G
55.     {
    $ U7 P" `$ \7 N0 V& @: U! |* I  q  Q6 G' W
56.         printf("recv() error\n");
    
57.         exit(1);
    - G6 q% `$ J1 ^& J9 a
58.     }
    " q  j. E" r& z/ ?1 @: K! v
59.     buf[num-1]='\0';
    : V4 g4 s! p$ m4 A* {
60.     printf("server message: %s\n",buf);
    , }& d4 r5 y7 D+ A' g! B/ C* L
61.     close(sockfd);
    # c: b+ a% k$ z: c, Y
62.     return 0;
    $ b8 d+ w: `% }6 V. `! d  F( ~
63. }

复制代码

（2）服务器端，编写server.c，内容如下
* }' ^/ E& `* A* b' A

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   6 J' ]+ ^6 N& c) i; p% ^4 ?
4. #include <string.h>
   + u& ^5 [0 X  m& [& G* R
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   , Y. \* Z2 i4 G' y
9. #include <arpa/inet.h>
   " k4 H2 ^" f  i% ^9 O
10. 
    
11. #define PORT 4321
    ' P. q& e2 B1 a6 h2 k
12. 
    
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    
16. int main(int argc, char *argv[])
    
17. {
    
18.     char buf[MAXRECVLEN];
    1 U  F# o  U+ L
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    / f9 F( F7 b1 h. g' U# ~' X
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    6 K/ `1 q$ n0 ^* M; ?
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
      k; ?' x. ^" a  T: Y
25.     {
    
26.         /* handle exception */
    6 q- p7 F' ?' V* n; w1 H
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    , Z9 u3 [. b2 L9 E7 f
29.     }
    + ]/ O" L+ X) K6 r% ]9 U, t
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    9 o, l! z+ d2 p% \5 l& l
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    " }* j2 e0 n* Z# F& O  i3 p
34. 
    4 G# ]* W' r2 D' ~+ ~- J  d9 B9 W
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);
    8 e( D  Y! D+ A; A/ ]6 ?" Q  }
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    
45.     }
    " b) p  O8 O, D4 |/ e
46.    
    ! b! i* W7 y3 }. r, }0 ]
47.     if(listen(listenfd, BACKLOG) == -1)
    3 p& q/ E5 B5 x' n) _  s
48.     {
    
49.         perror("listen() error. \n");
    ) N/ N( T2 l6 h3 |& _( p6 _% ]- Z) B% g
50.         exit(1);
    2 w; m: p8 }( `' z2 @
51.     }
    6 F  ^( m6 G. m- K8 q
52. 
    1 D2 {3 J# u* i0 a' G
53.     addrlen = sizeof(client);
    
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    0 m1 s% O- N6 N5 L
57.             perror("accept() error. \n");
    
58.             exit(1);
    
59.            }
    
60. 
    
61.         struct timeval tv;
    $ G+ o8 s! c% g* n( u! |
62.         gettimeofday(&tv, NULL);
    6 F4 B) M5 i) H+ b( \/ T: C+ W/ @) x
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);
    : @" S6 f- l+ o
64.         
    
65.         int iret=-1;
    
66.         while(1)
    
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    ( _7 H9 z2 ?6 \" L& v8 R5 j" U
69.             if(iret>0)
    
70.             {
    
71.                 printf("%s\n", buf);
    , \# q% ~, r! G4 V4 m* c
72.             }else
    
73.             {
    * n0 X& D3 Q/ X& F
74.                 close(connectfd);
    4 i9 m: Z9 P' J$ `7 i
75.                 break;
    
76.             }
    
77.             /* print client's ip and port */
    0 c2 y5 r* }* U9 @' m' M" C9 h  Q
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    
80.     }
    9 \* P3 G# P6 p- f$ X
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    
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
   ( j# @' X8 q! k; D7 \$ {* G; Y
2. 
   
3. server message:horst

复制代码

  [) G# {  G! ^

服务器端：

1. $./server
   - f* P3 X8 o  J3 D/ D
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端口等待下一次连接。

: m( ]9 b) J3 Z

admin

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

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   . Q1 y4 H; {# @" c6 h! e, ~; @
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
     C1 m% g" s9 p7 ~4 ^2 u/ W
6. #include<stdlib.h>                             // for exit  
   ' R" }$ a; p0 D/ h. j
7. #include<string.h>                             // for bzero  
   
8. 
   ! q$ V, Q+ J4 g( _; f) z4 B
9. #define HELLO_WORLD_SERVER_PORT       6666  
   4 L3 t. o/ o" T' [, \
10. #define BUFFER_SIZE                   1024  
    : b- g  m' A& Y% _9 [; B
11. #define FILE_NAME_MAX_SIZE            512  
    5 j3 M* D9 L0 d- v+ L* A1 ~# V, n
12. 
    ( |7 L2 _! r+ j
13. int main(int argc, char **argv)  
    
14. {  
    ; B6 C% r, u! F4 x7 z
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    / ^, y# O, K0 b/ v( b. a
18.         exit(1);  
    
19.     }  
    & P: }7 c/ h, }' f) R
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    ' r$ Q, {& d. {5 a
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    - A* S4 X8 \% y# w: t
24.     client_addr.sin_family = AF_INET; // internet协议族  
    5 d( k. @8 f+ o  a+ c; Z
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    9 D6 O/ a  a) Z) \7 D: o9 S
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    ! {+ \# B: K& i& f2 A6 t6 d
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    1 C; d6 q& b6 e+ i7 P& }/ y, P" z
30.     if (client_socket < 0)  
    8 y# `1 n( V6 {/ |
31.     {  
    4 ^/ S# b4 y) N. o' }# ^
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    
34.     }  
    5 C" x; `! G3 `: @
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
      W# W) B- F+ e- I" d( }9 S. r
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    ! n8 }' n( f' n- w5 u6 t
38.     {  
    ) |7 G0 D3 o. n$ d. L& z
39.         printf("Client Bind Port Failed!\n");  
    2 g  u: D8 m9 U# A+ f
40.         exit(1);  
    $ b& s5 f' |5 L; U3 u6 O7 a/ p+ `
41.     }  
    ! I; e0 v! N3 @; c+ [" @
42. 
    7 w, w" f; i6 v1 B8 S
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    5 z: O! y8 w, t
45.     bzero(&server_addr, sizeof(server_addr));  
    : A) P# n7 v9 v/ N7 c* G! c
46.     server_addr.sin_family = AF_INET;  
    
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    " f$ o2 D$ B1 `5 d# R( k( X! ?0 P" p
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    6 l  L% l: i' r' \; Z. j) q
50.     {  
    1 `) }/ A6 I& n4 V9 N: j" O& j
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    6 S2 S, E" Y9 W. A
53.     }  
    
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    1 X; T6 G: x4 {4 K
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)  
    0 ?8 u$ r0 l/ |' y; I, O
60.     {  
    9 ~1 d! w( h5 @& C& X
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    , G3 h4 h8 y! s0 ]% U
62.         exit(1);  
    
63.     }  
    
64. 
    0 g) p. c( k2 L3 h) M
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    4 |! o* @# L; D, x
69. 
    
70.     char buffer[BUFFER_SIZE];  
    
71.     bzero(buffer, sizeof(buffer));  
    3 ~; O/ f/ D$ R3 s0 o2 {5 T
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);  
    2 x% k" n, \& N7 K& J
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    9 l7 P6 {) I+ l2 Y! W, Q% g8 H! V8 O: N
77.     if (fp == NULL)  
    
78.     {  
    $ V1 R5 e' p2 }2 m
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    1 `' e: |, W% \. G
80.         exit(1);  
    
81.     }  
    : m7 P$ u, a. f3 o- z
82. 
    8 G4 ]$ b7 Z. t; y
83.     // 从服务器端接收数据到buffer中   
    4 P$ F9 R7 W& n
84.     bzero(buffer, sizeof(buffer));  
    + i# W8 W( W: T8 s: l% u  b+ K
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    # l1 V1 I# m3 J# i1 @9 c- h
87.     {  
    $ k" W: B4 r$ o4 g) K
88.         if (length < 0)  
    : R5 D; ?+ t" d' l: s$ H9 U3 b+ _
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    : ~0 N# P4 b8 u0 E6 }
91.             break;  
    5 u$ M0 h: {; w8 K3 V0 i
92.         }  
    
93. 
    * ^* `7 R/ `2 a: y
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    5 i3 F8 U! C5 ]! Z
95.         if (write_length < length)  
    ( X0 T* j; @' l
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    ; f$ B8 c. R, G( J, \2 {2 K/ h
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     % |- z5 Y1 ^1 c6 R4 v
101.     }  
     ; _) Q: ^' W7 s& {( R3 ]
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     % }  l! C4 f5 d6 u
106.     fclose(fp);  
     
107.     close(client_socket);  
     ' \; I( ?; g2 J! V1 ^# e! ]! t" `
108.     return 0;  
     
109. 
     
110. }  
     
111. 
     & L# E* [# q- {6 ^' D- E% Y$ W

复制代码

1. /*server.c*/
   9 Q7 f4 Z/ m% g# c+ S
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   : J% t! Y+ y" O4 Z1 n* q: W" F7 k
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   1 N, z4 |4 {7 l
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   ; U' M+ K$ I2 z; }7 D* [1 A
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   " f- t- b: L( _& ]( x  g7 j
10. #define LENGTH_OF_LISTEN_QUEUE     20
    5 R+ e8 x8 u9 O' F( `( l' r( l/ o
11. #define BUFFER_SIZE                1024
    9 X" P. _; ]9 H& O& R: W8 Y$ @
12. #define FILE_NAME_MAX_SIZE         512
    % b8 v. a4 f: }/ l
13. 
      u) |: Y5 Z# }& p- P4 ]
14. int main(int argc, char **argv)
    & h8 t# `" I5 u0 a
15. {
    7 r- c  s& L, {' y/ M" n- e
16.     // set socket's address information
    " O+ M: y! D) T4 j
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    + P1 M  ^8 X2 x+ a- N* _" ^" M
18.     struct sockaddr_in   server_addr;
    3 V( e" J9 o" u, \3 p& C
19.     bzero(&server_addr, sizeof(server_addr));
    
20.     server_addr.sin_family = AF_INET;
      U& v5 J! x$ `6 C/ j/ m! F" Y
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
      [) O, A+ E1 H
23. 
    
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    $ V, I+ P/ B2 I- i3 k- J' W1 D
30.         exit(1);
    ( W& N  V, \6 L- N5 Y' V( D
31.     }
    
32. 
    - F# o7 g$ v7 {8 O! C3 [- u
33.     // 把socket和socket地址结构绑定
    ( m4 E4 V( z# P
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    # k1 z5 P2 X  d
35.     {
    3 _& `6 d3 n1 r6 g: ?% B% R4 X3 n
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    - l7 g- ^0 g) _2 [  C
37.         exit(1);
    1 b3 C9 d7 B( Y; U5 z: G
38.     }
    
39. 
    
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    8 J6 [. b; z* a  y$ p, p
48.     while(1)
    ) \: ?) R- K9 }" R6 |! E8 J
49.     {
    9 l) O' U6 ~+ L
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    + K9 C# Z/ G- R) U  K2 M* a
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    . A1 u! h8 A$ k
57.         // 用select()来实现超时检测
    7 I& {" o# P% S* t
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    , F2 v& k" P% R. e
61.         if (new_server_socket < 0)
    
62.         {
    0 _& y* |$ J$ [# b4 D
63.             printf("Server Accept Failed!\n");
    
64.             break;
    6 {3 K. j/ j1 K$ F
65.         }
    $ ]3 O2 ~$ u! [* W8 G. V, p' @
66. 
    
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    ; m" @# A- m. W( t
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    ( B2 |; q$ n0 b; r& c- w  [
70.         if (length < 0)
    5 J8 L" W3 K% h3 F6 h4 c4 N5 V
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    ; _! ^- {, @0 z1 j
73.             break;
    ( q; l+ |  _& t; ~! H
74.         }
    * |) e* K2 z8 e- J
75. 
    * b' ]- n7 i) Q4 A; G
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    . A* K2 C" B, t, f
78.         strncpy(file_name, buffer,
    
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    & _1 w9 N8 ?$ U7 J% @# A( I
81.         FILE *fp = fopen(file_name, "r");
    % r6 j& f' [2 Z. ~
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    # _' Q: c3 o$ |$ b1 ~% R
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.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    " T) d7 r. l3 D6 h" R$ ]8 A( Z
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    ( h) c! g% D- x7 G5 O# ?, \& a7 z
96.                 {
    ; \0 @6 e! y  k$ D# u
97.                     printf("Send File:\t%s Failed!\n", file_name);
    * u7 k1 ?6 ^/ I% V: D
98.                     break;
    & p' k* ]4 c2 @# p. w
99.                 }
    3 S7 g- X6 y# a1 N5 g
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     9 Y  ?# b- l, ~4 v/ ?# O9 m7 I3 l
102.             }
     7 f& s9 q8 u" D4 b& {( g4 f* }
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     7 Q- k% }4 N9 s/ P/ v
105.         }
     8 j1 u7 Z6 y' u# c
106. 
     
107.         close(new_server_socket);
     / R: Q! |( Y' b/ ^
108.     }
     
109. 
     , ?9 d& |! E3 o1 o' x2 B: m
110.     close(server_socket);
     
111. 
     
112.     return 0;
     
113. }
     
114. 
     

复制代码

, A+ ]3 w( M/ D) _" {+ C% i3 B, ~

$ G" t$ b' D* P$ n8 q