0

我正在使用带有 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);
}

客户端代码是一个简单的接收超时发送

知道如何解决吗？

4

1 回答 1

0

首先想到的是让客户端的超时时间足够大，以使客户端不会超时，除非服务器实际上已经死了……但我相信你已经想到了。:)

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

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

于 2012-12-13T04:43:03.160 回答