lwip 同时开启不同端口的tcp server不能同时连接

发布于 2020-12-09 14:10:50 浏览：1673 订阅该版

我在调试lwip的时候，板子上开了3个TCP service，对应不同的端口(8000、8001、8002)，调试的时候发现只有一个客户端能连接上，开第二个客户端的时候会把之前的客户端的连接断开，不能同时三个都连接上，能帮忙分析一下吗 谢谢各位
```c
/*
 * Copyright (c) 2006-2018, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date             Author      Notes
 *
 */
/*
* 程序清单：tcp 服务端
 *
 * 这是一个 tcp 服务端的例程
 * 导出 tcpserv 命令到控制终端
 * 命令调用格式：tcpserv
 * 无参数
 * 程序功能：作为一个服务端，接收并显示客户端发来的数据 ，接收到 exit 退出程序
*/
#include <rtthread.h>
#include <sys/socket.h> /* 使用BSD socket，需要包含socket.h头文件 */
#include <netdb.h>
#include <string.h>
#include <finsh.h>

#include "my_uart.h"

#define DBG_SECTION_NAME    "tcpserver"
#define DBG_LEVEL           DBG_LOG
#include <rtdbg.h>

#define THREAD_PRIORITY         5
#define THREAD_STACK_SIZE       2048
#define THREAD_TIMESLICE        5

#define BUFSZ       (1024)

static const char send_data[] = "This is TCP Server from RT-Thread."; /* 发送用到的数据 */
static const char send1_data[1024]; 
static void tcpserv1_entry(void *parameter)
{
    char *recv_data; /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
    socklen_t sin_size;
    int sock, connected, bytes_received;
    struct sockaddr_in server_addr, client_addr;
    int ret;
    char *port_str;
    rt_uint16_t port;
    rt_uint8_t i;
  
    recv_data = rt_malloc(BUFSZ + 1); /* 分配接收用的数据缓冲 */
    if (recv_data == RT_NULL)
    {
        rt_kprintf("No memory\n");
        return;
    }

while(1)
        {
            port = 8001;
        
            /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
            if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
            {
                /* 创建失败的错误处理 */
                rt_kprintf("Socket error\n");

/* 释放已分配的接收缓冲 */
                rt_free(recv_data);
                return;
            }
        
            /* 初始化服务端地址 */
            server_addr.sin_family = AF_INET;
            server_addr.sin_port = htons(port); /* 服务端工作的端口 */
            server_addr.sin_addr.s_addr = INADDR_ANY;
            rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));

/* 绑定socket到服务端地址 */
            if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
            {
                /* 绑定失败 */
                rt_kprintf("Unable to bind\n");

/* 释放已分配的接收缓冲 */
//                rt_free(recv_data);
                continue;
            }

/* 在socket上进行监听 */
            if (listen(sock, 2) == -1)
            {
                rt_kprintf("Listen error\n");

/* release recv buffer */
//                rt_free(recv_data);
                continue;
            }

LOG_D("TCPServer Waiting for client on port %d...", port);
         
            sin_size = sizeof(struct sockaddr_in);

/* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
            connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
            /* 返回的是连接成功的socket */
            if (connected < 0)
            {
                rt_kprintf("accept connection failed! errno = %d\n", errno);
                continue;
            }

/* 接受返回的client_addr指向了客户端的地址信息 */
            rt_kprintf("I got a connection from (%s , %d)\n",
                       inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

/* 客户端连接的处理 */
            while (1)
            {
                /* 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据 */
                bytes_received = recv(connected, recv_data, BUFSZ, 0);
                if (bytes_received < 0)
                {
                    /* 接收失败，关闭这个connected socket */
                    closesocket(connected);
                    break;
                }
                else if (bytes_received == 0)
                {
                    /* 打印recv函数返回值为0的警告信息 */
                    rt_kprintf("\nReceived warning,recv function return 0.\r\n");
                    closesocket(connected);
                    break;
                }

/* 有接收到数据,在控制终端显示收到的数据 */
                rt_kprintf("PORT 8001 RECEIVED DATA =");
//                for(i = 0; i < bytes_received; i++)
//                {
//                  rt_kprintf(" %02x", recv_data[i]);
//                }
//                rt_kprintf("\n");
                
                
                
                /* 发送数据到connected socket */
                ret = send(connected, send_data, strlen(send_data), 0);
                if (ret < 0)
                {
                    /* 发送失败，关闭这个连接 */
                    closesocket(connected);
                    rt_kprintf("\nsend error,close the socket.\r\n");
                    break;
                }
                else if (ret == 0)
                {
                    /* 打印send函数返回值为0的警告信息 */
                    rt_kprintf("\n Send warning,send function return 0.\r\n");
                }
               
            }
            
            /* 退出服务 */
            closesocket(sock);  
        }

/* 释放接收缓冲 */
    rt_free(recv_data);

return ;
}

static void tcpserv2_entry(void *parameter)
{
    char *recv_data; /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
    socklen_t sin_size;
    int sock, connected, bytes_received;
    struct sockaddr_in server_addr, client_addr;
    int ret;
    char *port_str;
    rt_uint16_t port;
    rt_uint8_t i;
  
    recv_data = rt_malloc(BUFSZ + 1); /* 分配接收用的数据缓冲 */
    if (recv_data == RT_NULL)
    {
        rt_kprintf("No memory\n");
        return;
    }

while(1)
        {
            port = 8002;
      
            /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
            if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
            {
                /* 创建失败的错误处理 */
                rt_kprintf("Socket error\n");