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

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
# P1 e, i* R% w  Z# l（1）客户端程序，编写一个文件client.c，内容如下：
& O. [( A8 D, _7 e

1. #include <stdlib.h>
   
2. #include <stdio.h>
   ' m9 H0 g/ Z  L" g0 G3 P
3. #include <unistd.h>
   
4. #include <string.h>
   1 A1 N) z" }  d$ I% ^% r( h
5. #include <sys/types.h>
   " I8 o* |3 n4 k1 ?# F
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   + N, d9 G- r9 O" }6 M! ]
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   : p1 b0 M" I- n1 O5 Z( [2 U
9. 
   
10. #define PORT 4321   /* server port */
    9 R9 F5 ?9 T/ t* n' Q0 k- G, v
11. 
    
12. #define MAXDATASIZE 100
    + k! u2 _( ~3 X; W5 f
13. 
    1 q+ {7 M4 v  }( A
14. int main(int argc, char *argv[])
    7 i1 Y2 R/ l6 T. C+ \9 {8 ?6 G
15. {
    
16.     int sockfd, num;    /* files descriptors */
    ) l/ l1 }' D! u( L9 B- H% g
17.     char buf[MAXDATASIZE];    /* buf will store received text */
    3 V5 O9 C. _5 d4 |# ^
18.     struct hostent *he;    /* structure that will get information about remote host */
    & e3 q& M" N2 D/ \% Z$ b
19.     struct sockaddr_in server;
    
20.    
    
21.     if (argc != 2)
    
22.     {
    ) k" w9 j2 y3 M% Q, D
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    
25.     }
    
26.    
    0 s1 o( p9 q5 O" J( \, {0 l  [6 P7 ^
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    
29.         printf("gethostbyname() error\n");
    ! |$ d% m0 t1 f  b9 u: b
30.         exit(1);
    
31.     }
    . C, g  u: z$ Z* A" m
32.    
    7 R1 z: t1 K$ ~! z5 s/ T
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    2 j3 U7 V5 E1 i& U
35.         printf("socket() error\n");
    2 q  b7 W6 I) l' h
36.         exit(1);
    ) n, _/ }# N. S  r
37.     }
    
38.     bzero(&server,sizeof(server));
      B: j, W8 N) I& v
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)
    # m# p* n3 a. H- {$ m6 |$ u
43.     {
    / |/ ]2 ]$ T% o/ ]  _- `
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    " j# Z! Z5 Y% Q+ s1 Q9 s7 ~
47. 　　
    2 {1 u8 t: C2 r/ {- v& S* _& x5 e3 {
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    $ w2 [: K8 c! W5 @
51.         printf("send() error\n");
    
52.         exit(1);
    9 _" c& O2 n( p; t
53.     }
    7 V0 K3 h: ^5 W* C& C+ o# M
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    ( M9 T  v% l1 Y" A2 N! ^0 ?: v
56.         printf("recv() error\n");
    2 m: y3 F$ ^# C' x
57.         exit(1);
    $ R( J: d4 C% c* H. e! r, r
58.     }
    
59.     buf[num-1]='\0';
    6 f: }1 |0 {( k
60.     printf("server message: %s\n",buf);
    + ?) ~. V) ?- {4 _9 P' K" h
61.     close(sockfd);
    9 P2 D- R& T* F
62.     return 0;
    . {9 {+ O. e. l, L& _! R' a
63. }

复制代码

（2）服务器端，编写server.c，内容如下
# ]) P9 m. I  V9 k' {: }* b8 M3 S

1. #include <sys/time.h>
   ; C  ^7 W+ G+ V0 N$ w" C0 T0 J( j- e
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <unistd.h>
   ( S1 l2 X2 l8 J2 \
6. #include <sys/types.h>
   + H' h; G% t7 \- a% s' C8 C
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   * w7 h5 T$ S* s6 A, C
9. #include <arpa/inet.h>
   ' W' u+ w( ]' [. X1 v7 H7 Y- V
10. 
    
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    9 M- R+ N, n' Q- U# d- e7 s
15. 
    
16. int main(int argc, char *argv[])
    
17. {
    
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    + w) s) ^6 i2 D- ^) D
23.     /* Create TCP socket */
    
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    5 z( o5 g) k# _6 j1 L! n# C5 ?# h
25.     {
    
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    
28.         exit(1);
    
29.     }
    7 U  L; ~& k6 [- S3 B% K
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    ( R3 p% s, F' Y! I8 p
35.     bzero(&server, sizeof(server));
    
36. 
    
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
    0 P7 o9 ~  @: n: C
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    ( |0 ], \7 Q5 X, K4 {9 V
41.     {
    
42.         /* handle exception */
    7 s4 n& w5 ?$ ]$ y+ c% Z* q+ G0 G
43.         perror("Bind() error.");
    - G( j( D5 b# E8 ]
44.         exit(1);
    $ B$ f! k7 o: ?5 B; C
45.     }
    
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    , ]( H( _) l- }5 `9 }3 V" w
48.     {
    5 g, i, M; d7 G1 Z% A0 N
49.         perror("listen() error. \n");
    8 I: N& x- M/ h3 w3 @. w1 A$ O' Y
50.         exit(1);
    
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    0 g, a+ b* o$ m9 p
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    & A7 w; M0 f" K5 U" s
56.            {
    0 @$ a& S- `5 d/ M& h/ h
57.             perror("accept() error. \n");
    9 o/ I9 l9 b( K, u+ L" t; Q/ W
58.             exit(1);
    # w% V' Q' ~( E1 ^  K; M
59.            }
    
60. 
    
61.         struct timeval tv;
    ) p' D3 w5 I) k, e
62.         gettimeofday(&tv, NULL);
    + U: U4 o+ k3 u1 m6 \8 V9 d# I/ v! o
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.         
      s$ k! c3 h5 A8 @# u! U7 l. Z
65.         int iret=-1;
    
66.         while(1)
    5 w9 [& `! o8 U. V( H
67.         {
    * K0 o1 \) A$ j8 y1 Y* B
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    
70.             {
    # I7 _& y3 ~5 [$ n" D
71.                 printf("%s\n", buf);
    
72.             }else
    3 G5 K7 }- W7 C9 T/ Q' c+ m- l5 L
73.             {
    ; r# o& D1 G6 X3 b- S4 c- ~
74.                 close(connectfd);
    
75.                 break;
    " ^) K" n. `% Z* F$ b# U) K! P: N) |$ C
76.             }
    $ Y0 ?3 _' D& r
77.             /* print client's ip and port */
    ; ~% A( S9 g* S% _* _
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    2 o9 k) U, N& w+ l0 N  J" B0 z
79.         }
    
80.     }
    : B6 I0 p, f: k" g' }
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    9 Q+ G- n% ~2 y& l# Z
83. }

复制代码

' z! k5 T7 v7 ?6 x

（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
   ; l+ n) ]9 z0 V* Z% M) z$ }& y( `4 m
2. 
   ) X0 o: N" Z% _5 A8 [4 l' r
3. server message:horst

复制代码

服务器端：

1. $./server
   0 [" @. v3 m: R/ k
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端口等待下一次连接。

$ [' c% K; F8 |8 e

) s# b8 \. w* g" S+ q& O  @

admin

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

1. /*client.c*/
   - s, V: x" s) G9 p6 `( O0 f
2. #include<netinet/in.h>                         // for sockaddr_in  
   : g* U+ y9 }' P( k; X; f( H
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   ( |$ k9 I# N* r5 U
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   
7. #include<string.h>                             // for bzero  
   . X' I( C1 c1 t" i9 Q/ A, {/ m
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   $ a8 u! m5 R% E6 M$ b6 ^5 I" B& _4 h
10. #define BUFFER_SIZE                   1024  
    ! l% M2 O7 I  M. v# f! ?6 @
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    ) s4 Y: ]- y# F) v2 v
13. int main(int argc, char **argv)  
    1 N7 h# r* ]. f. x
14. {  
    + ^( ^7 I: B: z6 w5 {; \
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    
19.     }  
    
20. 
    / {/ Z5 t$ \: e) o
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    % Y$ r6 F. W- k3 b3 }0 O) p8 l
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    
24.     client_addr.sin_family = AF_INET; // internet协议族  
    ' U" Q. v9 q" I1 A) {# v
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    & |. N3 t. q5 N& c# e2 H4 o
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    . d! {3 c- |5 o' Z3 Z8 N' ~5 {- `
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    4 m/ @7 u$ F, f9 L; F4 K& z
30.     if (client_socket < 0)  
    
31.     {  
    5 s' x! m  N; ]9 R
32.         printf("Create Socket Failed!\n");  
    ) ]: L" u9 N$ Z8 U: ^
33.         exit(1);  
    ) Y& Z7 M9 m  s
34.     }  
    
35. 
    4 u" N" n# @9 o1 u, R
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    ) h8 }6 c) }- i: u
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    0 u  l  [/ C) L
41.     }  
    
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    & `) }* W: j/ j$ ?! W* q
44.     struct sockaddr_in  server_addr;  
    ! a+ n' {0 g  F/ z/ Y& g
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    
47. 
    7 L9 |% d3 f! e0 T
48.     // 服务器的IP地址来自程序的参数   
    9 h1 q2 M& Y" j- A
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    % U0 G1 q. K1 w( V. m
50.     {  
    ! F; E1 j: X# c! U4 Z
51.         printf("Server IP Address Error!\n");  
    ) M2 j* B5 i& W6 q8 j+ g
52.         exit(1);  
    
53.     }  
    . v0 F1 a/ o5 O' [+ E+ L8 j
54. 
    # \( |$ l4 j' O5 y6 n% k3 Y
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)  
    8 {2 i8 ^* h( L" m% r" F
60.     {  
    % h1 r* z) J* e  D3 E! ^% W
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    ' A+ A# Z5 Q1 c; h5 r
62.         exit(1);  
    . `  b1 s1 U& @
63.     }  
    7 l! [, u4 T5 i. ~7 a1 ?
64. 
    6 r- P8 b0 Q1 a
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    $ N" W7 `! D7 \5 f3 G
67.     printf("Please Input File Name On Server.\t");  
    ; p' I2 m3 G5 o+ h3 k
68.     scanf("%s", file_name);  
    
69. 
    ) n+ N+ Q3 [% ]8 [
70.     char buffer[BUFFER_SIZE];  
    / ~1 S# ^; |$ M1 D8 G) }
71.     bzero(buffer, sizeof(buffer));  
    - v/ w) P! J, o6 k  r4 B6 p
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);  
    , _' T- l3 k+ |, d5 \- K: Z: p/ }' V
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);  
    6 @, C" r4 G1 f$ S4 u; ?
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    1 I; f0 y0 X* E& ]! C+ G' k5 l% ^
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    9 T0 Z8 B: ?! r* R
88.         if (length < 0)  
    
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    
92.         }  
    
93. 
    ) Q9 J* A8 V$ J& L; u9 v  J
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    
95.         if (write_length < length)  
    : k2 O, o! a2 z( `" y
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    
99.         }  
    9 d; ^  y" c* P4 \8 [- \
100.         bzero(buffer, BUFFER_SIZE);  
     8 H) ^+ h' \1 }$ l, j/ U5 f, |/ r9 T
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     / U  N7 Q1 s4 O# I4 f
104. 
     / z/ v7 C3 _4 d8 x5 a4 q# X& h2 d2 f
105.     // 传输完毕，关闭socket   
     - z8 M$ J, Z. |  r# J
106.     fclose(fp);  
     
107.     close(client_socket);  
     : Q. |5 X; M# M: f5 y$ `5 ~
108.     return 0;  
     % n+ N' t$ g4 I! j
109. 
     ! V0 h: \# H$ z( ]+ S$ [1 D
110. }  
     % ^: L: ~  Z. m- M$ G6 {: q9 O7 x
111. 
     0 S, R, _" ]/ L  m; p4 H: ?: F% m

复制代码

1. /*server.c*/
   7 p4 L0 q. @1 _, x& O9 P7 u
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   
6. #include<stdlib.h>
   
7. #include<string.h>
   
8. 
   % }/ H. ^1 D- q/ V8 V# ~5 |& R
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. 
    ' X: s. n. a# _& G  ]" g
14. int main(int argc, char **argv)
    
15. {
    
16.     // set socket's address information
    7 t3 T0 Y. L6 f
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
      B) B4 h, X. f. }) e
18.     struct sockaddr_in   server_addr;
    - J1 G+ L9 y$ y
19.     bzero(&server_addr, sizeof(server_addr));
    
20.     server_addr.sin_family = AF_INET;
    6 k2 S% s* N8 e
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    " J, w' q) n; K7 }3 O) q; [: M
23. 
    5 Q) s+ l: J2 g
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    2 U! l4 W: d* g3 V- H( M
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    4 E6 m3 f7 O% |: ]: t, X
27.     if (server_socket < 0)
    % y9 c+ r* M: n' \
28.     {
    
29.         printf("Create Socket Failed!\n");
    $ @- h* j+ z8 B  s& k2 I
30.         exit(1);
    9 H2 }* i" H3 r1 h
31.     }
    
32. 
    
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    
35.     {
    ! w% z; R6 l  w3 k7 R
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    
38.     }
    ; N3 j% [( r4 e& U7 t0 R* U& [8 m
39. 
    
40.     // server_socket用于监听
    ) a$ b, W3 T7 }4 F( V* j
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    - W: c# T" `2 i- u
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    + q: |) a; k; w" y* i
45.     }
    
46. 
    * e0 |+ O# ^% p' T
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    
49.     {
    7 r" D: x  m  J/ H6 K3 P, Y. U1 Q
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    3 ?  h3 }2 Y* m  R7 S; K
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    8 W3 \- w, O% T5 W2 x& `
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);
    
61.         if (new_server_socket < 0)
    - c. O1 D, s, z$ j( }
62.         {
    ; R" v8 O8 \3 L4 w/ j; u7 x$ W2 M
63.             printf("Server Accept Failed!\n");
    + [+ ^6 _  k& O: H$ {) S; U
64.             break;
    " P5 ?# Z0 l. Y6 m% ?
65.         }
    ! P' b6 v# k$ W& [8 e5 Q3 n( W' `
66. 
    
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    4 \( |6 R. ~! O" A( k! G
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    
70.         if (length < 0)
    
71.         {
    * o4 Y- `* m( P. a$ T
72.             printf("Server Recieve Data Failed!\n");
    0 l; u, ?) P& a5 j
73.             break;
    
74.         }
    * G- ^& c7 o$ Y3 J; N& c: b
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    6 M! e- d6 u3 t$ G$ p. U( Q
77.         bzero(file_name, sizeof(file_name));
    , |. H1 j' j& V9 j1 Q
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");
    - ^  F# @# k+ w8 N+ K& P+ T4 A
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    4 a8 l7 g5 s& `- g5 p4 T* Z8 n) k
86.         else
    
87.         {
    - G+ T& l# G* x& i
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    3 n* X# e- ?# h4 w# d
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    " w, z7 n! j* G, P% g
91.             {
    : P7 o! `3 e% e% `: ^
92.                 printf("file_block_length = %d\n", file_block_length);
    , Z# S9 A# a* z4 D" t6 y! F
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    . k. i, O$ O- ]5 [8 |- v
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    2 o) d; ~0 p3 ?0 @/ G
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    # X* H5 `: l3 ^! w& H# c0 |
98.                     break;
    0 \; ~- {8 H3 |9 o/ m2 f
99.                 }
    ; u+ ?) E& O' F% S" q* L2 l8 y
100. 
     ( y+ a3 y% J; \, H$ V) R4 D1 C: B" w" _) s
101.                 bzero(buffer, sizeof(buffer));
     + l7 v" L6 z+ a8 C7 |9 P. E
102.             }
     
103.             fclose(fp);
     : Q3 r. |6 d# ^5 Y/ d
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     % {4 P4 P$ `  L6 R; C: c
105.         }
     8 e+ S0 A: N! E# q! t; q! i4 w
106. 
     
107.         close(new_server_socket);
     
108.     }
     " O' {# ?5 z% I5 o% `, X" \
109. 
     
110.     close(server_socket);
     $ t8 t+ s3 E( G2 O2 i4 o- U. \
111. 
     0 H3 t: L1 q: @1 w2 S
112.     return 0;
     5 @6 |: I  g2 O/ W  D% W) k
113. }
     ! y( l  D9 f7 g7 k! c. a: i
114. 
     + k) K/ n5 F* O' o

复制代码

+ [8 c+ `( U1 W. J& t  M
* ~. l% O7 l: U: ?- ~
+ m3 b* U8 D; y1 m' X