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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   # u% {. ?4 N8 q& A! G0 \
4. #include <string.h>
   2 Y1 W2 m* ^' n% [. n
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   : S' E9 D0 p/ z- Y+ W" ~
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   
10. #define PORT 4321   /* server port */
    + }3 a  n4 p1 A0 N; l
11. 
    , W, O$ y% ~2 i! F2 O
12. #define MAXDATASIZE 100
    
13. 
    / U0 {" o9 l! Y3 n4 z* P# r
14. int main(int argc, char *argv[])
    2 B0 I# f) T6 k/ `9 a* ~; s2 t' u
15. {
    8 r; E3 r0 B) o9 {6 \
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;
    * b% S/ ?) O* B3 E: L
20.    
    
21.     if (argc != 2)
    
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    
25.     }
    ) `- a  O$ R/ K0 C
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    9 r0 c" S+ v2 M% U- q# v
28.     {
    
29.         printf("gethostbyname() error\n");
    + |: _+ n2 g/ @& p8 j) x
30.         exit(1);
    
31.     }
    4 D  Y1 a! |% H
32.    
    6 V$ i5 F* }8 s: [# Q0 @" j
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    + W+ X7 P  \; g: F
34.     {
    
35.         printf("socket() error\n");
    
36.         exit(1);
    3 p2 T; ?- @8 ]
37.     }
    0 q& N- j9 U8 ^# M
38.     bzero(&server,sizeof(server));
    ( x+ ?% f3 ~: y# u' u1 w$ w
39.     server.sin_family = AF_INET;
    
40.     server.sin_port = htons(PORT);
    . r2 a8 g( Q5 Y# s# z" N" }
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    * g" _' G. D1 N# t) }
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    & u- ?9 k+ r8 b" D1 a! h/ s
43.     {
    2 w6 ]. \. g" q- O2 G' m
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    
47. 　　
    8 D$ b$ B) x7 ]- ~# p& t5 B' J
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    2 Z( j# V3 \* B) x% s+ O
51.         printf("send() error\n");
    2 H# B/ ~6 [% s: \
52.         exit(1);
    7 m! U% S3 U: g, Z2 {& C/ g# r: w6 g
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    
56.         printf("recv() error\n");
    
57.         exit(1);
    : V, }; U( d  u; c1 Q
58.     }
    & |$ ^/ ^& x$ J1 j0 {
59.     buf[num-1]='\0';
    6 {- P3 J5 Z% Y7 d5 H3 c0 C; v
60.     printf("server message: %s\n",buf);
    9 l# A; `& u* e, N! N5 w5 T; C8 [
61.     close(sockfd);
    
62.     return 0;
    
63. }

复制代码

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

1. #include <sys/time.h>
   3 _6 g: |1 q; g
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   0 [3 A% P, y& t
10. 
    
11. #define PORT 4321
    ' |( e! k0 X. D4 K0 j
12. 
    
13. #define BACKLOG 1
    , m- M1 }% M8 c
14. #define MAXRECVLEN 1024
    
15. 
    1 D- i. v+ @" ?; a; y* J! J
16. int main(int argc, char *argv[])
    3 c9 w! ]& M: H
