1、UDP Client
- m. L' Q" {! W3 p2 m5 [! H1 S, D

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team *
   5 a. `* d# e2 m/ ~; q
3. * SPDX-License-Identifier: Apache-2.0 *
   ) X, z/ @8 s! Q& x
4. * Change Logs: * Date            
   " ^  @& g% ~7 `% O* b; ]% l
5. Author      Notes *
   
6. */
   ' c' w8 W3 ?2 y2 k, o
7. /*
   $ j, ]  @' x  |7 F( }( }* U
8. * 程序清单：udp 客户端 *
   ! Y  v; z) [- Y6 V# V
9. * 这是一个 udp 客户端的例程
   ; B  z  h' n. c2 S2 o% U9 K$ e
10. * 导出 udpclient 命令到控制终端
    
11. * 命令调用格式：udpclient URL PORT [COUNT = 10]
    0 Y4 ~8 u/ h9 q2 K) H, L1 [
12. * URL：服务器地址  PORT：端口号  COUNT：可选参数 默认为 10
    
13. * 程序功能：发送 COUNT 条数据到服务远端
    
14. */
    . x1 E* y' G* r' O' l3 V5 N" M/ b
15. #include <rtthread.h>
    6 E2 ~$ f' K8 q: w* A: E4 w% ?" U
