@amazon-devices/expo-file-system 2.0.9000000000 → 3.0.0

package/kepler/CurlWrapper.cpp

@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2026 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "CurlWrapper.h"
+
+#include <Kepler/turbomodule/TMLog.h>
+
+#include <cstring>
+#include <fstream>
+#include <mutex>
+#include <string>
+
+static std::once_flag curlInitFlag;
+
+CurlWrapper::CurlWrapper() {
+    std::call_once(curlInitFlag, []() {
+        TMDEBUG("[CurlWrapper] Initializing libcurl (once)");
+        curl_global_init(CURL_GLOBAL_ALL);
+    });
+}
+
+CurlWrapper::~CurlWrapper() {
+    // curl_global_cleanup() is intentionally not called here.
+    // Per libcurl docs, curl_global_init/cleanup are not thread-safe and
+    // cleanup should only happen once at application shutdown, not per-instance.
+}
+
+size_t CurlWrapper::writeToFileCallback(void* contents, size_t size, size_t nmemb, void* userp) {
+    auto* file = static_cast<std::ofstream*>(userp);
+    size_t totalBytes = size * nmemb;
+    file->write(static_cast<const char*>(contents), totalBytes);
+    if (file->fail()) {
+        TMERROR(std::string("[CurlWrapper] Failed to write ") + std::to_string(totalBytes) + " bytes to file");
+        return 0;
+    }
+    return totalBytes;
+}
+
+size_t CurlWrapper::headerCallback(char* buffer, size_t size, size_t nitems, void* userdata) {
+    auto* headers = static_cast<std::map<std::string, std::string>*>(userdata);
+    size_t totalSize = size * nitems;
+    std::string headerLine(buffer, totalSize);
+
+    auto colonPos = headerLine.find(':');
+    if (colonPos != std::string::npos) {
+        std::string key = headerLine.substr(0, colonPos);
+        std::string value = headerLine.substr(colonPos + 1);
+
+        auto trimStart = value.find_first_not_of(" \t");
+        auto trimEnd = value.find_last_not_of(" \t\r\n");
+        if (trimStart != std::string::npos && trimEnd != std::string::npos) {
+            value = value.substr(trimStart, trimEnd - trimStart + 1);
+        }
+
+        (*headers)[key] = value;
+    }
+    return totalSize;
+}
+
+size_t CurlWrapper::readFromFileCallback(void* ptr, size_t size, size_t nmemb, void* userp) {
+    auto* file = static_cast<std::ifstream*>(userp);
+    file->read(static_cast<char*>(ptr), size * nmemb);
+    return file->gcount();
+}
+
+void CurlWrapper::setCommonOptions(
+        CURL* curl,
+        const std::map<std::string, std::string>& requestHeaders,
+        struct curl_slist** headerList) {
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 16L);
+    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
+    curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
+    curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
+    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 30L);
+    // libcurl/OpenSSL are statically linked, so their compiled-in default CA
+    // location does not match the device. Point TLS verification at the device
+    // CA trust store explicitly.
+    curl_easy_setopt(curl, CURLOPT_CAINFO, "/etc/ssl/certs/ca-certificates.crt");
+    curl_easy_setopt(curl, CURLOPT_CAPATH, "/etc/ssl/certs");
+    // Abort if transfer speed drops below 1 byte/sec for 60 seconds
+    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1L);
+    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 60L);
+
+    for (const auto& [key, value] : requestHeaders) {
+        std::string header = key + ": " + value;
+        *headerList = curl_slist_append(*headerList, header.c_str());
+    }
+    if (*headerList) {
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, *headerList);
+    }
+}
+
+CurlResponse CurlWrapper::downloadToFile(
+        const std::string& url,
+        const std::string& filePath,
+        const std::map<std::string, std::string>& requestHeaders) {
+    CurlResponse response;
+
+    std::shared_ptr<CURL> curl(curl_easy_init(), curl_easy_cleanup);
+    if (!curl) {
+        response.errorMessage = "Failed to initialize curl";
+        TMERROR(std::string("[CurlWrapper] ") + response.errorMessage);
+        return response;
+    }
+
+    std::ofstream outputFile(filePath, std::ios::binary);
+    if (!outputFile.is_open()) {
+        response.errorMessage = "Failed to open output file: " + filePath;
+        TMERROR(std::string("[CurlWrapper] ") + response.errorMessage);
+        return response;
+    }
+
+    struct curl_slist* headerList = nullptr;
+    char errorBuffer[CURL_ERROR_SIZE] = {0};
+
+    curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
+    curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, writeToFileCallback);
+    curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &outputFile);
+    curl_easy_setopt(curl.get(), CURLOPT_HEADERFUNCTION, headerCallback);
+    curl_easy_setopt(curl.get(), CURLOPT_HEADERDATA, &response.headers);
+    curl_easy_setopt(curl.get(), CURLOPT_ERRORBUFFER, errorBuffer);
+    setCommonOptions(curl.get(), requestHeaders, &headerList);
+
+    TMDEBUG(std::string("[CurlWrapper] Starting download: ") + url + " -> " + filePath);
+    CURLcode res = curl_easy_perform(curl.get());
+    outputFile.close();
+
+    if (res != CURLE_OK) {
+        std::string errorDetail = (errorBuffer[0] != '\0') ? errorBuffer : curl_easy_strerror(res);
+        response.errorMessage = "Download failed: " + errorDetail;
+        TMERROR(std::string("[CurlWrapper] ") + response.errorMessage);
+        std::remove(filePath.c_str());
+    } else {
+        curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &response.statusCode);
+        TMDEBUG(std::string("[CurlWrapper] Download complete, HTTP status: ") + std::to_string(response.statusCode));
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+            response.success = true;
+        } else {
+            response.errorMessage = "HTTP error: " + std::to_string(response.statusCode);
+            std::remove(filePath.c_str());
+        }
+    }
+
+    if (headerList) {
+        curl_slist_free_all(headerList);
+    }
+    return response;
+}
+
+CurlResponse CurlWrapper::uploadFromFile(
+        const std::string& url,
+        const std::string& filePath,
+        const std::string& httpMethod,
+        const std::map<std::string, std::string>& requestHeaders) {
+    CurlResponse response;
+
+    std::shared_ptr<CURL> curl(curl_easy_init(), curl_easy_cleanup);
+    if (!curl) {
+        response.errorMessage = "Failed to initialize curl";
+        TMERROR(std::string("[CurlWrapper] ") + response.errorMessage);
+        return response;
+    }
+
+    std::ifstream inputFile(filePath, std::ios::binary | std::ios::ate);
+    if (!inputFile.is_open()) {
+        response.errorMessage = "Failed to open input file: " + filePath;
+        TMERROR(std::string("[CurlWrapper] ") + response.errorMessage);
+        return response;
+    }
+    auto fileSize = inputFile.tellg();
+    inputFile.seekg(0, std::ios::beg);
+
+    // Cap response body at 1MB to prevent OOM when servers echo back uploaded content
+    static constexpr size_t MAX_RESPONSE_BODY_SIZE = 1 * 1024 * 1024;
+    std::string responseBody;
+    bool responseBodyTruncated = false;
+
+    struct WriteToStringContext {
+        std::string* body;
+        bool* truncated;
+    };
+    WriteToStringContext writeCtx{&responseBody, &responseBodyTruncated};
+
+    auto writeToString = [](void* contents, size_t size, size_t nmemb, void* userp) -> size_t {
+        auto* ctx = static_cast<WriteToStringContext*>(userp);
+        size_t totalBytes = size * nmemb;
+        if (ctx->body->size() + totalBytes > MAX_RESPONSE_BODY_SIZE) {
+            *ctx->truncated = true;
+            return totalBytes;  // Consume but don't store
+        }
+        ctx->body->append(static_cast<const char*>(contents), totalBytes);
+        return totalBytes;
+    };
+
+    struct curl_slist* headerList = nullptr;
+    char errorBuffer[CURL_ERROR_SIZE] = {0};
+
+    curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
+    curl_easy_setopt(curl.get(), CURLOPT_UPLOAD, 1L);
+    curl_easy_setopt(curl.get(), CURLOPT_READFUNCTION, readFromFileCallback);
+    curl_easy_setopt(curl.get(), CURLOPT_READDATA, &inputFile);
+    curl_easy_setopt(curl.get(), CURLOPT_INFILESIZE_LARGE, static_cast<curl_off_t>(fileSize));
+    curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, +writeToString);
+    curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &writeCtx);
+    curl_easy_setopt(curl.get(), CURLOPT_HEADERFUNCTION, headerCallback);
+    curl_easy_setopt(curl.get(), CURLOPT_HEADERDATA, &response.headers);
+    curl_easy_setopt(curl.get(), CURLOPT_ERRORBUFFER, errorBuffer);
+
+    if (httpMethod == "POST") {
+        curl_easy_setopt(curl.get(), CURLOPT_POST, 1L);
+        curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDSIZE_LARGE, static_cast<curl_off_t>(fileSize));
+        curl_easy_setopt(curl.get(), CURLOPT_READFUNCTION, readFromFileCallback);
+        curl_easy_setopt(curl.get(), CURLOPT_READDATA, &inputFile);
+    } else if (httpMethod != "PUT") {
+        curl_easy_setopt(curl.get(), CURLOPT_CUSTOMREQUEST, httpMethod.c_str());
+    }
+
+    setCommonOptions(curl.get(), requestHeaders, &headerList);
+
+    TMDEBUG(std::string("[CurlWrapper] Starting upload: ") + filePath + " -> " + url + " (" + httpMethod + ")");
+    CURLcode res = curl_easy_perform(curl.get());
+    inputFile.close();
+
+    if (res != CURLE_OK) {
+        std::string errorDetail = (errorBuffer[0] != '\0') ? errorBuffer : curl_easy_strerror(res);
+        response.errorMessage = "Upload failed: " + errorDetail;
+        TMERROR(std::string("[CurlWrapper] ") + response.errorMessage);
+    } else {
+        curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &response.statusCode);
+        TMDEBUG(std::string("[CurlWrapper] Upload complete, HTTP status: ") + std::to_string(response.statusCode));
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+            response.success = true;
+        } else {
+            response.errorMessage = "HTTP error: " + std::to_string(response.statusCode);
+        }
+    }
+
+    if (responseBodyTruncated) {
+        TMDEBUG(std::string("[CurlWrapper] Response body truncated at ") + std::to_string(MAX_RESPONSE_BODY_SIZE) + "B");
+        responseBody += "\n... [truncated]";
+    }
+    response.headers["__response_body__"] = responseBody;
+
+    if (headerList) {
+        curl_slist_free_all(headerList);
+    }
+    return response;
+}

