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

admin

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

1. #include <stdlib.h>
   " J4 n- v8 S: t% o" C" t
2. #include <stdio.h>
   1 \, ^  M$ c  z1 B: A( U
3. #include <unistd.h>
   
4. #include <string.h>
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   3 ^! b+ P- e; r
7. #include <netinet/in.h>
   # ]1 S' C& y7 j; ]8 E
8. #include <netdb.h>  /* netdb is necessary for struct hostent */
   8 C% ~$ X: S+ {6 q% s: y
9. 
   
10. #define PORT 4321   /* server port */
    
11. 
    0 e; C* w; f" y+ {
12. #define MAXDATASIZE 100
    
13. 
    + [+ B) M  E; V8 C- |3 r$ \
14. int main(int argc, char *argv[])
    
15. {
    
16.     int sockfd, num;    /* files descriptors */
    " |% Y+ c4 ~1 `3 B+ q1 o0 Z
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;
    ! Z, H( M5 T* b
20.    
    
21.     if (argc != 2)
    
22.     {
    ( Y8 O2 l7 s* G/ a) N
23.         printf("Usage: %s <IP Address>\n",argv[0]);
    9 N4 j, h& B2 Y6 W
24.         exit(1);
    
25.     }
    * ^" \* Z7 ^( g) g, Y
26.    
    
27.     if((he=gethostbyname(argv[1]))==NULL)
    
28.     {
    
29.         printf("gethostbyname() error\n");
    ( l+ V( g# r- H. R
30.         exit(1);
    
31.     }
    1 T" @4 \# }6 ]
32.    
    9 Y& ^8 T5 U9 a% i7 O
33.     if((sockfd=socket(AF_INET,SOCK_STREAM, 0))==-1)
    
34.     {
    . R1 q. ?& T, k( r' [  S3 [
35.         printf("socket() error\n");
    7 ]. v! w/ x& s1 G
36.         exit(1);
    ' {& d6 e/ v2 |# Z" C* c
37.     }
    
38.     bzero(&server,sizeof(server));
    $ D: _. W2 E0 K1 j- k3 |8 H$ i% e
39.     server.sin_family = AF_INET;
    2 d5 G3 L2 M9 _
40.     server.sin_port = htons(PORT);
    3 k8 I8 G0 i7 T1 K; F
41.     server.sin_addr = *((struct in_addr *)he->h_addr);
    / p# o. t" Z1 b" t5 C
42.     if(connect(sockfd, (struct sockaddr *)&server, sizeof(server))==-1)
    
43.     {
    0 \  d8 D# O5 i  G. \
44.         printf("connect() error\n");
    
45.         exit(1);
    
46.     }
    ( V2 _# x* j$ {* Y/ y
47. 　　
    
48. 　　char str[] = "horst\n"
    
49. 
    ! i$ ?4 ]. L5 D% y
50.     if((num=send(sockfd,str,sizeof(str),0))==-1){
    ; G$ B1 y4 C1 u9 s/ Y) L8 p
51.         printf("send() error\n");
    
52.         exit(1);
    
53.     }
    ) {- V* K0 C! N9 T
54.     if((num=recv(sockfd,buf,MAXDATASIZE,0))==-1)
    : L$ C! W+ G* e6 k' s7 @
55.     {
    
56.         printf("recv() error\n");
    , B/ ^! K" `" ^
57.         exit(1);
    5 {% b  Q, z- g
58.     }
    
59.     buf[num-1]='\0';
    4 k2 Z! }+ S) |, o; a
60.     printf("server message: %s\n",buf);
    
61.     close(sockfd);
    3 ]5 _6 e. [+ h4 ]- B- y7 h' n6 m9 f+ b
62.     return 0;
    0 F# H8 f1 w0 Y( C' }
63. }

复制代码

（2）服务器端，编写server.c，内容如下
& J. s0 d: I7 N- }  W# ?, K

1. #include <sys/time.h>
     T8 |: [) F2 Q- R5 r' Q) f
2. #include <stdlib.h>
   
3. #include <stdio.h>
   $ g' t% s: `" _" ]/ i& u3 @
4. #include <string.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   - y6 i# ?0 b7 N( B7 e3 V
7. #include <sys/socket.h>
   
8. #include <netinet/in.h>
   
9. #include <arpa/inet.h>
   
10. 
    
11. #define PORT 4321
    
12. 
    . V9 o6 @% C" D9 X6 G! X5 q9 t3 A
13. #define BACKLOG 1
    
14. #define MAXRECVLEN 1024
    
15. 
    6 m  _- U; `( p5 F* j9 Z
16. int main(int argc, char *argv[])
    % K" ]2 D( K) G
17. {
    7 S: t/ H6 U$ s! g
18.     char buf[MAXRECVLEN];
    1 ^# O* k7 J- F  J2 ~* N8 W
19.     int listenfd, connectfd;   /* socket descriptors */
    + g) f  w. q3 v6 _. _: ^7 P% K; T
20.     struct sockaddr_in server; /* server's address information */
    
21.     struct sockaddr_in client; /* client's address information */
    
22.     socklen_t addrlen;
    
23.     /* Create TCP socket */
    * i4 a3 Q% H3 t9 {7 H
24.     if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
25.     {
    & C& V6 j: L7 H& k
26.         /* handle exception */
    * o/ l$ W& Q) G& M0 p
27.         perror("socket() error. Failed to initiate a socket");
    ' K% z: [5 T1 l7 M
28.         exit(1);
    3 Q6 `# r$ I; e' j' {& R
29.     }
    