16. #include <sys/socket.h> /* 使用BSD socket，需要包含sockets.h头文件 */
    , x, l3 c4 Q0 d4 t- C  a( y
17. #include <netdb.h>
    
18. #include <string.h>
    
19. #include <finsh.h>
    5 |, y# i5 m5 x9 J! r
20. 
    # E5 ~" ^# D2 e
21. const char send_data[] = "This is UDP Client from RT-Thread.\n";
    
22. /* 发送用到的数据 */
    
23. void udpclient(int argc, char **argv)
    
24. {
    
25.     int sock, port, count;
      b3 y4 t- R* J
26.     struct hostent *host;
    
27.     struct sockaddr_in server_addr;
    * l6 L9 C' d( O4 I5 X
28.     const char *url;
    
29.     if (argc < 3)
    
30.         {
    ) F1 W& M- _+ U3 O7 I% j* {
31.             rt_kprintf("Usage: udpclient URL PORT [COUNT = 10]\n");
    % W" E7 d" K( W! g9 U
32.             rt_kprintf("Like: tcpclient 192.168.1.9 8000\n");
    
33.             return ;
    : J: U3 ^2 [# N- I+ o& a' g, E, G
34.         }
    
35.     url = argv[1];
    
36.     port = strtoul(argv[2], 0, 10);
    
37.     if (argc > 3)
    
38.         count = strtoul(argv[3], 0, 10);
    6 T: {! u% \7 s: C/ [) J
39.     else
    - w( K4 H* R: m! r
40.         count = 10;
    
41.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    
42.     host = (struct hostent *) gethostbyname(url);
    8 t! ~# y4 H- e. t
43.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    , o6 M  D: c$ A$ I: O1 }
44.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    
45.         {
    
46.             rt_kprintf("Socket error\n");
    / q( z- l/ t! f5 d) n% s' Z8 m
47.             return;
    
48.         }
    
49.     /* 初始化预连接的服务端地址 */
    ) J9 n/ K  ^4 C1 c) t8 F" @$ A6 L1 U& @
50.     server_addr.sin_family = AF_INET;
    ) \  n: i# f/ s9 t4 `0 J# @
51.     server_addr.sin_port = htons(port);
    
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次数据 */
    2 {& D8 H- Y, l5 Q8 F
55.     while (count)
    8 }- l$ A3 a1 w( h3 b
56.         {
    
57.             /* 发送数据到服务远端 */
    
58.             sendto(sock, send_data, strlen(send_data), 0,               (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
    + L3 {5 w% y0 V' G8 q7 v, j' o
59.             /* 线程休眠一段时间 */
    
60.             rt_thread_delay(50);
    
61.             /* 计数值减一 */
    / r+ L9 A6 w' k6 K% m( c, Z
62.             count --;
    - b3 ]5 E! G6 q, S
63.         }
    ( A3 g% }' s, C" r! s
64.     /* 关闭这个socket */
    3 o$ W7 V( ~3 L% F: o2 v
65.     closesocket(sock);
    % n2 y$ {1 K+ Y4 j, j2 N
66. }
    
67. MSH_CMD_EXPORT(udpclient, a udp client sample);
    
68. 
    : C3 o/ }$ u& v" Y' R9 `

复制代码

2、UDP Server
) V' J0 @, J# }, B( x' F

1. #include <rtthread.h>
   
2. #include <sys/socket.h>
   
3. /* 使用BSD socket，需要包含socket.h头文件 */
   ; O* V0 u4 A! X' f
4. #include <netdb.h>
   
5. #include <string.h>
   
6. #include <finsh.h>
   
7. #define BUFSZ   1024
   + w* h8 W  _4 P
8. static void udpserv(int argc, char **argv)
   ; k7 J8 E+ F4 @; h: y, S: @
9. {
   
10.     int sock;
    & I  Q; Y8 n2 E( h1 d5 z
11.     int bytes_read;
    
12.     char *recv_data;
    
13.     socklen_t addr_len;
    
14.     struct sockaddr_in server_addr, client_addr;
    
15.     /* 分配接收用的数据缓冲 */
    5 ]( U* @5 M  _) m5 I# H0 f
16.     recv_data = rt_malloc(BUFSZ);
    9 r3 Z. S2 {9 A( |( s/ P
17.     if (recv_data == RT_NULL)
    
18.         {
    
19.             /* 分配内存失败，返回 */        
    
20.                         rt_kprintf("No memory\n");
    
21.             return;
    
22.         }
    
23.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    8 Q6 B, D+ z7 l2 M
24.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    
25.         {
    
26.             rt_kprintf("Socket error\n");
    
27.             /* 释放接收用的数据缓冲 */        
    # q& z( O8 y- e/ J7 _
28.                         rt_free(recv_data);
    
29.             return;
    $ B) Z! m$ j  i5 p. ]2 ?
30.         }
    * a# @$ y) d8 L6 {6 g7 m
31.     /* 初始化服务端地址 */
    
32.     server_addr.sin_family = AF_INET;
    5 {  w; W* Q) s' Z
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));
    - ~9 |9 `9 H8 J) d- B
36.     /* 绑定socket到服务端地址 */
    
37.     if(bind(sock, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) == -1)
    7 n* \- `3 }; j( i- ]
38.         {
    
39.             /* 绑定地址失败 */
    
40.             rt_kprintf("Bind error\n");
    
41.             /* 释放接收用的数据缓冲 */
    ; g9 ^* {* r, C
42.             rt_free(recv_data);
    
43.             return;
    
44.         }
    6 A$ I; A' {. n1 K' z
45.     addr_len = sizeof(struct sockaddr);
    
46.     rt_kprintf("UDPServer Waiting for client on port 5000...\n");
    1 ?# C5 X3 k' R2 x* `# V+ I
47.     while (1)
    
48.         {
    2 z3 p; J# g. z/ s$ \, z
49.             /* 从sock中收取最大BUFSZ - 1字节数据 */
    
50. 
    # I& o% x0 B- g- l  w$ h* {
51.             bytes_read = recvfrom(sock, recv_data, BUFSZ - 1, 0,
    $ V3 M8 ]# e/ u: Y/ e# O
52.                                   (struct sockaddr *)&client_addr, &addr_len);
    
53.             /* UDP不同于TCP，它基本不会出现收取的数据失败的情况，除非设置了超时等待 */
    - h# ]# X. i: x8 H4 Y8 |) H
54.             recv_data[bytes_read] = '\0';         /* 把末端清零 */
    7 [5 t8 _9 k$ @# j
55.             /* 输出接收的数据 */
    
56.             rt_kprintf("\n(%s , %d) said : ", inet_ntoa(client_addr.sin_addr),
    
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，退出 */        
    
62.                         if (strcmp(recv_data, "exit") == 0)
    9 D) V% I  ~' ]
63.                 {
    
64.                     closesocket(sock);            /* 释放接收用的数据缓冲 */
    ! Q, z% |& C! I( {, b9 q
65.                     rt_free(recv_data);
    
66.                     break;
    
67.                 }
    ; m! x2 E5 _" C! p2 o7 G5 A
68.         }
    0 V& Z% T3 v( ?; T
69.     return;
    6 z8 ?( g% {9 ^1 Y9 I) Z
70. }
    ( ^2 [, r$ j/ @* J. P( Y
71. 
    ( O6 {& {* c; L' O: \
72. MSH_CMD_EXPORT(udpserv, a udp server sample);
    

复制代码

3、TCP Client

1. /*
     V& d+ @- K0 j, F
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   3 \, o! }1 L) D) [: M
3. *
   
4. * SPDX-License-Identifier: Apache-2.0 *
   
5. * Change Logs:
   % t6 B" A6 h: e3 \( C
6. * Date             Author      Notes *
   9 A) z6 }; Y3 o% T
7. */
   
8. /*
   . c' d5 q3 \$ U0 Q6 U9 g: V
9. * 程序清单：tcp 客户端
   7 i7 m; k- N" d4 }/ c, M
10. *
    
11. * 这是一个 tcp 客户端的例程
    
12. * 导出 tcpclient 命令到控制终端
    7 T: i! j8 O- N' F2 O7 H2 n
13. * 命令调用格式：tcpclient URL PORT
    
14. * URL：服务器地址 PORT:：端口号
    * Y9 ]( ]0 h, D  [
15. * 程序功能：接收并显示从服务端发送过来的信息，接收到开头是 'q' 或 'Q' 的信息退出程序
    
16. */
    
17. #include <rtthread.h>
    
18. #include <sys/socket.h>
    
19. /* 使用BSD socket，需要包含socket.h头文件 */
    
20. #include <netdb.h>
    
21. #include <string.h>
    
22. #include <finsh.h>
    & I# D; g+ s, [; m/ c
23. #define BUFSZ   1024
    
24. static
    
25. const char send_data[] = "This is TCP Client from RT-Thread.";
    * J' B# @& W1 m# m
26. /* 发送用到的数据 */
    
27. void tcpclient(int argc, char **argv)
    $ b, @, @& c. E% H
28. {
    - s( X' v$ c  s0 N4 P, O
29.     int ret;
    
30.     char *recv_data;
    
31.     struct hostent *host;
      Q% j. v8 X: Z& D
32.     int sock, bytes_received;
    1 K) V' d+ l7 q9 `5 S, {2 P
33.     struct sockaddr_in server_addr;
    0 z2 c# L6 _, W
34.     const char *url;
    
35.     int port;
    2 s9 j9 h" e5 Z! D7 d
36.     if (argc < 3)
    $ O; q; p+ G6 i( t4 ^
37.         {
    
38.             rt_kprintf("Usage: tcpclient URL PORT\n");
    
39.             rt_kprintf("Like: tcpclient 192.168.12.44 5000\n");
    
40.             return ;
    
41.         }
    
42.     url = argv[1];
    
43.     port = strtoul(argv[2], 0, 10);
    , s( K7 `/ S* F0 v* V/ Q
44.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    
45.     host = gethostbyname(url);
    
46.     /* 分配用于存放接收数据的缓冲 */
    
47.     recv_data = rt_malloc(BUFSZ);
    
48.     if (recv_data == RT_NULL)
    
49.         {
    ) j9 z, H5 n: V; x, E0 f# F* s' z
50.             rt_kprintf("No memory\n");
    
51.             return;
    
52.         }
    5 ^/ v6 ?: t+ J0 a
53.     /* 创建一个socket，类型是SOCKET_STREAM，TCP类型 */
    
54.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    7 g$ |+ o  U9 T
55.         {
    
56.             /* 创建socket失败 */
    
57.             rt_kprintf("Socket error\n");
    . I) r  @( v8 b$ K
58.             /* 释放接收缓冲 */
    
59.             rt_free(recv_data);
    ) E1 M# M+ Y! H4 T; [4 K
60.             return;
    
61.         }
    
62.     /* 初始化预连接的服务端地址 */
    6 x0 s( u" q6 D: ^" t/ d" Y2 U
63.     server_addr.sin_family = AF_INET;
    
64.     server_addr.sin_port = htons(port);
    : R  n0 v+ ?& c0 j, f. N6 l8 f
65.     server_addr.sin_addr = *((struct in_addr *)host->h_addr);
    8 ?$ z8 }1 ?" e+ h
66.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    
67.     /* 连接到服务端 */
    
68.     if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    
69.         {
    
70.             /* 连接失败 */
    
71.             rt_kprintf("Connect fail!\n");
    + Y! ^  S1 @/ V8 F% c* [. ?  |& f
72.             closesocket(sock);
    & b& b- b% }6 R4 q
73.             /*释放接收缓冲 */
    
74.             rt_free(recv_data);
    / U2 A, Z( {; m% r
75.             return;
    
76.         }
    
77.     while (1)
    ' G1 R' f% i( s: a
78.         {
    
79.             /* 从sock连接中接收最大BUFSZ - 1字节数据 */
    % q  p) V  \5 {  @
80.             bytes_received = recv(sock, recv_data, BUFSZ - 1, 0);
    
81.             if (bytes_received < 0)
    
82.                 {
    
83.                     /* 接收失败，关闭这个连接 */
    8 u. W6 F" n0 y: T  u3 A
84.                     closesocket(sock);
    
85.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    
86.                     /* 释放接收缓冲 */
    7 T( B& D3 L2 z- ^0 x  P
87.                     rt_free(recv_data);
    
88.                     break;
    # N& k6 V/ k* |* X( Y5 F
89.                 }
      f, N; S+ H2 `% @% L
90.             else if (bytes_received == 0)
    
91.                 {
    " G" ?& w4 O) ^7 f
92.                     /* 默认 recv 为阻塞模式，此时收到0认为连接出错，关闭这个连接 */
    . d1 b& M* ]3 ~  o
93.                     closesocket(sock);
    2 d0 V  J; j( d3 |- ~5 N0 F
94.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    
95.                     /* 释放接收缓冲 */
    
96.                     rt_free(recv_data);
    
97.                     break;
    + p, w  g! X3 C
98.                 }
    
99.             /* 有接收到数据，把末端清零 */
    2 q& O- n1 c/ [. Z2 }8 F" Q. P3 K
100.             recv_data[bytes_received] = '\0';
     9 V' H. d$ o9 ^* Q" Q& V
101.             if (strncmp(recv_data, "q", 1) == 0 || strncmp(recv_data, "Q", 1) == 0)
     0 P# g" f) [3 H; [( v4 x
102.                 {
       ]+ @) u7 Q) x
103.                     /* 如果是首字母是q或Q，关闭这个连接 */
     
104.                     closesocket(sock);
     
105.                     rt_kprintf("\n got a 'q' or 'Q',close the socket.\r\n");
     
106.                     /* 释放接收缓冲 */
     4 u3 a! {  a# e8 Y5 ?
107.                     rt_free(recv_data);
     
108.                     break;
     : Q, ]. p0 E+ K% \" ]6 H
109.                 }
     
110.             else
     
111.                 {
     
112.                     /* 在控制终端显示收到的数据 */
     
113.                     rt_kprintf("\nReceived data = %s ", recv_data);
     
114.                 }        /* 发送数据到sock连接 */
     
115.             ret = send(sock, send_data, strlen(send_data), 0);
     
116.             if (ret < 0)
     & {. `/ t+ }6 `0 ]  k6 m: s
117.                 {
     8 `& t- p8 h% C* J, C. @
118.                     /* 接收失败，关闭这个连接 */
     3 C" r& x# M. E9 `- e
119.                     closesocket(sock);
     9 t  Z1 J& X/ _6 w( [( Y" H
120.                     rt_kprintf("\nsend error,close the socket.\r\n");
     
121.                     rt_free(recv_data);
     7 t6 W( L8 `+ B6 m9 `
122.                     break;
       S0 g; A0 a: E* i0 t
123.                 }
     
124.             else if (ret == 0)
     ' Z% a4 i7 g8 l( M' \& [( _$ @
125.                 {
     
126.                     /* 打印send函数返回值为0的警告信息 */
     
127.                     rt_kprintf("\n Send warning,send function return 0.\r\n");
     
128.                 }
     
129.         }
     + ~4 x7 L$ w  m" J. K( V9 s
130.     return;
     $ H9 f) o1 Q: f
131. }
     
132. MSH_CMD_EXPORT(tcpclient, a tcp client sample);
       t6 a9 a' O8 J* x4 E% y1 ~! X& `

复制代码

4、TCP server
3 r; q% A+ c2 V0 D1 ]8 ~7 W) P

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   
3. *
   
4. * SPDX-License-Identifier: Apache-2.0
   / Q3 L  ^: {0 }0 G& \
5. *
     i  ^2 H6 X$ F0 M* ?: v
6. * Change Logs:
   " C  l3 h# r" Z1 Q% n+ t7 U
7. * Date             Author      Notes
   $ e+ D  u# @+ m. p3 l+ }" M
8. *
   
9. */
   
10. /*
    0 }! ]0 u& ^$ |; ?, h
11. * 程序清单：tcp 服务端
    ' `  K, l& M$ B* k1 B/ F+ [
12. *
    
13. * 这是一个 tcp 服务端的例程
    
14. * 导出 tcpserv 命令到控制终端
    
15. * 命令调用格式：tcpserv
    
16. * 无参数
    
17. * 程序功能：作为一个服务端，接收并显示客户端发来的数据 ，接收到 exit 退出程序
    
18. */
    ( E/ z- M0 P0 A3 W' V% r, M
19. #include <rtthread.h>
    7 D) Z* u4 H* A& Y8 x
20. #include <sys/socket.h>
    0 s1 {/ M; ]% B' \$ R: ]# V
21. /* 使用BSD socket，需要包含socket.h头文件 */
    ) T9 K& K( Y! g
22. #include <netdb.h>
    5 A- W! I+ G, p( x% @9 }' z- M
23. #include <string.h>
    
24. #include <finsh.h>
    ( c' T0 Z* |6 c  W9 m# r; y
25. #define BUFSZ       (1024)
    * b. E: U  M- Y; {
26. static const char send_data[] = "This is TCP Server from RT-Thread.";
    
27. /* 发送用到的数据 */
    
28. static void tcpserv(int argc, char **argv)
    / f. E8 r& {. E7 y4 Z
29. {
    . I( u* V8 T6 H1 i6 d+ g# Q
30.     char *recv_data;
    1 `4 s: _7 [, x  |& w9 g+ O
31.     /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
    
32.     socklen_t sin_size;
    ; w" K! @! o3 f& ^
33.     int sock, connected, bytes_received;
    
34.     struct sockaddr_in server_addr, client_addr;
    
35.     rt_bool_t stop = RT_FALSE;
    
36.     /* 停止标志 */
    9 L# @; G9 w4 X- s1 d
37.     int ret;
    
38.     recv_data = rt_malloc(BUFSZ + 1);
    , m0 a+ T+ y$ P
39.     /* 分配接收用的数据缓冲 */
    2 m# b. t( n2 {# x* C3 }
40.     if (recv_data == RT_NULL)
    8 g7 ^7 {4 N! Q- v+ g' D
41.         {
    5 m, {6 W1 v2 Y5 K1 o& O7 b( w; S
42.             rt_kprintf("No memory\n");
    % S% y+ g/ U* k* u" `
43.             return;
    
44.         }
    % z7 F2 k  ], \" w8 l. ~
45.     /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
    
46.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
47.         {
    8 A8 A! A% z# }( T: p; d) i
48.             /* 创建失败的错误处理 */
    2 @9 p1 S! k7 b
49. 
    
50.             rt_kprintf("Socket error\n");
    
51.             /* 释放已分配的接收缓冲 */
    2 z" E8 r: q% i! u
52.             rt_free(recv_data);
    " P' L1 v; R$ T) ^. i
53.             return;
    4 A7 A/ ^. E7 ~6 O: _9 k
54.         }
    # H0 L! x" i8 D
55.     /* 初始化服务端地址 */
    
56.     server_addr.sin_family = AF_INET;
    " ?1 \% A, m( X) l6 L' O8 b
57.     server_addr.sin_port = htons(5000);
    
58.     /* 服务端工作的端口 */
    ) j: r- _% s# X9 D
59.     server_addr.sin_addr.s_addr = INADDR_ANY;
    . [2 o2 N2 H0 N9 y' [7 a" \( C
60.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    
61.     /* 绑定socket到服务端地址 */
    
62.     if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    
63.         {
    5 w3 \% v/ ^# i. X& C
64.             /* 绑定失败 */
    
65.             rt_kprintf("Unable to bind\n");
    
66.             /* 释放已分配的接收缓冲 */
    
67.             rt_free(recv_data);
    3 X$ u7 ]( e: A- Z( L) b8 n
68.             return;
    
69.         }
    
70.     /* 在socket上进行监听 */
    
71.     if (listen(sock, 5) == -1)
    % K- K2 x+ G. L3 C% J7 y
72.         {
    
73.             rt_kprintf("Listen error\n");
    , U# k. K4 ~2 T" ~( u; q
74.             /* release recv buffer */
    
75.             rt_free(recv_data);
      |& a1 Q3 L) T4 M* L" b
76.             return;
    , H; `7 v- x. o; p
77.         }
    
78.     rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
    
79.     while (stop != RT_TRUE)
    # M8 a; W" w, h' @, D7 v
80.         {
    . a& D# ]1 z8 M1 H& Z) g& ^9 J
81.             sin_size = sizeof(struct sockaddr_in);
    
82.             /* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
    
83.             connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
    
84.             /* 返回的是连接成功的socket */
    
85.             if (connected < 0)
    
86.                 {
    
87.                     rt_kprintf("accept connection failed! errno = %d\n", errno);
    8 P3 H6 v- U/ H# P: s8 H
88.                     continue;
    
89.                 }
    
90.             /* 接受返回的client_addr指向了客户端的地址信息 */
    
91.             rt_kprintf("I got a connection from (%s , %d)\n",
    
92.                        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    4 D. H: L7 B% O$ y. r2 U9 |: ?+ n9 W6 h
93.             /* 客户端连接的处理 */
    # o. Y# a  R/ D1 O
94.             while (1)
    
95.                 {
    * D- v2 f' e0 v7 ~; y2 C9 @
96.                     /* 发送数据到connected socket */
    , K# x% f8 {+ A
97.                     ret = send(connected, send_data, strlen(send_data), 0);
    5 x8 E& X% J& s1 r4 K8 ?$ U
98.                     if (ret < 0)
    
99.                         {
    
100.                             /* 发送失败，关闭这个连接 */
     
101.                             closesocket(connected);
     
102.                             rt_kprintf("\nsend error,close the socket.\r\n");
     
103.                             break;
     
104.                         }
     ; [/ N) Q! a" S
105.                     else if (ret == 0)
     
106.                         {
     
107.                             /* 打印send函数返回值为0的警告信息 */
     ) p. {; D, _# l  k0 B2 h2 r
108.                             rt_kprintf("\n Send warning,send function return 0.\r\n");
     # \3 ^* E, G5 S* m/ _- }
109.                         }
     - q" T' ~4 @1 r4 j1 p
110.                     /* 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据 */
     * q* {3 c' c! L( F4 g: t
111.                     bytes_received = recv(connected, recv_data, BUFSZ, 0);
     . A" I# W/ j/ K6 R
112.                     if (bytes_received < 0)
     
113.                         {
     0 o7 {2 ]2 N9 Y: u6 E
114.                             /* 接收失败，关闭这个connected socket */
       Z1 ]0 S7 y, g7 Y* G1 Z) I
115.                             closesocket(connected);
     
116.                             break;
     : u2 X; d, m/ z/ `8 p, R
117.                         }
     & l# I' @1 X0 b. Z6 {+ \
118.                     else if (bytes_received == 0)
     
119.                         {
     
120.                             /* 打印recv函数返回值为0的警告信息 */
     
121.                             rt_kprintf("\nReceived warning,recv function return 0.\r\n");
     " r" Z% ^/ s  Q* v
122.                             closesocket(connected);
     ) q! K! `( h" d, W
123.                             break;
     6 l+ }+ ~, `8 x6 @! p* T/ x
124.                         }
     5 b7 y* {2 U$ H0 C! `; g
125.                     /* 有接收到数据，把末端清零 */
     7 F; x- ~# M' h! H& C
126.                     recv_data[bytes_received] = '\0';
     / |+ N5 l2 G9 W- l) E
127.                     if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
     , b, @5 a# `, _+ Y* L% h
128.                         {
     : [+ Z" R* e/ n/ ]' \
129.                             /* 如果是首字母是q或Q，关闭这个连接 */
     
130. 
     
131.                             closesocket(connected);
     3 g8 u$ h( Z$ b
132.                             break;
     % O2 A6 G5 p1 ?% d" @- U
133.                         }
     % W$ Y3 b& Y: s+ j4 d( C
134.                     else if (strcmp(recv_data, "exit") == 0)
     
135.                         {
     ; n0 W5 t7 `. v
136.                             /* 如果接收的是exit，则关闭整个服务端 */
     
137.                             closesocket(connected);
     - j: z  L$ m# c; y- e! }3 F
138.                             stop = RT_TRUE;
     + a! {6 p' B( \, N9 Z% M* U
139.                             break;
     1 H' ?6 U; R' [% P; o
140.                         }
     / S4 |/ B4 N+ v) _! z
141.                     else
     - @/ e: @6 ], [  r  T
142.                         {
     * D" p$ S5 A+ \. B  b: c
143.                             /* 在控制终端显示收到的数据 */
     
144.                             rt_kprintf("RECEIVED DATA = %s \n", recv_data);
     
145.                         }
     3 t$ y" S/ ~* ^, W
146.                 }
     
147.         }    /* 退出服务 */
     
148.     closesocket(sock);
     1 h8 a3 Y& l- a+ Z- G) b( ]
149.     /* 释放接收缓冲 */
     
150.     rt_free(recv_data);
     
151. 
     3 G6 Z6 m- [$ _% S$ c9 j; Y
152.     return ;
     
153. }
     
154. MSH_CMD_EXPORT(tcpserv, a tcp server sample);

复制代码

/ \" s$ l4 K- }/ Y7 k6 t7 G9 V5 S搬运过来，给需要的朋友~
- q7 N  {2 C+ b3 C

感谢分享

感谢分享