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

admin

本文给出一个很实用的服务端和客户端进行TCP通信的小例子。具体实现上非常简单，只是平时编写类似程序，具体步骤经常忘记，还要总是查，暂且将其记下来，方便以后参考。
（1）客户端程序，编写一个文件client.c，内容如下：
; J' i( o. y+ `2 s( l! c8 a8 x' c) c

1. #include <stdlib.h>
   # S! C+ N% @. ?0 I  F# b" ?9 y
2. #include <stdio.h>
   
3. #include <unistd.h>
   : @; i3 }+ L4 r
4. #include <string.h>
   ) o6 w6 m  B  U& r" V+ ]; V8 H& w
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   0 n4 @: Y5 E$ j0 P* J5 J
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   & F: [' \$ l  Z* s: S
10. #define PORT 4321   /* server port */
    
11. 
    ! d* s: v8 ]6 u8 y5 V  r% a
12. #define MAXDATASIZE 100
    ! J* Z' Q2 a* f$ H4 H# P
13. 
    + T1 y# E' F' i$ r. C/ y( m
14. int main(int argc, char *argv[])
      L8 N, G: d8 B4 F( E3 E
15. {
    , Q& J; M% k3 t8 V: l; i
16.     int sockfd, num;    /* files descriptors */
    % A5 v* T2 i0 u
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;
    
20.    
    ' B* q: K8 p/ I  D' J
21.     if (argc != 2)
    
22.     {
    " R  K6 [+ h% i9 {  @
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    
25.     }
    & v6 a) c: H: k9 A/ K. C
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    4 w# E5 {, u* w6 o0 X4 Y9 G
28.     {
    : Y# O0 o8 O! Y4 D. E* i0 i& S
29.         printf("gethostbyname() error\n");
    
30.         exit(1);
    
31.     }
      t1 S/ g2 H/ {8 J1 G: E3 B
32.    
    8 ~0 ?9 n6 Y) n, h) p! V3 O6 E
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    0 S: L/ x* X: p* p/ |" w) z, f
35.         printf("socket() error\n");
    $ R7 P/ |( N* N6 C+ Y" x
36.         exit(1);
    9 V7 N- f6 V! ]
37.     }
    
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    9 ^# Q. M" V4 M1 ]! ^; w  {
40.     server.sin_port = htons(PORT);
    3 v& ]( y. X. r* Y* E' y
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    # c; O2 M/ H3 O; B7 a
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    " F8 n2 u, k$ ?0 c
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    / a+ y+ h& J* C, Y+ d( T- ~
47. 　　
    5 W- Y4 y, N4 P3 f3 [
48. 　　char str[] = "horst\n"
    9 B) r" [: h- y- F
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    9 |$ z6 t9 o' b
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    * \& W0 w( z6 S' i6 H* F; _+ W
55.     {
    
56.         printf("recv() error\n");
    
57.         exit(1);
    
58.     }
    
59.     buf[num-1]='\0';
    
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    
62.     return 0;
    
63. }

复制代码

（2）服务器端，编写server.c，内容如下
# D" ~  H& Y2 U- H8 _( ^- d" u# Y

1. #include <sys/time.h>
   7 Z9 p4 j1 X+ x1 ?
2. #include <stdlib.h>
   2 F' [+ O3 J" J0 b# ]9 f* r
3. #include <stdio.h>
   
4. #include <string.h>
   % o9 s3 K) R1 g
5. #include <unistd.h>
   0 a- R) O* a' x4 y1 S5 q0 _
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   , x' m1 {. O. s5 O# c
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   & r) A. E! _3 {4 G" {
10. 
    
11. #define PORT 4321
    
12. 
    # I0 C) M6 c3 e$ W
13. #define BACKLOG 1
    7 `- U7 @' G. r, u' P2 o
14. #define MAXRECVLEN 1024
    % @' p6 X+ x3 q- h; k4 |
15. 
    6 ?( _8 n/ S6 ~( V1 O' N0 L
16. int main(int argc, char *argv[])
    1 n) e5 T+ {7 T: A
17. {
    # l- E0 \1 [/ G, w! F
18.     char buf[MAXRECVLEN];
    
19.     int listenfd, connectfd;   /* socket descriptors */
    
20.     struct sockaddr_in server; /* server's address information */
    ' R0 e( i0 y, L5 |: s7 W0 I
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    * g' c) G9 l# z- L
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    
26.         /* handle exception */
    7 @" G2 p2 L1 W# I7 m5 v: V
27.         perror("socket() error. Failed to initiate a socket");
    / N7 ~5 q3 p! U& w+ E" }& @
28.         exit(1);
    1 f: o4 i6 W* y' |" H& r7 _
29.     }
    
30. 
    # y, y# h% V* t2 q
31.     /* set socket option */
    $ j* @- w# U% z6 z6 J
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    ) ~4 k$ O0 a" a5 T/ S6 T
35.     bzero(&server, sizeof(server));
    
36. 
    / a# L* `' i2 d2 A* }
37.     server.sin_family = AF_INET;
    , C- A5 w! F$ Z) T# z
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    ( F* }. m! d' J8 R) V, C5 l
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    % z# x* X/ V4 S" k: h
41.     {
    
42.         /* handle exception */
    8 Y2 b2 r( j! o+ S* |2 ?
43.         perror("Bind() error.");
    
44.         exit(1);
    
45.     }
    ' j9 J$ M/ y0 ]
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    . C  a: W& H1 T- B$ m
48.     {
    
49.         perror("listen() error. \n");
    % F, N0 a% h& k( u
50.         exit(1);
    0 d# l1 l' h; B3 G5 F: ?
51.     }
    
52. 
    * G! m) u$ |' z9 w0 T( i+ F+ l
53.     addrlen = sizeof(client);
    
54.     while(1){
    , [9 h6 W2 |, i4 O8 `( m3 G
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    $ _/ b* V4 U2 k3 \  {, I2 P  c
56.            {
      j- Q8 B: T$ m0 T& Z
57.             perror("accept() error. \n");
    3 d+ C* t2 Z- K4 z* q6 b
58.             exit(1);
    ; k; y8 J1 R; C+ O4 R! W6 _$ y
59.            }
    
60. 
    ! b# C' ]9 x' e
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.         
    
65.         int iret=-1;
    - f6 q) C  L1 k8 E9 a# S$ [' x
66.         while(1)
    " w( a- a  W- i9 C2 }) J) z
67.         {
    2 Q" j# ?) Q+ o7 W" s' X
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    5 r: H% r3 b1 n+ O8 I" D+ @
70.             {
    
71.                 printf("%s\n", buf);
    ; ], B+ |' g& s( D: P! B
72.             }else
    
73.             {
    - Q  k$ G& x4 x& s: j4 O. c+ m3 k
74.                 close(connectfd);
    $ A) u' P6 _3 H, p8 b$ C; l
75.                 break;
    
76.             }
    ! f( w* N8 k2 U( v
77.             /* print client's ip and port */
    6 P1 C( z$ L+ ~( e1 ?0 T
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    
80.     }
    
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    + `$ c, y" U/ y1 P
83. }

复制代码

+ `! @1 Z/ o' q7 g( Y% ^

（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. 
   6 P7 d2 E8 [) Y+ @# b
3. server message:horst

复制代码

3 |' Y% x; K( ?0 J8 c6 b

服务器端：

1. $./server
   ' N/ P! A, @' w# K7 e' w* f
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端口等待下一次连接。

1 H( r  a& p& x. E' |. ]8 Y  J


6 p) u5 C5 K% c- `5 D, H! `

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
. f- Z( i! g) q: e: L' @; U! D5 h

1. /*client.c*/
   % ~5 d) `( [1 y+ |: G
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 @! o3 K/ J; e, d; {$ z
7. #include<string.h>                             // for bzero  
   
8. 
   0 j7 ~( A$ W) k! s% z
9. #define HELLO_WORLD_SERVER_PORT       6666  
   
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    $ Y' t2 h9 Z! P! K: [% T
12. 
    
13. int main(int argc, char **argv)  
    8 O8 X; b+ E; i3 x- Q
14. {  
    
15.     if (argc != 2)  
    
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    ! k1 Q) `5 n9 u* B8 b+ S' _3 a& H
18.         exit(1);  
    , }" h! p3 v5 m
19.     }  
    1 Y+ U9 @3 G. g/ v, s5 G
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    3 G5 M( X% h5 F3 C- T2 N' ]
22.     struct sockaddr_in client_addr;  
    
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, 让系统自动分配一个空闲端口  
    ! @1 @2 D- _" R% |8 V" k6 `
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    / c$ ]8 i3 f+ Y0 a8 Y
30.     if (client_socket < 0)  
    
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    8 `7 ~# r$ k) \( h& d4 d
33.         exit(1);  
    ) y, Z: z& Z" }! k
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    " V  Y& A" E# w" y
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    3 Y" B9 Q' [5 u9 ?# [9 P1 m# t& H
38.     {  
    : ~7 p" P) @  `; E& z4 T
39.         printf("Client Bind Port Failed!\n");  
      X+ ^" R$ `& X' R4 H8 U
40.         exit(1);  
    
41.     }  
    " [5 w' z* B3 [1 a6 \( N# D
42. 
    1 v; W1 f7 E) ~
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    . ]/ Y7 ]5 `' R8 c" L
46.     server_addr.sin_family = AF_INET;  
    
47. 
    % }2 d7 J6 I  a0 @6 D
48.     // 服务器的IP地址来自程序的参数   
    , {) ^1 ?. a5 J7 ^1 g
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    / r0 w! m/ u/ m8 h6 C
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    
53.     }  
    . d1 I$ |, k: ^0 I
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    % r( {/ i7 o7 q' o
56.     socklen_t server_addr_length = sizeof(server_addr);  
    & E0 L% v% {6 E# p) k$ f
57. 
    0 Y4 {6 ^# ?. |" i+ F  t9 W% ~' _
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    & z9 }% r4 j  n0 H; {, k1 `) n& w
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    ) N& e; }" E* i/ U1 l5 k. X' n
60.     {  
    ( J6 V9 b- R. T. z  ?
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    & {5 h* {  N2 z+ V  ^& n
63.     }  
    
64. 
    # j. S+ R5 \  I& h4 x& x
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    / a* e, z* y# M# Z/ p0 m
66.     bzero(file_name, sizeof(file_name));  
    % Y* Q' `, u5 L2 x( q
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    % k  p3 _5 J1 Y6 ~+ s
69. 
    5 T6 R; k% {  A4 Y3 O
70.     char buffer[BUFFER_SIZE];  
    . H+ k3 b8 P( r; ?! {! g! L2 ?
71.     bzero(buffer, sizeof(buffer));  
    6 D8 R  K4 l8 w% V- _3 e% b* ~
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    6 K/ o8 [4 _& \: b
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    - f/ A* v' ], P) u9 [2 M) r; U8 ?0 Q' }3 }
75. 
    
76.     FILE *fp = fopen(file_name, "w");  
    
77.     if (fp == NULL)  
      ]4 w! U& t8 Z/ L' A/ T
78.     {  
    
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    . `, P0 S. ?% A. G1 t. C
81.     }  
    ) }5 N" n7 b  d0 n/ g8 q1 Q0 i
82. 
    
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    4 `: H* ^+ x. i3 @! ^/ s" |& r2 {
87.     {  
    7 z5 K' s+ H- \% u) Z( Z" K2 Q2 D: ^
88.         if (length < 0)  
    
89.         {  
    ( H* e9 d6 E: O
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    ( T) J- N6 Z* c# a
91.             break;  
    
92.         }  
    7 y/ m% q  g2 p
93. 
    6 \5 O- ?5 ^+ {: P/ ?- @
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    
95.         if (write_length < length)  
    ( k  k1 D: u/ O6 p
96.         {  
    & c: C( C+ W2 ?( l4 p
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    
99.         }  
    4 q" q7 Y* X5 [# X" x2 _
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     
102. 
     2 L" k/ O1 L9 {- U; l8 t9 J
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     
104. 
       ]. x. ~4 h  ]+ C: O. |
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     
107.     close(client_socket);  
     ! i. Y, ^6 C+ s. O# C% J5 u
108.     return 0;  
     
109. 
     / W8 m$ Y" V9 p; S9 T
110. }  
     
111. 
     + O1 i+ t3 V  g# G  u5 u0 f- O

复制代码

1. /*server.c*/
   " S  j# E- j7 E" ?5 w2 m
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   0 ?" ~4 W- Y; w- D9 S+ z
4. #include<sys/socket.h>
   9 p2 A$ Q9 c& Z* ]5 K3 a
5. #include<stdio.h>
   ( `# K+ n) S# z0 B% S6 X
6. #include<stdlib.h>
   8 L* P: J* F" B( O8 U
7. #include<string.h>
   3 e. P- C! Q( H0 Q! U7 N# r5 K
8. 
   ; ^: X7 v+ g1 f' b
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    , c& V* @, G/ I! l3 w* ~& t
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    / M0 d8 C2 ]4 Y- [* D# o
14. int main(int argc, char **argv)
    1 Q. Z$ {( a8 B9 {. D7 w4 x) Q% t! D
15. {
    6 c4 Z3 r# f8 I) d! r  `
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;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    * Y  Q* M( ]! H/ \' }
23. 
    
24.     // create a stream socket
    + A7 G0 f+ W; D# S6 T* ~
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    7 l2 B3 V& D( A- R) R' y4 _
27.     if (server_socket < 0)
    
28.     {
    
29.         printf("Create Socket Failed!\n");
    - }$ Z3 W  b3 |6 Y
30.         exit(1);
    ( ?: ^) z1 r, a* M4 T: }
31.     }
    
32. 
    
33.     // 把socket和socket地址结构绑定
    6 S/ _9 h! o) p  E9 l
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    
35.     {
    ) X* o' z5 g! _, q- b8 S
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    4 `% {) D- F- o( r$ s: s1 K, }
38.     }
    0 c9 ^4 g0 p2 o; r. M5 a
39. 
    
40.     // server_socket用于监听
    , k* n3 t: V# x& d8 [
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
      x( t* D4 U' B$ i4 v
42.     {
    
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    * G0 n: R5 q+ k& }: C
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    
49.     {
    % I# `/ r( i5 B
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    1 d8 K2 p( d3 d5 k7 _- F6 T
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    7 ?; `, I' K- Y8 E9 m, K
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    ; W6 Q; W5 o# `/ Y6 W
54. 
    
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    . a& P$ A" d/ A+ J+ X/ f8 u
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    
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);
    : a  X! _* e: L+ q$ o, n9 w
61.         if (new_server_socket < 0)
    ) m# z- ]+ H! Y
62.         {
    
63.             printf("Server Accept Failed!\n");
    
64.             break;
    + ]0 H) L4 Y+ K& w
65.         }
    ( j6 n, ^  \" M3 k8 t8 A( _; q
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)
    & u( S# W! c: {( I8 x; J
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    ( h" t; I* s5 u: a: k& g% J
73.             break;
    ' L1 s" M4 s6 x5 X# n
74.         }
    
75. 
    ' |! [9 ]$ M. c, D4 ]4 U- f
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    4 t6 F& \+ |* I  s3 `
78.         strncpy(file_name, buffer,
    : x9 B0 B, H. n, t1 w* k
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    . F/ C5 P% ]9 u: m
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    ( \. C# |- n4 c5 V8 [
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    
86.         else
    ) w6 l) T5 ~- P7 G6 I
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    5 r/ O& k: c6 h% ?6 X& b  t' F
89.             int file_block_length = 0;
    ; _4 b& a4 j) z  Q9 V; r; h
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    - v) w3 p3 X+ K0 W
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    # J0 U' u* \8 q* h3 a
93. 
    & `+ Q/ c; d  b; ^( H) t2 I
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    6 I! U7 P' }, ~* m" l
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    2 C  S! w, v/ r/ g. v3 R9 p
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    * @& r$ i1 \1 H+ T! @: f& \
98.                     break;
    7 E, _  |: o7 n- m
99.                 }
    : u9 r8 A5 ^/ ?5 b& r
100. 
     - I! U7 f  `- o2 Z
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     / Z- w5 @2 E% w" g! Q
105.         }
     " q; N1 k# I6 c6 \% J
106. 
     
107.         close(new_server_socket);
     , P; _; X- d7 O# H; [2 x& V
108.     }
     * V# \1 o. I  l$ _" K8 |
109. 
     6 s1 w" `! v5 K- B6 J0 G
110.     close(server_socket);
     
111. 
     ( |  y9 E4 N, K, i/ C" n
112.     return 0;
     , [) o6 F, k% |! T" i1 U
113. }
     " @( N+ K* u3 T% `, D% B* R
114. 
     6 l$ ?2 ?; _- I1 X1 a* e3 v

复制代码

" l8 L+ A2 _) D