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

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
0 s) a9 l& u7 C; i* _" F3 @0 h（1）客户端程序，编写一个文件client.c，内容如下：
/ a3 {) m* _0 j  m. |

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
     r! V7 e# X9 R
4. #include <string.h>
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   ' u/ U2 H2 \' j; x* E
7. #include <netinet/in.h>
   - w7 g1 Z: ^, h  e
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   % t4 T$ }3 B' Y) q: ~0 p4 o: h( Z
10. #define PORT 4321   /* server port */
    
11. 
    0 Y- r/ Q) v; Z: ^+ l6 h7 o
12. #define MAXDATASIZE 100
    
13. 
    : W: g  G, A: j& D' z9 a
14. int main(int argc, char *argv[])
    
15. {
    
16.     int sockfd, num;    /* files descriptors */
    
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    $ D! ^+ w; x- F; C. T% ]$ ~; t
18.     struct hostent *he;    /* structure that will get information about remote host */
      F5 k( R4 H7 ~  Z
19.     struct sockaddr_in server;
    & o: [/ Z& J3 C6 y
20.    
    
21.     if (argc != 2)
    
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    8 F6 R. d% Y, ]# ]! C
24.         exit(1);
    8 W  I- V( S8 V7 b2 G: U6 [2 c4 f
25.     }
    
26.    
    ) d. _& |' ~) W- t8 R6 u
27.     if((he=gethostbyname(argv[1]))==NULL)
    # {+ G+ {) n+ r' ]# q% V
28.     {
    * r1 O* [1 R+ _( c( C
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    
31.     }
    & m  x) h+ ^. Y: i, a
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    5 D' I8 y- C1 N" D4 m0 I2 b/ `
34.     {
    3 d& x, N- Q, e$ R1 m$ q$ [
35.         printf("socket() error\n");
    & k' ~2 o/ N- |/ l- j+ j* p
36.         exit(1);
    
37.     }
    4 [7 d; ~1 j: C% m7 g1 h, k
38.     bzero(&server,sizeof(server));
    # x! l' }( I4 Z5 t
39.     server.sin_family = AF_INET;
    % R9 d3 \7 F+ k' H
40.     server.sin_port = htons(PORT);
    6 \5 p5 f8 J+ `; s) z
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    ; D" Q3 ~0 Z/ [0 p+ {7 ]
44.         printf("connect() error\n");
    % V5 Y3 e- `& {
45.         exit(1);
    % Y  F% }$ F8 K
46.     }
    
47. 　　
    6 Q6 F+ Z1 l6 [7 k& Z6 }, [/ T
48. 　　char str[] = "horst\n"
    " R  f+ x" W8 m' S, R
49. 
    , [' \$ _3 L+ q$ F
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
      B4 M0 R! i* I" I0 V
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    4 [. w/ n2 F4 U, k" K" Z* U
55.     {
    . {# I/ ^+ m3 \
56.         printf("recv() error\n");
    
57.         exit(1);
    
58.     }
    ' f& Q- H5 `& T7 m( ]
59.     buf[num-1]='\0';
    8 U/ w8 K: m* Q# P) A0 G3 G1 o
60.     printf("server message: %s\n",buf);
    - Y* |( i. n+ n( ~& |  k% V
61.     close(sockfd);
    : p/ M  v  u8 p3 F9 C% Q1 u0 o; s2 W
62.     return 0;
    3 j) A: M' q) r, j; S- }, P
63. }

复制代码

（2）服务器端，编写server.c，内容如下
4 n6 d0 W6 u" @; ]& H& o5 c

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   ' E' t3 z* U+ t: h# i
3. #include <stdio.h>
   * V" b: B9 f/ B3 o
4. #include <string.h>
   6 X; p: i$ d) ?% l, I4 R# X
5. #include <unistd.h>
   
6. #include <sys/types.h>
   5 y0 q: _0 A& L$ Y* n
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   / m! g+ I1 R0 r, d# ?4 {
9. #include <arpa/inet.h>
   
10. 
    
11. #define PORT 4321
    
12. 
    ) `9 I+ j6 X8 x3 k9 }# I$ m
13. #define BACKLOG 1
    ) C( O2 @& D2 Z; F/ Z
14. #define MAXRECVLEN 1024
    ( H: m1 x. _  {* k5 [: S1 B0 F( h; S
15. 
    
16. int main(int argc, char *argv[])
    
17. {
    & ^, C0 N! I. X0 a
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    : t* z- {5 v# |4 f* r8 {; H4 i
21.     struct sockaddr_in client; /* client's address information */
    9 n: Q/ I: `0 H. K/ l, w$ M
22.     socklen_t addrlen;
      X. A! j5 v- ]+ _5 a7 @( G  Y
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    - ]: M# h; O, I& `9 L8 r
26.         /* handle exception */
    5 w3 E$ C  \2 Z$ v+ d6 v
27.         perror("socket() error. Failed to initiate a socket");
    ; _8 l. P# P+ W4 [$ k
28.         exit(1);
    ( _4 o5 y9 ?" r6 s. a8 n9 H
29.     }
    3 {: ~9 I( {! t
30. 
    
31.     /* set socket option */
    $ N( d' Q0 u1 X
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    : M% E1 |( T7 B; N8 p- m
34. 
    
35.     bzero(&server, sizeof(server));
    . b! W# z0 c9 n1 D0 w
36. 
    ( z5 l' V% Q( s2 y  y
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
    4 x/ A" b- g$ M
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    ! ^8 N' u- m4 u
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    : }& Z+ _+ m6 @3 x( U
41.     {
    5 Q/ \  b* N6 F# D; A/ ^% o( z
42.         /* handle exception */
    
43.         perror("Bind() error.");
    ! N7 c0 e/ x( \1 h
44.         exit(1);
    . H6 x* H3 @8 F9 \/ J
45.     }
    
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    ) T4 h/ s& s9 z+ o( R
49.         perror("listen() error. \n");
    
50.         exit(1);
    
51.     }
    % l  i. V  L7 q" j2 s
52. 
    + A# Y) Y* _5 u, v7 m8 [, q- U6 c/ j' j
53.     addrlen = sizeof(client);
    " s6 h7 D% P9 [% P. Z/ `
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    9 e+ f- g% x+ W& s' ~
56.            {
    # F: @$ ?6 h' M: V& [, F
57.             perror("accept() error. \n");
    " I" }  a3 [0 U" L8 c" y( W
58.             exit(1);
    
59.            }
    
60. 
    & q5 P$ H, L0 x8 ?) `+ \, g' P
61.         struct timeval tv;
    
62.         gettimeofday(&tv, NULL);
    ; Q' u- U" _7 ^- V& {
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)
    & w' r# V! P5 I/ ?6 X& z
67.         {
    3 X2 l, X- b  @
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    9 c+ d6 V0 B! F# A' i/ P
70.             {
    
71.                 printf("%s\n", buf);
    ) Y* M( h  x$ X' H8 N
72.             }else
    
73.             {
    
74.                 close(connectfd);
    6 G( P; N8 ]2 X* `
75.                 break;
    & R" k6 ?- r! @% }3 Q0 l6 O
76.             }
    
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    : ^$ v7 H3 M2 B8 O5 G
79.         }
    
80.     }
    : B1 l2 h3 U. ^6 ^! v# |, R
81.     close(listenfd); /* close listenfd */
    # K4 N  o  _# H* N
82.     return 0;
    : ?  t4 p3 t# ^& e" [" N3 p
83. }

复制代码

4 [; z& }2 q" K' o0 L

（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. 
   ) l# }6 W. I5 U/ g
3. server message:horst

复制代码

) F0 @7 H4 i# q" j, o2 M

服务器端：

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端口等待下一次连接。

: r4 v. s9 Z% l. c
+ h  l. L6 `, n  Z& M! O
9 i) [! ?" {% z3 K0 b

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
1 E+ ]  C3 ?1 j( `: h

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   % W! g5 u& i5 @( e* l  d: k& w
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  
   
7. #include<string.h>                             // for bzero  
   
8. 
   & `. p; q/ d3 s
9. #define HELLO_WORLD_SERVER_PORT       6666  
   
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    & `# Q; f. v  [& k
13. int main(int argc, char **argv)  
    4 D; }5 ?5 B8 h# o  C# u) U: N. E0 S
14. {  
    ! j' r1 C2 r! R& O2 k' {( {
15.     if (argc != 2)  
    0 p* _' U$ }% d* z& L5 O
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    6 ~  r- P5 l8 m' c$ a; \5 c3 O5 s
18.         exit(1);  
    4 k2 H. K# l7 D' ]
19.     }  
    
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
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, 让系统自动分配一个空闲端口  
    / S# m; p, w" S
27. 
    ; ?+ I/ M, d/ ?( q% N% i) C7 L3 T
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    8 h: E, Y5 b0 x* ^' M/ P
31.     {  
    % W3 m0 Y$ |8 ]# N7 J3 t
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    , e1 k0 O# n& g- t$ G
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    ) u3 Y4 r8 |3 Q# ?& C
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    
41.     }  
    % {4 N$ Y( C! I* l, H- e& G
42. 
    : i1 f0 m: \, \: u; I2 r3 n$ p
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    % i6 x7 O; R# M6 N- N
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    6 S6 O; H  [& V' J0 o
51.         printf("Server IP Address Error!\n");  
    : d  c7 Y- `# u  _7 M
52.         exit(1);  
    
53.     }  
    ; }4 \4 S" i+ ?" _( [1 l' y
54. 
    2 @+ s8 R) i3 r& n7 O
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    5 @* _& U9 D1 B' a8 j8 ?4 ?
56.     socklen_t server_addr_length = sizeof(server_addr);  
    ; l" ?* _3 Y9 \# c/ f
57. 
    " U& W+ X5 J/ Z% w0 N/ p
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    & l+ N0 V" S. h8 Q% T0 d6 A
63.     }  
    - M' D3 _4 U9 G& |, m
64. 
    ) h& R6 w0 ~9 R3 n
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    1 b( f  ]' [- u- N2 w' [
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    ( s/ C. [; n, K$ Y7 M
69. 
    
70.     char buffer[BUFFER_SIZE];  
    
71.     bzero(buffer, sizeof(buffer));  
    / j4 E1 g8 Y# U/ a; J: K
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    # O5 e9 Y& |% `. _
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    ' c! O8 m' A5 [! u6 }/ S, ]0 k+ F
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    ' |! Y. _4 G  ~" ?2 u; n
88.         if (length < 0)  
    
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    3 x2 `# z4 G% ]
91.             break;  
    . r, h+ p9 u% Q
92.         }  
    # X9 a2 W, Y0 N5 j7 @% N
93. 
    
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    ) ?9 N, e3 U" w& A
95.         if (write_length < length)  
    " }: Z5 S8 t4 C4 `4 f- _- k
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    8 d% _6 _9 z0 U% @! `4 G( y
98.             break;  
    
99.         }  
    5 Y" |+ x; P. B! p6 A- L, E
100.         bzero(buffer, BUFFER_SIZE);  
     4 D  y) G' ~- u) S" F0 U" v
101.     }  
     * {# t% x0 T8 d- P6 H' @4 M3 C
102. 
     4 u# d1 e# V0 T' P6 P
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     ! Q1 t. [" [5 K6 h
107.     close(client_socket);  
     % |* o6 _4 S: N2 c  o5 ?4 o
108.     return 0;  
     
109. 
     - `. U+ [, Q% X: z4 O' ~/ `
110. }  
     # z4 c  P" J& M% Z) C1 r. k
111. 
     4 N( z; C3 y% @6 ^5 q1 J

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   9 ^; l& B) t. t) I3 f0 F1 x) L* y
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   8 m0 X' i: x# H( |
5. #include<stdio.h>
   : x6 U& w* o( u$ k- @9 M; [
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    3 O; H3 ?9 a. m$ i% B
11. #define BUFFER_SIZE                1024
      B& d: D9 X* s+ ]
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    2 t+ S( f# t- C
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;
    : X( p1 t4 i# @
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    4 m9 n2 S7 _6 |/ _
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    8 K: L, n. M; M' d; T3 C
23. 
    ! H! r' u2 a$ o4 J% o
24.     // create a stream socket
    % r* m/ k' f* l" I" n) M8 _
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    
28.     {
      D7 `$ i5 v7 o/ r7 n- _
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    
31.     }
    * e3 p3 B9 K& a) o" C+ B5 g
32. 
    
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    , L$ Z4 L" w* u- V$ V- c) ]
35.     {
    ! z. T' c# Y( U/ h5 q6 k3 G) W/ S2 M
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    " e4 c3 Q3 {: D* g
38.     }
    
39. 
    
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    # T! |) {5 D' e$ j
42.     {
    0 g1 _( C/ F. I
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    
46. 
    4 I' T) @+ m# c. q7 G7 c: L0 Q
47.     // 服务器端一直运行用以持续为客户端提供服务
    ' h, q2 l! q  [) j% f
48.     while(1)
    , h* Z3 O/ }; y. ]) N
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    4 |: H0 x% x' q: D
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    / ~0 f' g& Y" r: j" T  t
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    * ?9 @+ b( q' m+ y
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    3 e8 D1 O: U- w6 u8 u
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    2 x0 @- `6 |& L/ H
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    ; @, b: e# B) d' [
61.         if (new_server_socket < 0)
    
62.         {
    
63.             printf("Server Accept Failed!\n");
    
64.             break;
    
65.         }
    
66. 
    
67.         char buffer[BUFFER_SIZE];
    - `7 T5 a# y. m' [9 J! D$ B5 c
68.         bzero(buffer, sizeof(buffer));
    + A: h" e$ L/ v7 n9 h9 i6 B" b
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    
70.         if (length < 0)
    8 @8 i/ |$ ]1 {; _& S
71.         {
    , _5 h, M8 ^. C0 T
72.             printf("Server Recieve Data Failed!\n");
    
73.             break;
    
74.         }
    7 e0 e. R* r" U; B8 O: U0 T0 q
75. 
    6 ?3 s9 ]. v3 ]8 _0 _% l+ {4 U
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    4 B8 U9 A( W, p7 P! I5 R/ V# F
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    7 p0 W5 D( [" K2 G3 I) A6 D
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    + K3 N0 |2 X/ j3 ?; p) |' k
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    
83.         {
    ; c" w. l+ o4 D: b* E" C: A
84.             printf("File:\t%s Not Found!\n", file_name);
    : i2 d' ?) Y7 O+ R
85.         }
    
86.         else
    1 o; c5 W+ ~! C2 `9 i* L. P
87.         {
    $ {) X) u0 `! p* B- p7 g5 z
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    - X/ a9 ^! Y  U6 b
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    + ?. g: x, o& f: J, W
93. 
    9 M' v+ ~9 n  f7 D" L
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    % N4 p& [% K# f" B% C  [
97.                     printf("Send File:\t%s Failed!\n", file_name);
    - ^3 Q9 G7 Z6 q: @
98.                     break;
    
99.                 }
    
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     - X2 U, l9 Y0 s$ {
103.             fclose(fp);
     7 ?+ E8 A* _& [
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     ! y/ L  E5 n( K$ i# W) R: z; [- P
106. 
     8 x- h) C5 h' E! o3 @" V+ K
107.         close(new_server_socket);
     ' N% u7 X2 e7 w" Q+ I" S  \! c
108.     }
     $ j# E1 H; G- g  {1 Z
109. 
     / V) A% T( c- T' a. s. f: o* H6 Q* B
110.     close(server_socket);
     ' L0 X: i/ D1 v+ Y4 O
111. 
     ; L' S3 g, F! p1 ?* `
112.     return 0;
     9 U3 V* C; t( f8 T) K
113. }
     3 T0 z  Y" G; x* n; P7 l- }" ^/ ]" Q' W
114. 
     

复制代码

7 U7 W$ l1 C3 T7 B4 j
' n1 J3 U) J/ t* M$ e* I