怎么确保RL-TCPnet建立的tcp server只接收一个Client的请求，其他client再连接时提示连接失败

木兰花

怎么确保RL-TCPnet建立的tcp server只接收一个Client的请求，即有一个client连接到server后，其他client就无法再连接这个server了，其他client再连接时提示连接失败，这个需要怎么配置呢？

哪位这样操作过，指点一下，谢谢先

eric2013

原始Socket不用配置，TCP就是一对一的。一个服务器对应一个客户端。

如果你用的是BSD Socket，链接后关闭监听就可以了。

木兰花

eric2013 发表于 2018-7-30 12:13
原始Skcket不用配置，TCP就是一对一的。一个服务器对应一个客户端。

如果你用的是BSD Socket，链接后关 ...

listen函数的参数中没有关闭监听的参数啊，怎么关闭监听呢

eric2013

看这个帖子里面BSD Socket例子即可

http://www.armbbs.cn/forum.php?m ... &extra=page%3D1

captainliuy

木兰花 发表于 2018-7-30 21:06
listen函数的参数中没有关闭监听的参数啊，怎么关闭监听呢

关掉listen的sock就行，适当的时候关掉newconn，然后就可以重新listen了

1.                /* listen for incoming connections (TCP listen backlog = 1) */
   
2.                 listen(sock, 1);
   
3. 
   
4.                 size = sizeof(remotehost);
   
5.                 newconn = accept(sock, (struct sockaddr *)&remotehost, (socklen_t *)&size);
   
6.                 close(sock);

复制代码

木兰花

captainliuy 发表于 2018-7-31 12:05
关掉listen的sock就行，适当的时候关掉newconn，然后就可以重新listen了

测试发现，只需listen(sock, 0);即可实现只连接一个连接的需求，不关闭监听socket可以吗？

木兰花

eric2013 发表于 2018-7-31 02:04
看这个帖子里面BSD Socket例子即可

http://www.armbbs.cn/forum.php?mod=viewthread&tid=26034&extra ...

谢谢啦，这个例程写的很好，太感谢啦

1. void TCPnetTest(void)
   
