1、UDP Client
/ L: S- ]. }! T& m! ?/ v

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team *
   
3. * SPDX-License-Identifier: Apache-2.0 *
   9 S2 c6 j+ n# I7 A" _
4. * Change Logs: * Date            
   9 ~9 n9 k+ X! t: d
5. Author      Notes *
   
6. */
   
7. /*
   
8. * 程序清单：udp 客户端 *
   
9. * 这是一个 udp 客户端的例程
   
10. * 导出 udpclient 命令到控制终端
    & g' H, L( E0 c' @. t
11. * 命令调用格式：udpclient URL PORT [COUNT = 10]
    ; K; i9 \; N1 P1 h2 H% J2 Z
12. * URL：服务器地址  PORT：端口号  COUNT：可选参数 默认为 10
    3 h/ P# c$ c+ n8 P. H
13. * 程序功能：发送 COUNT 条数据到服务远端
    
14. */
    
15. #include <rtthread.h>
    1 p6 h! t" a+ E- F
16. #include <sys/socket.h> /* 使用BSD socket，需要包含sockets.h头文件 */
      e3 Z0 S/ V2 {7 L5 n( A' I
17. #include <netdb.h>
    7 C2 A% B  ]1 c
18. #include <string.h>
    $ w* P% j& v# |( o' A
19. #include <finsh.h>
    $ J# M7 q) T3 g) s% V1 a
20. 
    5 T7 ^- U7 i- r6 o: w, P, v. p
21. const char send_data[] = "This is UDP Client from RT-Thread.\n";
    ) A  D. k# S7 s/ t
22. /* 发送用到的数据 */
    % S; }. x$ x( r) N  }
23. void udpclient(int argc, char **argv)
    
24. {
    ) i$ D9 W  R9 z4 c9 x# k8 g
25.     int sock, port, count;
    - W& E: @0 u. G& @* v! m
26.     struct hostent *host;
    ; G/ p2 J/ B& _! Q6 R9 Y$ a
27.     struct sockaddr_in server_addr;
    , r: ^2 t, P! |) q$ N
28.     const char *url;
    7 d2 E7 C+ b5 n6 G8 w+ [. T- B
29.     if (argc < 3)
    # Z8 U: z2 r4 `
30.         {
    " ]3 ^" u) x. s% L
31.             rt_kprintf("Usage: udpclient URL PORT [COUNT = 10]\n");
    + d) c* ]  Z! [: g
32.             rt_kprintf("Like: tcpclient 192.168.1.9 8000\n");
    
33.             return ;
    
34.         }
    0 a0 `4 z8 l5 L% k4 b% ]
35.     url = argv[1];
    9 l4 o- f+ u5 C% g5 _8 C
36.     port = strtoul(argv[2], 0, 10);
    & C& A( H+ L! S% w
37.     if (argc > 3)
    0 h7 w: v, [1 f1 j# V% j$ m
38.         count = strtoul(argv[3], 0, 10);
    / R) ]: D2 R( W3 F
39.     else
    
40.         count = 10;
    0 ?$ }; g% [* S$ O6 `
41.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    
42.     host = (struct hostent *) gethostbyname(url);
      G" O- B, |0 |& P
43.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    % z6 Z* H: ~* o+ N$ A( F7 c$ M
44.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    : U/ m/ ?' w; |0 N$ k: N* @
45.         {
    
46.             rt_kprintf("Socket error\n");
    
47.             return;
    
48.         }
    . B: F4 {9 }5 M) s1 e+ S
49.     /* 初始化预连接的服务端地址 */
    * R4 R3 d1 S1 q  ]& s* J: C
