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

admin

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

1. #include <stdlib.h>
   8 e7 k& ?" F, @3 W
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <string.h>
   " r* F  i, G) h+ i6 m# H
5. #include <sys/types.h>
   $ U5 _1 K* A$ J' P
6. #include <sys/socket.h>
   3 H5 V" ^. f& c* w* t0 M& p
7. #include <netinet/in.h>
   
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   4 [/ B5 Q6 X: H* D1 J
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    4 ^, O- i  L+ C5 C$ t4 I
12. #define MAXDATASIZE 100
    
13. 
    
14. int main(int argc, char *argv[])
    
15. {
    
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 */
    1 K' n! e, {! Z: L2 b
19.     struct sockaddr_in server;
      @( w0 d9 e5 ?1 r; `! u- w& E$ k6 v
20.    
    
21.     if (argc != 2)
    
22.     {
    $ W# G  _; r+ c& A+ l) r
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    
25.     }
    . [8 h! F8 A( r5 D# h0 ~
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    6 W2 {# d5 u( t, k7 T* \3 ]1 x# s
28.     {
    
29.         printf("gethostbyname() error\n");
    + c; I/ s, K( j7 x$ W1 P& L" W
30.         exit(1);
    
31.     }
    3 q. n6 ~1 {: p. b% F
32.    
    ! Y& `' U# I" ?* A% [( d
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    0 M& p8 q% q4 d: J  Z2 R: b
34.     {
    ' A! m, R& B1 l( ~0 b5 `9 v
35.         printf("socket() error\n");
    
36.         exit(1);
    
37.     }
    + ^. Y: |* ]6 n
38.     bzero(&server,sizeof(server));
    9 w5 h* {4 D, x+ J, H5 z6 ~# ~4 E4 a
39.     server.sin_family = AF_INET;
    8 t- _4 l5 o' l& n, L) ]
40.     server.sin_port = htons(PORT);
    & I3 w3 q' T1 i& z3 h- o$ e
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    ! p# D2 [1 E# w5 e% J
44.         printf("connect() error\n");
    ; p% Y! ^  G: n/ }; L& m  l* u
45.         exit(1);
    " Q- ]% |1 b9 ^' P1 ~# Z
46.     }
    - Y' ]( e% a# j3 B; p
47. 　　
    
48. 　　char str[] = "horst\n"
    $ f3 Q$ Q1 [1 f; z% L+ H: d
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    
52.         exit(1);
    " u4 M( j. W; g5 d9 ^- N
53.     }
    9 u9 Q" p3 }+ ~8 b) |9 j
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    6 \' H" o7 _# G) @  ?* h/ S- c
56.         printf("recv() error\n");
    
57.         exit(1);
    
58.     }
    
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    * j. ^6 v* _4 N: Z- G, E+ T& r" c3 T
62.     return 0;
    1 Y' F  h6 e8 p* H
63. }

复制代码

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

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   , O; R* [& u! V& Q9 p
3. #include <stdio.h>
     ?" M* z. g$ J
4. #include <string.h>
   4 i2 ?+ Q4 v# R0 i
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    * o- @$ F" ~/ b; S
11. #define PORT 4321
    
12. 
    
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    
16. int main(int argc, char *argv[])
    % a, ^& `2 ~0 `6 K0 U
17. {
    9 p; h) H2 t2 t0 U3 H9 s$ d' h
18.     char buf[MAXRECVLEN];
    5 A- D3 f! N5 P; y
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    % V0 w# T3 v( S% j1 m" ?- z
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    ( i! n6 {: t# d' G
23.     /* Create TCP socket */
      Z% u3 g. o" |! L9 j
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    
26.         /* handle exception */
    $ C$ S+ ^5 `# H8 q: r
27.         perror("socket() error. Failed to initiate a socket");
    ( X/ A3 M/ [2 M" H
28.         exit(1);
    
29.     }
    
30. 
    0 {5 s3 j" {- B( Y) ?* m) P3 _' D
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
      P& e6 Y/ `0 N0 A
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    : f8 t6 n; y0 ~$ s" n/ S9 \& e
34. 
    
35.     bzero(&server, sizeof(server));
    
36. 
    
37.     server.sin_family = AF_INET;
    
38.     server.sin_port = htons(PORT);
    6 o/ ~5 y- f0 n& E, d! ^3 a
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    ; t  ]0 a* k% w* s1 ?
42.         /* handle exception */
    
43.         perror("Bind() error.");
    0 O8 V0 Y7 N5 O& }2 I$ u# d
44.         exit(1);
    
45.     }
    / |3 H" I5 a! O- ]$ v
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
      \- T* F& g, p2 g3 q
