1、UDP Client

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team *
   , c4 T' w3 n' p0 O# M
3. * SPDX-License-Identifier: Apache-2.0 *
   
4. * Change Logs: * Date            
   
5. Author      Notes *
   ) P/ |+ ~0 i% q6 ~/ N. v8 t( X9 t
6. */
   ' z( `* T0 d5 M3 c% s
7. /*
   
8. * 程序清单：udp 客户端 *
   
9. * 这是一个 udp 客户端的例程
   ) D* {0 R8 d: t3 `5 c# _0 ?1 }3 P$ @
10. * 导出 udpclient 命令到控制终端
    - u1 J- z( C7 N( j0 V0 e
11. * 命令调用格式：udpclient URL PORT [COUNT = 10]
    ' w; h2 G+ S0 h& R
12. * URL：服务器地址  PORT：端口号  COUNT：可选参数 默认为 10
    
13. * 程序功能：发送 COUNT 条数据到服务远端
    & k+ W9 s. T7 j& f
14. */
    
15. #include <rtthread.h>
    1 U7 G4 d& ?* S6 P$ {$ A
16. #include <sys/socket.h> /* 使用BSD socket，需要包含sockets.h头文件 */
    8 |0 i4 }# P& `0 ?
17. #include <netdb.h>
    
18. #include <string.h>
    $ l; M- f2 \  r0 C6 u
19. #include <finsh.h>
    
20. 
    9 s0 D1 C4 I, s/ S
21. const char send_data[] = "This is UDP Client from RT-Thread.\n";
    ; b3 L. n5 h5 G# {( F, j$ O
22. /* 发送用到的数据 */
    
23. void udpclient(int argc, char **argv)
    
24. {
    
25.     int sock, port, count;
    
26.     struct hostent *host;
    ; q. r! m& P, t8 o
27.     struct sockaddr_in server_addr;
    
28.     const char *url;
    7 |0 i0 N( L/ B% d
29.     if (argc < 3)
    $ k# a( Y7 \9 a& W
30.         {
    
31.             rt_kprintf("Usage: udpclient URL PORT [COUNT = 10]\n");
    0 i6 g; |# Z/ X, D
32.             rt_kprintf("Like: tcpclient 192.168.1.9 8000\n");
    0 D* _' s% ?0 O
33.             return ;
    
34.         }
      J8 k! ]8 q2 Z/ G
35.     url = argv[1];
    
36.     port = strtoul(argv[2], 0, 10);
    / l+ h$ I% [) t; S/ [" O
37.     if (argc > 3)
    ! T- f' W9 X& k2 w4 R; q
38.         count = strtoul(argv[3], 0, 10);
    " h4 M4 [# @; H; R/ ~
39.     else
    
40.         count = 10;
    0 c+ ]  H1 M9 ]/ P6 g! X  q  d
41.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    7 z. N2 h3 i5 N5 [/ d
42.     host = (struct hostent *) gethostbyname(url);
    
43.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    6 {# H; q& T: c) ?
44.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    9 W, S' `/ O% f
45.         {
    3 F" H2 s9 s  Y" V* q
46.             rt_kprintf("Socket error\n");
    3 A: u6 L& p' L+ E$ Q
47.             return;
    ' }, H2 W. ~2 ?* L  T$ m: l
48.         }
    & r' O8 ]0 ]. C* |( T& |7 k" z
49.     /* 初始化预连接的服务端地址 */
    
50.     server_addr.sin_family = AF_INET;
    . j/ b* C( }' J4 ]* O+ [. A# Y
51.     server_addr.sin_port = htons(port);
    : Z8 l8 D4 c/ ~# S
52.     server_addr.sin_addr = *((struct in_addr *)host->h_addr);
    
53.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    
54.     /* 总计发送count次数据 */
    " k7 }! ^) }" w6 c
55.     while (count)
    7 q  g# a% E  i( o) W
56.         {
    
57.             /* 发送数据到服务远端 */
    
58.             sendto(sock, send_data, strlen(send_data), 0,               (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
    8 r+ n# V$ E$ S' Z; Y& M7 K
59.             /* 线程休眠一段时间 */
    
60.             rt_thread_delay(50);
    
61.             /* 计数值减一 */
    
62.             count --;
    
63.         }
    
64.     /* 关闭这个socket */
    , W( r( Z+ C1 p3 `# k( _- S% Y
65.     closesocket(sock);
    
66. }
    
67. MSH_CMD_EXPORT(udpclient, a udp client sample);
    
68. 
    

复制代码

2、UDP Server
) \, _2 G7 [$ W. e8 ^6 `3 l% V) }

1. #include <rtthread.h>
   2 A9 f1 [# Y8 r0 h7 G4 v% a
2. #include <sys/socket.h>
   
3. /* 使用BSD socket，需要包含socket.h头文件 */
   
4. #include <netdb.h>
   
5. #include <string.h>
   6 F  X' X6 t$ G( `+ U
6. #include <finsh.h>
   
7. #define BUFSZ   1024
   
8. static void udpserv(int argc, char **argv)
   
9. {
   / o8 i: u; }' ?7 L5 O+ @
10.     int sock;
    - _0 o1 H1 P. M  S. O) \
11.     int bytes_read;
    
12.     char *recv_data;
    
13.     socklen_t addr_len;
    3 v8 _$ H# v( J$ p
14.     struct sockaddr_in server_addr, client_addr;
    
15.     /* 分配接收用的数据缓冲 */
    2 g7 _9 a/ d6 t( g
16.     recv_data = rt_malloc(BUFSZ);
    9 R+ q3 B1 y% P# X
17.     if (recv_data == RT_NULL)
    
18.         {
    
19.             /* 分配内存失败，返回 */        
    , \+ B' Q- s9 \
20.                         rt_kprintf("No memory\n");
    & @* x# G; T' a/ e
21.             return;
    ( R- N" g/ l! k
22.         }
    6 U/ V; `7 P1 s- ?% l
23.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    , M8 s4 u; g- ]1 D4 m2 T" D
24.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    & }0 ]! T6 x& ]& V. Q
25.         {
    " D- \# P( v$ ]; o9 j7 E0 y7 u3 X
26.             rt_kprintf("Socket error\n");
    4 v; {3 g) R" K. V# Q7 S9 ?
27.             /* 释放接收用的数据缓冲 */        
    $ G+ u, \6 O1 D; N! ~- c
28.                         rt_free(recv_data);
    
29.             return;
    
30.         }
    
31.     /* 初始化服务端地址 */
    
32.     server_addr.sin_family = AF_INET;
    
33.     server_addr.sin_port = htons(5000);
    
34.     server_addr.sin_addr.s_addr = INADDR_ANY;
    
35.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    
36.     /* 绑定socket到服务端地址 */
    
37.     if(bind(sock, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) == -1)
    
38.         {
    2 F9 w: R. I; a7 Q% {- k+ [
39.             /* 绑定地址失败 */
    2 \( E7 {7 k6 [/ a6 _! N: g
40.             rt_kprintf("Bind error\n");
    
41.             /* 释放接收用的数据缓冲 */
    
42.             rt_free(recv_data);
    
43.             return;
    : r% i+ T! Z; `6 D
44.         }
    7 _  p7 y4 k8 W% x% p, g3 K7 ^2 U
45.     addr_len = sizeof(struct sockaddr);
    , r9 q1 K: w- @$ E6 l( B4 q
46.     rt_kprintf("UDPServer Waiting for client on port 5000...\n");
    - j$ A- m8 j0 O! f
47.     while (1)
    
48.         {
    
49.             /* 从sock中收取最大BUFSZ - 1字节数据 */
    ; o  @! c7 j* R) t  k( v1 u4 |& p9 j3 |
50. 
    
51.             bytes_read = recvfrom(sock, recv_data, BUFSZ - 1, 0,
    9 w, f- ~4 @6 z3 u+ p+ f
52.                                   (struct sockaddr *)&client_addr, &addr_len);
    
53.             /* UDP不同于TCP，它基本不会出现收取的数据失败的情况，除非设置了超时等待 */
    
54.             recv_data[bytes_read] = '\0';         /* 把末端清零 */
    2 B2 F6 b$ ~' R! a3 }
55.             /* 输出接收的数据 */
    
56.             rt_kprintf("\n(%s , %d) said : ", inet_ntoa(client_addr.sin_addr),
    , |& C* j2 f& |. |+ L# V; E$ i
57.                        ntohs(client_addr.sin_port));
    
58.             rt_kprintf("%s \n", recv_data);
    
59.                         //udp 用 sendto 函数发送
    
60.                         sendto(sock,recv_data,bytes_read,0,(struct sockaddr *)&client_addr,addr_len);
    
61.             /* 如果接收数据是exit，退出 */        
    ( G% ]% M4 T* |
62.                         if (strcmp(recv_data, "exit") == 0)
    . E1 J( `: m! B: A% z4 Q" @
63.                 {
    ( W8 {9 t+ `' t/ Q/ G6 N
64.                     closesocket(sock);            /* 释放接收用的数据缓冲 */
    ; [  l! Z7 S$ i2 X2 I3 N
65.                     rt_free(recv_data);
    
66.                     break;
    
67.                 }
    
68.         }
    7 J( [* M. L6 m3 {- E5 a
69.     return;
    % g  e5 R: o+ q1 V+ V7 p! q! p
70. }
    1 X1 G4 T0 l6 P1 n- X+ r7 ~
71. 
    ( S  V$ y, j" Y% T
72. MSH_CMD_EXPORT(udpserv, a udp server sample);
    

复制代码

3、TCP Client

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   
3. *
   
4. * SPDX-License-Identifier: Apache-2.0 *
   
5. * Change Logs:
   ; m( _$ x1 Q" o8 X+ m
6. * Date             Author      Notes *
   
7. */
   
8. /*
   
9. * 程序清单：tcp 客户端
   
10. *
    
11. * 这是一个 tcp 客户端的例程
    ! {; q8 ^; s9 E4 }$ q8 M0 w. f
12. * 导出 tcpclient 命令到控制终端
    . o1 }+ G. ^' X5 I8 [; k; X* X
13. * 命令调用格式：tcpclient URL PORT
    
14. * URL：服务器地址 PORT:：端口号
    , g1 J8 c) ~! ?' P  o3 ]& C" H/ `4 ?
15. * 程序功能：接收并显示从服务端发送过来的信息，接收到开头是 'q' 或 'Q' 的信息退出程序
    
16. */
    0 G* V# `8 w3 u
17. #include <rtthread.h>
    
18. #include <sys/socket.h>
    7 ^3 f( o* B# I) Q& \) N
19. /* 使用BSD socket，需要包含socket.h头文件 */
    $ v) [( G5 t, r/ V+ Q2 x* t% `
20. #include <netdb.h>
    
21. #include <string.h>
    
22. #include <finsh.h>
    % z) ]% T) o2 ~3 U+ @. ?
23. #define BUFSZ   1024
    
24. static
    
25. const char send_data[] = "This is TCP Client from RT-Thread.";
    7 d# l3 E+ P/ E' R* D
26. /* 发送用到的数据 */
    
27. void tcpclient(int argc, char **argv)
    6 P$ k* b, i$ L5 X/ X" _
28. {
    # s3 t, W2 [9 h% `; R* d
29.     int ret;
    
30.     char *recv_data;
    
31.     struct hostent *host;
    5 J8 N+ F& p) D. i
32.     int sock, bytes_received;
    . p4 d) k! z* s- D# [) G( o3 A
33.     struct sockaddr_in server_addr;
    / b+ j3 M/ L4 q* y5 N. |: K6 p
34.     const char *url;
    
35.     int port;
    / B' p6 T! z" w7 [2 T$ w! Y
36.     if (argc < 3)
    9 Z' f# v0 r# V) x
37.         {
    ; A. E* ^0 P: M7 q3 H9 X
38.             rt_kprintf("Usage: tcpclient URL PORT\n");
    , b  ?. c5 e% i7 l
39.             rt_kprintf("Like: tcpclient 192.168.12.44 5000\n");
    , ^3 ?0 c$ ^5 s4 ~) x% F
40.             return ;
    ; r. h4 D& \. p5 _: B* u* W# p/ f
41.         }
    
42.     url = argv[1];
    
43.     port = strtoul(argv[2], 0, 10);
    
44.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    6 `4 q, t; m6 ?7 T$ K/ X9 k" f
45.     host = gethostbyname(url);
    
46.     /* 分配用于存放接收数据的缓冲 */
      o- v8 H  o4 s( Y+ |6 t- {
47.     recv_data = rt_malloc(BUFSZ);
    
48.     if (recv_data == RT_NULL)
    
49.         {
    
50.             rt_kprintf("No memory\n");
    " W- i. N& R7 D5 F# w1 C/ n$ Z
51.             return;
    2 h$ I+ l6 I7 I( K7 h. d3 V. P0 U) E
52.         }
    
53.     /* 创建一个socket，类型是SOCKET_STREAM，TCP类型 */
    
54.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
55.         {
    
56.             /* 创建socket失败 */
    ! s6 T" y0 {* d/ N4 U* O
57.             rt_kprintf("Socket error\n");
    
58.             /* 释放接收缓冲 */
    7 H, F; L+ C' ?& X) L
59.             rt_free(recv_data);
    6 ]5 ?! _$ P2 T/ d4 W, {$ O; b8 J
60.             return;
    5 P  U) L+ L  n/ C
61.         }
    
62.     /* 初始化预连接的服务端地址 */
    6 x+ O8 A4 R+ n: ?
63.     server_addr.sin_family = AF_INET;
    " s% H- N0 j$ z  V  E  b/ ?
64.     server_addr.sin_port = htons(port);
    
65.     server_addr.sin_addr = *((struct in_addr *)host->h_addr);
    8 S* o8 X% p( u9 ]! N! e* ~
66.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    1 b: V* e, D$ `6 P  j1 P
67.     /* 连接到服务端 */
    
68.     if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    ; [5 p& x* w7 L5 x; @1 j8 y
69.         {
    
70.             /* 连接失败 */
    
71.             rt_kprintf("Connect fail!\n");
    ; \2 A/ ]5 C+ a
72.             closesocket(sock);
    7 ]$ n; H; o9 ?! P) S& S, m
73.             /*释放接收缓冲 */
    
74.             rt_free(recv_data);
    & c- F$ }4 R% Q( ]
75.             return;
    
76.         }
    - O( R! \' i2 W* y  V
77.     while (1)
    
78.         {
    
79.             /* 从sock连接中接收最大BUFSZ - 1字节数据 */
    
80.             bytes_received = recv(sock, recv_data, BUFSZ - 1, 0);
    
81.             if (bytes_received < 0)
    + R/ \' [3 s2 O' i. n3 \' Q
82.                 {
    
83.                     /* 接收失败，关闭这个连接 */
    ( }! |: i2 o* `  E8 ?! X
84.                     closesocket(sock);
    
85.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    5 `& c/ g' r6 F
86.                     /* 释放接收缓冲 */
    
87.                     rt_free(recv_data);
    # ~3 n2 M( g, \1 @2 p% @6 ~6 a
88.                     break;
    ( {! n$ d7 W8 F* h% i6 s
89.                 }
    9 m  N, Q7 g" d, }( S5 x. z4 m
90.             else if (bytes_received == 0)
    ! @( L* Y6 S0 [- F% N
91.                 {
      h4 I, e' ~  w) t2 G% F
92.                     /* 默认 recv 为阻塞模式，此时收到0认为连接出错，关闭这个连接 */
    * V: X0 C! A# `
93.                     closesocket(sock);
    6 T  z8 B. ^9 S! O+ d* U
94.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    . H- H/ I8 o) q/ u  c% z, q
95.                     /* 释放接收缓冲 */
    4 E9 V' }" I& a2 c% p
96.                     rt_free(recv_data);
    
97.                     break;
    
98.                 }
    & D" m( P" G5 k7 _: O3 I- ?) O  P
99.             /* 有接收到数据，把末端清零 */
    + L3 f1 R; N. N* c
100.             recv_data[bytes_received] = '\0';
     ; I; x$ w0 F8 K  i+ R6 H) O! N1 h3 Y
101.             if (strncmp(recv_data, "q", 1) == 0 || strncmp(recv_data, "Q", 1) == 0)
     $ C: b( F- M8 y4 g
102.                 {
     
103.                     /* 如果是首字母是q或Q，关闭这个连接 */
     6 R. G. M( k8 g' n
104.                     closesocket(sock);
     # L. i. C" i. z" e
105.                     rt_kprintf("\n got a 'q' or 'Q',close the socket.\r\n");
     : ]; D* y6 a2 Z7 x6 m+ V
106.                     /* 释放接收缓冲 */
     
107.                     rt_free(recv_data);
     0 W- ~! p; b8 R( A
108.                     break;
     # r+ ?; f4 q8 I# |
109.                 }
     
110.             else
     2 J6 U. [# {( j  ?# v( e" L
111.                 {
     : S; x* O4 M; T, x- B6 E
112.                     /* 在控制终端显示收到的数据 */
     
113.                     rt_kprintf("\nReceived data = %s ", recv_data);
     
114.                 }        /* 发送数据到sock连接 */
     
115.             ret = send(sock, send_data, strlen(send_data), 0);
     ( b: g7 p+ y* z' k
116.             if (ret < 0)
     2 _9 T7 a  H6 k, ?% D
117.                 {
     ( }. c' p( G5 E: }. P. F* I7 L
118.                     /* 接收失败，关闭这个连接 */
     + E3 j& H8 _3 j5 A
119.                     closesocket(sock);
     
120.                     rt_kprintf("\nsend error,close the socket.\r\n");
     
121.                     rt_free(recv_data);
     - w0 E. z5 ~- ?2 B0 s/ [
122.                     break;
     ( ^/ i) |1 O3 I7 X0 u9 b6 P
123.                 }
     / B* I7 S- o+ S! k) `3 K
124.             else if (ret == 0)
     $ Q0 B& T2 f* j; c, t0 u
125.                 {
     
126.                     /* 打印send函数返回值为0的警告信息 */
     
127.                     rt_kprintf("\n Send warning,send function return 0.\r\n");
     . ^7 z. p) p% U. w) ~( ]
128.                 }
     6 i) ?; n5 }6 g5 P  U: G4 L" g. P4 k
129.         }
     
130.     return;
     
131. }
     0 F4 r8 m1 L4 Q# j; z
132. MSH_CMD_EXPORT(tcpclient, a tcp client sample);
     ) C9 T0 g: |, V! p# V

复制代码

4、TCP server
) F! p4 C* g: R

1. /*
   3 B$ ^3 G' I. t" E0 L
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   
3. *
   " e. y. @& o! n! r7 q
4. * SPDX-License-Identifier: Apache-2.0
   # o; j3 e. `% C% o+ b
5. *
   
6. * Change Logs:
   3 Q# t. H- o& }" n2 \% j# }) w7 f
7. * Date             Author      Notes
   
8. *
   ! V1 y7 O+ r, i2 w& c
9. */
   
10. /*
    5 v% e7 r/ R9 I6 E2 G0 R1 }0 T7 O
11. * 程序清单：tcp 服务端
    
12. *
    
13. * 这是一个 tcp 服务端的例程
    6 I) z- W/ w% i! u5 X7 V- ]
14. * 导出 tcpserv 命令到控制终端
    # B0 G7 t7 _2 t! k( L
15. * 命令调用格式：tcpserv
    
16. * 无参数
    
17. * 程序功能：作为一个服务端，接收并显示客户端发来的数据 ，接收到 exit 退出程序
    $ C6 u# ]; P$ c, ~) f: O
18. */
    ) k3 K. {: g0 [
19. #include <rtthread.h>
    
20. #include <sys/socket.h>
    
21. /* 使用BSD socket，需要包含socket.h头文件 */
    
22. #include <netdb.h>
    0 v. c. |9 U; s3 T/ h" D
23. #include <string.h>
    
24. #include <finsh.h>
    4 y$ B5 M* z8 J3 h# L
25. #define BUFSZ       (1024)
    4 h4 o* E/ g& C1 m9 i1 {+ l
26. static const char send_data[] = "This is TCP Server from RT-Thread.";
    
27. /* 发送用到的数据 */
    
28. static void tcpserv(int argc, char **argv)
    $ g% F  v& Y: t/ d3 |
29. {
    
30.     char *recv_data;
    
31.     /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
    7 K# B( S, I' G8 x$ P: Q& m' W. k% I
32.     socklen_t sin_size;
    - W+ B3 u; p$ ]* g
33.     int sock, connected, bytes_received;
    6 T4 I$ {6 f1 p3 p
34.     struct sockaddr_in server_addr, client_addr;
    
35.     rt_bool_t stop = RT_FALSE;
    1 I3 _6 b! `$ P9 S
36.     /* 停止标志 */
    3 ~% U% J6 u- c5 P
37.     int ret;
    8 r8 @% Y2 ?# m3 L: Q8 M) b/ Y
38.     recv_data = rt_malloc(BUFSZ + 1);
    8 L$ O2 J- M' u: O* w9 N/ L
39.     /* 分配接收用的数据缓冲 */
    
40.     if (recv_data == RT_NULL)
    
41.         {
    
42.             rt_kprintf("No memory\n");
    
43.             return;
    
44.         }
    $ S. N  q* F* f5 [0 H
45.     /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
    
46.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    ) ~7 S' M2 [7 a; J$ `
47.         {
    
48.             /* 创建失败的错误处理 */
    8 ]' o0 k1 x! ^: c* n
49. 
    ! W7 a/ D/ h' G2 u0 v
50.             rt_kprintf("Socket error\n");
    
51.             /* 释放已分配的接收缓冲 */
    
52.             rt_free(recv_data);
    
53.             return;
    
54.         }
    2 D$ X% I  k& e
55.     /* 初始化服务端地址 */
    
56.     server_addr.sin_family = AF_INET;
    / w6 s1 l5 |- |" m: D$ z5 F
57.     server_addr.sin_port = htons(5000);
    " i/ B8 Z: p' m" j! b+ h$ j0 Y
58.     /* 服务端工作的端口 */
    
59.     server_addr.sin_addr.s_addr = INADDR_ANY;
    
60.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    
61.     /* 绑定socket到服务端地址 */
    ) Z; s. g  E% ~/ n* O/ g
62.     if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    : D9 [$ [) I5 Y) z1 t9 v1 f
63.         {
    ' H5 m5 E8 B% r; p. O3 M
64.             /* 绑定失败 */
    
65.             rt_kprintf("Unable to bind\n");
    + T1 z( n8 n$ {% U( |
66.             /* 释放已分配的接收缓冲 */
    # b: `( z; b! _, t$ B% ^
67.             rt_free(recv_data);
    1 g" k' N# y* s& F- q7 _( g
68.             return;
    
69.         }
    . }0 I1 d  P# Q2 J- U# d
70.     /* 在socket上进行监听 */
    ) h/ r+ E6 Q2 p, c" z' v  S( G
71.     if (listen(sock, 5) == -1)
    / C3 a% d7 l0 `2 }  N4 A
72.         {
    " ~# E" s7 O+ S) G
73.             rt_kprintf("Listen error\n");
    5 R2 J+ Q: H9 V2 _
74.             /* release recv buffer */
    
75.             rt_free(recv_data);
    
76.             return;
    1 l5 H. `6 _7 m% p* ~+ E
77.         }
    
78.     rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
    
79.     while (stop != RT_TRUE)
    8 z* g* O! {8 N# o7 }
80.         {
    
81.             sin_size = sizeof(struct sockaddr_in);
    
82.             /* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
    
83.             connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
    $ l/ m) E/ y  m/ |- D: `4 D1 w
84.             /* 返回的是连接成功的socket */
    + ?( a& J" N4 I1 k2 U
85.             if (connected < 0)
    1 z; k% f; I$ c7 U
86.                 {
    4 [. J' E. p7 d! \4 O# `
87.                     rt_kprintf("accept connection failed! errno = %d\n", errno);
    # U: c" g+ o! @  _; @& G
88.                     continue;
    6 A- E1 S) c) F, j/ x8 }) a
89.                 }
    " C) N" p+ t1 `/ }; F: }
90.             /* 接受返回的client_addr指向了客户端的地址信息 */
    ' j( L# O' j5 P  P" W
91.             rt_kprintf("I got a connection from (%s , %d)\n",
    
92.                        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    
93.             /* 客户端连接的处理 */
    5 @8 r, K9 X# @/ @2 p/ c4 w8 @
94.             while (1)
    4 i9 s" s' E9 \$ [
95.                 {
    
96.                     /* 发送数据到connected socket */
    4 K+ r; d8 [! F' S6 C
97.                     ret = send(connected, send_data, strlen(send_data), 0);
    
98.                     if (ret < 0)
    
99.                         {
    - J: Q8 M. O# }: G; f9 t
100.                             /* 发送失败，关闭这个连接 */
     ! g. n# Y4 h7 g
101.                             closesocket(connected);
     
102.                             rt_kprintf("\nsend error,close the socket.\r\n");
     ' S5 B+ P2 J* G8 W7 `, D5 _5 D" E
103.                             break;
     5 n9 l% R* `9 e( K0 V7 B* ^
104.                         }
     7 A- w7 D: x$ D( ]
105.                     else if (ret == 0)
     
106.                         {
     
107.                             /* 打印send函数返回值为0的警告信息 */
     5 c/ K9 Z3 m$ T  G1 B- Z9 G% h
108.                             rt_kprintf("\n Send warning,send function return 0.\r\n");
     1 \) Y8 y" `% d1 o, C1 y% @- F* T* c$ D- v
109.                         }
     ( _5 Q; s/ E9 s+ V& j9 |
110.                     /* 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据 */
     
111.                     bytes_received = recv(connected, recv_data, BUFSZ, 0);
     5 z: ]  B. ]$ C' q( y
112.                     if (bytes_received < 0)
     
113.                         {
     
114.                             /* 接收失败，关闭这个connected socket */
     
115.                             closesocket(connected);
     
116.                             break;
     0 K8 u. q  a/ a  Y4 _) a
117.                         }
     ' P( O  ~( y; A, ]; }$ z; W( n; }
118.                     else if (bytes_received == 0)
     
119.                         {
     
120.                             /* 打印recv函数返回值为0的警告信息 */
     9 K9 C% \; z" s5 f* G+ `- u: t. b
121.                             rt_kprintf("\nReceived warning,recv function return 0.\r\n");
     / Y7 f; ^- h% O4 R7 H
122.                             closesocket(connected);
     
123.                             break;
     
124.                         }
     
125.                     /* 有接收到数据，把末端清零 */
     
126.                     recv_data[bytes_received] = '\0';
     
127.                     if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
     
128.                         {
     ' u* a" J! X1 m& s- f* \
129.                             /* 如果是首字母是q或Q，关闭这个连接 */
     $ [! k  u& I* n; b
130. 
     5 U7 q' b: ?* ~  _
131.                             closesocket(connected);
     0 ^& ?6 f/ u  ]; H+ n
132.                             break;
     $ v: ~7 F6 j/ @/ F
133.                         }
     1 T6 t8 b1 T  Y8 f, l1 t
134.                     else if (strcmp(recv_data, "exit") == 0)
     
135.                         {
     6 i  v& Y7 P, X- T1 A9 W$ _3 Y2 Z0 D
136.                             /* 如果接收的是exit，则关闭整个服务端 */
     
137.                             closesocket(connected);
     
138.                             stop = RT_TRUE;
     
139.                             break;
     
140.                         }
     
141.                     else
     
142.                         {
     8 z/ E+ F4 J6 h7 Y& o
143.                             /* 在控制终端显示收到的数据 */
     
144.                             rt_kprintf("RECEIVED DATA = %s \n", recv_data);
     
145.                         }
     
146.                 }
     " p7 \7 Y" V% m7 t5 I+ y
147.         }    /* 退出服务 */
     
148.     closesocket(sock);
     8 }! {4 H1 A+ M# H6 ]9 e" |
149.     /* 释放接收缓冲 */
     
150.     rt_free(recv_data);
     4 P' N$ H7 K  f* x
151. 
     % T. h* w, M. K) V5 @: f
152.     return ;
     
153. }
     
154. MSH_CMD_EXPORT(tcpserv, a tcp server sample);

复制代码

5 u1 F! \8 k' ~, `$ l搬运过来，给需要的朋友~
: f( h" u) _3 W# p, T1 F

感谢分享

感谢分享