Function AcceptLoop

src/platform/win/http_server.cpp:480–545

}

static void AcceptLoop() {
    LOG("[HTTP] Accept loop started on port %u", g_port.load());
    while (g_running.load()) {
        // use select with a timeout so we can check g_running periodically
        fd_set readfds;
        FD_ZERO(&readfds);
        FD_SET(g_listenSock, &readfds);

        timeval tv;
        tv.tv_sec = 1;
        tv.tv_usec = 0;

        int sel = select(0, &readfds, nullptr, nullptr, &tv);
        if (sel <= 0) continue;

        SOCKET client = accept(g_listenSock, nullptr, nullptr);
        if (client == INVALID_SOCKET) continue;

        // Reject connections from other processes
        if (!IsConnectionFromSteam(client)) {
            closesocket(client);
            continue;
        }

        // SO_SNDTIMEO matters too: a stalled final send() can wedge a slot and saturate the thread cap.
        DWORD rcvTimeout = 30000; // 30s
        DWORD sndTimeout = 30000; // 30s
        setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (const char*)&rcvTimeout, sizeof(rcvTimeout));
        setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, (const char*)&sndTimeout, sizeof(sndTimeout));

        // handle each connection on its own thread so parallel uploads don't queue up
        {
            std::lock_guard<std::mutex> lk(g_clientMtx);
            PruneClientThreads();

            // At the cap: backpressure instead of rejecting. A closed socket surfaces
            // as a Steam cloud error; waiting for a slot lets large bursts drain.
            int waitMs = 0;
            while (g_clientSlots.size() >= kMaxClientThreads && g_running.load() &&
                   waitMs < kAcceptBackpressureMaxMs) {
                std::this_thread::sleep_for(std::chrono::milliseconds(20));
                waitMs += 20;
                PruneClientThreads();
            }
            if (g_clientSlots.size() >= kMaxClientThreads) {
                LOG("[HTTP] Thread cap (%zu) still full after %dms, rejecting connection",
                    kMaxClientThreads, waitMs);
                closesocket(client);
                continue;
            }

            auto doneFlag = std::make_shared<std::atomic<bool>>(false);
            auto wrapper = [doneFlag](SOCKET s) {
                HandleClient(s);
                doneFlag->store(true);
            };
            try {
                g_clientSlots.push_back({std::thread(wrapper, client), doneFlag});