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

admin

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

1. #include <stdlib.h>
   & l) t$ g# w/ z; A$ y* S3 W2 N" U
2. #include <stdio.h>
   6 w$ _* v; q. K. C( F, n5 y7 m
3. #include <unistd.h>
   " E! @8 ^( }2 M
4. #include <string.h>
   9 A0 }5 f. z! m2 [! _, c0 a5 K9 T1 [
5. #include <sys/types.h>
   2 b" W* ?; S( f! O) H5 K1 M) F
6. #include <sys/socket.h>
   6 O1 c/ `6 n6 n8 v
7. #include <netinet/in.h>
   ; T* d; |' ]/ S* [  J6 {
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   
9. 
   5 O3 Y+ l' ^' \2 q: R" ^4 g) D1 p: d
10. #define PORT 4321   /* server port */
    
11. 
    
12. #define MAXDATASIZE 100
    % P+ w$ j3 z) Y$ z% e- T2 c& M) e
13. 
    * _/ z$ u5 p. _# {% |. l0 b9 {
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 */
    0 }( U; Z1 R5 W8 n9 a
19.     struct sockaddr_in server;
    
20.    
    
21.     if (argc != 2)
    * D& y# A& Z" n/ p
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    3 B' N2 B* u; x0 g9 T
24.         exit(1);
    
25.     }
    
26.    
    . `+ c0 f: e$ r* @! y0 M
27.     if((he=gethostbyname(argv[1]))==NULL)
    3 U- d- l% ]* ]" ?5 Z! U
28.     {
    6 d% p( y) T: ^/ ?! I& j
29.         printf("gethostbyname() error\n");
    3 q: \) d2 a5 ]! l- e# [
30.         exit(1);
    
31.     }
    
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    
35.         printf("socket() error\n");
    0 n1 r9 i% D/ D0 @  |6 S
36.         exit(1);
    + c6 J) w7 Z& ~6 e& P& |
37.     }
    * @7 l' l% ^$ x& R" L/ p$ {; Z
38.     bzero(&server,sizeof(server));
    
39.     server.sin_family = AF_INET;
    - l" A0 F6 P( W
40.     server.sin_port = htons(PORT);
    
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    ; t7 P# m+ @1 k9 I
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    ! C7 `  b4 a( f8 e2 V% f
43.     {
    
44.         printf("connect() error\n");
    
45.         exit(1);
    5 q9 [" {# T+ a! u9 ~
46.     }
    : p! u5 `; [( H
47. 　　
    " M7 Q; S/ X% c
48. 　　char str[] = "horst\n"
    
49. 
    
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    8 R1 s9 \  ~4 _4 G
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    - d. J$ \/ e  d
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    4 ?9 _7 ?2 ?" w! I: w# ^; ~
56.         printf("recv() error\n");
    " O) T- b- {3 O* v5 \0 o% z9 _
57.         exit(1);
    " A  V$ c0 Q3 v& p
58.     }
    & b0 x0 v* k0 S, w2 f. @1 X- |9 y# ^
59.     buf[num-1]='\0';
    6 N" D) ^: i5 P
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    
62.     return 0;
    
63. }

复制代码

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

1. #include <sys/time.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   * h' h% @7 {; ^; s9 }$ t5 L
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   " N2 I. S7 @4 S3 S
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    ' _6 Y, y2 Q. `9 ~7 a
11. #define PORT 4321
    
12. 
    1 ~0 ^7 |6 G& n8 L9 V9 U; t
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    6 y- @: h8 Q0 v* k, e4 X
15. 
    
16. int main(int argc, char *argv[])
    
17. {
    * j% U2 B6 ]" U
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 */
    $ Q8 P$ C. j) G+ F' I# R4 C
22.     socklen_t addrlen;
    4 z" V) L! x7 P/ S) T# [
