1、UDP Client

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team *
   
3. * SPDX-License-Identifier: Apache-2.0 *
     k/ ~0 D5 X+ _0 r
4. * Change Logs: * Date            
   & a9 X$ `7 |! J" d' N( X& T0 Y
5. Author      Notes *
   4 I" b) r& k( m/ {! g
6. */
   
7. /*
   ' G* p9 M2 ]! p5 a. l/ }) p
8. * 程序清单：udp 客户端 *
   ' w( l( {6 \0 L, g+ j
9. * 这是一个 udp 客户端的例程
   
10. * 导出 udpclient 命令到控制终端
    
11. * 命令调用格式：udpclient URL PORT [COUNT = 10]
    4 j! z1 W% l& f6 `
12. * URL：服务器地址  PORT：端口号  COUNT：可选参数 默认为 10
    
13. * 程序功能：发送 COUNT 条数据到服务远端
    
14. */
    
15. #include <rtthread.h>
    ( K3 O  S: M) L* N
16. #include <sys/socket.h> /* 使用BSD socket，需要包含sockets.h头文件 */
    
17. #include <netdb.h>
    4 _( D, Q, t4 q& `7 F0 X2 ?. F& f
18. #include <string.h>
    ! V% L, k9 w$ q( o$ ^3 w
19. #include <finsh.h>
    
20. 
    
21. const char send_data[] = "This is UDP Client from RT-Thread.\n";
    
22. /* 发送用到的数据 */
    
23. void udpclient(int argc, char **argv)
    
24. {
    5 l" y. Z0 y8 I
25.     int sock, port, count;
    
26.     struct hostent *host;
    - f5 n3 S) F9 Q
27.     struct sockaddr_in server_addr;
    
28.     const char *url;
    
29.     if (argc < 3)
    
30.         {
    
31.             rt_kprintf("Usage: udpclient URL PORT [COUNT = 10]\n");
    * X' B9 R2 f0 U3 W8 M/ H
32.             rt_kprintf("Like: tcpclient 192.168.1.9 8000\n");
    + ~+ k  Q. p; e: k' T7 r( w
33.             return ;
    ( J0 g9 _  f2 s6 }1 T( P) i
34.         }
    
35.     url = argv[1];
    / g( W- y' K% V2 K
36.     port = strtoul(argv[2], 0, 10);
    7 M% a1 ^7 z$ Z' `6 V  h+ y$ I
37.     if (argc > 3)
    
38.         count = strtoul(argv[3], 0, 10);
    . v7 L% j, N$ @) p) F
39.     else
    
40.         count = 10;
    6 s( J3 F: I1 U: w) E
41.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    ; P2 r! b1 i. k' w9 {9 c
42.     host = (struct hostent *) gethostbyname(url);
    
43.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    * \! u$ |) Y# j2 ?! ~& q* v; O
44.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    ( r$ u& d$ D8 ~2 e1 j
45.         {
    , m# L4 R0 O1 Y+ c3 |0 `4 f" P/ a
46.             rt_kprintf("Socket error\n");
    * }8 e5 `4 |6 L, Y! f' y$ p6 O
47.             return;
    
48.         }
    
49.     /* 初始化预连接的服务端地址 */
    / Z3 G, j5 q! h( ]; f/ y% M
50.     server_addr.sin_family = AF_INET;
    " S/ \. c  Y6 r" W, H, s- i
51.     server_addr.sin_port = htons(port);
    6 H: D, J; u. I( {
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次数据 */
    & Q2 @8 i9 `# G! C) U0 T
55.     while (count)
    
56.         {
    
57.             /* 发送数据到服务远端 */
    
58.             sendto(sock, send_data, strlen(send_data), 0,               (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
    
59.             /* 线程休眠一段时间 */
    ( I# J: W3 T- Y5 A" B& O" a
60.             rt_thread_delay(50);
    
61.             /* 计数值减一 */
    9 u% l: R6 g& j0 c. A+ j
62.             count --;
    
63.         }
    ( P  A' h$ C0 u  m; S0 S
64.     /* 关闭这个socket */
    + g5 C, S# ]/ E8 _
65.     closesocket(sock);
    3 }9 U/ g1 Q$ W& d' u& {; O6 B
66. }
    4 {6 q( r; g/ `3 a# t' T) A( ]
67. MSH_CMD_EXPORT(udpclient, a udp client sample);
    , Q6 Y; P) B2 C5 w9 Z4 ]
68. 
    

复制代码

2、UDP Server
" K3 t/ `  Y! `2 z1 `/ h

1. #include <rtthread.h>
   0 e+ b1 Z4 P+ j! H
2. #include <sys/socket.h>
   3 k& ]* T3 N3 T% D
3. /* 使用BSD socket，需要包含socket.h头文件 */
   , m0 V( T' U; k; J: x: v1 ?
4. #include <netdb.h>
   
5. #include <string.h>
   
6. #include <finsh.h>
   ! l7 ]3 H& K. A/ d9 l
7. #define BUFSZ   1024
   
8. static void udpserv(int argc, char **argv)
   + V$ V; |6 h6 J
9. {
   
10.     int sock;
    , ?( ^1 [7 X0 g! U
11.     int bytes_read;
    
12.     char *recv_data;
    5 X$ S+ D  h3 _9 C
13.     socklen_t addr_len;
    7 n5 Z# w) S5 t, J7 O0 H
14.     struct sockaddr_in server_addr, client_addr;
    
15.     /* 分配接收用的数据缓冲 */
    
16.     recv_data = rt_malloc(BUFSZ);
    % B2 H. B$ K* t9 ]
17.     if (recv_data == RT_NULL)
    0 Z: w) X5 v8 x; S% Z0 J, b, U
18.         {
    
19.             /* 分配内存失败，返回 */        
    2 D5 z- L+ x8 C$ j# ~! D. `- V
20.                         rt_kprintf("No memory\n");
    ( K" k3 ?6 ?& y  y/ b. j; V
21.             return;
    
22.         }
    
23.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    ! S- Q0 q. j5 q
24.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    
25.         {
    % t6 h2 U* K. Q# t" ?% X: p8 G
26.             rt_kprintf("Socket error\n");
    ; f( l4 S( t+ d
27.             /* 释放接收用的数据缓冲 */        
    7 U6 C) A0 x5 @3 S2 g, E
28.                         rt_free(recv_data);
    
29.             return;
    
30.         }
    ! f" [2 d2 ?. F9 L
31.     /* 初始化服务端地址 */
    
32.     server_addr.sin_family = AF_INET;
    & |2 W# c% d+ o% W0 |: b& M
33.     server_addr.sin_port = htons(5000);
    
34.     server_addr.sin_addr.s_addr = INADDR_ANY;
    ! E" u" T% _8 f6 s
35.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    . ^- a0 r9 _+ i: l& J3 A
36.     /* 绑定socket到服务端地址 */
    ' u/ Z5 C7 ^$ T" m+ c) J! B! W6 v
37.     if(bind(sock, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) == -1)
    1 C+ o4 b' E( s/ X2 |3 T9 ~3 X, o) s
38.         {
    
39.             /* 绑定地址失败 */
    
40.             rt_kprintf("Bind error\n");
    - u! G1 A/ e+ c% \- T( K% k
41.             /* 释放接收用的数据缓冲 */
    - ?7 r  l/ v" d( F. |) \9 \+ e3 }
42.             rt_free(recv_data);
    ! _, m8 x% @' I
43.             return;
    
44.         }
    1 x# v( t1 y0 e4 z% j- l
45.     addr_len = sizeof(struct sockaddr);
    + y0 Y; ~3 {  s
46.     rt_kprintf("UDPServer Waiting for client on port 5000...\n");
    % I/ d6 h" V! [
47.     while (1)
    
48.         {
    
49.             /* 从sock中收取最大BUFSZ - 1字节数据 */
    
50. 
    
51.             bytes_read = recvfrom(sock, recv_data, BUFSZ - 1, 0,
    1 ?7 |, B% t7 N+ m6 Q! T" X
52.                                   (struct sockaddr *)&client_addr, &addr_len);
    ! r/ A, c5 R7 Z* V+ l, h1 X
53.             /* UDP不同于TCP，它基本不会出现收取的数据失败的情况，除非设置了超时等待 */
    + J% B  J" _4 c( |0 f8 {) v! P! v
54.             recv_data[bytes_read] = '\0';         /* 把末端清零 */
    
55.             /* 输出接收的数据 */
    - `* M0 u! \# E; V
56.             rt_kprintf("\n(%s , %d) said : ", inet_ntoa(client_addr.sin_addr),
    5 U" O: o, g( P; w% H5 _6 D. x$ t. q2 @
57.                        ntohs(client_addr.sin_port));
    % u6 O$ H0 L/ E' l
58.             rt_kprintf("%s \n", recv_data);
    ' o& \6 v" w$ P0 Q1 V
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)
      V$ E1 }  c! U4 m0 `5 ]
63.                 {
    5 `/ S) K( \$ J# |+ S7 @  ?
64.                     closesocket(sock);            /* 释放接收用的数据缓冲 */
    
65.                     rt_free(recv_data);
    5 C3 f6 K. `8 I7 |5 z" R: h; i
66.                     break;
    ' B- K% `& E$ U9 D
67.                 }
    4 y. t' h3 J# v" {
68.         }
    
69.     return;
      o, q0 i+ m+ c/ ~/ z  D
70. }
    & n8 l& ]% U& v9 P& F' l* n
71. 
    / a7 f4 @& S9 |
72. MSH_CMD_EXPORT(udpserv, a udp server sample);
    , B' t$ n; G/ ~; x

复制代码

3、TCP Client

1. /*
   ; t& M5 \6 `) @% e( Z# m
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   5 z  F+ U- ]2 u- \: J
3. *
   # d5 v& |# l: G) Z  `& d0 D
4. * SPDX-License-Identifier: Apache-2.0 *
   " c. {% k* W; J' B
5. * Change Logs:
   ) ^! p. J! D) g* Y( g5 P
6. * Date             Author      Notes *
   
7. */
   ) a% h9 }% F2 k) C- m
8. /*
   : R2 f% s( ?9 \3 L
9. * 程序清单：tcp 客户端
   
10. *
    
11. * 这是一个 tcp 客户端的例程
    
12. * 导出 tcpclient 命令到控制终端
    
13. * 命令调用格式：tcpclient URL PORT
    0 {& n. h9 b* a/ T
14. * URL：服务器地址 PORT:：端口号
    
15. * 程序功能：接收并显示从服务端发送过来的信息，接收到开头是 'q' 或 'Q' 的信息退出程序
    
16. */
    
17. #include <rtthread.h>
    
18. #include <sys/socket.h>
    5 i: D9 i- A8 Q" p
19. /* 使用BSD socket，需要包含socket.h头文件 */
    
20. #include <netdb.h>
    $ \+ w! y. k0 a: S7 `
21. #include <string.h>
    ; R2 `) {6 s4 U0 j
22. #include <finsh.h>
    
23. #define BUFSZ   1024
    ( t' c0 j5 J8 }3 x7 N) l% a5 k5 R
24. static
    
25. const char send_data[] = "This is TCP Client from RT-Thread.";
    
26. /* 发送用到的数据 */
    
27. void tcpclient(int argc, char **argv)
    7 j+ C/ p0 p1 x0 [& h7 s
28. {
    - ~: @: o' K8 s# G
29.     int ret;
    
30.     char *recv_data;
    2 G( p7 {3 M$ c3 p$ t- E. m
31.     struct hostent *host;
    " Q% f+ R* d; i  }3 @
32.     int sock, bytes_received;
    
33.     struct sockaddr_in server_addr;
    % {# f3 A1 l- g! B  d- W
34.     const char *url;
    8 [# }* c: `$ s$ Z
35.     int port;
    9 j0 K; P( Y, e4 \1 q
36.     if (argc < 3)
    
37.         {
    * m) m8 x: O; \' b
38.             rt_kprintf("Usage: tcpclient URL PORT\n");
    7 f; E$ Q+ a1 v! s1 l
39.             rt_kprintf("Like: tcpclient 192.168.12.44 5000\n");
    
40.             return ;
    , d2 A8 m! H  k. [5 \6 V# z
41.         }
    7 ]0 e5 U' x0 i7 S1 Q! @$ h
42.     url = argv[1];
    * j: Z% I; K' ~/ I
43.     port = strtoul(argv[2], 0, 10);
    $ d, U4 a. G* g4 A$ A
44.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    
45.     host = gethostbyname(url);
    9 T% t  K7 s+ b2 T4 f, F& v
46.     /* 分配用于存放接收数据的缓冲 */
    
47.     recv_data = rt_malloc(BUFSZ);
    ; F- X. k: p) u; L  d; k
48.     if (recv_data == RT_NULL)
    
49.         {
    
50.             rt_kprintf("No memory\n");
    # y8 ?, s# K" C8 N
51.             return;
    
52.         }
    5 c! i7 T7 g( ~6 ]
53.     /* 创建一个socket，类型是SOCKET_STREAM，TCP类型 */
    2 @3 y1 H8 l% X) V" y
54.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
55.         {
    
56.             /* 创建socket失败 */
    3 I% ?) [5 ?$ n
57.             rt_kprintf("Socket error\n");
    : T# x3 j3 X/ ~9 E3 ~
58.             /* 释放接收缓冲 */
    2 g- Z. s" W/ P+ P! R1 m- t, R
59.             rt_free(recv_data);
    ! E5 {" h  U  k1 ]+ v
60.             return;
    ; _( Y/ w9 V. P/ [6 ]
61.         }
    
62.     /* 初始化预连接的服务端地址 */
      H7 k2 {6 i7 {. t
63.     server_addr.sin_family = AF_INET;
    $ Z6 |; ?4 _7 U0 d! T& ?
64.     server_addr.sin_port = htons(port);
    7 s$ n% Q  [* v
65.     server_addr.sin_addr = *((struct in_addr *)host->h_addr);
    
66.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    3 A/ P8 R& t1 }  I3 K
67.     /* 连接到服务端 */
    
68.     if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    
69.         {
    4 H, K6 p$ g* U$ ~# P
70.             /* 连接失败 */
    
71.             rt_kprintf("Connect fail!\n");
    , z2 d( B$ I. m9 }1 J- n- V' a
72.             closesocket(sock);
    $ A! N6 e5 c+ R+ Q# O
73.             /*释放接收缓冲 */
    
74.             rt_free(recv_data);
    
75.             return;
    6 |; _: K  L+ X- N1 V( t9 W
76.         }
    0 P. t% o2 a2 k
77.     while (1)
    
78.         {
    % o$ T2 i  Q5 Y3 e
79.             /* 从sock连接中接收最大BUFSZ - 1字节数据 */
    
80.             bytes_received = recv(sock, recv_data, BUFSZ - 1, 0);
    
81.             if (bytes_received < 0)
    6 f6 ^9 f1 x. `9 f
82.                 {
    
83.                     /* 接收失败，关闭这个连接 */
    
84.                     closesocket(sock);
    
85.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    " f4 N; S7 B" q, W  U" J" Z* t
86.                     /* 释放接收缓冲 */
    3 [2 l4 ~& n# `
87.                     rt_free(recv_data);
    ! N0 K& V. U8 g. r8 _' y7 l( N
88.                     break;
    
89.                 }
    5 o" [8 @# z3 I4 W3 G2 K0 v' ?# Z7 N
90.             else if (bytes_received == 0)
    ! g' Z1 \- U+ D8 B/ U2 B8 ~0 `$ ^& H
91.                 {
    : N: e8 f& W) v. P9 u! n
92.                     /* 默认 recv 为阻塞模式，此时收到0认为连接出错，关闭这个连接 */
    ! ~$ v% U1 F  N6 w# ]
93.                     closesocket(sock);
    
94.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    
95.                     /* 释放接收缓冲 */
    4 B, k0 h/ W& `: Q, e+ M/ d  c
96.                     rt_free(recv_data);
    
97.                     break;
    * ~3 \1 d1 K! B: e
98.                 }
    
99.             /* 有接收到数据，把末端清零 */
    + f( y  G# R2 A% p) Z2 t
100.             recv_data[bytes_received] = '\0';
     . r  h' N2 A: p3 ?0 G- g
101.             if (strncmp(recv_data, "q", 1) == 0 || strncmp(recv_data, "Q", 1) == 0)
     ( k& w# }. F6 C% N: A( d
102.                 {
     + E" b% A1 f8 |8 _4 Q
103.                     /* 如果是首字母是q或Q，关闭这个连接 */
     2 O- p  ~* ~% x5 Q5 ?0 I  {
104.                     closesocket(sock);
     
105.                     rt_kprintf("\n got a 'q' or 'Q',close the socket.\r\n");
     ) m9 n2 d3 m% ]9 R, n; E
106.                     /* 释放接收缓冲 */
     & ]8 G2 C" U1 P5 E
107.                     rt_free(recv_data);
     7 D6 W$ ]; q7 u$ u! X; S9 x
108.                     break;
     7 B9 V- z8 }: v
109.                 }
     & ]# Q: ?, e( Q
110.             else
     * l8 t" V) @1 N2 _) ]3 }
111.                 {
     & ^* }" A' C' C" ^3 ]% U$ x
112.                     /* 在控制终端显示收到的数据 */
     & r7 K' R) q0 q! |1 ^
113.                     rt_kprintf("\nReceived data = %s ", recv_data);
     4 j$ F: X7 x" F) h" d% g! d
114.                 }        /* 发送数据到sock连接 */
     8 o+ q9 u9 `( e" w! E6 }
115.             ret = send(sock, send_data, strlen(send_data), 0);
     % J1 L% w. g! u7 k$ Y- p9 Q% D) H
116.             if (ret < 0)
     ) w5 [. X  u# u# M. P1 ^
117.                 {
     
118.                     /* 接收失败，关闭这个连接 */
     
119.                     closesocket(sock);
     ; Z/ K* N7 a! ~: [+ W1 k0 n8 }
120.                     rt_kprintf("\nsend error,close the socket.\r\n");
     
121.                     rt_free(recv_data);
     : a! T& o# P9 ^3 M$ {$ ]% ~9 S
122.                     break;
       }/ O/ j+ v+ c, r8 ]
123.                 }
     8 F8 R& _4 G: l" l" _5 K9 J6 e
124.             else if (ret == 0)
     
125.                 {
     
126.                     /* 打印send函数返回值为0的警告信息 */
     ) U3 E3 t  x7 N) d% ]& ?
127.                     rt_kprintf("\n Send warning,send function return 0.\r\n");
     
128.                 }
     
129.         }
     % {. H0 l' x* k0 e& l( u3 i
130.     return;
     3 n5 P1 t% z" W4 @/ b9 D
131. }
     
132. MSH_CMD_EXPORT(tcpclient, a tcp client sample);
     0 L( G2 P  Y4 F, x1 B, s

复制代码

4、TCP server

1. /*
   # T  {, c4 O8 D4 a* B
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   
3. *
   # x! [+ s' P1 E
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   
6. * Change Logs:
   ! k% h# L7 d. ]: m6 l0 F
7. * Date             Author      Notes
   
8. *
   5 [  U) z/ T7 L6 o- a
9. */
   , f" G  p/ b% @
10. /*
    
11. * 程序清单：tcp 服务端
      Z; V( B: O5 Z+ _+ v8 Y; z( u
12. *
    - j3 i- I* j9 h+ U4 e: I5 \! \" M" R+ ^
13. * 这是一个 tcp 服务端的例程
    
14. * 导出 tcpserv 命令到控制终端
    
15. * 命令调用格式：tcpserv
    
16. * 无参数
    4 W8 F% y1 L: b$ i6 d- e
17. * 程序功能：作为一个服务端，接收并显示客户端发来的数据 ，接收到 exit 退出程序
    / G9 l* c" A  }7 ~4 }' @
18. */
    , K8 l& e7 @5 p& d* {5 v
19. #include <rtthread.h>
    * i" {& _* N# B5 l( J# }* Z
20. #include <sys/socket.h>
    
21. /* 使用BSD socket，需要包含socket.h头文件 */
    7 L$ h+ E4 B$ b# D+ K4 P
22. #include <netdb.h>
    ) p+ i/ F( w! ^$ {# {) C
23. #include <string.h>
    
24. #include <finsh.h>
    
25. #define BUFSZ       (1024)
    / g; [  L4 s; @0 t# ~5 E
26. static const char send_data[] = "This is TCP Server from RT-Thread.";
    
27. /* 发送用到的数据 */
    - K- F7 u/ f* t7 d  P+ G, X& y& M
28. static void tcpserv(int argc, char **argv)
      y- U4 y8 Y2 e* {7 W# P6 W$ r6 i
29. {
    / B* z% r5 r8 o$ L
30.     char *recv_data;
    . u: ~% F+ X) k
31.     /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
    3 A2 i2 v' w/ a- E% J) G
32.     socklen_t sin_size;
    
33.     int sock, connected, bytes_received;
    ( y" Q0 z7 _6 j* E" _$ M
34.     struct sockaddr_in server_addr, client_addr;
    
35.     rt_bool_t stop = RT_FALSE;
    ' E9 X: [9 u9 l7 a& c' s
36.     /* 停止标志 */
    & G0 ~. l$ [: m9 C& Q6 L- ^$ s
37.     int ret;
    - }7 u' q2 U4 v+ b& K; ^4 y. g
38.     recv_data = rt_malloc(BUFSZ + 1);
    
39.     /* 分配接收用的数据缓冲 */
    
40.     if (recv_data == RT_NULL)
    5 r/ Y/ V8 A- a1 p$ c6 ]& O, b, }
41.         {
    9 X- Y5 N5 T( g. E5 z
42.             rt_kprintf("No memory\n");
    
43.             return;
    # w7 l* n% \7 X3 K
44.         }
    ' i3 G& X& u( `6 A3 ]
45.     /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
    0 R& }# _  m8 d# j: p% A
46.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    
47.         {
    - @4 D6 o4 }% ^/ J% s
48.             /* 创建失败的错误处理 */
    - L1 Z% d5 D) Y( I
49. 
    * `' A2 P6 L8 S7 S: h
50.             rt_kprintf("Socket error\n");
    
51.             /* 释放已分配的接收缓冲 */
    
52.             rt_free(recv_data);
    2 {1 o! @4 s' q& F1 A7 S2 M/ ?
53.             return;
    
54.         }
    9 L4 ~2 ?4 X: r% V4 j
55.     /* 初始化服务端地址 */
    
56.     server_addr.sin_family = AF_INET;
    
57.     server_addr.sin_port = htons(5000);
    2 ~6 \2 n1 L" ~& y6 j
58.     /* 服务端工作的端口 */
    ; Q& D$ z5 {: k# n2 V( H; q
59.     server_addr.sin_addr.s_addr = INADDR_ANY;
    
60.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    , f+ S5 j: ?) g; t
61.     /* 绑定socket到服务端地址 */
    
62.     if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    
63.         {
    
64.             /* 绑定失败 */
    
65.             rt_kprintf("Unable to bind\n");
    , O, ]# ^6 ?2 d1 N$ H% H; F) s3 ^
66.             /* 释放已分配的接收缓冲 */
    6 j; \2 h. `) Y# v6 {" {/ d
67.             rt_free(recv_data);
    
68.             return;
    
69.         }
    
70.     /* 在socket上进行监听 */
    4 W4 u, l" k( W9 O
71.     if (listen(sock, 5) == -1)
    
72.         {
    
73.             rt_kprintf("Listen error\n");
    " U% J- c# ]- T. [/ ?7 K; ^& W  d
74.             /* release recv buffer */
    
75.             rt_free(recv_data);
    
76.             return;
    9 d: I  x; @# Q4 m0 X/ r
77.         }
    
78.     rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
    3 d; P" R2 ^& t5 `$ x% m
79.     while (stop != RT_TRUE)
    
80.         {
    - _8 X6 R3 e$ [3 @. |' N
81.             sin_size = sizeof(struct sockaddr_in);
    
82.             /* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
    + [. H: L$ N; t% x; Q. G. K
83.             connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
    
84.             /* 返回的是连接成功的socket */
    
85.             if (connected < 0)
    
86.                 {
    4 h# x& H0 \9 B: ]" Q/ d
87.                     rt_kprintf("accept connection failed! errno = %d\n", errno);
    3 q  [0 s3 H" e* ^
88.                     continue;
    
89.                 }
    
90.             /* 接受返回的client_addr指向了客户端的地址信息 */
    + u  P& @0 f& z0 E7 @
91.             rt_kprintf("I got a connection from (%s , %d)\n",
    
92.                        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    
93.             /* 客户端连接的处理 */
    ! A9 \0 p. Z$ r1 m
94.             while (1)
    4 z1 ]# q- l1 Y, h8 I  _- p# l
95.                 {
    
96.                     /* 发送数据到connected socket */
    
97.                     ret = send(connected, send_data, strlen(send_data), 0);
    2 k0 ]  X0 Y6 e+ w* K
98.                     if (ret < 0)
    * D" F. }# U& f$ P- C
99.                         {
    
100.                             /* 发送失败，关闭这个连接 */
     / g  B' N: x% T0 X0 [$ l$ a; P  U4 c
101.                             closesocket(connected);
     # w3 D$ t" Q* b8 y, E% l" U1 [' b
102.                             rt_kprintf("\nsend error,close the socket.\r\n");
     
103.                             break;
     
104.                         }
     
105.                     else if (ret == 0)
     ( r/ O- E# \9 v
106.                         {
     
107.                             /* 打印send函数返回值为0的警告信息 */
     . N6 X% l4 o  f' L' _7 }2 ^
108.                             rt_kprintf("\n Send warning,send function return 0.\r\n");
     . f7 N0 Q/ t& X% X
109.                         }
     
110.                     /* 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据 */
     
111.                     bytes_received = recv(connected, recv_data, BUFSZ, 0);
     $ O1 l2 ?1 Y( z) D
112.                     if (bytes_received < 0)
     
113.                         {
     
114.                             /* 接收失败，关闭这个connected socket */
     
115.                             closesocket(connected);
     4 T8 Y8 I+ l0 M; L
116.                             break;
     0 M6 c) e8 u9 H- W5 {
117.                         }
     * Y. e1 y# l: R7 \$ B6 ?5 {
118.                     else if (bytes_received == 0)
     
119.                         {
     
120.                             /* 打印recv函数返回值为0的警告信息 */
     
121.                             rt_kprintf("\nReceived warning,recv function return 0.\r\n");
     
122.                             closesocket(connected);
     
123.                             break;
     7 Y( f8 V8 n/ ~5 i- v# W3 K
124.                         }
     : r+ a: q7 Y/ J$ [7 g- ]
125.                     /* 有接收到数据，把末端清零 */
     
126.                     recv_data[bytes_received] = '\0';
     % b+ u+ o* A* t7 j2 x# Y" O6 g
127.                     if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
     # w( O2 ~  d8 N
128.                         {
     
129.                             /* 如果是首字母是q或Q，关闭这个连接 */
     / X; k) W" a: H* _- }9 F' d
130. 
     
131.                             closesocket(connected);
     
132.                             break;
     
133.                         }
     
134.                     else if (strcmp(recv_data, "exit") == 0)
     
135.                         {
     # S9 ?. u2 @6 A, j& `* J8 v0 L& [
136.                             /* 如果接收的是exit，则关闭整个服务端 */
     
137.                             closesocket(connected);
     
138.                             stop = RT_TRUE;
     
139.                             break;
     0 Y  S+ y& X+ D4 {$ `) |
140.                         }
     
141.                     else
     
142.                         {
     4 z5 K9 A% g  N7 s, f1 t4 ^5 O" p* }
143.                             /* 在控制终端显示收到的数据 */
     ' X6 _0 ~% p& T
144.                             rt_kprintf("RECEIVED DATA = %s \n", recv_data);
     , e' l# V7 U: f! X9 c+ G5 `
145.                         }
     
146.                 }
     
147.         }    /* 退出服务 */
     
148.     closesocket(sock);
     
149.     /* 释放接收缓冲 */
     , x+ `8 W2 v. Z5 z
150.     rt_free(recv_data);
     
151. 
     
152.     return ;
     . j  z! P' k9 a; b+ {& X
153. }
     
154. MSH_CMD_EXPORT(tcpserv, a tcp server sample);

复制代码

6 M; y& }" d3 ?* n# D
6 O" S+ M3 Z2 k搬运过来，给需要的朋友~

感谢分享

感谢分享