48.     {
    
49.         perror("listen() error. \n");
    $ \3 P1 X: ^. T1 D1 O& Z6 t
50.         exit(1);
    0 u! R, n) E  h5 a8 u
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    0 ~  _  l- n7 m3 h  @. V5 _
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    5 H0 Z) k/ |5 t: N( P. `
57.             perror("accept() error. \n");
    
58.             exit(1);
    
59.            }
    ! B; Q0 M; A9 a# f9 e  n0 n
60. 
    - w; R1 T7 w0 @. g) y% x" p
61.         struct timeval tv;
    
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);
    
64.         
    5 Q$ s' h; Z5 T8 X" X8 @% z
65.         int iret=-1;
    
66.         while(1)
    
67.         {
    ; p- g6 a  x( {6 P3 o
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    8 n4 ]  A% o. |! g& s! U
69.             if(iret>0)
    8 B. |! Z( W# m9 L, h. H) X2 I
70.             {
    9 V, y* s& n% }$ H0 i; s/ \7 N, F
71.                 printf("%s\n", buf);
    2 f/ a* L5 w. ]- h, s4 a' I8 O
72.             }else
    * U! z. d+ k9 }  G
73.             {
    8 ^/ Z# R4 R: g! }2 Y) k
74.                 close(connectfd);
    - ?6 d" \( T+ q
75.                 break;
    , R' S' ]  q' R. K0 P# m# o
76.             }
    $ H# s( B% D9 W! L. ?- s( n
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    & T; k0 P, Q/ S8 r+ u- x" z" N
80.     }
    
81.     close(listenfd); /* close listenfd */
    2 B. H2 X2 z' s6 Z9 B
82.     return 0;
    
83. }

复制代码

) S# w' {3 V0 z, Q$ c

（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. 
   - n! @& X  Y+ c* E- @$ G
3. server message:horst

复制代码

服务器端：

1. $./server
   : Q! ?- V1 t0 a' g$ K8 z6 @( S
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端口等待下一次连接。

% E6 b* U" t. u" ?$ P" i% @$ h" E

- `3 p4 V' l( g( B

admin

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

1. /*client.c*/
   " ~+ X- y. W" w8 A9 U
2. #include<netinet/in.h>                         // for sockaddr_in  
   / E# V. ]6 O+ Q: I; N1 z, x# h
3. #include<sys/types.h>                          // for socket  
   
4. #include<sys/socket.h>                         // for socket  
   " r1 P! R! s: S6 {1 g" T/ K
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   
7. #include<string.h>                             // for bzero  
   
8. 
   * C7 I( P- `1 _9 p. S
9. #define HELLO_WORLD_SERVER_PORT       6666  
   + A8 Z& k5 a; Z& L
10. #define BUFFER_SIZE                   1024  
    2 y' h- }9 U5 Q. V6 U
11. #define FILE_NAME_MAX_SIZE            512  
    
12. 
    3 c8 j, k, ^0 e6 u" m
13. int main(int argc, char **argv)  
    1 c/ s' Z( }7 Y! Q6 d/ k
14. {  
    ) f/ N; u7 ]4 \" s) q
15.     if (argc != 2)  
    
16.     {  
    7 q9 E/ o% A7 Z. b
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    
19.     }  
    / I, `9 L+ m+ M7 h+ [/ N3 P! ]4 O
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    ' _0 `& v5 R! u4 \7 s  j
22.     struct sockaddr_in client_addr;  
    " I% P$ t; c1 l% z  }& k
23.     bzero(&client_addr, sizeof(client_addr));  
    
24.     client_addr.sin_family = AF_INET; // internet协议族  
    & H0 Q+ m* N5 z  f- M
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    
27. 
    9 D9 D0 m2 a: {: U. l: |- U
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    0 h6 d) i9 z# S* ]
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    . C3 L0 J9 R( D1 E9 E
30.     if (client_socket < 0)  
    ' h" {9 p. r# I) \2 Q+ w" s7 J
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    ( Q5 I$ k1 p2 Z9 B* U9 N2 k: `
33.         exit(1);  
    
34.     }  
    2 o, e5 k7 U6 N* K1 e9 T* b9 }2 P8 {  h
35. 
    ; v$ e& H5 T" D7 S3 _; s7 S* [
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    ! M2 B( X. N7 Z# C! l' \
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    3 a6 [# }" T2 s( g
38.     {  
    
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    
41.     }  
    
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    # B2 H3 B8 P: R: t& r
46.     server_addr.sin_family = AF_INET;  
    0 Y5 V  n% J* U1 M- ~. T) P- e
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    ) K3 y" ^* p: r8 j1 p  S, O- A5 n1 C+ |
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
      D& R+ \6 z# x5 r0 p7 j
51.         printf("Server IP Address Error!\n");  
    # O: f! b7 y6 b& V  k9 V5 {, f
52.         exit(1);  
    
53.     }  
    9 P; r. j. J$ g
54. 
    6 N* B, j; q- s" @
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    ' ]* ?7 c; i$ s3 [5 V4 H
56.     socklen_t server_addr_length = sizeof(server_addr);  
    
57. 
    ( A9 C# ?' \- n, G
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    - @8 U: l( o3 b$ R! Q
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    4 B0 A- t  ]( u+ j/ ?% s* R
62.         exit(1);  
    + i' i; u2 O: l  L
63.     }  
    3 t& K, u  j" F# \, V3 t. g2 }8 g
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    + I% y; O% g! Z/ C  Z
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    
69. 
    
70.     char buffer[BUFFER_SIZE];  
    
71.     bzero(buffer, sizeof(buffer));  
    6 m' D0 {  n+ Y4 }( K5 U1 \
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    8 V9 r7 E; U% l$ }
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    % u! Y& ]) t$ h$ }9 x
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
    ) b2 @; Y! k1 P  F8 F" f
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    1 ]3 N) z' |" e& s/ Y. `/ x
84.     bzero(buffer, sizeof(buffer));  
    + U% s0 C7 I0 J, l+ |
85.     int length = 0;  
    0 O% @- g% l) Z; J4 _
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    
88.         if (length < 0)  
    
89.         {  
      j; b8 w) `9 b, {
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    
92.         }  
    
93. 
    % T* J" Z" @9 [7 M) t( r$ m
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    $ o% }- V! J/ |
95.         if (write_length < length)  
    + H" w! Z5 P- [: t, Z# {5 L
96.         {  
    5 D! g3 g5 C* S3 i+ M& W
97.             printf("File:\t%s Write Failed!\n", file_name);  
    + T% B! Y3 c, m2 A+ w0 I5 ~1 j5 }
98.             break;  
    
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     ; F; l  [) f( f# w
101.     }  
     - n  {2 t& s, `5 @! n; w: w
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
     + `4 i9 X" M, \% ^8 n
105.     // 传输完毕，关闭socket   
     5 @5 `( T! t- P9 r
106.     fclose(fp);  
     
107.     close(client_socket);  
     
108.     return 0;  
     . C& r$ r. V& a
109. 
     
110. }  
     
111. 
     $ j  J, S' C$ e

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   " H' A4 r. v" S
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   
6. #include<stdlib.h>
     A) J+ H$ {5 |& ?/ Q) O! s
7. #include<string.h>
   4 D( `, A5 P, o' o: p/ D( K! b
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   0 S7 z: o* g4 h" {* m
10. #define LENGTH_OF_LISTEN_QUEUE     20
    - ?7 ^( `  S& z+ |0 u% P7 ^
11. #define BUFFER_SIZE                1024
    3 b" h+ G& e/ D! N, T; R5 ^
12. #define FILE_NAME_MAX_SIZE         512
    3 i. j' D- Q! G1 d" D( R
13. 
    % y1 I) j; c6 k
14. int main(int argc, char **argv)
    / g  W  T* l; y$ A: m5 S
15. {
    
16.     // set socket's address information
    , J0 }7 ]* v+ d& a  |- |4 }" H( p" _
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    / @8 m5 m& p, E4 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);
    