50.     server_addr.sin_family = AF_INET;
    , A% `. _+ H8 i6 ?0 p
51.     server_addr.sin_port = htons(port);
    ' A. _( }) r0 Q
52.     server_addr.sin_addr = *((struct in_addr *)host->h_addr);
    8 t7 s$ X. |" i
53.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    
54.     /* 总计发送count次数据 */
      C4 P9 f" f' ?. B! ^- q
55.     while (count)
    
56.         {
    : x. [, f/ y0 ~" a
57.             /* 发送数据到服务远端 */
    
58.             sendto(sock, send_data, strlen(send_data), 0,               (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
    / Z3 k) W/ t) K' \
59.             /* 线程休眠一段时间 */
    8 y& d: ~5 H% N/ x" u" f
60.             rt_thread_delay(50);
    ! X0 r0 L& I" \& W
61.             /* 计数值减一 */
    & y7 ]( h0 T, ~" i- ^3 M7 q6 r
62.             count --;
    ' X- e; b+ ]1 O8 g  q1 k3 J
63.         }
    
64.     /* 关闭这个socket */
    ( d& t! P3 _' p0 n
65.     closesocket(sock);
    
66. }
    - {1 D2 z0 R0 ^  k* [5 w
67. MSH_CMD_EXPORT(udpclient, a udp client sample);
    
68. 
    

复制代码

2、UDP Server

1. #include <rtthread.h>
   ) E5 J& v* L. Q# W
2. #include <sys/socket.h>
   
3. /* 使用BSD socket，需要包含socket.h头文件 */
   % q% Y8 Y6 d# Q5 p) X' S9 P3 q2 {
4. #include <netdb.h>
   
5. #include <string.h>
   ! p' M4 D  U" G- t8 T  g- i- |
6. #include <finsh.h>
   4 p5 y% k& \- a3 D) l8 J- V
7. #define BUFSZ   1024
   1 n$ V) m: w: Z$ v% c8 ^- _
8. static void udpserv(int argc, char **argv)
   7 m- s- ?4 b3 t' W
9. {
   
10.     int sock;
    ; F( w3 `, b$ n* P8 g6 }
11.     int bytes_read;
    8 a( _. {/ y) G! ?. p$ L+ q: o
12.     char *recv_data;
    
13.     socklen_t addr_len;
    
14.     struct sockaddr_in server_addr, client_addr;
    3 G1 [) p) `6 \/ G% [  \; ~
15.     /* 分配接收用的数据缓冲 */
    
16.     recv_data = rt_malloc(BUFSZ);
    
17.     if (recv_data == RT_NULL)
    7 H5 p1 q2 X& m7 W( \/ S
18.         {
    
19.             /* 分配内存失败，返回 */        
      J" G9 W5 D# O
20.                         rt_kprintf("No memory\n");
    + z" s4 Y6 x5 F: Z' G" `
21.             return;
    
22.         }
    
23.     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
    
24.     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
    
25.         {
    * W; ~, i6 `  d* _9 f
26.             rt_kprintf("Socket error\n");
    ! W+ s/ ?; C2 _, h0 a! M
27.             /* 释放接收用的数据缓冲 */        
    
28.                         rt_free(recv_data);
    6 F! A7 V; r" S6 i# C0 M
29.             return;
    
30.         }
    
31.     /* 初始化服务端地址 */
    
32.     server_addr.sin_family = AF_INET;
    1 N3 O# ]( b0 X
33.     server_addr.sin_port = htons(5000);
    
34.     server_addr.sin_addr.s_addr = INADDR_ANY;
    8 O# B9 u; b7 }
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)
    ! h/ V& @1 I' P
38.         {
    
39.             /* 绑定地址失败 */
    2 w8 v3 m3 p3 Z
40.             rt_kprintf("Bind error\n");
    # [: |. x- c, }0 f1 H! R1 t) u5 a/ B7 V
41.             /* 释放接收用的数据缓冲 */
    6 }% i% v9 c) T
42.             rt_free(recv_data);
    
43.             return;
    
44.         }
    5 ?6 E" i2 \7 _
45.     addr_len = sizeof(struct sockaddr);
    0 C  [7 g- l# h( z- d
46.     rt_kprintf("UDPServer Waiting for client on port 5000...\n");
    0 [9 D& K. F4 @
47.     while (1)
    
48.         {
    & D9 c) _) y" i  q5 u
49.             /* 从sock中收取最大BUFSZ - 1字节数据 */
    3 {9 V: I' b3 P7 u* h3 ]
50. 
    
51.             bytes_read = recvfrom(sock, recv_data, BUFSZ - 1, 0,
    
52.                                   (struct sockaddr *)&client_addr, &addr_len);
    
53.             /* UDP不同于TCP，它基本不会出现收取的数据失败的情况，除非设置了超时等待 */
    
54.             recv_data[bytes_read] = '\0';         /* 把末端清零 */
    * G5 C/ W6 w+ V% S( R- J& N. h% ^$ d
55.             /* 输出接收的数据 */
    0 L  J% Q% c9 q, D' s  ~- e* c
56.             rt_kprintf("\n(%s , %d) said : ", inet_ntoa(client_addr.sin_addr),
    3 J5 D1 }- L" T, [* t
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);
    ) M! b7 {2 R, B' F5 `# k8 Y5 C* Z- I
61.             /* 如果接收数据是exit，退出 */        
    - t" w9 y# {- r9 T
62.                         if (strcmp(recv_data, "exit") == 0)
    9 L9 }1 E  ?8 E5 v) }
