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

admin

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

1. #include <stdlib.h>
   
2. #include <stdio.h>
   ( |% F; f1 k* W& D6 n! J. H9 ?
3. #include <unistd.h>
   " f; w# _! V9 m8 s
4. #include <string.h>
   ! S+ k- b$ N& C6 X1 t# ~* E' x
5. #include <sys/types.h>
   * F. E% T* D8 {+ a& l' D
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   1 I; X. ^- K$ s- b1 I2 L
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    
12. #define MAXDATASIZE 100
    $ v' a6 @' v+ l
13. 
    
14. int main(int argc, char *argv[])
    ; w, Y; q) ^% {+ ?
15. {
    ( y% t2 P& r7 a5 l
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 */
    " ~& c! t. E9 U$ j
19.     struct sockaddr_in server;
    " Q4 W9 K' m" |2 E9 _' E
20.    
    
21.     if (argc != 2)
    
22.     {
    
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    
24.         exit(1);
    5 k* O, Q7 H' }+ b3 I
25.     }
    
26.    
    7 f3 e% p+ a) \0 U6 p0 V* i9 m* |
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    
29.         printf("gethostbyname() error\n");
      s! J0 O8 i. R8 w! v$ }
30.         exit(1);
    ( ~4 I4 i" X0 O; V" H% f
31.     }
    6 y& X' K0 Y9 d
32.    
    
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    
35.         printf("socket() error\n");
    5 k/ K; {5 i/ e8 \( ^" x' l, z) u
36.         exit(1);
    
37.     }
    : ^% Q' u3 X8 s$ W  k3 y# E
38.     bzero(&server,sizeof(server));
    4 n0 i- j6 A: V; R% i
39.     server.sin_family = AF_INET;
    
40.     server.sin_port = htons(PORT);
    ' }) |# \6 U# t4 _; C! b# _$ Z1 w
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    9 U$ L/ P. P9 A% Y) T
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    * M* Y' N& Y1 ]8 K$ E" b# b  e
43.     {
    
44.         printf("connect() error\n");
    0 S1 g) }! d: }) ^
45.         exit(1);
    3 P2 z" O. y& t4 |/ E
46.     }
    
47. 　　
    + K9 Y- w* w3 O6 X- J$ E. c7 b
48. 　　char str[] = "horst\n"
    
49. 
    ) k8 q4 `$ J' N/ I- c; y
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
      n$ }2 T, y$ Y0 [4 [3 G
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    ! H6 a+ _) _7 o9 J, D5 A4 e
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    
55.     {
    ) k9 T# B( W! ^1 Z) y
56.         printf("recv() error\n");
    ; d# o) H! }, i5 E* W( ~1 N/ |* R
57.         exit(1);
    
58.     }
    
59.     buf[num-1]='\0';
    4 D- U" p( j8 ^1 B- v9 D  u4 Q
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    
62.     return 0;
    3 u& q% ?1 _% W: U
63. }

复制代码

（2）服务器端，编写server.c，内容如下
" u2 J6 c1 u: ^0 i& u) v- U

1. #include <sys/time.h>
   $ k6 o& r% _/ U2 }0 j2 h$ {
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   & P, R7 ^8 ^$ H% ^
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   7 Z9 G9 N' l2 o, @1 R/ w: O8 D
9. #include <arpa/inet.h>
   6 O( y/ _9 _! _. Y
10. 
    
11. #define PORT 4321
      k( G4 Y( }5 N$ }, r9 N
12. 
    * D$ L, n. ?6 Q" v! ^" d  g, k# N( k% f
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    * B! k& g+ A: p! z' o
15. 
    ) j9 G) v' Z& r
16. int main(int argc, char *argv[])
    
17. {
    1 S! s6 O+ L0 Y# ]. E/ l# I5 M
18.     char buf[MAXRECVLEN];
    ( X' T' b0 w. z* q9 c; X
19.     int listenfd, connectfd;   /* socket descriptors */
    2 r/ _1 o* x* P4 I+ U- O
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    0 M: ~. a) O  s; \& ?/ C% J% l
23.     /* Create TCP socket */
    * Y* D$ g% j7 Q7 i6 m* Y; T0 i
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    
26.         /* handle exception */
    
27.         perror("socket() error. Failed to initiate a socket");
    2 U: ~! ^) X; ?( E
28.         exit(1);
    / ~4 q) G- M# p- [
29.     }
    # a" X) q% P' R0 Q
30. 
    
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    $ s  Q( j& D- B/ a& V9 [
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    
35.     bzero(&server, sizeof(server));
    2 [' G8 s1 i/ c0 [& x' v) n
36. 
    
37.     server.sin_family = AF_INET;
    # [/ G+ Y! T8 k
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    0 y( d1 j/ g9 l2 O/ `5 x9 o5 {' h' Q. V
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    3 q6 C, E5 [/ A) H
41.     {
    1 X( T+ v" K+ |4 V+ L
42.         /* handle exception */
    
43.         perror("Bind() error.");
    
44.         exit(1);
    
45.     }
    
46.    
    7 i* `- |1 D. @- f4 Z
47.     if(listen(listenfd, BACKLOG) == -1)
    + T8 T3 I4 n- Z- l( N; B( n
48.     {
    
49.         perror("listen() error. \n");
    
50.         exit(1);
    9 B) R( a  J0 e# M5 y+ Q
51.     }
    % ~1 H& N4 c8 V7 w9 A' q
52. 
    
53.     addrlen = sizeof(client);
    
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    . y* G  J, t5 J) q3 w
56.            {
    
57.             perror("accept() error. \n");
    
58.             exit(1);
    & @' m+ ~# ?# J0 `9 H. K. k
59.            }
    4 M5 g. s  I1 \7 o; G  G& N
60. 
    
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);
    & }9 K$ C! c) ?4 c! m