30. 
      Q9 d0 A, C  E
31.     /* set socket option */
    
32.     int opt = SO_REUSEADDR;
    . q8 ?9 V9 ]8 a
33.     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
34. 
    
35.     bzero(&server, sizeof(server));
      ]/ q2 v# K/ h! _
36. 
    7 ]2 g9 d* O8 P" Z
37.     server.sin_family = AF_INET;
    3 h% z' w) d6 u! ~% @" }
38.     server.sin_port = htons(PORT);
    
39.     server.sin_addr.s_addr = htonl(INADDR_ANY);
    
40.     if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
    
41.     {
    ! O% B2 ?- ~7 a5 L6 ^7 S
42.         /* handle exception */
    . Y% s6 x1 s+ O! c& a1 w0 V
43.         perror("Bind() error.");
    
44.         exit(1);
    
45.     }
    
46.    
    1 m2 P4 X8 \9 l2 p
47.     if(listen(listenfd, BACKLOG) == -1)
    4 w' e1 m- z& c0 c  k
48.     {
    . r) M7 l( m  l3 u1 ?# M) A
49.         perror("listen() error. \n");
    7 s4 [8 l; Q9 e; L8 r& u- d
50.         exit(1);
    5 Y" ~6 g/ ~0 ~, x( |9 |
51.     }
    9 A4 `$ P% [6 @: H5 i8 t' s
52. 
    8 @6 d& V  c0 U3 P* n
53.     addrlen = sizeof(client);
    " |1 Q5 a' n6 {2 }% c
54.     while(1){
    
55.         if((connectfd=accept(listenfd,(struct sockaddr *)&client, &addrlen))==-1)
    
56.            {
    + a% o3 \* _9 a, ~5 Y0 j. @
57.             perror("accept() error. \n");
    
58.             exit(1);
    
59.            }
    4 S1 @) i5 |5 H+ q3 W9 @2 W
60. 
    
61.         struct timeval tv;
    
62.         gettimeofday(&tv, NULL);
    / v) O9 ^& z* k3 F
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;
    
66.         while(1)
    
67.         {
    
68.             iret = recv(connectfd, buf, MAXRECVLEN, 0);
    9 `* K8 n. i- Q$ r
69.             if(iret>0)
    ' ^. ^; U4 y7 O& B0 N3 R  o0 z
70.             {
    
71.                 printf("%s\n", buf);
    * @4 Q9 T; ]9 @( M1 w2 e
72.             }else
    & P* m8 a3 F$ ?- `& S, o  e8 A  V
73.             {
    
74.                 close(connectfd);
    
75.                 break;
    / Z  [" e" f; g& Y7 k& p% ?; m
76.             }
    
77.             /* print client's ip and port */
    * F6 m# o! P# P& `
78.             send(connectfd, buf, iret, 0); /* send to the client welcome message */
    8 X4 {+ d! K  G! Z# @7 Q8 X
79.         }
    
80.     }
    - m; l' k5 l' ?4 V# F
81.     close(listenfd); /* close listenfd */
    
82.     return 0;
    
83. }

复制代码

（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. 
   
3. server message:horst

复制代码

" E3 R+ V- h2 `6 z! A

服务器端：

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

; b# \) F/ I% _) |. {

admin

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

1. /*client.c*/
   