63.                 {
    / |: P# S4 V" F6 m! q2 f
64.                     closesocket(sock);            /* 释放接收用的数据缓冲 */
    
65.                     rt_free(recv_data);
    
66.                     break;
    
67.                 }
    ' |& a: x2 _7 w! w
68.         }
    $ D' {% G/ p) }
69.     return;
    $ u3 g+ P7 e- g" C4 ]" m  b
70. }
    
71. 
    
72. MSH_CMD_EXPORT(udpserv, a udp server sample);
    6 ]2 p7 B- r" T# d( X

复制代码

3、TCP Client

1. /*
   
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   $ o% C% q  P  k/ P% a' J
3. *
   : w9 J& ?% X7 |0 O" S% x
4. * SPDX-License-Identifier: Apache-2.0 *
   # L2 O( q. v/ a$ K9 K
5. * Change Logs:
   
6. * Date             Author      Notes *
   
7. */
   7 \; z& z8 w; Y! o. G9 U2 W" ^
8. /*
   9 @! v( W0 {9 V) e
9. * 程序清单：tcp 客户端
   
10. *
    
11. * 这是一个 tcp 客户端的例程
    
12. * 导出 tcpclient 命令到控制终端
    - G) J; B( N' r  j8 N
13. * 命令调用格式：tcpclient URL PORT
    
14. * URL：服务器地址 PORT:：端口号
    : M4 e" @  M8 E) s0 V. E" `
15. * 程序功能：接收并显示从服务端发送过来的信息，接收到开头是 'q' 或 'Q' 的信息退出程序
    
16. */
    2 j0 r1 u5 \) O3 X; `# V; n
17. #include <rtthread.h>
    
18. #include <sys/socket.h>
    # g" i  f  K3 \2 }7 z: |
19. /* 使用BSD socket，需要包含socket.h头文件 */
    & a$ Y* R* }( _
20. #include <netdb.h>
    
21. #include <string.h>
    * x: a/ [6 A2 m; n& G
22. #include <finsh.h>
    
23. #define BUFSZ   1024
      A8 Z' X& Q! d# T6 |: n, t
24. static
    / X+ n5 C5 V1 i
25. const char send_data[] = "This is TCP Client from RT-Thread.";
    + J9 |- c) ]5 O
26. /* 发送用到的数据 */
    7 t- f7 C, f- N* }6 `& P$ v
27. void tcpclient(int argc, char **argv)
    
28. {
    
29.     int ret;
    4 J% ?( Q3 q% y% `3 H, n; j# v( F
30.     char *recv_data;
    
31.     struct hostent *host;
    
32.     int sock, bytes_received;
    + k" r& ?+ T6 ?. @9 {
33.     struct sockaddr_in server_addr;
      Y' ^5 s& M8 {. V( f# Y$ V
34.     const char *url;
    
35.     int port;
    
36.     if (argc < 3)
    - E0 {( ^+ N8 Y( R7 D, h
37.         {
    + l* q; `2 L9 E2 y+ s
38.             rt_kprintf("Usage: tcpclient URL PORT\n");
    # p# n) U. m1 ]6 a, D% l
39.             rt_kprintf("Like: tcpclient 192.168.12.44 5000\n");
    
40.             return ;
    # A: v2 E4 k# S8 A% T% ~+ t& o5 l2 X
41.         }
    
42.     url = argv[1];
    
43.     port = strtoul(argv[2], 0, 10);
    : A4 l$ m4 Z8 N6 _, l
44.     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    
45.     host = gethostbyname(url);
    
46.     /* 分配用于存放接收数据的缓冲 */
    ; K! l! W7 U7 G6 V3 N
47.     recv_data = rt_malloc(BUFSZ);
    
48.     if (recv_data == RT_NULL)
    & ~% r% @* ^- W8 L
49.         {
    4 v. d; O4 y* e& r" e
50.             rt_kprintf("No memory\n");
    $ q7 q. y" x$ g# M' Z  ]% a, J
51.             return;
    
52.         }
    ) b; G: D) Y, n% r* X
53.     /* 创建一个socket，类型是SOCKET_STREAM，TCP类型 */
    
54.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    , v4 w$ y" k) |0 S  l/ Y
55.         {
    
56.             /* 创建socket失败 */
    1 P( k! ]' S# m: S9 G' l
57.             rt_kprintf("Socket error\n");
    $ N5 Z6 h, |6 b# [
58.             /* 释放接收缓冲 */
    
59.             rt_free(recv_data);
    
60.             return;
    # e; P; t; K: m
61.         }
    
62.     /* 初始化预连接的服务端地址 */
    
63.     server_addr.sin_family = AF_INET;
    3 ?, p4 V  d/ ^" r  _0 c3 f$ f
64.     server_addr.sin_port = htons(port);
    ' H0 K$ X1 g5 a+ ]  k& r) H
65.     server_addr.sin_addr = *((struct in_addr *)host->h_addr);
    
66.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    9 Z4 j- h: _" F! d2 X+ N
67.     /* 连接到服务端 */
    6 r1 q& ]6 g* Y9 l* ^2 {, @, [
68.     if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    ) H7 W% K) y7 x- L
69.         {
    4 a. f: a+ Z  F& ^, z+ T- ]
70.             /* 连接失败 */
    
71.             rt_kprintf("Connect fail!\n");
    
72.             closesocket(sock);
    ; _6 x& G: x6 {9 f6 a' v
73.             /*释放接收缓冲 */
    ( B9 r- w' I! d
74.             rt_free(recv_data);
    ! \' V. o/ C' c$ D  m/ Z/ R4 K  z- c
75.             return;
    
76.         }
    
77.     while (1)
    
78.         {
    
79.             /* 从sock连接中接收最大BUFSZ - 1字节数据 */
    
80.             bytes_received = recv(sock, recv_data, BUFSZ - 1, 0);
    9 s' t1 X$ i: W& |- c8 y8 f3 n: ^
81.             if (bytes_received < 0)
    
82.                 {
    & q/ q; K1 e  r2 y( D  T
83.                     /* 接收失败，关闭这个连接 */
    & L+ g5 Y- |, c4 `5 ]! p5 u" Y2 e
84.                     closesocket(sock);
    0 q4 D  c* [. J, k; B7 ~
85.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    8 P6 e: Y5 ?. Q7 P; F8 h: R( J
86.                     /* 释放接收缓冲 */
    ' u( \6 H7 m' l& B4 F
87.                     rt_free(recv_data);
    
88.                     break;
    
89.                 }
    3 J" I& L8 a1 D8 g
90.             else if (bytes_received == 0)
    / r5 ?, L+ }/ c' a4 Q
91.                 {
    6 y& o$ c, l( c4 D3 V. q
92.                     /* 默认 recv 为阻塞模式，此时收到0认为连接出错，关闭这个连接 */
    
93.                     closesocket(sock);
    , e- g! s/ D+ T$ c, c* H7 t
94.                     rt_kprintf("\nreceived error,close the socket.\r\n");
    + U8 w- j0 j% W' ^
95.                     /* 释放接收缓冲 */
    
96.                     rt_free(recv_data);
    & {3 u& F  T' T9 ?
97.                     break;
    
98.                 }
    
99.             /* 有接收到数据，把末端清零 */
    
100.             recv_data[bytes_received] = '\0';
     
101.             if (strncmp(recv_data, "q", 1) == 0 || strncmp(recv_data, "Q", 1) == 0)
     
102.                 {
     / B4 A7 f# z4 P& l
103.                     /* 如果是首字母是q或Q，关闭这个连接 */
     
104.                     closesocket(sock);
     
105.                     rt_kprintf("\n got a 'q' or 'Q',close the socket.\r\n");
     
106.                     /* 释放接收缓冲 */
     
107.                     rt_free(recv_data);
     
108.                     break;
     
109.                 }
     
110.             else
     3 ?. r' P8 `2 Q" @! |, A
111.                 {
     
112.                     /* 在控制终端显示收到的数据 */
     ! Q! D6 @1 e( J$ J$ W3 Q
113.                     rt_kprintf("\nReceived data = %s ", recv_data);
     0 G7 d8 m) h6 Z4 |5 U' S, m
114.                 }        /* 发送数据到sock连接 */
     
115.             ret = send(sock, send_data, strlen(send_data), 0);
     
116.             if (ret < 0)
     % f4 Y8 Q5 r/ |& U- T1 W" x! A+ D
117.                 {
     + M7 J; Q1 f) f# F4 |( x& B2 |
118.                     /* 接收失败，关闭这个连接 */
     3 u  E% p4 ]$ Z1 c$ i8 p% ?" c: Q
119.                     closesocket(sock);
     ' U; t6 Z3 c0 ~* Z/ V& Y: C
120.                     rt_kprintf("\nsend error,close the socket.\r\n");
     
121.                     rt_free(recv_data);
     
122.                     break;
     , f6 \+ U, {8 Q6 G2 J
123.                 }
     
124.             else if (ret == 0)
     : m+ [- C5 c( |1 o/ Z" e. z5 j9 n
125.                 {
     % l9 `  ^  P0 L9 `, G3 L( X/ h! [$ s
126.                     /* 打印send函数返回值为0的警告信息 */
     8 O0 n4 ?( n& V  f9 G7 l: n. M2 i( d
127.                     rt_kprintf("\n Send warning,send function return 0.\r\n");
     
128.                 }
     
129.         }
     9 g2 K3 h+ ?4 ]% |7 j5 d6 Q( K
130.     return;
     + ^  F) t' m; e& `  F( X( [5 c2 B
131. }
     ! P! [- v. z, n8 v3 i
132. MSH_CMD_EXPORT(tcpclient, a tcp client sample);
     

复制代码

4、TCP server

1. /*
   2 A  F* ]$ `$ p8 `% B8 c- v+ O
2. * Copyright (c) 2006-2018, RT-Thread Development Team
   
3. *
   ) o' S3 I7 \% A6 ~' p$ ~, F
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   
6. * Change Logs:
   
7. * Date             Author      Notes
   " P6 j. }) f& j, T1 q; F/ ~# s( B  b
8. *
   ) N% A' K9 Y% |' i  g$ z% o9 J
9. */
   
10. /*
    + C! B" W! W/ m! ^7 G
11. * 程序清单：tcp 服务端
    
12. *
    ( p8 Q% N" ~+ h  @
13. * 这是一个 tcp 服务端的例程
    9 u1 F( H% ]- ?% y, t
14. * 导出 tcpserv 命令到控制终端
    + m; [8 S3 W) |+ x4 l3 |  C
15. * 命令调用格式：tcpserv
    / x. F1 m! k. N/ p
16. * 无参数
    . k8 V+ I' \+ M5 f: J
17. * 程序功能：作为一个服务端，接收并显示客户端发来的数据 ，接收到 exit 退出程序
    
18. */
    
19. #include <rtthread.h>
    
20. #include <sys/socket.h>
    # ~' }( k4 B# i' q9 h
21. /* 使用BSD socket，需要包含socket.h头文件 */
    
22. #include <netdb.h>
    
23. #include <string.h>
    
24. #include <finsh.h>
    
25. #define BUFSZ       (1024)
    " V" w( E/ i8 c' u! V
26. static const char send_data[] = "This is TCP Server from RT-Thread.";
    ( `* H5 i  l# g( ^6 J: t
27. /* 发送用到的数据 */
    
28. static void tcpserv(int argc, char **argv)
    
29. {
    
30.     char *recv_data;
    
31.     /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
    
32.     socklen_t sin_size;
    
33.     int sock, connected, bytes_received;
    7 d6 \4 f3 |: {- a' M; h3 d
34.     struct sockaddr_in server_addr, client_addr;
    
35.     rt_bool_t stop = RT_FALSE;
    9 ^* V9 p, v8 t5 l& Q+ _
36.     /* 停止标志 */
    
37.     int ret;
    
38.     recv_data = rt_malloc(BUFSZ + 1);
    
39.     /* 分配接收用的数据缓冲 */
    
40.     if (recv_data == RT_NULL)
    
41.         {
    
42.             rt_kprintf("No memory\n");
    # N) t, E% g& v% P# u" L) _, J
43.             return;
    ! A1 H. c$ S/ _* |+ ~! ~
44.         }
      D7 ~8 \/ o, L8 s! C& X: |" j
45.     /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
    & t* d' R* H7 ?) m# N5 w
46.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    3 Y: |) t2 e6 g% N7 B8 B! y" C6 Q
47.         {
    8 W: x5 ~, p4 d  N, s5 `2 {
48.             /* 创建失败的错误处理 */
    
49. 
    : {/ {0 e3 M. B2 j6 w: x
50.             rt_kprintf("Socket error\n");
    6 H' g8 R4 Q- R) i* w1 E
51.             /* 释放已分配的接收缓冲 */
    
52.             rt_free(recv_data);
    & D' L; z4 d! E* Y: z; Q1 d5 q' D0 N
53.             return;
    
54.         }
    5 a* Q" ^) T' `# w3 q/ p+ K; v! x
55.     /* 初始化服务端地址 */
    4 h/ S4 L# r* G- ?% k# u5 L
56.     server_addr.sin_family = AF_INET;
    * D- O, {) ?5 `  `4 N3 O/ `
57.     server_addr.sin_port = htons(5000);
    & Y0 }4 \8 m/ m5 I7 A; Y0 _+ h- Y
58.     /* 服务端工作的端口 */
      C$ N0 H5 [8 j9 M3 j& t
59.     server_addr.sin_addr.s_addr = INADDR_ANY;
    
60.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    8 R" {. v8 M- N; T0 f9 ?" d& y
61.     /* 绑定socket到服务端地址 */
    
62.     if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    # {. u2 N0 D( a
63.         {
    
64.             /* 绑定失败 */
    + {9 s9 t* o- L6 H9 A$ n
65.             rt_kprintf("Unable to bind\n");
    
66.             /* 释放已分配的接收缓冲 */
    
67.             rt_free(recv_data);
    
68.             return;
    
69.         }
    
70.     /* 在socket上进行监听 */
    
71.     if (listen(sock, 5) == -1)
    
72.         {
    & s- O( z. ^; e& D2 x# a
73.             rt_kprintf("Listen error\n");
    
74.             /* release recv buffer */
    7 i! d# ~8 z2 c' ^3 y( t2 e! [
75.             rt_free(recv_data);
    ; `) z6 z- X' F, F- ^' [, E
76.             return;
    
77.         }
    ! X0 N: ?& n% F% j2 ?2 U1 ?
78.     rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
    
79.     while (stop != RT_TRUE)
    
80.         {
    6 x" K/ B9 }6 y" v7 b; Q8 U# Q
81.             sin_size = sizeof(struct sockaddr_in);
    ( a& H8 o4 k( H
82.             /* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
    " [& y% i7 }" D$ a, o
83.             connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
    + B! c1 `% r+ W5 X
84.             /* 返回的是连接成功的socket */
    # M; S0 q0 V! E9 {3 C
85.             if (connected < 0)
    
86.                 {
      {1 r5 A; [! ^" |+ X7 |
87.                     rt_kprintf("accept connection failed! errno = %d\n", errno);
    
88.                     continue;
    
89.                 }
    * k) g! Y% _9 S, `
90.             /* 接受返回的client_addr指向了客户端的地址信息 */
    
91.             rt_kprintf("I got a connection from (%s , %d)\n",
    0 U5 w6 Q$ |9 A( T3 h1 O
92.                        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    + B# p* ?% \+ O1 a2 t" M
93.             /* 客户端连接的处理 */
    
94.             while (1)
    
95.                 {
    
96.                     /* 发送数据到connected socket */
    1 p+ H, v9 O8 h  ~+ ^
97.                     ret = send(connected, send_data, strlen(send_data), 0);
    + `5 ?6 L1 U8 @8 D
98.                     if (ret < 0)
    
99.                         {
    # h3 ]' T  i; Q5 r, d
100.                             /* 发送失败，关闭这个连接 */
     
101.                             closesocket(connected);
     4 ^( R; L& E* N$ r0 e* y2 p
102.                             rt_kprintf("\nsend error,close the socket.\r\n");
     
103.                             break;
     
104.                         }
     ) N0 f$ B" b, t2 a+ y9 I
105.                     else if (ret == 0)
     
106.                         {
     " W0 ?* h: k' v6 H
107.                             /* 打印send函数返回值为0的警告信息 */
     
108.                             rt_kprintf("\n Send warning,send function return 0.\r\n");
     3 {( \' h2 s* m
109.                         }
     2 ?, X  i4 ~4 B- q( ^8 r
110.                     /* 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据 */
     
111.                     bytes_received = recv(connected, recv_data, BUFSZ, 0);
     
112.                     if (bytes_received < 0)
     % O0 h* w, \1 `* ^: A% \
113.                         {
     
114.                             /* 接收失败，关闭这个connected socket */
     
115.                             closesocket(connected);
     + b7 e$ B( E7 F8 c% I
116.                             break;
     ; s1 \6 _* C8 {
117.                         }
     & y4 c# j, I" c+ f$ t" c
118.                     else if (bytes_received == 0)
     
119.                         {
     
120.                             /* 打印recv函数返回值为0的警告信息 */
     $ c1 ?/ b  X3 ^' s
121.                             rt_kprintf("\nReceived warning,recv function return 0.\r\n");
     
122.                             closesocket(connected);
     
123.                             break;
     $ t' B, j! c  v$ Y6 b) A
124.                         }
     - S  F7 h! Q% R
125.                     /* 有接收到数据，把末端清零 */
     
126.                     recv_data[bytes_received] = '\0';
     
127.                     if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
     
128.                         {
     ! ]) z6 o. n) Q8 |7 {- h  g5 R+ a
129.                             /* 如果是首字母是q或Q，关闭这个连接 */
     
130. 
     
131.                             closesocket(connected);
     
132.                             break;
     ! g" j; s4 N- T, p
133.                         }
     
134.                     else if (strcmp(recv_data, "exit") == 0)
     
135.                         {
     
136.                             /* 如果接收的是exit，则关闭整个服务端 */
     0 l4 S! W0 G4 t+ v% k
137.                             closesocket(connected);
     
138.                             stop = RT_TRUE;
     3 L, L. t; t6 E, B- n  [# W% @% |
139.                             break;
     
140.                         }
     
141.                     else
     
142.                         {
     
143.                             /* 在控制终端显示收到的数据 */
     
144.                             rt_kprintf("RECEIVED DATA = %s \n", recv_data);
     , f) K9 @$ I( B! K
145.                         }
     ' K! ~: [# \$ w- m! ]; L( W/ C: j5 ^
146.                 }
     % T) C& G, W) m5 v
147.         }    /* 退出服务 */
       i2 \) e, P6 z" j9 l
148.     closesocket(sock);
     " u. E' P9 e4 L
149.     /* 释放接收缓冲 */
     5 M% T3 `2 t2 A4 d# y0 Q' q9 D
150.     rt_free(recv_data);
     
151. 
     1 S: _5 ^& Q: _) Y6 ]2 N/ h1 d
152.     return ;
     : ]" m+ H6 X! S! ?* _
153. }
     
154. MSH_CMD_EXPORT(tcpserv, a tcp server sample);

复制代码

搬运过来，给需要的朋友~
$ }0 Y* a  f2 b# J+ Q# {

感谢分享

感谢分享