Function receiveByteArray

Tactility/Source/network/HttpdReq.cpp:74–115

}

std::unique_ptr<char[]> receiveByteArray(httpd_req_t* request, size_t length, size_t& bytesRead) {
    assert(length > 0);
    bytesRead = 0;

    // We have to use malloc() because make_unique() throws an exception
    // and we don't have exceptions enabled in the compiler settings
    auto* buffer = static_cast<char*>(malloc(length));
    if (buffer == nullptr) {
        LOGGER.error(LOG_MESSAGE_ALLOC_FAILED_FMT, length);
        return nullptr;
    }

    constexpr int MAX_TIMEOUT_RETRIES = 5;
    int timeout_retries = 0;
    while (bytesRead < length) {
        size_t read_size = length - bytesRead;
        int bytes_received = httpd_req_recv(request, buffer + bytesRead, read_size);
        if (bytes_received == HTTPD_SOCK_ERR_TIMEOUT) {
            // Timeout - retry with backoff
            timeout_retries++;
            if (timeout_retries >= MAX_TIMEOUT_RETRIES) {
                LOGGER.warn("Recv timeout after {} retries, read {}/{} bytes", timeout_retries, bytesRead, length);
                free(buffer);
                return nullptr;
            }
            LOGGER.warn("Recv timeout, retry {}/{}", timeout_retries, MAX_TIMEOUT_RETRIES);
            vTaskDelay(pdMS_TO_TICKS(100 * timeout_retries)); // Exponential backoff
            continue;
        }
        if (bytes_received <= 0) {
            LOGGER.warn("Received error {} after reading {}/{} bytes", bytes_received, bytesRead, length);
            free(buffer);
            return nullptr;
        }

        // Successful read - reset timeout counter
        timeout_retries = 0;
        bytesRead += bytes_received;
    }

    return std::unique_ptr<char[]>(buffer);
}

std::string receiveTextUntil(httpd_req_t* request, const std::string& terminator) {
    size_t read_index = 0;