在C++中实现Linux TCP服务器 - 监听多个端口

Question

我有一个关于tcp服务器的问题。我想要监听多个端口以响应客户端请求，应该是一种事件驱动的方式。每个端口表示不同类型的响应。我读了很多有关epoll、poll、select或多线程的书籍和示例，如Unix网络编程。但可能我需要一些关键词来开始。我应该如何正确地开始？

希望我的问题很容易理解。 感谢每一个回答！

为了缩小范围，这是我的想法... 我开始考虑这个：

如果我有一个"服务器管理器"，其中有很多服务器，我可以按照以下方式做吗？

创建套接字(ServerList); 检查套接字(SocketList, master_set);

在服务器管理器中： 1）用for循环创建所有服务器套接字（函数：socket/setsockopt/ioctl/bind/listen）

void CreateSockets(map<int,ServerType> ServerList)
{
    fd_set        master_set;
    map<int,ServerType>::iterator it;
    map<int,int> SocketList;
    for (it= ServerList.begin();it!= ServerList.end();it++)
    {
        listen_sd = socket(AF_INET, SOCK_STREAM, 0);
        if (listen_sd < 0)
        {
            perror("socket() failed");
            exit(-1);
        }
        rc = setsockopt(listen_sd, SOL_SOCKET,  SO_REUSEADDR,
                (char *)&on, sizeof(on));
        if (rc < 0)
        {
            perror("setsockopt() failed");
            close(listen_sd);
            exit(-1);
        }
        rc = ioctl(listen_sd, FIONBIO, (char *)&on);
        if (rc < 0)
        {
            perror("ioctl() failed");
            close(listen_sd);
            exit(-1);
        }
        memset(&addr, 0, sizeof(addr));
        addr.sin_family      = AF_INET;
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
        addr.sin_port        = ((*it).second->Port);
        rc = bind(listen_sd,(struct sockaddr *)&addr, sizeof(addr));
        if (rc < 0)
        {
            perror("bind() failed");
            close(listen_sd);
            exit(-1);
        }
        rc = listen(listen_sd, 32);
        if (rc < 0)
        {
            perror("listen() failed");
            close(listen_sd);
            exit(-1);
        }
        SocketList.insert(make_pair(((*it).second->Port),listen_sd));
        FD_ZERO(&master_set);
        max_sd = listen_sd;
        FD_SET(listen_sd, &master_set);
    }
}

下一步： 2）以某种方式等待服务器管理器中的某些事件（使用套接字描述符列表进行选择）

void CheckSockets(map<int,int> SocketList, fd_set master_set)
 {
    fd_set working_set;
    do
    {
        memcpy(&working_set, &master_set, sizeof(master_set));
        ready_descriptors = select(max_sd + 1, &working_set, NULL, NULL, NULL);

        if (ready_descriptors >0)
        {
            desc_ready = rc;
            for (i=0; i <= max_sd  &&  desc_ready > 0; ++i)
            {
                if (FD_ISSET(i, &working_set))
                {
                    desc_ready -= 1;
                    if (i == listen_sd)
                    {
                        do
                        {
                            new_sd = accept(listen_sd, NULL, NULL);
                            if (new_sd < 0)
                            {
                                //error
                            }
                            FD_SET(new_sd, &master_set);
                            if (new_sd > max_sd)
                                max_sd = new_sd;
                        } while (new_sd != -1);
                    }
                    else
                    {
                        do
                        {
                            //Go into server and recv and send ( Input Parameter = i)
                            CheckServer(i);
                        } while (TRUE);
                    }
                }
            }
        }
        else {endserver=true;}
    }while(endserver=true;)

}

3) 进入服务器并处理问题（接收/发送）????

    void CheckServer( int sd)
 {
    rc = recv(sd, buffer, sizeof(buffer), 0);

    //some stuff in between

    rc = send(i, buffer, len, 0); 
 }

这个能行吗？

有些部分是从IBM的非阻塞IO源代码中使用和更改的。

---

感谢您的所有帮助。我已经做了一些事情，但还有一件事情没法工作。

我到目前为止所做的：

1）单独服务器的构造函数包括套接字操作。 2）我能够返回套接字ID并将其保存在服务器管理器中。 3）管理器有一个for循环，其中包含select命令，以检查套接字上是否有任何事件。 4）如果发生什么事情，所有受影响的套接字将依次响应。

我的问题是：

如果我在请求服务器数据时始终保持连接和断开连接，则运行良好。 当我的客户端被配置成保持连接时，由于我的代码正在等待断开连接，所以一切都被阻塞了。

以下是每个部分的代码片段：

