Method SocketHandlerConnected

src/httpserver.cpp:837–908

}

void HTTPServer::SocketHandlerConnected(const IOReadiness& io_readiness) const
{
    for (const auto& [sock, events] : io_readiness.events_per_sock) {
        if (m_interrupt_net) {
            return;
        }

        auto it{io_readiness.httpclients_per_sock.find(sock)};
        if (it == io_readiness.httpclients_per_sock.end()) {
            continue;
        }
        const std::shared_ptr<HTTPRemoteClient>& client{it->second};

        bool send_ready = events.occurred & Sock::SendEvent;
        bool recv_ready = events.occurred & Sock::RecvEvent;
        bool err_ready = events.occurred & Sock::ErrorEvent;

        if (send_ready) {
            // Try to send as much data as is ready for this client.
            // If there's an error we can skip the receive phase for this client
            // because we need to disconnect.
            if (!client->MaybeSendBytesFromBuffer()) {
                recv_ready = false;
            }
        }

        if (recv_ready || err_ready) {
            std::byte buf[0x10000]; // typical socket buffer is 8K-64K

            const ssize_t nrecv{WITH_LOCK(
                client->m_sock_mutex,
                return client->m_sock->Recv(buf, sizeof(buf), MSG_DONTWAIT);)};

            if (nrecv < 0) {
                const int err = WSAGetLastError();
                if (IOErrorIsPermanent(err)) {
                    LogDebug(
                        BCLog::HTTP,
                        "Permanent read error from %s (id=%llu): %s",
                        client->m_origin,
                        client->m_id,
                        NetworkErrorString(err));
                    client->m_disconnect = true;
                }
            } else if (nrecv == 0) {
                LogDebug(
                    BCLog::HTTP,
                    "Received EOF from %s (id=%llu)",
                    client->m_origin,
                    client->m_id);
                client->m_disconnect = true;
            } else {
                // Reset idle timeout
                client->m_idle_since = Now<SteadySeconds>();

                // Prevent disconnect until all requests are completely handled.
                client->m_connection_busy = true;