2. {  
   
3.         char dbuf[10];
   
4.         int len;
   
5.         int sock, sd, res;
   
6.         SOCKADDR_IN addr;
   
7.         SOCKADDR_IN ReAddr;
   
8. 
   
9.        
   
10.         while (1)
    
11.         {
    
12.                 /* 创建一个socket
    
13.                    第1个参数AF_INET：当前仅支持这个类型的地址族。
    
14.                    第2个参数SOCK_STREAM：表示数据流通信类型，即使用的TCP。
    
15.                    第3个参数0 ：配置为0的话，自动跟第2个参数进行协议匹配，这里就是TCP协议。
    
16.                 */
    
17.                 sock = socket (AF_INET, SOCK_STREAM, 0);
    
18. 
    
19.                 /* 端口号设置为1001 */
    
20.                 addr.sin_port        = htons(LocalPort_NUM);
    
21.                
    
22.                 /* 与函数socket中的AF_INET作用一样 */
    
23.                 addr.sin_family      = PF_INET;
    
24.                 /*
    
25.                    INADDR_ANY就是指定地址为0.0.0.0的地址，这个地址事实上表示不确定地址，或所有地址，
    
26.                    任意地址。用在这里的话就表示监控端口号为ddr.sin_port的所有IP地址消息。一般主要用
    
27.                    于有多个网卡或者IP地址的情况。开发板只用了DM9161的网口，就是监听这个网口的IP地址。
    
28.                 */
    
29.                 addr.sin_addr.s_addr = INADDR_ANY;
    
30.                
    
31.                 /* 给socket绑定IP和端口号 */
    
32.                 bind (sock, (SOCKADDR *)&addr, sizeof(addr));
    
33. 
    
34.                 /* 设置监听，最大监听1个连接 */
    
35.                 listen (sock, 1);
    
36.                
    
37.                 /*
    
38.                    等待soket连接请求，有的话，自动创建1个新的socket进行连接通信，没有的话，等待连接。
    
39.                    注意，能够accept的个数受到listen函数的限制，而listen函数又受到Net_Config.c中宏定义
    
40.                    BSD_NUMSOCKS 的限制。
    
41.                 */
    
42.                 len = sizeof(ReAddr);
    
43.                 sd = accept (sock, (SOCKADDR *)&ReAddr, &len);
    
44.                 printf_debug ("远程客户端请求连接IP: %d.%d.%d.%d\n", ReAddr.sin_addr.s_b1,
    
45.                                                              ReAddr.sin_addr.s_b2,
    
46.                                                                                                                          ReAddr.sin_addr.s_b3,
    
47.                                                              ReAddr.sin_addr.s_b4);
    
48.                 printf_debug ("远程客户端端口号: %d\n", ntohs(ReAddr.sin_port));
    
49.                
    
50.                 /* 关闭监听socket，这个监听socket是调用函数socket后自动创建的 */
    
51.                 closesocket (sock);
    
52.                 sock = sd;
    
53. 
    
54.                
    
55.                 while (1)
    
56.                 {
    
57.                         /*
    
58.                           socket数据接收函数，如果recv工作在阻塞模式，使用这个函数注意以下事项：
    
59.                           1. 此函数的溢出时间受到Net_Config.c中宏定义 BSD_RCVTOUT 的限制。溢出时间到会自动退出。
    
60.                           2. 这个函数接收到一次数据包就会返回，大于或者小于设置的缓冲区大小都没有关系，如果数据量
    
61.                              大于接收缓冲区大小，用户只需多次调用函数recv进行接收即可。
    
62.                           3. 实际接收到数据大小通过判断此函数的返回值即可。
    
63.                         */
    
64.                         res = recv (sock, dbuf, sizeof(dbuf), 0);
    
65.                         if (res <= 0)
    
66.                         {
    
67.                                 printf_debug("退出接收函数，重新开始监听%s\r\n", ReVal_Table[abs(res)]);
    
68.                                 break;
    
69.                         }
    
70.                         else
    
71.                         {
    
72.                                 printf_debug("Receive Data Length = %d\r\n", res);
    
73.                                 switch(dbuf[0])
    
74.                                 {
    
75.                                         /* 字符命令 1 */
    
76.                                         case '1':
    
77.                                                 sendbuf[0] = '1';
    
78.                                                 sendbuf[1] = '2';
    
79.                                                 sendbuf[2] = '3';
    
80.                                                 sendbuf[3] = '4';
    
81.                                                 sendbuf[4] = '5';
    
82.                                                 sendbuf[5] = '6';
    
83.                                                 sendbuf[6] = '7';
    
84.                                                 sendbuf[7] = '8';
    
85.                                                 sendbuf[8] = '\r';
    
86.                                                 sendbuf[9] = '\n';                                               
    
87.                                                 res = send (sock, (char *)sendbuf, 10, 0);
    
88.                                                 if (res < 0)
    
89.                                                 {
    
90.                                                         printf_debug("函数send发送数据失败\r\n");
    
91.                                                 }
    
92.                                                 else
    
93.                                                 {
    
94.                                                         printf_debug("函数send发送数据成功\r\n");                                                       
    
95.                                                 }
    
96.                                                 break;
    
97.                                        
    
98.                                         /* 字符命令 2 */
    
99.                                         case '2':
    
100.                                                 /* 将数据缓冲区清成字符0，方便网络调试助手查看数据 */
     
101.                                                 len = sizeof(sendbuf);
     
102.                                                 memset(sendbuf, 48, len);
     
103.                                        
     
104.                                                 /* 这里仅初始化了数据包的前4个字节和最后4个字节 */
     
105.                                                 sendbuf[0] = 'a';
     
106.                                                 sendbuf[1] = 'b';
     
107.                                                 sendbuf[2] = 'c';
     
108.                                                 sendbuf[3] = 'd';
     
109.                                                 sendbuf[len - 4] = 'e';
     
110.                                                 sendbuf[len - 3] = 'f';
     
111.                                                 sendbuf[len - 2] = 'g';
     
112.                                                 sendbuf[len - 1] = 'h';                                       
     
113.                                                 res = send (sock, (char *)sendbuf, len, 0);
     
114.                                                 if (res < 0)
     
115.                                                 {
     
116.                                                         printf_debug("函数send发送数据失败%s\r\n", ReVal_Table[abs(res)]);
     
117.                                                 }
     
118.                                                 else
     
119.                                                 {
     
120.                                                         printf_debug("函数send成功发送数据 = %d字节\r\n", res);                                                       
     
121.                                                 }
     
122.                                                 break;
     
123.                                
     
124.                                         /* 其它数值不做处理 */
     
125.                                         default:                     
     
126.                                                 break;
     
127.                                 }
     
128.                         }
     
129. 
     
130.                 }
     
131.                
     
132.                 /*
     
133.                    溢出时间到，远程设备断开连接等，程序都会执行到这里，我们在这里关闭socket，
     
134.                    程序返回到第一个大while循环的开头重新创建socket并监听。
     
135.                 */
     
136.                 closesocket (sock);
     
137.         }
     
138. }
     

复制代码

木兰花

eric2013 发表于 2018-7-31 02:04
看这个帖子里面BSD Socket例子即可

http://www.armbbs.cn/forum.php?mod=viewthread&tid=26034&extra ...

测试发现，只需listen(sock, 0);即可实现只连接一个连接的需求，为什么还有关闭闭监听socket呢？

eric2013

木兰花 发表于 2018-8-1 18:31
测试发现，只需listen(sock, 0);即可实现只连接一个连接的需求，为什么还有关闭闭监听socket呢？

监听本身也要占用1个Socket的，所以要关闭了，无需再占用资源。

配置为0也行吗，这个回头我也测试下。

木兰花

eric2013 发表于 2018-8-1 18:40
监听本身也要占用1个Socket的，所以要关闭了，无需再占用资源。

配置为0也行吗，这个回头我也测试下。

哦哦，那我也关闭它吧
配置为0时似乎不太稳定，有时只能连接一个client，有时第二个也能连接成功，但是数据收发不了