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

admin

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

1. #include <stdlib.h>
   3 |) X& Q/ ], z9 n  ~9 I
2. #include <stdio.h>
   
3. #include <unistd.h>
   7 O$ V( Z8 x) A/ z6 S- `( L  Q8 ?4 Z
4. #include <string.h>
   
5. #include <sys/types.h>
   & U) u) j* I& e1 h
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   3 h. A/ b/ d2 w) R" ?& Q9 X
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   
10. #define PORT 4321   /* server port */
    7 G0 }# y8 p! e2 ?7 F) y2 w" j" u
11. 
      ^% O3 |7 O0 x' y
12. #define MAXDATASIZE 100
    6 y6 u) j  [8 o+ H* X# C0 U
13. 
    1 ^/ F" W# J& d; V
14. int main(int argc, char *argv[])
    
15. {
    
16.     int sockfd, num;    /* files descriptors */
    
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    - \, U/ Y- `9 X+ y! p
18.     struct hostent *he;    /* structure that will get information about remote host */
    . q6 o1 t' _1 b& @; ?! K( o" s* h/ F( u
19.     struct sockaddr_in server;
    
20.    
    
21.     if (argc != 2)
    
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    9 b7 C+ E7 M$ g
25.     }
    5 ?# m+ `* e/ N1 d: w
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    
31.     }
    4 m0 ^) X8 e  Z
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    : L3 F( G' N9 f2 j/ o
34.     {
    
35.         printf("socket() error\n");
    4 @9 g) S5 `; P+ f+ d9 ~- o
36.         exit(1);
    
37.     }
    
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    , E3 d4 h3 }: ?9 V& b3 J
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)
    4 g- o. o' a3 y6 w5 m0 ~3 q- f1 m8 l
43.     {
    ) V5 h& D3 m2 ^$ A0 ^0 V
44.         printf("connect() error\n");
    # y2 g) m/ s8 d% k* t/ F
45.         exit(1);
    6 r2 f3 K; M3 O$ T, f( f- x
46.     }
    " T0 f3 g2 D( q$ g5 \3 Y
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    # n8 c; o& X: t0 A8 r$ }
52.         exit(1);
    
53.     }
    3 s. i1 I1 s  b# A; `
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    
56.         printf("recv() error\n");
    
57.         exit(1);
    
58.     }
    
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    7 V2 ?/ `& Q, [- ~7 t) X
61.     close(sockfd);
    6 E  L* f' n( F7 E# }4 A
62.     return 0;
    0 S0 B3 O- {) k9 o/ O
63. }

复制代码

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

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   ' V% I8 ^+ a1 w3 ^1 u# r7 V
3. #include <stdio.h>
   " ]- j, z6 ^/ ?  K. ?9 a" Z
4. #include <string.h>
   
5. #include <unistd.h>
   ! L0 i" D. u+ `) U, x! x
6. #include <sys/types.h>
   , ~) u0 A; k. F: I9 e' }- e
7. #include <sys/socket.h>
   4 S1 h" x/ F. ]5 ~
8. #include <netinet/in.h>
   6 ~( `; y5 O) t& y5 e% b* O
9. #include <arpa/inet.h>
   ( |3 S1 j! z1 z, ^5 Y9 `8 D( y( T
10. 
    
11. #define PORT 4321
    & [% f& ?  e% P/ [+ h( Y
12. 
    ) k+ ]0 t3 T- [9 T% V4 }: U* F1 Y
13. #define BACKLOG 1
    % `0 e8 x8 L2 \  y
14. #define MAXRECVLEN 1024
    1 n8 h! X( m% `1 k( ?
15. 
    * l% a  O: f) v2 V
16. int main(int argc, char *argv[])
    
17. {
    
18.     char buf[MAXRECVLEN];
    4 _4 u; _7 J5 ]% V! q
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    * l! E7 E. p3 H9 u, x: v6 Z
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    9 _+ o! m9 Y! }" B9 j$ f
25.     {
    
26.         /* handle exception */
    # b2 l/ |0 Y, O
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    2 \, j- a9 |3 S
29.     }
    & ^9 ]- E/ g) F: B8 c
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    " L* C, w. ?5 d7 u4 N/ B# z
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    2 ^3 z# _# l0 b7 R& h  p6 z! G
34. 
    ) b5 O( c& @* b8 L
35.     bzero(&server, sizeof(server));
    + s8 c5 Q% W) m& [0 c" P
36. 
    
37.     server.sin_family = AF_INET;
    # R5 q- s/ }2 w( H8 Q: M( K$ g
38.     server.sin_port = htons(PORT);
    : Y4 @: d7 Y: J! a1 A( S
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    + y( z4 p- n+ K) U
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    9 [0 k  }7 L. l: |* F
42.         /* handle exception */
    1 U# U/ m: v- n4 q
43.         perror("Bind() error.");
      q. t3 h. o: d- D
44.         exit(1);
    8 p4 E2 L% g, ]% n+ D9 {! p
45.     }
    
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    9 @2 d5 C! x4 ]+ J- r3 Y! {
48.     {
    5 a4 y/ l7 P! }
49.         perror("listen() error. \n");
    2 }8 y2 e' P; a
50.         exit(1);
    ! s' e2 K0 u1 v! u; Y9 u# L: `  F
51.     }
    3 q( h. P) T. O0 k6 _
52. 
    
53.     addrlen = sizeof(client);
    
54.     while(1){
    2 a0 g) W6 {+ ~; X' Z% M* ^& }
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    
57.             perror("accept() error. \n");
    
58.             exit(1);
    $ d  j+ g! k: a0 U3 w& H) X2 N( n& r  D
59.            }
    % B( I% W+ d0 m& y9 _0 V9 c
60. 
    * \4 y2 O' z# {( u; l
61.         struct timeval tv;
    / L& U5 o+ z1 [5 m5 d7 @7 ]
62.         gettimeofday(&tv, NULL);
    
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);
    2 V: |) @9 [! Q1 `9 b
64.         
    
65.         int iret=-1;
    
66.         while(1)
    . j$ L% W4 j: I' R5 Y( A  I1 Q
67.         {
      G# |& c% }% y4 r# U: g+ b
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    
70.             {
    5 k( ^+ Z9 ^4 c! f' N8 Y
71.                 printf("%s\n", buf);
    
72.             }else
    1 _4 J; n- {/ q& b% ^* Y- g/ v- b
73.             {
    
74.                 close(connectfd);
    ! L! ~+ e9 R$ d6 z- \
75.                 break;
    
76.             }
    
77.             /* print client's ip and port */
    0 @4 ^% a' \& c- u
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    ! b1 x- D2 e; I. W6 \
80.     }
    
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    
83. }

复制代码

) T1 o; e8 P4 C/ t* [& e6 }
- L/ F% ?6 z8 z0 x6 T/ 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. 
   
3. server message:horst

复制代码

服务器端：

1. $./server
   & z& R4 g- z$ Q  I# q4 H- ?* M
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端口等待下一次连接。

% {' X" T7 W% t" Z* x+ w

admin

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

1. /*client.c*/
     Z! B( }% ~; t
2. #include<netinet/in.h>                         // for sockaddr_in  
   
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  
   ; O( m& ?6 K5 I. q* v$ D1 K4 b1 O8 n1 \  w
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   / p* P8 z2 u4 M: c* S' i
10. #define BUFFER_SIZE                   1024  
    ' Y9 M  O6 ]9 N5 D; s9 G
11. #define FILE_NAME_MAX_SIZE            512  
    4 G# c2 @; \9 z0 b) P
12. 
    % D# K9 C% M' C8 e
13. int main(int argc, char **argv)  
    
14. {  
    
15.     if (argc != 2)  
    
16.     {  
    2 Z2 c  C# h: l- J
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    : Q- U9 ~- R8 [8 B+ h" R6 I/ S
19.     }  
    
20. 
    * u$ V( I* d: B2 x
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    - Q4 `( w6 x9 T- t4 `
23.     bzero(&client_addr, sizeof(client_addr));  
    / i8 o+ ?: J0 U# c
24.     client_addr.sin_family = AF_INET; // internet协议族  
    & p' Z4 }; i5 X; l+ Y+ P
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  
    * s( {, r7 D: x. l
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    
31.     {  
    5 z9 j0 v" {, ~- l; J
32.         printf("Create Socket Failed!\n");  
    4 f+ M) D- d& b! C% z' J' q
33.         exit(1);  
    # f. N+ O& W( ]; q" [) Q% d
34.     }  
    / r+ o& v# @$ a. f) Q- H" D
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    4 V0 ~  \2 {! @* D8 N0 h2 y$ `
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    & ]: L- Z6 P' `. r
40.         exit(1);  
    
41.     }  
    1 @) T, c% u) B8 S3 ~9 s
42. 
    & p. G3 s" [4 p2 T0 E3 G# _; P
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    5 c/ D9 h8 Y( B1 D* r% ], g+ ]
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    $ a  {) X6 g" @; [
46.     server_addr.sin_family = AF_INET;  
    
47. 
    3 G- m+ S3 N+ `: S7 Q; D
48.     // 服务器的IP地址来自程序的参数   
    2 s! H& M( z$ W+ _& q) K$ A
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    + A7 J' C' L2 O2 h5 D6 d- R
50.     {  
    # M: z, G# w! s5 t- x! ^! S0 }+ P
51.         printf("Server IP Address Error!\n");  
    1 f/ G& v3 B: G+ {
52.         exit(1);  
    
53.     }  
    7 K/ C0 n! S' n+ F% g7 k
54. 
    * f; p/ x0 w! h4 W4 O
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    " w& U9 X: G% X
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    0 S% q+ e6 a2 u# `
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    
63.     }  
    
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    $ W- b; P/ t4 s3 I
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    % r- M" w) e- j; E* b/ u
69. 
    
70.     char buffer[BUFFER_SIZE];  
    
71.     bzero(buffer, sizeof(buffer));  
    / h* K2 N5 s3 C" Z& G4 Z, L3 R
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);  
    % o+ h* ^# D/ I0 h$ @9 v% X% P% f
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    ( h& [7 g) {9 X- b
77.     if (fp == NULL)  
    
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    # R$ M+ W1 w2 Q; j: D
80.         exit(1);  
    ; i# w5 e/ M% L- t& r$ \  O# g
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    ( H7 Q& j2 b- [+ `1 o6 I& I' h
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    4 O, ]: n9 r0 c- ^4 b) F8 ]" ]
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    
88.         if (length < 0)  
    
89.         {  
      m$ u1 m# a! \; u
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)  
    " u( t. z/ b8 e
96.         {  
      m! V5 J( R8 J8 R/ Y9 A
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    $ Y3 p" D7 E& v/ W
99.         }  
    6 I$ s) r( C7 e$ p
100.         bzero(buffer, BUFFER_SIZE);  
     ; _- @( \& e2 i2 [" x: w" \: S- q
101.     }  
     
102. 
     6 h# N1 \, G- d7 x4 {1 R
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     7 h- M7 k- B0 @& q! L9 W
107.     close(client_socket);  
     3 n: I9 N8 R. e0 u7 u( d) ~: ]
108.     return 0;  
     8 |$ }9 ~: k7 R2 D+ U: @0 m
109. 
     0 s- _1 u5 l& @$ o$ s* w% V% t
110. }  
     
111. 
     6 j" T* _9 z/ d" r

复制代码

1. /*server.c*/
   0 G% ]$ o- \. G' s
2. #include<netinet/in.h>
   1 l* x! P( R' t, A7 _
3. #include<sys/types.h>
   & S  P7 q  ^- U" p0 ^" e
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   4 S+ x3 W: @2 I7 M# a! a- N
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
     ]$ m( w) ^# J  Q* Z
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   6 l* d1 q+ e" K5 f
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    * r3 ?! [4 Z, u7 e6 [; y
12. #define FILE_NAME_MAX_SIZE         512
    * a" i* ]% \; u0 K$ X& Q' t7 u9 c
13. 
    
14. int main(int argc, char **argv)
    
15. {
    ) e! P* z7 A9 b9 ^2 K
16.     // set socket's address information
    
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    , W6 a* |0 [+ l2 g# ]! z/ f6 s
19.     bzero(&server_addr, sizeof(server_addr));
    
20.     server_addr.sin_family = AF_INET;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    / y$ U0 z1 c+ X! \5 |( r
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    / `7 \- [5 w/ X
23. 
    
24.     // create a stream socket
    ' f, j( P" q  ?: \; v" j# G
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    . d, V) a" ~; t$ }  z
28.     {
    . T3 ]* x0 K$ ~# B
29.         printf("Create Socket Failed!\n");
    1 _8 d, e$ M/ F
30.         exit(1);
    
31.     }
    
32. 
    4 G- r7 H  T5 R# @7 |
33.     // 把socket和socket地址结构绑定
    . g+ A5 e! K( [( w, F0 q
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    8 @* Q. Z+ V+ e- M$ t
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    % ]* F5 g8 s5 H2 {* q) O! y1 }4 R
38.     }
    
39. 
    
40.     // server_socket用于监听
    5 ?' O, H' K% y3 K8 v
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    $ B8 X8 N2 Y" }6 Y1 `6 f$ M
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    + u4 H7 i/ A/ w% U
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    0 v# k# Y% f6 d6 n( T
48.     while(1)
    
49.     {
    # B( \$ x4 N0 P% z; n
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    7 @% w" R# z- t& z* S: F( Q& s
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    0 ?9 G) |' j. J. B7 @3 M
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    ( E6 o8 S% P5 U# B# p
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    4 y( o1 v& w" G$ [4 i4 F6 B6 t
59.         // 这里的new_server_socket代表了这个通信通道
    : ?" s3 |. o/ s8 i3 e' P4 a
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    ( l; }" C, q; i$ {5 n7 k) N: s
61.         if (new_server_socket < 0)
    ) K$ U- @7 F  h9 [" B, b
62.         {
    
63.             printf("Server Accept Failed!\n");
    
64.             break;
    
65.         }
    
66. 
    
67.         char buffer[BUFFER_SIZE];
    4 m3 N; z1 a) H$ X
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    0 F" L3 E' t# e4 w" T: ?; O1 v
70.         if (length < 0)
    . ~! z# N; Z7 M6 U  s4 c: S/ I& M
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    ; t% P9 @- \# C
73.             break;
    0 X) e9 t6 `# k3 ]8 m% f
74.         }
    
75. 
    $ y+ V$ e3 k, J
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    8 p; a6 I4 I  d* B( K7 Q
77.         bzero(file_name, sizeof(file_name));
    ( ^" Y% r: u: P2 A6 m! E" P
78.         strncpy(file_name, buffer,
    5 ^) N8 a' Z6 B$ l/ \: z; l. r+ P
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    5 [8 ~; c; o# R7 W0 b
81.         FILE *fp = fopen(file_name, "r");
    ( ?* Z' {  z/ A' V
82.         if (fp == NULL)
    9 F% H" R& r5 z  _
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    " l: i& @1 |' e( }7 L. E3 N
85.         }
    
86.         else
    0 ^4 g; L5 y$ r
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    9 D# J$ ?$ w! w; n5 a7 U$ D# x' j
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    ' D3 C& R$ N% x4 F
91.             {
    4 C2 @& F# f. }2 Q! l" _4 {4 p
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    2 y+ T$ c1 F; k6 W: K
96.                 {
    / a5 M4 f! r. b( F. W9 T! g- K+ v, e% L: J
97.                     printf("Send File:\t%s Failed!\n", file_name);
    2 u, k$ K- z/ h, v  y& d, g) T1 h
98.                     break;
    
99.                 }
    
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     . `% T( h1 u2 o1 _
102.             }
     
103.             fclose(fp);
     . I( S8 l# M, V% ^* W; Y0 c
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     8 V1 h1 s4 q% ?% \+ P) p
105.         }
     3 A4 o" [; R' t6 H3 _
106. 
     
107.         close(new_server_socket);
     1 m% R& t& o- X& i3 Q
108.     }
     
109. 
     - l- m9 C+ [3 `7 D# ?, b
110.     close(server_socket);
     
111. 
     
112.     return 0;
     
113. }
     8 A' e% x$ a5 Z- q( E: ?8 I4 V
114. 
     

复制代码

8 M: r! E! N8 g# J  a
3 u( W3 W$ v% }5 h+ ?/ C, O
- w# r& K! T( X* h* ?6 D1 y- n