2. #include<netinet/in.h>                         // for sockaddr_in  
   , g. P* y9 x3 |. a
3. #include<sys/types.h>                          // for socket  
   % r# C! E$ G  z, f+ N6 `
4. #include<sys/socket.h>                         // for socket  
   0 g; U; _9 [  m, M6 ^' N
5. #include<stdio.h>                              // for printf  
   
6. #include<stdlib.h>                             // for exit  
   # W% y+ c9 @7 N* T9 Z* F# }) N
7. #include<string.h>                             // for bzero  
   . `5 b, X  R! y( B
8. 
   0 u4 g7 Y! w0 s4 x
9. #define HELLO_WORLD_SERVER_PORT       6666  
   ; t" Q% p- Q4 d( L- I" ?/ u
10. #define BUFFER_SIZE                   1024  
    
11. #define FILE_NAME_MAX_SIZE            512  
    . J  F7 i$ F2 S9 U* Q
12. 
    , \) `& y3 g4 B( J# I; U
13. int main(int argc, char **argv)  
    ) t8 r, d+ e- {* w: ^1 |: ^& _
14. {  
    
15.     if (argc != 2)  
    
16.     {  
    4 `. M% [* o  L& y
17.         printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
    0 S' {$ c0 A$ T* U' n9 |. F
18.         exit(1);  
    ; O$ K* |9 R: I( c1 f& `
19.     }  
    
20. 
    8 C) x: Y; l7 G1 v! Y6 d
21.     // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    3 N0 O# {. ?2 {
22.     struct sockaddr_in client_addr;  
    ) O& Q# i9 l$ s
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表示自动获取本机地址  
    6 b: n/ g/ V# D* [8 x/ z
26.     client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口  
    7 D7 s2 _, j9 }$ b: {! q* C
27. 
    
28.     // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket  
    ; u+ n6 J5 k6 `3 E
29.     int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
      I$ P5 e" R6 d! L( @
30.     if (client_socket < 0)  
    
31.     {  
    
32.         printf("Create Socket Failed!\n");  
    ' E8 H" j5 P# c1 A% k7 c
33.         exit(1);  
    
34.     }  
    ; a% p$ B/ G! l
35. 
    
36.     // 把客户端的socket和客户端的socket地址结构绑定   
    
37.     if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    
38.     {  
    ! D9 M8 |- R: c) h) W4 u' r
39.         printf("Client Bind Port Failed!\n");  
    & m& ^9 I* F1 M* `; q% D7 l
40.         exit(1);  
    
41.     }  
    
42. 
    - q- K) x# k0 ?3 H2 M% }
43.     // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    " N* P; w3 I# d1 D$ P
44.     struct sockaddr_in  server_addr;  
    ! `6 U$ ~  [, ~- R
45.     bzero(&server_addr, sizeof(server_addr));  
    " H  S( q8 D9 F" |
46.     server_addr.sin_family = AF_INET;  
    
47. 
    6 S5 j, U$ ?' C$ V& s
48.     // 服务器的IP地址来自程序的参数   
    . B! S3 \2 ]9 f  y' |% B
49.     if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    
50.     {  
    + z: [4 }( e$ }: V$ N& l" ~
51.         printf("Server IP Address Error!\n");  
    
52.         exit(1);  
    / \" D5 @) s! T* j9 i
53.     }  
    1 U8 G4 u/ m  N, M2 }. N( T
54. 
    1 r" t, Q6 l% }7 M6 M
55.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    1 f' n, P! ?' K) M
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 _8 i/ F/ x; L3 ]0 ]- D' ^" o% H  M
60.     {  
    & ~# q4 K/ k4 y% u: u
61.         printf("Can Not Connect To %s!\n", argv[1]);  
    
62.         exit(1);  
    
63.     }  
    8 F$ m" m' l. W# P6 v2 d
64. 
    : a3 `- B: \- k0 Q% W; S9 I
65.     char file_name[FILE_NAME_MAX_SIZE + 1];  
    * P" R+ D9 D! O+ v1 [: g
66.     bzero(file_name, sizeof(file_name));  
    
67.     printf("Please Input File Name On Server.\t");  
    
68.     scanf("%s", file_name);  
    . [, i  l7 k. n% E; j$ O. e' O' o
69. 
    
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));  
    + {. B; X/ R- L; ]+ D0 I
73.     // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    
74.     send(client_socket, buffer, BUFFER_SIZE, 0);  
    