64.         
    
65.         int iret=-1;
    ; g8 k3 {3 N& q7 r) V' H
66.         while(1)
    5 \" ^) t7 m1 V2 ^( B( |  C* u
67.         {
    & @0 T; p4 d: V
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    4 L8 M: S+ Z7 r# ?; _+ C) J" v
69.             if(iret>0)
    
70.             {
    
71.                 printf("%s\n", buf);
    0 C. S# M$ b( q) H7 g8 k+ C8 o
72.             }else
    3 b) M: i7 _8 J9 H; y% f( Z
73.             {
    
74.                 close(connectfd);
    3 _& y7 N: h. ?9 J8 J" a
75.                 break;
    4 p% R- q8 d" r
76.             }
    # h' h4 y8 I) t) z
77.             /* print client's ip and port */
    
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
      [& _% b- @% A
79.         }
    " p6 B& i2 }$ ]; x) M) y
80.     }
    
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    ! g5 A+ ^6 k4 z* G. t- E
83. }

复制代码

2 P& @3 t2 l  U3 P7 u- ?3 D

（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 W& E# E: @8 c
2. 
   " }  C2 H: X. O2 B$ z" w- Y' o- J
3. server message:horst

复制代码

& v( ]: v8 y7 V  k% a! B6 [, n

服务器端：

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! a1 u7 m. Q: |+ v  G: I

, m& C2 l  i# R4 c% N5 C

admin

服务端启动,客户端通过ip地址连接服务端,然后输入要发送的文件名,发送文件到服务段.
' B+ T# S; ]) H+ V6 Z4 h: A

1. /*client.c*/
   ! |- t6 i/ z( t% W4 w" B. M
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. #include<string.h>                             // for bzero  
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT       6666  
   . {6 ?8 z- \8 ?; o4 w
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    4 Q- N7 h+ Y# }9 ^6 ^
12. 
    
13. int main(int argc, char **argv)  
    
14. {  
    
15.     if (argc != 2)  
    . h6 U8 N# L, {7 s
16.     {  
    7 U+ s& V$ U, D
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    
18.         exit(1);  
    % }5 K7 {- S4 R
19.     }  
    . E2 _  o7 o" E& {, w4 a
20. 
    
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    3 d* X$ k$ T- P5 Y- U) }
22.     struct sockaddr_in client_addr;  
    
23.     bzero(&client_addr, sizeof(client_addr));  
    0 t$ M# f! |: E6 S4 A, r
24.     client_addr.sin_family = AF_INET; // internet协议族  
    , {/ B, E% A" o
25.     client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    4 c" K* |) i( \9 \5 I0 o
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    - K  u- ^, J0 {$ p$ ?0 T
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    : z7 y+ C* n& B
30.     if (client_socket < 0)  
    
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    9 c- h* I; i8 U; |+ v
33.         exit(1);  
    " \  D: Z: P% k3 k& [% z
34.     }  
    
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    5 V- J) Q3 Q/ X6 d# E$ y
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    3 T* X0 q5 J& K. }
38.     {  
    1 Q5 b$ p3 `6 x9 u# ^- Q( x
39.         printf("Client Bind Port Failed!\n");  
    
40.         exit(1);  
    
41.     }  
    
42. 
    
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    1 j% `- d# L, S; ^" g
44.     struct sockaddr_in  server_addr;  
    
45.     bzero(&server_addr, sizeof(server_addr));  
    
46.     server_addr.sin_family = AF_INET;  
    
47. 
    
48.     // 服务器的IP地址来自程序的参数   
    4 \$ {' d1 A, u; d7 a2 E
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    
51.         printf("Server IP Address Error!\n");  
    ( S5 U$ @: S  X5 C5 M8 n6 J, ^
52.         exit(1);  
    
53.     }  
    & x! n% ?# K1 h6 `- ?) P
54. 
    
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    
56.     socklen_t server_addr_length = sizeof(server_addr);  
    % U$ _, ?$ a; F' s
57. 
    
58.     // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
    
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 g9 `- m0 n" m) ~( x# M- E
62.         exit(1);  
    7 `4 ]' h  h- j9 B. G' z; K  h
63.     }  
    
64. 
    
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    
66.     bzero(file_name, sizeof(file_name));  
    1 X( P* L; f9 h+ c+ b& C
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    4 ]2 c6 z0 M- y- ~6 A+ e) X0 P
69. 
    , z# |' t! ^# |5 t* i' m0 A- v
70.     char buffer[BUFFER_SIZE];  
    " d+ q8 F) ^, s0 b' d! e: ]
71.     bzero(buffer, sizeof(buffer));  
    
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);  
    2 r. U/ p) s4 f0 ?+ f3 u( @
75. 
    8 e/ r' m1 h' Z* v4 u4 V; U' l' R' y
76.     FILE *fp = fopen(file_name, "w");  
    : r, z" G1 r  d" e+ A
77.     if (fp == NULL)  
    & I1 L/ |4 i( _
78.     {  
    0 v, W8 T* m* y
79.         printf("File:\t%s Can Not Open To Write!\n", file_name);  
    
80.         exit(1);  
    
81.     }  
    
82. 
    
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    
85.     int length = 0;  
    
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    ! K& [0 d+ I, A( n' p5 H1 Y
87.     {  
    
88.         if (length < 0)  
    % H' ]) a: f# w" m
89.         {  
    
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    
91.             break;  
    
92.         }  
    4 [. Z9 b, f+ @2 e' c5 \
93. 
    
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    $ O( D7 d/ r: @  n! o/ P
95.         if (write_length < length)  
    / T& F! p  Y+ K# I# G% q! m
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    
98.             break;  
    
99.         }  
    
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     3 d! ]1 ]$ S. t
102. 
     / G. y0 u+ L4 L7 b  P. {
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     ( m+ Y8 W: B- I$ h$ A: A" e
104. 
     
105.     // 传输完毕，关闭socket   
     
106.     fclose(fp);  
     
107.     close(client_socket);  
     + T* g# o, {" t0 F8 X- G/ z
108.     return 0;  
     : Y. e3 o1 B" J
109. 
     ! o" e5 W& H1 k# s" G) ~% A
110. }  
     1 \4 I% I' Q2 E' h+ _  v, s( x# c
111. 
     

复制代码

1. /*server.c*/
     f+ z) |1 T' V9 S
2. #include<netinet/in.h>
   . q: j3 ^1 J5 E) v
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   ; t7 `* Y' g0 B& _0 I# `
6. #include<stdlib.h>
   6 t! k- A0 v! V
7. #include<string.h>
   
8. 
   
9. #define HELLO_WORLD_SERVER_PORT    6666         //端口号
   : |9 R2 u) Z. y
10. #define LENGTH_OF_LISTEN_QUEUE     20
    
11. #define BUFFER_SIZE                1024
    9 L( o- T- _6 m3 p9 x
12. #define FILE_NAME_MAX_SIZE         512
    
13. 
    
14. int main(int argc, char **argv)
    
15. {
    1 I9 e( ?! {3 ?( Z1 i
16.     // set socket's address information
    
17.     // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    # |) {' ~7 J$ S, A: z: N& f, r/ s
18.     struct sockaddr_in   server_addr;
    & r+ _9 p, Q' c5 o5 B1 d# t  K/ n
19.     bzero(&server_addr, sizeof(server_addr));
    4 K8 Q; e3 V0 N+ y: m/ v
20.     server_addr.sin_family = AF_INET;
    
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    : y$ G0 B, |* D2 j+ b$ f6 |
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    
23. 
    
24.     // create a stream socket
    
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    , }6 L1 j; j4 P8 I* m+ e7 v) u
27.     if (server_socket < 0)
    7 c) q9 S3 f* }" }0 s% }4 s% c
28.     {
    ' T, Y1 G5 a& b* H
29.         printf("Create Socket Failed!\n");
    ; Y; L5 J7 b. z, F$ P' D3 X
30.         exit(1);
    0 ?9 B: H8 {: \2 R  E, t
31.     }
    : h# X! [  T- F$ X9 g: z' r8 ^, i
32. 
    & T4 K' S9 V  k1 [% h$ q
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    ' x9 M# J- U3 M) B
35.     {
    
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    . u5 {0 G' \& H% l
37.         exit(1);
    . @/ S* |4 l0 f' z: l$ ~8 Q
38.     }
    - }5 ]+ t  W0 T+ E3 T
39. 
    . x5 s- ^. P. L7 X5 c
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    
42.     {
    
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    
46. 
    4 Z& b& l. K' e( E& g; J8 O
47.     // 服务器端一直运行用以持续为客户端提供服务
    * r+ U$ _( R$ |- f0 q8 s
48.     while(1)
    
49.     {
    ; g# L2 @3 c4 g: Y! Y; O
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    2 k, F0 M1 |0 p+ u; ~9 Q+ m3 P
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    3 g5 C$ s) I; v% F
52.         struct sockaddr_in client_addr;
    
53.         socklen_t          length = sizeof(client_addr);
    # X, S. t, r+ o4 D. ?
54. 
    , f; w* f3 W" x0 M  i0 m% k% j
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    # F* Z$ x$ B" f8 Y7 c) ^
57.         // 用select()来实现超时检测
    - i' N, X& t& M1 H  D7 u; f' q
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    " j1 |7 ]0 B; Q6 }
59.         // 这里的new_server_socket代表了这个通信通道
    
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    / }- f5 q* o" @: J- [* U; J) n4 D
61.         if (new_server_socket < 0)
    
62.         {
    % ]5 b% y4 ~- f* i) J7 N2 ?
63.             printf("Server Accept Failed!\n");
    
64.             break;
    " S) {/ [, ]# A! c8 I
65.         }
    
66. 
    
67.         char buffer[BUFFER_SIZE];
    1 W- i1 g" k8 g7 X0 c* [
68.         bzero(buffer, sizeof(buffer));
    
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    " Q. F2 s6 u) y6 [
70.         if (length < 0)
    
71.         {
    
72.             printf("Server Recieve Data Failed!\n");
    # L" e% s# Q  C, l1 ^
73.             break;
    0 z7 @- E+ b. ~# a% ?: [& ^
74.         }
    + t, n( B8 v% s0 x
75. 
    
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    , a5 X6 V$ Q# N# o! z, Y
78.         strncpy(file_name, buffer,
    & h6 B- O6 D& G, m+ X7 p
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    4 c, M: t* t7 J2 {
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    : x/ G5 m$ A0 l+ j- V
82.         if (fp == NULL)
    
83.         {
    
84.             printf("File:\t%s Not Found!\n", file_name);
    3 X; o  o( R$ N! i& Q6 d, Q. B/ y& g
85.         }
    / E- o& x* r  p
86.         else
    
87.         {
    ' M9 `+ m$ Q. M% p
88.             bzero(buffer, BUFFER_SIZE);
    . I) T$ H; L( C) Q
89.             int file_block_length = 0;
    3 k" f( x: n% y9 N- z* t0 _. u
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
    
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    / d0 n" A% D& V
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    : e. q- W  |: f3 Y
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    5 Z: X) \2 [  s. e6 r; t
97.                     printf("Send File:\t%s Failed!\n", file_name);
    9 O* e# P' U: C5 d, c
98.                     break;
    5 L& a. e# c5 E5 Q) f+ e: W
99.                 }
    
100. 
     9 _: a7 l8 f0 q' D1 d" {9 ^
101.                 bzero(buffer, sizeof(buffer));
     ) }. A. s  ~. }( Y
102.             }
     / x2 y% |: s- l/ O! O
103.             fclose(fp);
     ) ]( B) L" u8 J1 N3 K0 C9 ^
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     
106. 
     8 }; v0 h' q/ R, t& p( f# O: o
107.         close(new_server_socket);
     8 K8 Y  q* D% [: m$ y7 _4 n' ]
108.     }
     
109. 
     
110.     close(server_socket);
     + e/ E5 h3 }8 B% h% b$ m
111. 
     
112.     return 0;
     
113. }
     
114. 
     ( T. _! F, }4 T6 @5 H

复制代码

9 \, S* ]9 M2 Q7 x+ Y2 X0 }3 r4 z