23.     /* Create TCP socket */
    7 [3 t1 U  c/ A: E2 R
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    $ p0 u* v. b2 c& T
25.     {
    1 P6 |! H/ L2 j6 R- U' p( g
26.         /* handle exception */
    ) q( W: r4 F6 k2 X4 {4 x
27.         perror("socket() error. Failed to initiate a socket");
    ; N9 A! o) Y9 r
28.         exit(1);
    & `5 M0 c5 C: k
29.     }
    
30. 
    4 k: e, i9 e: e9 f% [9 n
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    $ r0 i5 T# J" o7 F
34. 
    
35.     bzero(&server, sizeof(server));
    7 O7 F' h; c  R7 z# z) j
36. 
    
37.     server.sin_family = AF_INET;
    % F9 S8 M; V7 y# h: z3 n
38.     server.sin_port = htons(PORT);
    # Z8 }4 e+ g& O' {
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    1 W8 |+ ?7 X- {) S0 b( W
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    # y. Z9 c7 l: m5 E7 w, c# V
41.     {
    ' R+ l6 T8 {9 T$ h* t- V
42.         /* handle exception */
    ; b6 @/ q( L3 N" a, y1 @
43.         perror("Bind() error.");
    
44.         exit(1);
    ) y5 Q) W4 t- a) |5 Y9 O4 e9 [
45.     }
    
46.    
    
47.     if(listen(listenfd, BACKLOG) == -1)
    
48.     {
    
49.         perror("listen() error. \n");
    1 N- ^# b1 P7 C; F& P) n( C
50.         exit(1);
    
51.     }
    
52. 
    
53.     addrlen = sizeof(client);
    4 Y# |& e; m& y: p7 o
54.     while(1){
    ; l" F8 [; t0 [; ^
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    + @) i& n& r0 A# B
56.            {
    
57.             perror("accept() error. \n");
    8 v* g* i& n* u* }
58.             exit(1);
    5 X8 v6 ?* Z3 k# G/ c$ K+ `
59.            }
    
60. 
    $ I  `% `4 g/ Z( R
61.         struct timeval tv;
    " F# H$ {/ O: M4 X; s
62.         gettimeofday(&tv, NULL);
    ) @/ q' l" V$ \+ h
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);
    % n# m5 Q/ F+ Z. [8 F0 S/ W
64.         
    
65.         int iret=-1;
    
66.         while(1)
    7 X/ W3 Q+ P  n6 e3 b1 ~% Y3 R
67.         {
    & X* f! Z! v+ P8 v' u0 o: V2 a9 q; B
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    
69.             if(iret>0)
    4 h0 |) |& U- S- p" i, o: Z
70.             {
    % c! q1 O6 x9 }6 X% i6 s" L" Y
71.                 printf("%s\n", buf);
    + \1 _+ o: z. P
72.             }else
    * F* p  q6 ?* }: f
73.             {
    
74.                 close(connectfd);
    
75.                 break;
    ; @5 j4 e' c' j* y) u
76.             }
    # p2 X. H7 n1 n
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    
79.         }
    
80.     }
    
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    9 k1 _- t7 Y/ l- j( m2 J  s2 g3 U* t+ g
83. }

复制代码

6 p7 L2 E% i& F& z( N" ~" ]8 m

（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
   6 Q/ m7 M0 x- K% A+ G5 I
2. 
   
3. server message:horst

复制代码

服务器端：

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

2 w0 p6 A/ d6 y( F8 H. s' j8 ]
  }" X; L+ f3 O( N/ _9 y
8 l) f) G+ y, U' ]' r

admin

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

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   / s, S* x; s. }2 P
3. #include<sys/types.h>                          // for socket  
   2 V9 `2 C2 c  T& N* p
4. #include<sys/socket.h>                         // for socket  
   
5. #include<stdio.h>                              // for printf  
   4 {( d( a; O2 s0 K, L0 l* O
6. #include<stdlib.h>                             // for exit  
   
7. #include<string.h>                             // for bzero  
   ' z- L" w+ W% A2 X
8. 
   ) B! Q: ]& ?8 d/ C0 b  U
9. #define HELLO_WORLD_SERVER_PORT       6666  
   4 a! Y- C/ |/ G( I7 k8 C
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
      @1 a9 P5 B3 L- [/ K" v0 i
12. 
    - w* x3 c4 |7 [( E5 `* a
13. int main(int argc, char **argv)  
    
14. {  
    
15.     if (argc != 2)  
    # c) D" x% B9 Y, O* @! u
16.     {  
    
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    9 G6 R8 h8 W/ Y- y; x
18.         exit(1);  
    
19.     }  
    
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    ) {6 G' I% g0 B4 t5 r8 }' _9 D. M# X
24.     client_addr.sin_family = AF_INET; // internet协议族  
    ! S  ^% v' n0 ]( r2 g7 O; H* F
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    1 }# F# _6 s$ |. O, k
27. 
    + l9 i$ t. i* m+ k# I0 O
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    
30.     if (client_socket < 0)  
    
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    
33.         exit(1);  
    
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    7 t$ v7 l" X2 Y: |& I& Z6 A1 R  D
39.         printf("Client Bind Port Failed!\n");  
    6 r. l# @4 X$ J- D; }' F4 D/ d
40.         exit(1);  
    
41.     }  
    " t" }" L+ `8 Y7 \+ I& A& U
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    - O5 R7 N( ]4 l6 I) Y, q5 ~' u
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    ' W+ `0 u; L7 E" x! t( `. |9 D
46.     server_addr.sin_family = AF_INET;  
    8 S( a# y! x3 T* R/ x
47. 
    ( f) P  |1 z: }( `/ C( U
48.     // 服务器的IP地址来自程序的参数   
    5 o- U3 C- B7 Q8 q
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    . e3 F/ e; p: G' e4 j
50.     {  
    7 k" {+ B8 W% s
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    - R. L5 c' i# s
53.     }  
    $ |% \7 U! X( V2 T0 @" o
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    & E, f4 |) b& Y* [/ \
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    6 s8 x1 e; L2 a+ Z; c/ _" P
59.     if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    ( o2 i! F+ v1 N6 b2 T8 ]( C
60.     {  
    
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    : o- U/ ~1 V. V" R7 D
62.         exit(1);  
    
63.     }  
    
64. 
    7 c. J* K2 E3 i3 o! |. _. v
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    / X% K3 p2 _% I
66.     bzero(file_name, sizeof(file_name));  
    
67.     printf("Please Input File Name On Server.\t");  
    0 W$ \% v. b& B" d
68.     scanf("%s", file_name);  
    4 _9 Q. E. Z! S2 d9 Y  N8 r
69. 
    4 S/ y) i& l+ e8 ^; X; @0 A2 k
70.     char buffer[BUFFER_SIZE];  
    
71.     bzero(buffer, sizeof(buffer));  
    
72.     strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    ' k) X1 i; k5 i! n: @# n. u
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    6 ^9 Z  h# \% r0 E0 N
75. 
    3 a$ y  ]3 c4 [) T! G7 |% }
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);  
    ) E0 w: J0 L5 I* R* @8 N* u
80.         exit(1);  
    % M  y& V; Q8 G  W# [8 W5 y" ^
81.     }  
    1 d: s! W! Q+ H! }
82. 
    ' O4 }2 F0 w. d4 F- j! Z! N1 T
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    9 g2 v8 u3 U" F4 d- K5 H8 F; G
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    
87.     {  
    
88.         if (length < 0)  
    
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    : B, [% l' s2 \8 y, @7 {
91.             break;  
    
92.         }  
    9 C8 s. ]  r/ M2 {  ^, m& |
93. 
    + Z- R( J: ]! ~6 V$ J- p! f0 Q, j# t" ^
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    / ^. s. E% k  d, A- Z. @* G; h! ]. s; s
95.         if (write_length < length)  
    
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    
99.         }  
    ; f, }/ Q0 N! k! Z7 o6 w
100.         bzero(buffer, BUFFER_SIZE);  
     , N# b$ a* T, f2 a
101.     }  
     
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     ; I: g% J: v' D+ F
104. 
     
105.     // 传输完毕，关闭socket   
     5 o- I% a! ~% D: T6 \9 j
106.     fclose(fp);  
     
107.     close(client_socket);  
     
108.     return 0;  
     - x+ ^6 V5 S( U* {& l; @# w1 [" b+ y
109. 
     
110. }  
     3 D0 l: f# b( `" w
111. 
     1 J" C0 Z5 d" Z, Y7 t: ^. T6 M

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   
3. #include<sys/types.h>
   : [6 W9 F% X3 A' n4 d7 h6 p- @) V6 l
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   ' W) D$ w9 z. t& H
6. #include<stdlib.h>
   5 F" d6 ^. l7 e" V2 O# _
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   & U4 P2 _+ A; [2 R. L
10. #define LENGTH_OF_LISTEN_QUEUE     20
    . A+ y  Z/ `& x+ \( u* w
11. #define BUFFER_SIZE                1024
    7 A/ u4 G5 i( e5 v* G
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    # B) Q6 z( B  J8 A0 ]2 \* N
14. int main(int argc, char **argv)
    
15. {
    * T: j- A- X& g, R( H4 u# W( U+ O
16.     // set socket's address information
    ! x; m$ R* h  I0 X2 @
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    
18.     struct sockaddr_in   server_addr;
    ( O" D) B7 a: h/ _
19.     bzero(&server_addr, sizeof(server_addr));
    & b1 C" G: y' E
20.     server_addr.sin_family = AF_INET;
    # ?% n  K4 M# T4 P5 |
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    
23. 
    , `& @( A& U* G6 ?* j  _
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    ) A3 y7 M5 k# R7 d
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    " e6 l; H5 X7 Y$ O9 d; S" P
27.     if (server_socket < 0)
    ) h" z# s$ o; E! {
28.     {
    6 T8 y8 c' s" V
29.         printf("Create Socket Failed!\n");
    ! K6 [2 j- m, m: M- o
30.         exit(1);
    
31.     }
    0 m4 n5 }) [  Y3 c4 k" B
32. 
    ( R$ K) ~5 P6 z4 d! k4 ~% Z& b
33.     // 把socket和socket地址结构绑定
    . @! e% n2 j+ Z  a, y% C
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    5 T1 {4 C4 \& e- L; D* K
35.     {
    2 h5 W  Z$ u2 c/ c8 g1 \8 X0 h7 F# P
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    
37.         exit(1);
    
38.     }
    9 T' o; [6 ^6 O6 y
39. 
    
40.     // server_socket用于监听
    ! w* h; v% t2 O8 ^5 k5 ^
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    & F$ \  n7 O1 y* o" J: g  N
43.         printf("Server Listen Failed!\n");
    . @4 n8 H  a. v
44.         exit(1);
    0 r5 w3 M* n  W  k! Q) O
45.     }
    
46. 
    
47.     // 服务器端一直运行用以持续为客户端提供服务
      j* `6 h4 c+ m+ r2 s4 c
48.     while(1)
    
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    
52.         struct sockaddr_in client_addr;
    + n6 `- [2 z$ _
53.         socklen_t          length = sizeof(client_addr);
    
54. 
    % G- [. R$ a0 s! @7 Y
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    7 T8 [0 X) ]) f9 ]9 j" _3 p, R. N7 C2 x9 i
57.         // 用select()来实现超时检测
    , @5 ^& y* Y9 x4 K0 M
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    
59.         // 这里的new_server_socket代表了这个通信通道
    8 V( q- B# `7 ~
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    
61.         if (new_server_socket < 0)
    
62.         {
    + m1 M, W  G8 h" T
63.             printf("Server Accept Failed!\n");
    % D; f  {) `" J3 H
64.             break;
    
65.         }
    
66. 
    
67.         char buffer[BUFFER_SIZE];
    1 Z3 X. N1 t9 Q9 [
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
      h3 I0 U9 {. e2 [/ i, K
70.         if (length < 0)
    ) g$ y/ K. A. O0 a# G
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    0 O- `: [+ {7 a) z2 B
73.             break;
    3 J: l# p% J% r9 h; Q. u; q1 e$ z
74.         }
    ) N* ?3 g; h9 n# }
75. 
    6 [6 @+ Y& q8 L7 F4 F4 T9 p
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    * J/ L1 ~6 A+ b1 X9 h' t' }2 t
78.         strncpy(file_name, buffer,
    , ^" o' m# |! |& Y* s
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    ) }. w4 h- i  C! D; e0 O
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    ( P  `0 q' Q3 d$ ?6 E
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    
85.         }
    
86.         else
    ( I! x8 L8 ?- P0 K8 B
87.         {
    
88.             bzero(buffer, BUFFER_SIZE);
    / Z; {8 y, y; ~; x) l( y. ~
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    ! I9 O7 M2 X4 M0 ^4 r$ v, ~
91.             {
    , d/ _) H' }5 U4 _
92.                 printf("file_block_length = %d\n", file_block_length);
    7 t% ^3 r$ y3 ]: I6 x" H% I9 x) t
93. 
    
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    9 m, x7 Z0 Z& @4 _# z$ W
96.                 {
    
97.                     printf("Send File:\t%s Failed!\n", file_name);
    * o( P6 f5 ?5 X, Q# r: m7 E
98.                     break;
    1 c3 |3 k5 l/ b# t9 F' Z
99.                 }
    + C3 m* o% f8 ?' `
100. 
     
101.                 bzero(buffer, sizeof(buffer));
     
102.             }
     
103.             fclose(fp);
     
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     1 _* V. S7 \. {. K. H# v
105.         }
     - [/ ^8 J. w5 v8 N( R5 J
106. 
     8 k9 W3 [- a, d; ]' t
107.         close(new_server_socket);
     " O% g6 w: U3 K" I7 l
108.     }
     
109. 
     
110.     close(server_socket);
     
111. 
     7 n0 M" n* }4 H" F
112.     return 0;
     $ {! F8 N, k, {- C. _
113. }
     ( v0 J4 N* O6 s1 V4 [+ }  o
114. 
     

复制代码