75. 
    # p/ \. a% D# H4 p+ l; ?
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);  
    
80.         exit(1);  
    ! h- Q2 N3 j8 \* B
81.     }  
    " E" x+ E9 G$ Y6 g& G& k" H
82. 
    5 X; P' w. K) |9 b$ e1 }
83.     // 从服务器端接收数据到buffer中   
    
84.     bzero(buffer, sizeof(buffer));  
    ) A6 @8 ], t6 }4 C1 e
85.     int length = 0;  
    6 l; w. s( W+ X! R; O2 Q; W/ m" J
86.     while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    % o- c+ _  F) h  x/ l" q' j& U
87.     {  
    , r  l" i& p& g- T% |
88.         if (length < 0)  
    
89.         {  
      f+ C3 O6 r8 B2 o8 q0 X2 u) r
90.             printf("Recieve Data From Server %s Failed!\n", argv[1]);  
    , X* k+ N$ Q6 t1 v+ }% e
91.             break;  
    8 e, l1 v& }! N. v) D5 w. I. f/ n
92.         }  
    
93. 
    ! z5 }' P  k1 U! u. m& k
94.         int write_length = fwrite(buffer, sizeof(char), length, fp);  
    
95.         if (write_length < length)  
    
96.         {  
    
97.             printf("File:\t%s Write Failed!\n", file_name);  
    8 Z' V  l% E0 ]0 b, y0 ]) r! {
98.             break;  
    
99.         }  
    0 b5 q) H. }* K( H2 L: m
100.         bzero(buffer, BUFFER_SIZE);  
     
101.     }  
     , f+ f3 ~, `- F. O* c8 z5 m
102. 
     
103.     printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
     " q' ^, y- M' V# H( i
104. 
     7 R9 |4 o2 Y& n+ \* }
105.     // 传输完毕，关闭socket   
     . c7 H: i, b' ~: `1 g# e  g- ^2 e/ w
106.     fclose(fp);  
     
107.     close(client_socket);  
     ( [6 y" O( W. Y$ E1 ~
108.     return 0;  
     8 V8 G5 T9 A6 U, P7 X; r
109. 
     0 R5 D* M- B+ L
110. }  
     
111. 
     

复制代码

1. /*server.c*/
   
2. #include<netinet/in.h>
   2 p  Q% [9 R$ `7 c$ D* X& d' C& V
3. #include<sys/types.h>
   
4. #include<sys/socket.h>
   
5. #include<stdio.h>
   . E+ u( Q. U# N
6. #include<stdlib.h>
   8 v0 Z* D3 ^+ ^3 a5 B( C, B
7. #include<string.h>
   3 R" b- q( {( @5 P' ?9 x
8. 
   
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
    ) q5 C4 t  t/ A* _5 ^
13. 
    
14. int main(int argc, char **argv)
    
15. {
    - u& e( |( ~  B* V- B/ h' S9 B, W
16.     // set socket's address information
    4 \; M* {( e$ k: w5 y* i' ]5 {
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;
    2 l+ b3 R4 ?% y/ f5 P/ U" s
21.     server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    
22.     server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    6 J+ }. d5 _. z
23. 
    # ]+ h/ H+ N: c4 J
24.     // create a stream socket
    0 h7 K( u; |9 }$ Q# d0 _8 V
25.     // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    
26.     int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    
27.     if (server_socket < 0)
    9 M- |* t* v  l7 w% k3 Z2 r
28.     {
    
29.         printf("Create Socket Failed!\n");
    
30.         exit(1);
    6 P: z: Y; c6 a( Y3 A+ H3 U5 m! M& M6 O
31.     }
    
32. 
    
33.     // 把socket和socket地址结构绑定
    
34.     if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    
35.     {
    9 T' b/ a! L8 k/ y- F3 V
36.         printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
    6 }$ u- K4 C' x& \1 K
37.         exit(1);
    
38.     }
    5 f3 V& g* I* q+ f4 Q
39. 
    
40.     // server_socket用于监听
    
41.     if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    & J2 Y3 s( d) b' O$ j1 u0 P
42.     {
    6 {3 ?* s, I2 M) T- n! c9 Y
43.         printf("Server Listen Failed!\n");
    
44.         exit(1);
    
45.     }
    
46. 
    " h) b6 S! Z, k# `. J) B
47.     // 服务器端一直运行用以持续为客户端提供服务
    
48.     while(1)
    
49.     {
    
50.         // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept
    ( B2 C" V# E6 Y6 m3 a
51.         // 接受此请求，同时将client端的地址和端口等信息写入client_addr中
    0 z4 j& G, E# C; Q: n6 P0 v* V, o1 h3 g
52.         struct sockaddr_in client_addr;
    + B1 W5 l9 Z& d- }$ }/ w4 [
53.         socklen_t          length = sizeof(client_addr);
    
54. 
      w2 v) i9 M9 x8 I0 G
55.         // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中
    
56.         // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性，可以
    . n# Y+ u# I! [8 S- L( E/ w$ Y
57.         // 用select()来实现超时检测
    8 r+ l' _* h" r3 i, M- }0 Y
58.         // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信
    ) j9 F. Z8 R2 s2 h
59.         // 这里的new_server_socket代表了这个通信通道
    " U  i8 O2 J  N8 z$ j
60.         int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
    
61.         if (new_server_socket < 0)
    $ ^4 R; l2 ?8 p- u7 M* O
62.         {
    
63.             printf("Server Accept Failed!\n");
    % q: g. u8 `' d4 a3 k& p
64.             break;
    
65.         }
    / p& v) R! ]8 ^; \' K: q
66. 
    
67.         char buffer[BUFFER_SIZE];
    
68.         bzero(buffer, sizeof(buffer));
    ( W% u1 h# N/ g" i- c3 ~6 F
69.         length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
    3 a7 v$ J  l! V! n# {
70.         if (length < 0)
    
71.         {
    0 R9 c* H. j3 R' T2 R9 _3 C
72.             printf("Server Recieve Data Failed!\n");
    9 W9 y, J( Z' ]) o
73.             break;
    
74.         }
    1 t# ]4 p5 T/ _" ?' F1 O8 E
75. 
    3 s. ?! _4 v: M* Z3 I6 D
76.         char file_name[FILE_NAME_MAX_SIZE + 1];
    
77.         bzero(file_name, sizeof(file_name));
    , V1 R# h- v0 ~+ u  [
78.         strncpy(file_name, buffer,
    
79.                 strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));
    & P/ Z3 ]" `+ i; X' `7 w+ k5 n1 @
80. 
    
81.         FILE *fp = fopen(file_name, "r");
    
82.         if (fp == NULL)
    ! |4 C. M6 A2 {2 J  D" v
83.         {
    - \5 }! f# Y& J6 b+ [" v! w: [
84.             printf("File:\t%s Not Found!\n", file_name);
    # N* C& m% v# a
85.         }
    , y& \! {  |) b7 r2 w7 \2 G
86.         else
    & }( s( p" }; `( @
87.         {
    " Z" Z2 C/ t; t& T" u$ s% n
88.             bzero(buffer, BUFFER_SIZE);
    8 o0 f# B! V# h/ h
89.             int file_block_length = 0;
    
90.             while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
    
91.             {
    4 c9 z  W) m' k/ x
92.                 printf("file_block_length = %d\n", file_block_length);
    
93. 
    , q' e# U7 ]0 N+ W
94.                 // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
    / n0 I& R2 u" ?
95.                 if (send(new_server_socket, buffer, file_block_length, 0) < 0)
    
96.                 {
    ( n8 |& `  d* a/ ]# v* V! J0 v
97.                     printf("Send File:\t%s Failed!\n", file_name);
    
98.                     break;
    2 Z# v# ^: y" `( c
99.                 }
    ; [; J4 @; H/ F7 S
100. 
     : c2 D* _6 O% b4 z
101.                 bzero(buffer, sizeof(buffer));
     * X$ A6 @* t8 }$ R. \" c
102.             }
     9 y, s6 ~5 ?! B+ q
103.             fclose(fp);
     # q, s3 Y* `7 m+ c
104.             printf("File:\t%s Transfer Finished!\n", file_name);
     
105.         }
     $ x9 c; k2 {* g/ c
106. 
     
107.         close(new_server_socket);
     8 {( V# F- s+ ]( p* @
108.     }
     ) w8 g+ ]+ r* `: Y- _. d/ _
109. 
     , t2 ?7 }! H1 v8 t9 W# x
110.     close(server_socket);
     
111. 
     " t, V3 B/ l$ O( L  X4 C
112.     return 0;
     . M; l# F5 A- d; g+ @
113. }
     
114. 
     

复制代码

, `: |% _7 I8 O# e( m+ x1 b2 P( i0 Y9 ^
- R' ?& T0 S: J( i