23. 
    8 T2 L# B# ~* Y1 Q1 J
24.     // create a stream socket
    3 Z' T' M7 E! x( O
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    ! |  I! A' C1 w3 a. p4 Y, H
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    
28.     {
    + F5 q. b8 d' \7 u
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    3 h' N+ p, d+ Y4 [6 W! R- x' s
31.     }
    
32. 
    2 ^- _# U0 G$ j. x0 _! ^. L% Q
33.     // 把socket和socket地址结构绑定
    2 f1 G, b$ x1 [8 G" f& w( r
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    + F) Y- |( A9 x4 `  w* S
35.     {
    8 m/ g  f' {9 T& K+ T  r) N
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    , M: T. F! X# z0 e2 y4 n/ b7 B. Z
37.         exit(1);
    
38.     }
    * t5 U% u1 g% |
39. 
    , h# P1 y! [9 [, x' c
40.     // server_socket用于监听
    " b; Z# h. y! \( e! W
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    " G( u( \+ f; g: t# h
42.     {
    $ M* K5 c0 q; ?+ {/ U
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    & f( u" m; R) [* Z1 B
45.     }
    ( k: c4 [2 k3 V- V) a' a1 w2 ]
46. 
    & Q, [8 v* ~# E7 C# Y5 J' Z6 I0 y
47.     // 服务器端一直运行用以持续为客户端提供服务
    + b$ G4 j0 S/ W
48.     while(1)
    / y# R+ ]( A$ J/ V- a
49.     {
    7 W! [- T" L. G
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    : s, a8 j$ ]5 p) e, g
53.         socklen_t          length = sizeof(client_addr);
    5 K" o' j9 _% Y6 a6 ]! L; G% i
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
57.         // 用select()来实现超时检测
    - ~0 S8 {% Z- k  d. M5 Z
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    9 P5 r0 L5 d1 N
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    
61.         if (new_server_socket < 0)
    * C0 V+ q1 m6 I3 m
62.         {
    ! x, M1 Q- e0 u) `
63.             printf("Server Accept Failed!\n");
    
64.             break;
    1 Z7 ?6 Q5 x: S" x
65.         }
    / ~2 l* F# p( {2 G- f; l
66. 
    
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    8 E: c  u5 }' j* i
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    & B; l2 @1 K! ]4 y4 M% L0 E
70.         if (length < 0)
    
