Function handleHttpRequest

switch/source/server.cpp:230–331

    }

    void handleHttpRequest(s32 clientSocket)
    {
        // Read only up to and including the header terminator; the body is either
        // streamed to disk (upload paths) or read into RAM afterwards (others).
        std::string data;
        data.reserve(4096);
        constexpr size_t RECV_CHUNK = 64 * 1024;
        std::vector<char> buffer(RECV_CHUNK);
        size_t headerEnd = std::string::npos;
        int idleMs       = 0;

        while (true) {
            ssize_t received = pollRecv(clientSocket, buffer.data(), buffer.size(), idleMs, false, HEADER_TIMEOUT_MS);
            if (received <= 0) {
                break;
            }
            data.append(buffer.data(), received);
            headerEnd = data.find("\r\n\r\n");
            if (headerEnd != std::string::npos) {
                break;
            }
            if (data.size() > MAX_HEADER_SIZE) {
                break; // no terminator within the cap: abandon
            }
        }
        if (headerEnd == std::string::npos) {
            return; // never got a complete header block
        }

        std::string headers  = data.substr(0, headerEnd);
        std::string path     = extractPath(headers);
        size_t contentLength = parseContentLength(headers);
        size_t bodyStart     = headerEnd + 4;

        // Streaming upload path.
        std::string tmpPath;
        Server::UploadHandler uploadHandler;
        bool isUpload = false;
        {
            std::lock_guard<std::mutex> lock(handlersMutex);
            auto it = uploadHandlers.find(path);
            if (it != uploadHandlers.end()) {
                tmpPath       = it->second.first;
                uploadHandler = it->second.second;
                isUpload      = true;
            }
        }
        if (isUpload) {
            const char* leftover = data.data() + bodyStart;
            size_t leftoverLen   = data.size() - bodyStart;
            bool complete        = streamBodyToFile(clientSocket, tmpPath, contentLength, leftover, leftoverLen);
            if (!complete) {
                // Cancelled, stalled, or dropped mid-upload: drop the request and
                // clear the transfer UI; the handler never runs on a partial body.
                std::remove(tmpPath.c_str());
                TransferStatus::end();
                Logging::info("Upload to {} abandoned before the full body arrived.", path);
                return;