1）

       Server::Server() 
    {

    listen_sd = socket(AF_INET, SOCK_STREAM, 0);
    ret = setsockopt(listen_sd, SOL_SOCKET,  SO_REUSEADDR,(char *)&on, sizeof(on));
    ret = ioctl(listen_sd, FIONBIO, (char *)&on);

    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port        = htons(Server_Port);
    ret = bind(listen_sd,(struct sockaddr *)&addr, sizeof(addr));
    ret = listen(listen_sd, 32);
    Socket = listen_sd;
}

2)

Socket= new_Server->GetSocket();
SocketList.insert(make_pair(Socket,new_Server->ServerID));

3)

 while (TRUE)
    {
        FD_ZERO(&working_set);
        for (i=0;i < max_conn;i++) 
{
            if (SocketArray[i] >= 0) {FD_SET(SocketArray[i], &working_set);}
        }

        ret = select(max_sd+1, &working_set, NULL, NULL, NULL);

    desc_ready= ret;
        for (i=0; i <= max_sd  &&  desc_ready > 0; ++i)
        {

            if (FD_ISSET(i, &working_set)) //jeder Peer der was hat
            {
                desc_ready -= 1;
//delete all loops to get the correct object 
                        (Server).second->DoEvent(i);

            }
        }
    }

4)

new_sd = accept(new_sd, NULL, NULL);
    if (new_sd < 0)
    {
        if (errno != EWOULDBLOCK)
        {
            perror("  accept() failed");
        }
    }
do
{


    rc = recv(new_sd, buffer, sizeof(buffer), 0);
//edit datastream and create response
            rc = send(new_sd, buffer, len, 0);
        if (rc < 0)
        {
            perror("  send() failed");
            close_conn = TRUE;
            break;
        }

    }while (TRUE);

我只是删除了错误处理的部分，例如listen/bind等，只是为了在这里缩短代码......原本它就在那里。

- user2545592

---

这个问题太宽泛了，请将其缩小到可以回答的范围。 - Mgetz

你已经查看过Beej的网络编程指南了吗？那里有所有基础知识（虽然是C风格）。 - codeling

请了解反应器模式... - Sambuca

我在想是否已经有一些类/库了。 - Alex

我需要非阻塞服务器套接字。我想要编写的程序如下：1）建立所有必要的套接字2）等待一个或多个套接字上的事件3）如果有事件，则响应这些特定套接字上的每个请求...我的问题是将这个想法转换为源代码，因为我不确定哪些命令对我来说最好...同时考虑运行时间、响应时间和套接字最大数量的限制...希望我已经缩小了范围。 - user2545592

我不确定为什么这个问题太宽泛了？对于一个自定义应用程序来监听多个端口是可以的，那么在这种情况下如何使用select呢？ - Manoj Pandey

Answer 1

大致步骤如下：您可以有多个TCP服务器（也称为服务器套接字）监听每个端口。接下来，您可以使用select()并传递每个这些服务器套接字的文件描述符。如果在任何一个上获得连接，则select将返回读事件并标记具有连接的服务器套接字的fd。您需要在该服务器fd上调用accept()。

您不能使单个TCP套接字监听多个端口。

- Manoj Pandey

---

谢谢您的回答。我正在考虑使用select，但是我不想有任何超时 - 所以我需要非阻塞服务器套接字。使用select是否可能实现这一点？因为accept会等待，对吧？ - user2545592

Select是一个阻塞调用。您可以将超时作为参数传递给select，但不指定它（也就是将其传递为NULL）意味着只有在有事件（在这种情况下是读事件）时，select才会超时。顺便说一句，您始终可以拥有多个线程，一个线程可以为所有服务器fd执行select。 - Manoj Pandey

谢谢。还有一个问题。如果我有一个拥有许多服务器的“服务器管理器”，我可以按照以下方式操作吗？在服务器管理器中：1）使用for循环创建所有服务器套接字（函数：socket/setsockopt/ioctl/bind/listen）2）以某种方式等待服务器管理器中的某些事件（使用套接字描述符列表进行选择）3）进入服务器并处理问题（recv/send）？ - user2545592

是的，您需要为每个端口创建TCP服务器（绑定/侦听步骤）-使用for循环可以。接下来，您可以使用select并传递每个服务器的文件描述符到select fd集中，并等待读事件（请阅读有关select的内容！）。一旦有传入连接，select将取消阻塞并返回具有挂起连接的服务器的fd（或fds）。我们可以在这些fd上调用accept（）。accept（）将返回子连接的fd，我们可以在此子fd上执行recv / send操作。 - Manoj Pandey