Question

我遇到了tcp服务器的问题。我想听多个端口来响应客户端。它应该是一种基于事件的。每个端口都表示另一种响应。我读了很多关于epoll，poll，select或multithreading的内容。我尝试使用Unix网络编程等书中的大量例子。但可能我需要一些触发关键字。我怎么能正常开始？

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

让我知道我的想法...... 我开始想到这个：

如果我有一台带有大量服务器的“服务器管理器”，我可以按如下方式进行操作吗？

CreateSockets（SERVERLIST）; CheckSockets（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）进入服务器并处理问题（recv / send）????

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

    //some stuff in between

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

这可行吗？

从IBM非阻塞IO源代码中使用和更改了某些部分。

谢谢你的帮助。我能够完成一些事情，但有一件事仍然无法运作。

到目前为止我做了什么：

1）个人服务器的consrtuctor包括套接字操作。 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);

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

Answer 1

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

你不能让一个TCP套接字监听多个端口。

Linux TCP服务器 - 用C ++监听多个端口

1 个答案: