Question

我正在使用带有O_NONBLOCK的套接字，选择，保持活动连接和类似HTTP的东西。

每个服务器连接和客户端使用缓冲区来获取所有已发送的数据，直到收到完整的消息

如何工作：

客户端发送数据“A”
客户端尝试从服务器接收响应
服务器收到但不立即回复
客户端超时
服务器发送响应“A”（但客户端现在不接收）

另一个请求：

客户端发送数据“B”
服务器发送响应“B”
客户收到“AB”响应而不是“B”

问题是客户端收到以前的缓冲消息

源代码：

Server.cpp基类：

bool Server::start()
{
    struct sockaddr_in client_addr;
    SOCKET client_socket, max_sock;
    Connection* conn;
    int addrlen = sizeof(struct sockaddr_in);
    std::list<Connection*>::iterator it, itr;
    int response;
    fd_set fdset, read_fds;

    max_sock = m_socket;
    FD_ZERO(&fdset);
    FD_SET(m_socket, &fdset);
    onStart();

    while(true)
    {
        // make a copy of set
        read_fds = fdset;
        // wait for read event
        response = select(max_sock + 1, &read_fds, NULL, NULL, NULL);
        if(response == -1)
            break;
        // check for new connections
        if(FD_ISSET(m_socket, &read_fds))
        {
            response--;
            // accept connections
            client_socket = accept(m_socket, (struct sockaddr*)&client_addr, &addrlen);
            if(client_socket != INVALID_SOCKET)
            {
                conn = new Connection(*this, client_socket, &client_addr);
                m_connections.push_front(conn);
                // add connection to set for wait for read event
                FD_SET(client_socket, &fdset);
                // allow select new sock from select funcion
                if(max_sock < client_socket)
                    max_sock = client_socket;
            }
        }
        // check for received data from clients
        it = m_connections.begin();
        while(it != m_connections.end() && response > 0)
        {
            conn = *it;
            // verify if connection can be readed
            if(FD_ISSET(conn->getSocket(), &read_fds))
            {
                response--;
                conn->receive();
                if(!conn->isConnected())
                {
                    FD_CLR(conn->getSocket(), &fdset);
                    // remove connection from list
                    itr = it;
                    it++;
                    m_connections.erase(itr);
                    delete conn;
                    continue;
                }
            }
            it++;
        }
    }
    onFinish(response >= 0);
    return response >= 0;
}

main.cpp服务器实现：

void ClientConnection::onReceive(const void * data, size_t size)
{
    const char *str, *pos = NULL;
    HttpParser* p;

    buffer->write(data, size);
    do
    {
        str = (const char*)buffer->data();
        if(contentOffset == 0)
        {
            pos = strnstr(str, buffer->size(), "\r\n\r\n");
            if(pos != NULL)
            {
                contentOffset = pos - str + 4;
                p = new HttpParser((const char*)buffer->data(), contentOffset);
                contentLength = p->getContentLength(); 
                delete p;
            }
        }
        if(buffer->size() - contentOffset < contentLength || contentOffset == 0)
            return;
        proccessRequest();
        keepDataStartingOf(contentOffset + contentLength);
    }
    while(buffer->size() > 0);
}

客户端代码是一个带有超时的简单recv发送

任何想法如何解决？

Answer 1

首先想到的是让客户端的超时足够大，客户端不会超时，除非服务器真的死了......但我相信你已经想到了这一点。：）

因此，假设这不是一个足够好的修复，接下来要尝试的是让客户端发送每个请求的ID号。可以使用简单的计数器生成ID号（例如，对于客户端的第一个请求，它将请求标记为0，第二个标记为1，等等）。发送回复时，服务器将在回复中包含相同的ID号。

当客户端收到回复时，它会将回复数据中的ID号与其计数器的当前值进行比较。如果两个数字相同，则处理数据。如果没有，它会忽略数据。瞧瞧！

客户端获取服务器响应超时后，如何使服务器忽略客户端发送的数据？

1 个答案: