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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   . v( B0 D8 p* z: k- u
4. #include <string.h>
   2 \# J$ W% m% }. S
5. #include <sys/types.h>
   + u/ j( O4 ^5 G  s4 K$ V# }
6. #include <sys/socket.h>
   . Y8 \7 @# ^/ e
7. #include <netinet/in.h>
   , t, J/ ?7 S( d2 l) {$ ~
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   
10. #define PORT 4321   /* server port */
    $ n# n& o3 h8 n2 O
11. 
    / {  d( X  ]9 C) U) f  E( |" J! X
12. #define MAXDATASIZE 100
    ; L# G$ W2 g: v; M* Y  @
13. 
    2 ?* A  f1 ?- M; V  V! Z/ _
14. int main(int argc, char *argv[])
    ! q8 \- q4 P3 e- R0 o. s  J! n: Y' S
15. {
    
16.     int sockfd, num;    /* files descriptors */
    ( H. l2 L/ Y# Q
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    ' v5 t0 S- U2 v- }5 H
18.     struct hostent *he;    /* structure that will get information about remote host */
    
19.     struct sockaddr_in server;
    
20.    
    0 ^, \2 Z4 f% C) a& b0 W7 {8 X
21.     if (argc != 2)
    
22.     {
    $ a  n( E! u2 Z' t; l
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    
25.     }
    - \. j0 d. W$ ~) ~- Q7 b
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    6 X- U2 V) C' z* |2 @. O
28.     {
    $ ^# H$ m: g6 ]  g
29.         printf("gethostbyname() error\n");
    # f* V0 x# S- r  M8 Z  G
30.         exit(1);
    
31.     }
    
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    3 a0 f% X  W6 t$ A( o
35.         printf("socket() error\n");
    
36.         exit(1);
    
37.     }
    ; y3 O2 z! ^  ~8 O1 s  y" W# Y1 e: q
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    
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)
    
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
      g3 W- n) `1 j- B
46.     }
    ' n0 ~, {9 c4 h0 n$ [( m
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    $ L& a9 x" v8 a, L# {1 f3 t& S
51.         printf("send() error\n");
      b& n: Z$ C" q% E
52.         exit(1);
    4 V# a# f3 \; D/ A8 y! @- n
53.     }
    
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    
56.         printf("recv() error\n");
    
57.         exit(1);
    
58.     }
    . H* T1 t' I) v( v& N6 {5 D2 L% F! @
59.     buf[num-1]='\0';
    ' f+ x* l0 r! V0 X+ Z* F
60.     printf("server message: %s\n",buf);
    2 O$ V& Z% J  V6 q# O/ W/ H' P
61.     close(sockfd);
    . K* }/ a+ ?, S/ `
62.     return 0;
    
63. }

复制代码

（2）服务器端，编写server.c，内容如下
% W- `4 @6 k8 X4 _" X+ v

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   # P' U& r, K" |8 l  J
5. #include <unistd.h>
   / U- P! K$ Z, Q7 h
6. #include <sys/types.h>
   - w$ I' D; x* H; F( h3 T. q# ^
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    
11. #define PORT 4321
    ' C4 G1 t( I1 M
12. 
    
13. #define BACKLOG 1
    1 }. ?! w0 l9 ]- K, d$ A4 z0 \
14. #define MAXRECVLEN 1024
    . O% Z: |) |0 y( c- \
15. 
    
16. int main(int argc, char *argv[])
    
17. {
    
18.     char buf[MAXRECVLEN];
    ) c- }8 D9 a& ?" n9 F! y: g
19.     int listenfd, connectfd;   /* socket descriptors */
    ( s" m. k8 M: ?% V' w* h# `
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    2 _% h7 k4 Y* Y2 E0 N- y  y3 P
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    . }2 Y( }( d7 w" O5 v- q
28.         exit(1);
    
29.     }
    8 O* X8 q5 O( O* x& ]  `# @) Z
30. 
    1 A2 E. ^+ O# t+ q) P2 o# U
31.     /* set socket option */
    ( i; ?. m: e8 X4 [- O
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    
35.     bzero(&server, sizeof(server));
    
36. 
    
37.     server.sin_family = AF_INET;
    " t" p: A; f# [' u" z( X
38.     server.sin_port = htons(PORT);
    - A3 t9 C& O1 k( F
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    % l& ~$ {- L. X& B" c8 v9 F
42.         /* handle exception */
    
43.         perror("Bind() error.");
    % P% u& ]4 [1 R" j8 O" W
44.         exit(1);
    
45.     }
    
46.    
    3 Q0 L; {# L3 A$ K: r. n
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    6 D8 O4 ~- g/ f7 V- g3 a
49.         perror("listen() error. \n");
    
50.         exit(1);
    4 h+ Q6 R; u2 }% J
51.     }
    
52. 
    0 C9 \$ J+ u6 Z4 |& z
53.     addrlen = sizeof(client);
    6 k# Y% b1 T* Q6 Q0 W
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    ) ?8 T5 c1 c8 Q" ?4 t
56.            {
    
57.             perror("accept() error. \n");
    
58.             exit(1);
    
59.            }
    - s& X$ n, l- d6 D3 L- }0 Y9 F9 P( }
60. 
    
61.         struct timeval tv;
    * V/ g& s. m& b- a4 ]& n+ y( f1 g
62.         gettimeofday(&tv, NULL);
    1 d1 z& i% Y" V8 o  K! D9 r  _: e
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.         
    2 I$ Q3 J8 o$ S. |. K+ J7 Y  R
65.         int iret=-1;
    
66.         while(1)
    
67.         {
    ' W7 ?" V( Z5 L7 a7 @& H5 C: u
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    ( f) W' k* N- X1 v; O4 y
70.             {
    3 n; ^3 M! }- D
71.                 printf("%s\n", buf);
    ; e2 x. U: @2 V: T) w
72.             }else
    7 O  \& ^6 J6 z1 u# L2 g+ n: q
73.             {
    ) K" m6 |* y8 d% ^
74.                 close(connectfd);
    5 J" X0 f' A- a5 _/ B
75.                 break;
    
76.             }
    2 r0 o6 R4 G0 l7 m" A+ ^$ \
77.             /* print client's ip and port */
    1 u( A3 j1 ?+ T/ L9 G$ p
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    
80.     }
    
81.     close(listenfd); /* close listenfd */
    8 E  k# U6 G  J
82.     return 0;
    3 y+ m% _1 i4 G; g& c: G  [
83. }

复制代码

) |, \' h" a& X  ~" v! a4 R

（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
   & M. N! \% `8 m/ ]+ a) l& n
2. 
   
3. server message:horst

复制代码

: M" @7 N3 g; n- i

服务器端：

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

; I" g" {7 u/ s2 q0 k2 g9 K: z
& |5 e- h6 w/ X, k

9 K7 T: ~- ~& Q1 l* `5 z

admin

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

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   1 E! s$ h( K* C$ _' o1 F) _
3. #include<sys/types.h>                          // for socket  
   $ V! I1 y3 `6 n$ B4 P* T
4. #include<sys/socket.h>                         // for socket  
   , D( {# G& G1 }  h
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   
7. #include<string.h>                             // for bzero  
   ' N4 o: n. u& g& |  G) }0 N
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   , A" q; y5 X& z* g8 J! ^4 k* n6 z
10. #define BUFFER_SIZE                   1024  
    " m. U6 e, N+ |% w9 ^6 F: p) r
11. #define FILE_NAME_MAX_SIZE            512  
    & Q7 \" H4 |* i0 b4 _
12. 
    
13. int main(int argc, char **argv)  
    / Z" `) J' J8 q: ~2 q9 L
14. {  
    ! ^& }  Z& c# \& \
15.     if (argc != 2)  
    - Y) b4 C4 k. R# t! X6 I! V& A- H
16.     {  
    * f0 ]9 Y9 A. y: M! ~
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    6 P, Z2 j! p# ]9 G3 c$ d' z+ _
18.         exit(1);  
    7 b+ X+ [+ x5 U2 T1 g) ~4 Z; z/ I
19.     }  
    
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    % [0 t: S3 J5 u# F, J0 A* B: @
22.     struct sockaddr_in client_addr;  
    6 V8 R) ]' m; _2 w$ q
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, 让系统自动分配一个空闲端口  
    
27. 
    - R% V7 h9 I0 u! b- }( S- E. X, T/ D/ l
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    , M% \; o, N( S. J2 g0 Y4 m
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    - b6 Y' [4 x  t: d. R
33.         exit(1);  
      v  R( G; p* I. d
34.     }  
    7 m, A( d  B/ U
35. 
    9 l5 G" \; h$ P/ n( p& P
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    , s) S; O/ k* ^4 o9 [$ A% s
38.     {  
      E8 `* s) ~8 z$ P0 ~* w9 [4 z
39.         printf("Client Bind Port Failed!\n");  
    ! j/ J' e' n- I2 o' j1 Y
40.         exit(1);  
    ; i6 T* t2 H" U" R
41.     }  
    
42. 
    2 X1 w- F7 q4 R+ \
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;  
    9 I5 e/ L* Z( |2 X
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    3 }$ g1 P: v) S, b. f( b2 v# w
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    6 [' F; I; w. K3 z' _( c
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    & |0 S  A' [$ |% A; O
52.         exit(1);  
    
53.     }  
    ; l8 p2 H. _7 \1 z
54. 
      O2 S# |4 l) x; E8 s
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    
57. 
    + q3 j2 R% L9 e5 N) J1 C- o: d, ?
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    2 R/ t- L  ]" e) H) g; {, V
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    ' w$ X1 T4 j7 q3 B3 K
60.     {  
    ' n4 M( Z) y  O# S, ^
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    * N$ y* Z) f0 P; l4 N' [* r
62.         exit(1);  
    % h" [, P4 O! C3 i
63.     }  
    ' y$ }! }# a! D% x9 W- }
64. 
    - C# W. c0 e2 }' \+ X8 W2 X( B/ L
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    ! T( Q& ?; c9 Z- ^- H' x
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    
69. 
    
70.     char buffer[BUFFER_SIZE];  
    ( c* e% a5 z* V) E) y, p
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    5 o' K3 `7 J' _6 u* E; C0 e* O
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
      N& o1 Q5 U* @& I7 \' [2 j
75. 
    ( y8 G: U* t$ M, I/ C# P2 a
76.     FILE *fp = fopen(file_name, "w");  
    7 Z3 C$ A! f8 O' M+ \
77.     if (fp == NULL)  
    ! q4 T& q. z2 m
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    " Z! T- s+ f/ |7 K! F
80.         exit(1);  
    
81.     }  
    $ p* c) }" {+ z. A" t' C
82. 
    1 Z0 ?/ s# m0 E/ x' ?9 C
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    # C* [2 k7 S4 {- h: F8 r
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    
88.         if (length < 0)  
    
89.         {  
    * e7 U* k8 {, f  x' J
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    ( I: f4 c) X4 H; q1 m/ x% _* E: c
91.             break;  
    
92.         }  
    
93. 
    
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    ) l' v7 ?, d. x% }+ H
95.         if (write_length < length)  
    
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    + m4 P) Z7 P0 h
98.             break;  
    
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     1 q. k! v4 D* D4 e
104. 
     
105.     // 传输完毕，关闭socket   
     ( I3 C! x( D, ~
106.     fclose(fp);  
     
107.     close(client_socket);  
     / Z. R5 ?! w: l9 n
108.     return 0;  
     
109. 
     1 P" W; r5 k/ R! _
110. }  
     * D- H4 B; ~8 P2 _
111. 
     

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   * B" y- b* ^- t, b1 q% F  \' D
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   4 L% E2 {; o4 k9 k3 b+ ~: X& r$ j
5. #include<stdio.h>
   # S7 h5 x6 k0 U1 ~: t. u9 I9 H
6. #include<stdlib.h>
   0 f2 S9 u) E5 N, C$ z
7. #include<string.h>
   0 [# C# V6 {# q6 E# g
8. 
   * d7 U. |1 Q" p
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    ( x# q! Y% l4 q* q
11. #define BUFFER_SIZE                1024
    6 c  \' w3 s* y3 V' `, e4 o6 @
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    ; o" D& D7 q( f
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;
    3 ~% K3 T9 T. ?0 e4 Y3 R
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
    ; ?3 h6 u' f! H4 r
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    - |. F& L0 Y$ J$ s9 `! ]
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    * z0 z+ g) c/ K, h/ I
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    + L* W/ r9 p1 f9 ~: w& F4 z
31.     }
    2 o9 @2 P* O$ Q. W  P
32. 
    $ j8 `# T8 G) q. N, l
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    : W3 |8 V& c8 A8 {4 M8 Y% M1 C
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    " t2 @  t6 R- |* {; r
37.         exit(1);
    
38.     }
    
39. 
    0 v8 ~  E: U! q8 t5 x4 Y5 @
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    2 Z7 T- \' X3 w0 p$ k. l
42.     {
    
43.         printf("Server Listen Failed!\n");
    9 p( t: L4 w+ C
44.         exit(1);
    
45.     }
    
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    - G4 }- P" ~% b7 m
48.     while(1)
    " j, \2 m* Z4 R( X9 u. q
49.     {
    ) T* {# w; }" A+ M  `; _$ y
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    & Y; N) `' O: u4 T2 N9 a
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    ) G6 U! f* I- x  P/ M0 w
52.         struct sockaddr_in client_addr;
    " f# M+ \5 N" q2 b1 k; w1 V0 v( w
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    ) Y. U& F  F# [, B
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    - c/ Y/ y7 V: P. w' Y5 ^2 f+ H+ w
57.         // 用select()来实现超时检测
    
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    3 N9 s, D5 \3 ^: Y# ?/ i5 {0 a0 |
61.         if (new_server_socket < 0)
    
62.         {
    6 @6 _; E; N: [  ~: Z9 B8 V
63.             printf("Server Accept Failed!\n");
    
64.             break;
    
65.         }
    + P1 ^( ^; S; A8 x0 [8 X
66. 
    
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    1 [" _: w( d; I) m+ w1 c1 Q; D
70.         if (length < 0)
    
71.         {
    ) {' }- m+ L  T. Q' |. Y
72.             printf("Server Recieve Data Failed!\n");
    6 D5 [2 [2 W9 d' @9 t9 w
73.             break;
    
74.         }
    
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    ; x( V+ V1 ~+ ~. ^# l6 l9 s, Y
77.         bzero(file_name, sizeof(file_name));
    
78.         strncpy(file_name, buffer,
    
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    
83.         {
    . N# u$ p0 }& t, g1 X8 o
84.             printf("File:\t%s Not Found!\n", file_name);
    8 k3 g3 G( o: q+ U& u& j/ E6 _% P
85.         }
    : x' y- R3 a4 n) S& q& c
86.         else
    % A( y+ f( c# m7 y  p% t
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    ' ]9 b8 M0 I* n! t0 m
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    1 L8 N' |0 H3 C3 I% G$ j* f" @
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    ) h1 ~1 Q8 J+ J( T& t( E
93. 
    * F$ x" Z7 ^. x* J! z2 y
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    0 n- z6 \  @0 V; _) W# ^
96.                 {
    8 _9 q3 H2 j2 X% T' a" m! v+ R
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    
99.                 }
    
100. 
     $ q# B% B- v$ v' U
101.                 bzero(buffer, sizeof(buffer));
     * r$ ]( Q# F; h
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     ' S0 R) _" {/ f% `" {
106. 
     
107.         close(new_server_socket);
     " D! g, x0 j. I/ Q- j) [7 l0 I
108.     }
     2 n) p# t2 O. I6 g9 V$ _
109. 
     / J, s4 o8 R( Z& x
110.     close(server_socket);
     
111. 
     
112.     return 0;
     
113. }
     
114. 
     

复制代码