package/kepler/CurlWrapper.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+#pragma once
+
+#include <curl/curl.h>
+
+#include <map>
+#include <string>
+
+struct CurlResponse {
+    long statusCode = 0;
+    std::map<std::string, std::string> headers;
+    std::string errorMessage;
+    bool success = false;
+};
+
+/**
+ * libcurl wrapper for streaming HTTP file transfers directly to/from disk,
+ * bypassing the JS heap. Memory footprint is O(buffer_size) not O(file_size).
+ *
+ * Uses std::call_once for thread-safe one-time curl_global_init().
+ * curl_global_cleanup() is intentionally omitted per libcurl docs —
+ * it should only be called once at application shutdown.
+ */
+class CurlWrapper {
+public:
+    CurlWrapper();
+    ~CurlWrapper();
+
+    CurlWrapper(const CurlWrapper&) = delete;
+    CurlWrapper& operator=(const CurlWrapper&) = delete;
+
+    CurlResponse downloadToFile(
+            const std::string& url,
+            const std::string& filePath,
+            const std::map<std::string, std::string>& requestHeaders = {});
+
+    CurlResponse uploadFromFile(
+            const std::string& url,
+            const std::string& filePath,
+            const std::string& httpMethod,
+            const std::map<std::string, std::string>& requestHeaders = {});
+
+private:
+    static size_t writeToFileCallback(void* contents, size_t size, size_t nmemb, void* userp);
+    static size_t headerCallback(char* buffer, size_t size, size_t nitems, void* userdata);
+    static size_t readFromFileCallback(void* ptr, size_t size, size_t nmemb, void* userp);
+
+    void setCommonOptions(CURL* curl, const std::map<std::string, std::string>& requestHeaders,
+                          struct curl_slist** headerList);
+};