17. {
    + N% n# e; H) B; T4 N. J3 {* ?$ z
18.     char buf[MAXRECVLEN];
    1 t9 a" W- ^. g: R0 [) p
19.     int listenfd, connectfd;   /* socket descriptors */
    4 P( _( c+ U' q3 u+ m
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    ) a! T6 y2 T- F5 |* t  u9 Y# ^
25.     {
    & R$ F+ @/ J, o" p0 F8 W/ G* g8 m! S% o
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    - Z$ q4 p# r( s1 I
30. 
    % C; d2 o- a% j! T
31.     /* set socket option */
    $ a  d$ F" G$ y  \9 ~4 a
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    
35.     bzero(&server, sizeof(server));
    # B4 @4 U9 C2 |  m9 c' s) {
36. 
    0 V# P( v5 U# q7 J
37.     server.sin_family = AF_INET;
      o' L( d9 q) M  E- [
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    * N. v9 K$ g, k2 X/ ^3 G+ u( O$ U
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    
45.     }
    $ k" \# J: d) b: j
46.    
    6 B9 [- r; O& W2 ^: s; _- r
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    
49.         perror("listen() error. \n");
    4 ^! P; t8 L0 ?2 ~  X! V, q% A
50.         exit(1);
    
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    
54.     while(1){
    2 a2 I) w. V4 g  H) @9 O# ]+ T( a, j
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    ) f3 n9 X" b5 N9 a1 v+ d! z/ u; o( R
56.            {
    " |! F3 ?: w0 J) |# [
57.             perror("accept() error. \n");
    & U1 Y+ b& p4 b6 n6 L  \* s, i7 S, `' Z
58.             exit(1);
    
59.            }
    
60. 
    4 f! N, Q  h0 M- r& N: x* b! g
61.         struct timeval tv;
    - A! U( b+ [  E& i# h' \
62.         gettimeofday(&tv, NULL);
    # V/ |  p+ e" B* e/ Q$ v4 W) W
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;
      {6 M- S9 e) N5 f! i9 x
66.         while(1)
    
67.         {
    ! F9 z% |7 u: W# V* [
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    - L& C6 n2 _4 g7 g
69.             if(iret>0)
    
70.             {
    & u7 k( b. S4 X" h* G" D! k
71.                 printf("%s\n", buf);
    
72.             }else
    
73.             {
    ) D/ F& w6 w: N& e. @0 S5 C% C
74.                 close(connectfd);
    ' p0 }: Z# m) F5 Y/ w, ?5 o& n% F5 Y3 F
75.                 break;
    - \% B3 f4 |7 s9 i9 |
76.             }
    
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    ( }  }/ k( D) l  x6 D, B0 i
79.         }
    $ T" X4 U0 j5 T+ Y* x/ a
80.     }
    9 s, F. A6 B9 `) o
81.     close(listenfd); /* close listenfd */
    ; T2 d8 a8 {/ e, q- ]' H
82.     return 0;
    
83. }

复制代码

7 N/ u9 a, x" s4 J

（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. 
   
3. server message:horst

复制代码

服务器端：

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

% k9 L4 q$ n( W0 ?( L- q4 ^
5 |( f( ]- B2 j% q
+ x- x, ^3 j( _! b, s

admin

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

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   " u( r$ f8 L. `/ K5 b
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  
   6 W1 i/ Y' n# O
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    6 E: m5 U) Q2 Q% @8 x
13. int main(int argc, char **argv)  
    
14. {  
    8 n" q& w# I: Y- B( E; x) j
15.     if (argc != 2)  
    % ]2 \) y  w: T7 L$ E# \' t
16.     {  
    - x+ f: U- a, X) c; y
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    1 Z: K' P* g5 U4 d* m1 c" B9 M
19.     }  
    
20. 
    / K" x8 X% ?: Q4 C
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    % `1 `2 o" }+ [. T7 C% [) Y8 c# @
23.     bzero(&client_addr, sizeof(client_addr));  
    ) G* |5 O$ y4 g# Y9 M* s
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, 让系统自动分配一个空闲端口  
    ' w  v% z/ Z% R
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    
34.     }  
    0 X4 K; g4 `  O; ^$ W; L' ]* e8 p
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    7 e. S0 U! p2 X* l
41.     }  
    ; O5 |8 l' {, {1 C" K. J
42. 
    0 O& f# p6 ]2 |7 P: e
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. 
    4 H& A- I  m# \( D
48.     // 服务器的IP地址来自程序的参数   
    
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    . j6 l/ f, j* \# h: z/ u& B( Q% m0 h
52.         exit(1);  
    
53.     }  
    ! U7 o/ w- e( C9 s5 q7 Z" ~6 E9 K
54. 
    ; B" r, W; G# h
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
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)  
    
60.     {  
    9 P& o! I9 H' \
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    0 @' Y7 n5 n; h& L8 |
63.     }  
    ; `5 D: e% I% Y8 z+ s; l" ]
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    $ N* O# i  s4 O
66.     bzero(file_name, sizeof(file_name));  
    # P! d5 }# T5 m) k6 u: V3 g
67.     printf("Please Input File Name On Server.\t");  
    6 }" @+ E$ _$ ?9 d8 s; [! `
68.     scanf("%s", file_name);  
    9 D* R# }2 ^1 o; J
69. 
    
70.     char buffer[BUFFER_SIZE];  
    ) B6 Z7 q3 ~) b! d
71.     bzero(buffer, sizeof(buffer));  
    2 i: _3 o/ a" C) e  P, f0 z! H
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    2 D  L$ V; U. }3 F( H# ~
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    , k  }. d% g( N. i
75. 
    0 g( E! c9 o2 Y  J. {* U% w8 L
76.     FILE *fp = fopen(file_name, "w");  
    5 W  z; d$ m: V& p5 q, P
77.     if (fp == NULL)  
    ' H* ~# i& e6 o; H2 Q( x
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    . A! f' D3 L8 V- o2 k) l& _
81.     }  
    , d# m3 T" b4 N5 c- e- P
82. 
    
83.     // 从服务器端接收数据到buffer中   
    1 I/ H9 o( B' `1 q1 }& s: Z  t
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    ) Z( e9 B8 I6 c6 B7 \" \
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    
88.         if (length < 0)  
    
89.         {  
    " T/ _5 J9 I2 X( o, n2 p; H0 {8 L
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    ) f! w7 s) ~; T) H  U$ E
91.             break;  
    1 _) d, m$ m3 U+ c: u% l
92.         }  
    + l% h7 H$ f2 p+ U& `
93. 
    # c" q+ v' E# b
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    + [& Y) Y7 h8 ^- ?9 r# H- b
95.         if (write_length < length)  
    ; ~; X5 o& z6 a$ y2 O
96.         {  
    2 _' J% n- [6 S6 @, x
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    # F  W' [+ f/ y9 j: J; K9 F) M4 ?5 W
99.         }  
    - p$ |7 a3 s/ F8 a/ w7 x
100.         bzero(buffer, BUFFER_SIZE);  
     1 B! w$ U$ t9 p0 J5 [  N; t( W
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     - H, w8 E  b1 S& E6 `
106.     fclose(fp);  
     + ~0 o( M; e9 R$ V
107.     close(client_socket);  
     $ X1 a1 k# ^' M8 h4 V* m2 ]
108.     return 0;  
     9 t, j( C" b5 `# G' J% ?
109. 
     
110. }  
     
111. 
     

复制代码

1. /*server.c*/
   0 n, J) F' h$ w3 e( d
2. #include<netinet/in.h>
   - ?6 z& |. K" `' `$ m8 y' I5 i
3. #include<sys/types.h>
   ! {2 E( W: S; N3 o! R6 Q5 A7 `
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   8 {- q! ?" t: d9 Z5 Y
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   1 U9 M- V9 E6 s! B# Z
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    - M5 b0 H! P* I+ [* E( v: I1 X
12. #define FILE_NAME_MAX_SIZE         512
    1 v- q" T  f! V$ E, C
13. 
    9 ?: x5 F7 L5 `. C
14. int main(int argc, char **argv)
    $ S4 G# }* S" T- u8 \0 {5 w
15. {
    7 }4 l$ @7 o/ Y5 H
16.     // set socket's address information
    
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    # W8 f7 i- N" E
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);
    
23. 
    
24.     // create a stream socket
    # I0 E; Q. K$ O4 Y
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    9 y: F, U2 h: p$ q% M8 h( Y' v9 e
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    , `. X& ~2 b0 l/ o( e/ V8 x, c; Z
28.     {
    7 C4 ~/ u* v* H% k: L
29.         printf("Create Socket Failed!\n");
    ( c( Z! l- F0 s8 c
30.         exit(1);
    0 _- w1 a; U; Q9 w) J2 Q) N; h; o! ?
31.     }
    
32. 
    
33.     // 把socket和socket地址结构绑定
    / ^9 v- i4 C; I& z
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    
38.     }
    3 i7 X8 V3 ^& [2 x
39. 
    
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    : J" h) ^, K- m4 [2 m7 _
42.     {
    
43.         printf("Server Listen Failed!\n");
    5 x* X  X/ ^" N8 f6 d
44.         exit(1);
    
45.     }
    6 I' _8 l  Z7 @( B8 q" T4 L
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    ) q9 O  \9 J1 @' V4 D9 i
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    * f6 Y4 d9 Z& i0 J$ M2 l3 A" |$ }
52.         struct sockaddr_in client_addr;
    6 P* n" [* c. R/ u
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    - a; }# x* _2 t: }8 ]. K4 {
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    2 s8 P* y, j" x. ^  y
57.         // 用select()来实现超时检测
    ; q+ \8 J) P$ [0 |" m
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    # \6 L# Y3 k# P" s( T2 t
59.         // 这里的new_server_socket代表了这个通信通道
    ! u! P+ q% C! H6 b4 ^8 _# I' J( F! \
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    7 J' H: _! \/ t* i" [
61.         if (new_server_socket < 0)
    ; X8 o; `0 ^4 [/ I( m6 n3 G, U% Q
62.         {
    * s$ c; M, r5 I  J1 ^: d5 O
63.             printf("Server Accept Failed!\n");
    : [: J% c% Y- N8 p) _$ g6 [
64.             break;
    
65.         }
    
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)
    ; ]$ X) K! d) G: {/ v9 z
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    - ]4 v% g8 A( X4 C% M2 b% D
73.             break;
    
74.         }
    . r' U! ?5 r8 o1 L1 I: k" f1 s
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    1 S- e8 f' P8 I" |! a% H; I4 `
77.         bzero(file_name, sizeof(file_name));
    ; e/ b" y0 @/ P& Y5 K  S
78.         strncpy(file_name, buffer,
    ; C2 ~2 D* A8 e2 T2 }' k& a8 `7 c
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    ) D- G4 X5 Z$ L! E8 m$ t
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    & s$ ]7 @0 \: Y# P% q
85.         }
    
86.         else
    ! Q  w; c( K1 @9 {/ N
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    % N! C. t$ H) N
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
      g; @: [0 a* b* I: e
92.                 printf("file_block_length = %d\n", file_block_length);
    ! T' ^1 m0 q4 Z2 Q
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);
    - G! v/ w% J  _9 e$ l0 ~9 B
98.                     break;
    ) |; K2 ~- W! C" a, c
99.                 }
    ) g: a0 ^6 v. U* D, Z
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     & D* E6 X5 X$ b: i/ c3 s/ b
102.             }
     ! C4 s9 H1 k/ V
103.             fclose(fp);
     5 p$ ?' r7 |, g( h$ R; A
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     / T( t" z- r! a
105.         }
     ( h7 \# e! i& M. s) J9 W9 \
106. 
     1 y) k4 d: F- n1 l4 [
107.         close(new_server_socket);
     
108.     }
     
109. 
     ) \8 @) b( i3 S
110.     close(server_socket);
     
111. 
     & {! U: d4 q: E
112.     return 0;
       P4 ?( K2 b9 O* v7 @, W2 r
113. }
     : [* O' I; W4 X
114. 
       T0 [$ V4 c  Y) E* {3 d

复制代码

5 G1 y1 P- S2 [% C
+ B' I9 c# q) d$ q8 @7 M
, J& ]( x! C3 C! m
+ \, F& ~: q" v. A1 g