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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   1 l% g( d/ f( C1 y$ i9 L6 t
3. #include <unistd.h>
   0 `, b) L" d( W8 m* L" }
4. #include <string.h>
   , n5 c+ w: f- _; c/ g
5. #include <sys/types.h>
   ( g$ ^' X9 O  S4 `& _4 w9 }9 [
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   * Z( E0 Z. U2 b  L* [( g
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   $ y/ j2 E8 O  D* n1 _$ o* E
10. #define PORT 4321   /* server port */
    & l4 H5 x- @& F; H6 q, f1 {
11. 
    
12. #define MAXDATASIZE 100
    4 D: F6 K" Q- h, P# u
13. 
    ; B) V; f( d4 a$ ~% y  `
14. int main(int argc, char *argv[])
    ( V8 q7 e8 |- g
15. {
    " a/ g. H" c: A; [: X1 y
16.     int sockfd, num;    /* files descriptors */
    + C6 |3 ~2 Y  @- o- t
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;
    ! h  B9 `% G1 S
20.    
    
21.     if (argc != 2)
    . Z$ I) D. F* k. t0 Z* Z
22.     {
    / z; W3 r1 _" ]( t: x
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    3 C( o- J% V! [4 F
24.         exit(1);
    
25.     }
    
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    & v- P! h- }$ I: @
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    
31.     }
    1 Q* h3 n3 C( o/ I: h7 }+ z2 J
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    " d- F) h; Q& n: `
34.     {
    * T  l6 i9 C* |1 p% ?+ l
35.         printf("socket() error\n");
    
36.         exit(1);
    
37.     }
    
38.     bzero(&server,sizeof(server));
      T3 i" {2 `) o& V+ ^
39.     server.sin_family = AF_INET;
    1 Z# o$ G( n# z, B- S
40.     server.sin_port = htons(PORT);
    / c' N- d7 C4 u' n& l, `
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    $ T3 l+ r, ~4 b( z* V: h
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
    4 {: ^/ s' }( K% Q1 |6 I  y; Y
46.     }
    5 ]. k5 c1 f* f3 ^" ]7 a0 A/ D
47. 　　
    
48. 　　char str[] = "horst\n"
    , X$ Q. g7 f' z3 _
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    - R% q: O2 ^8 f; u. I! f# z
52.         exit(1);
    
53.     }
    9 J/ i5 o$ [/ T! [- d- R0 b% P9 y
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    
56.         printf("recv() error\n");
    # G% @1 v9 B  }) D
57.         exit(1);
    
58.     }
    
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    
62.     return 0;
    9 S4 S' _# ^" W% I5 f
63. }

复制代码

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

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   1 P- R, m7 p! L
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   7 ~2 q; b( j9 c
9. #include <arpa/inet.h>
   * I; f  h( @$ W  U9 G% u
10. 
    
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    " l( n* o3 \/ j1 s3 H& t) E: W
14. #define MAXRECVLEN 1024
    
15. 
    , V: H! d  e8 F) j4 e. Y2 D1 v
16. int main(int argc, char *argv[])
    
17. {
    + z! a9 ~: y  Y% A. |* w
18.     char buf[MAXRECVLEN];
    : W5 |" T% p: N. ~- t) i8 ?
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    - Y: z7 E4 K9 e  V
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    3 ]% q, [8 ~0 e4 p/ k. |4 _. Y
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    3 H% U- W# A$ _6 Q
25.     {
    
26.         /* handle exception */
    % `% C: |& V" V/ ^' Y/ {% X
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    / S. z. B. F- q3 t$ |1 _
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    ( o* P: F$ ^# U% i" `& A0 w" ?
35.     bzero(&server, sizeof(server));
    - v. O! v" S4 }2 M3 c! ~
36. 
    
37.     server.sin_family = AF_INET;
    4 i- y( W. x1 I% Q7 s, Z4 p
38.     server.sin_port = htons(PORT);
    + t9 p* M" X4 u
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    
42.         /* handle exception */
    
43.         perror("Bind() error.");
    ' M0 |, ^% W& q. d
44.         exit(1);
    ) z2 m4 R1 ?$ [
45.     }
    # A( r8 j& J# S: ^* K* g8 y. I! O
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    * \# ^  G5 P$ i# a. {
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
    - v% G, ~" [7 H$ u5 f2 Z& u
51.     }
    ' y# R' p4 T3 _( [" H
52. 
    
53.     addrlen = sizeof(client);
    2 \4 O' r6 C; c$ K1 `
54.     while(1){
    8 P1 r( \( |" W; Z8 H. Q
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    * }- t& ]  p) h+ O% A0 u
56.            {
    6 k  v: L# l, u+ t' I8 T0 ^3 j3 C
57.             perror("accept() error. \n");
    $ y& [2 r4 }% C; z: ~/ A% V
58.             exit(1);
    
59.            }
    : ^4 z) K  j8 {9 H0 J+ e
60. 
    
61.         struct timeval tv;
    
62.         gettimeofday(&tv, NULL);
    % x$ z: l4 D# {# Y$ V9 I8 ?
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;
    0 J: \# s8 T9 R9 t+ M. k
66.         while(1)
    & ~" h( z7 S% E- B  W! ^, e
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    % g: R% k) ]$ k+ w2 k' e
70.             {
    6 u% d( ~" p* }! D$ z7 |) L4 m
71.                 printf("%s\n", buf);
    
72.             }else
    
73.             {
    " L1 ?0 |9 K) a9 R. F1 Q# _# B
74.                 close(connectfd);
    
75.                 break;
    1 ?) C: E9 b( Y+ U; V& Y2 w) d  o
76.             }
    
77.             /* print client's ip and port */
    : O1 U3 X( T0 ~
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    . `; l/ E! f, e. g: n
79.         }
    
80.     }
    ( {/ f2 ^0 |9 E
81.     close(listenfd); /* close listenfd */
    % {: g* L) \8 o" \% Z
82.     return 0;
    1 T- H! A3 p' O3 l" Z+ v) H, x
83. }

复制代码

7 }6 X9 z( {3 Y& t0 S; E0 f3 _
' E: x  I  M1 M+ _8 K- _6 f

（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
   , V( U2 A4 p& `; S( G& A& M" k
2. 
   
3. server message:horst

复制代码

/ ^+ v1 s; F! d2 K6 L/ F

服务器端：

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

# Q' [4 m. U7 n* r

admin

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

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   
3. #include<sys/types.h>                          // for socket  
   , d" x* c- z1 u* _$ z4 J
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   / n0 f3 U  I$ @
6. #include<stdlib.h>                             // for exit  
   - [' q8 S" B8 S) a- R( Q3 n6 a( C
7. #include<string.h>                             // for bzero  
   7 Z( h- Y, m! \6 i1 \( A
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   2 H1 b4 n6 h8 c. ^1 F1 j, ~6 V
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    ) y$ E" E0 `  `+ H6 z: \5 _
13. int main(int argc, char **argv)  
    * h7 c! o6 ]" w7 Y) t' t
14. {  
    
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    # M; v3 Q4 y, D! ^* c
18.         exit(1);  
    ( ]" [( d9 h* C' p/ m& m
19.     }  
    
20. 
    + `: \  f1 h) B9 ~! Z
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    * i, F6 P$ E8 s7 A: O
22.     struct sockaddr_in client_addr;  
    - k  u0 ]! S3 K& U% w$ m: Q0 |% K
23.     bzero(&client_addr, sizeof(client_addr));  
    
24.     client_addr.sin_family = AF_INET; // internet协议族  
    * `3 {. y/ F' \
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    ! {  [3 r/ X1 t/ L2 V* g
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    , L  @4 i0 R  c
30.     if (client_socket < 0)  
      D5 Q0 h! F7 m0 I
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
      Z' b4 U) G/ F7 ?" @8 v
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    . C0 \3 t8 n2 u3 c  C+ }
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
      e0 F* w+ Y1 S3 G3 K6 z' V/ Q* y
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
      v* J, D0 B* J, u* b/ k
41.     }  
    0 I, V7 U! F. g& H
42. 
    $ l. Z  V, B; c# Y4 ?/ _3 U
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    ' D3 K+ i2 U5 D1 l; @1 T5 Z5 M5 a
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    
47. 
    9 f! R, W, v0 S
48.     // 服务器的IP地址来自程序的参数   
    
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    1 E4 \. C: @& q
52.         exit(1);  
    ' V9 G) I5 F* b2 t$ _
53.     }  
    8 g) l8 R& r* Z3 d6 O6 M
54. 
    : D. H! k2 O3 c9 V+ N6 k
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
      @1 }8 M. A0 v4 A/ \' U
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    
60.     {  
    ' _; c0 m- O. t; O3 v
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    
63.     }  
    / m: Z9 z$ c0 o0 x- [
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    ! T" ]) I3 V1 V7 e
66.     bzero(file_name, sizeof(file_name));  
    
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    
69. 
    " N. Q6 h* M3 n4 n5 X  l/ w
70.     char buffer[BUFFER_SIZE];  
    6 u/ q( q6 u2 c% A
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    , T2 z1 z! t9 f0 d5 V3 h, ?3 W5 I; I
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    # M1 E3 `0 U# O. Q
77.     if (fp == NULL)  
    8 q. \& A, t1 B7 `. S6 Y
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    / F. a9 S. m4 @
80.         exit(1);  
    2 o6 c; ~: N* c3 c$ W& I) C0 n
81.     }  
    . Z& H% p# A- c/ |/ c5 X. k0 K
82. 
    
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    9 V& Y( ~5 P+ I/ o3 y* a: j% Z
87.     {  
    , c2 X. s3 @! j3 }: a( L
88.         if (length < 0)  
    - T7 R8 ~; C' u* z% R) w+ {
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    ) A7 w: D. j0 r! q1 j  Y% n
92.         }  
    
93. 
    
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    % I' L: h* d7 W* e0 `- p
95.         if (write_length < length)  
    
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    , a* f8 F' t" U# F
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     7 O3 {" |7 e" _+ [1 O
101.     }  
     8 _0 n& c& e1 P* j$ e
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     , L# M. ^4 Z: E) W2 k
106.     fclose(fp);  
     % T7 C; V6 M8 |/ R( U
107.     close(client_socket);  
     
108.     return 0;  
     
109. 
     2 u8 A+ C: f# o  Z2 |9 R% E
110. }  
     ; L) j: U. X, e6 ]$ V+ V
111. 
     ! N9 A% f9 K) o" y6 I4 G6 z

复制代码

1. /*server.c*/
   7 a% K* A5 g; o4 Q3 o+ \- B
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   " o( b" U" r0 s7 y) I
4. #include<sys/socket.h>
   & l2 K( g! D$ }; p# W
5. #include<stdio.h>
   , c/ k0 m# n8 G% \7 `$ t
6. #include<stdlib.h>
   
7. #include<string.h>
   , E) ?7 O/ _0 ^7 N! s# _6 i
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    5 s8 m! ]  ~9 T5 R
15. {
    
16.     // set socket's address information
    7 v/ ^% i9 S1 |; q2 {/ i4 c* J! l
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    1 v0 v; Q6 W& j
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);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    . j% h$ N  u. J  j" O  k- \' z; E
23. 
    # H! S5 F- s" B% F# k, {7 A
24.     // create a stream socket
    - m% r# K1 A6 |7 N! n7 V% n$ ]
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    3 x! v' R6 u7 x
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    3 N8 W# T4 n" f. B
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    
31.     }
    ' O0 l8 t: p$ b5 E
32. 
    ) X. {5 R9 Y1 N$ v# W
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
      r% r, I  @+ g' Z+ W% `; q) u
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    9 _6 V% }' }& o$ _  c; v7 }' h$ o6 Q
37.         exit(1);
    * u2 K) j9 [8 p+ _5 n1 L2 U5 @
38.     }
    
39. 
    
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    / S& c* v! [3 [# v) ^
42.     {
    1 ?5 H: L# e* p4 d. W* C* z: ^
43.         printf("Server Listen Failed!\n");
    - V# D8 l+ o3 v( S' j4 G1 D
44.         exit(1);
    ( N( q8 a0 b: Y9 Z' Y8 z2 H
45.     }
    % E" X& ]" a' X' t2 Q" W
46. 
    2 q$ X( _( s& R" |& i: [
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    " S9 |2 u! p5 b8 l
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    $ t: a- O: J  A2 H
52.         struct sockaddr_in client_addr;
    - B; R# s9 A# D0 K  p& d
53.         socklen_t          length = sizeof(client_addr);
    * O/ G$ ?! l0 A: T
54. 
    2 v6 ]' ~' B7 |
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    8 g: V: o, p) d- k2 x
57.         // 用select()来实现超时检测
    " a: M8 ]% O7 _4 H9 o. A
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    
61.         if (new_server_socket < 0)
    
62.         {
    
63.             printf("Server Accept Failed!\n");
    
64.             break;
    ( P9 l1 I6 C, d, N! r9 ]8 O7 l4 K' {8 r
65.         }
    " C4 r# Y9 Q1 W  F# J5 v
66. 
    # ^+ ?7 I. |: K" P
67.         char buffer[BUFFER_SIZE];
    # a3 |$ H9 P5 b: z3 y
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    
70.         if (length < 0)
    
71.         {
    1 ]' W% d9 n& W3 a- U; Z
72.             printf("Server Recieve Data Failed!\n");
      h8 l: a; @; y( {
73.             break;
    ; s# `* S$ G: x" `, X
74.         }
    
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    * [, ]5 n. |: K* D; O  P
78.         strncpy(file_name, buffer,
    0 L. d0 i" Q8 x  [, f5 g$ l. I
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    ( g- a" [- {7 ?+ Q2 s) ^
80. 
    ' c2 }+ k/ O' d: b( o9 h
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    , r7 N4 w  j2 G
85.         }
    ( l3 [- U$ l0 a' ~) [9 O* b6 }
86.         else
    
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    9 ~$ d+ Z& g% ~7 x2 A$ l) k% P2 ]9 U
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    " s% I- N- r: \! @- J
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    % N4 ?5 u# c5 ^$ z3 x$ w
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    . K& z: G5 E) `3 F! n. j
97.                     printf("Send File:\t%s Failed!\n", file_name);
    7 o# ]: ]1 ^) L2 o  \2 I" L/ n
98.                     break;
    , @6 u# g. M8 b% T) Y8 H5 ]" s( v
99.                 }
    
100. 
     ( b; _% w9 T3 E# J
101.                 bzero(buffer, sizeof(buffer));
     5 {1 @% e6 ^6 O# W  @
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
       G# v- G6 W9 ~+ Q! W9 ?( `
105.         }
     " S" W1 [. X+ A) M
106. 
     
107.         close(new_server_socket);
     $ m7 _% E8 I1 D, |  u4 R" S6 _7 g
108.     }
     4 b: a1 v: M/ U. g! [& L
109. 
     0 P: ~9 X" ~" g5 Z0 K
110.     close(server_socket);
     % O, k" k! t! x1 M
111. 
     ( W7 w6 a- ]( D
112.     return 0;
     $ H0 B8 O4 ~: z& E  c7 i
113. }
     
114. 
     

复制代码

0 l! |: }1 l  y3 R. U' B# e
, ?7 J: J' K! p! E# ^
* j% K, x$ o* n' e