71.         {
    ) h. k& G/ A" t* Q0 O0 K3 s4 O
72.             printf("Server Recieve Data Failed!\n");
    2 _- _. C" o8 \, x% b
73.             break;
    - d! E. {8 `/ d, i- U4 J7 C
74.         }
    # i& _% }# n; e
75. 
    ; k9 b  x6 @/ V: V" c& k
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
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));
    ( }/ W' R! j( e& O
80. 
    7 s3 _6 Z( [( u# @$ |) n. b# @* `
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    : ~7 d. K( k: K# ~4 s& f
85.         }
    % k+ ~2 U0 M$ ~, k, J; @9 |9 V+ T% q
86.         else
      Q* s6 Y! w: ?  `% u* w3 {/ V
87.         {
    * z$ a' s5 ?+ C* c5 h: O2 n" M
88.             bzero(buffer, BUFFER_SIZE);
    
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
    : G. Y( P  i  ^0 j7 ~  W" h
92.                 printf("file_block_length = %d\n", file_block_length);
    + ]* D' j6 H6 K/ @3 T8 o2 M1 k  H
93. 
    + t5 ]& z( T6 q, }* Z! @- `& _$ U
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    ; o4 ^' g! R7 v0 d; c! V% n
96.                 {
    6 M; R+ `7 M: P4 Y1 p) S
97.                     printf("Send File:\t%s Failed!\n", file_name);
    ; L' d' @3 _+ M& D: v$ X& d, }
98.                     break;
    " ^3 L6 T, X% P
99.                 }
    
100. 
     4 a8 k& ^0 q& X1 p
101.                 bzero(buffer, sizeof(buffer));
     * c6 b; M& f" C
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     / N) ~1 [; r% S2 U1 P6 J- G
105.         }
       R4 w$ ]8 @, i/ ^, F
106. 
     . q& G0 N; d! U0 Y7 b) ~, x5 Q
107.         close(new_server_socket);
     / q" S; q# ?& f0 O; `) _3 N, i
108.     }
     % o/ R6 @) P/ B/ b, ^) u( S- K
109. 
     
110.     close(server_socket);
     
111. 
     
112.     return 0;
     7 X& t, H9 _7 b  A( B8 l
113. }
     7 \+ f, O( E3 R7 u0 z. U
114. 
     

复制代码

0 l& t0 E- O/ b& [, N
$ d  |: N- N; e) |' x# @
. @( O! a! w5 J7 Y6 R