HttpClient.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "HttpClient.hpp"
 
#include <curl/curl.h>
#include <mutex>
#include <sstream>
 
namespace {
    std::once_flag g_curlInitOnce;
 
    size_t writeCallback(char* ptr, size_t size, size_t nmemb, void* userdata) {
        if (!userdata) return 0;
        const size_t total = size * nmemb;
        auto* out = static_cast<std::string*>(userdata);
        out->append(ptr, total);
        return total;
    }
 
    curl_slist* buildHeaderList(const std::map<std::string, std::string>& headers) {
        curl_slist* list = nullptr;
        for (const auto& kv : headers) {
            std::string h = kv.first + ": " + kv.second;
            list = curl_slist_append(list, h.c_str());
        }
        return list;
    }
}
 
void HttpClient::ensureCurlGlobalInit() {
    std::call_once(g_curlInitOnce, []() {
        curl_global_init(CURL_GLOBAL_DEFAULT);
    });
}
 
HttpResponse HttpClient::get(
    const std::string& url,
    const std::map<std::string, std::string>& headers,
    long timeoutSeconds)
{
    return perform(url, "GET", "", headers, timeoutSeconds);
}
 
HttpResponse HttpClient::post(
    const std::string& url,
    const std::string& body,
    const std::map<std::string, std::string>& headers,
    long timeoutSeconds)
{
    return perform(url, "POST", body, headers, timeoutSeconds);
}
 
HttpResponse HttpClient::perform(
    const std::string& url,
    const char* method,
    const std::string& requestBody,
    const std::map<std::string, std::string>& headers,
    long timeoutSeconds)
{
    ensureCurlGlobalInit();
 
    HttpResponse resp;
 
    CURL* curl = curl_easy_init();
    if (!curl) {
        resp.error = "curl_easy_init() failed";
        return resp;
    }
 
    std::string responseBody;
    curl_slist* headerList = nullptr;
    std::map<std::string, std::string> merged = headers;
    if (merged.find("User-Agent") == merged.end() &&
        merged.find("user-agent") == merged.end())
    {
        merged["User-Agent"] = "BastionGuard/IdentityLeak (GTKMM4)";
    }
 
    if (merged.find("Accept") == merged.end() &&
        merged.find("accept") == merged.end())
    {
        merged["Accept"] = "application/json";
    }
 
    headerList = buildHeaderList(merged);
 
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 5L);
 
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeoutSeconds);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
 
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &responseBody);
 
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
 
    if (headerList) {
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerList);
    }
 
    if (std::string(method) == "POST") {
        curl_easy_setopt(curl, CURLOPT_POST, 1L);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, requestBody.c_str());
        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)requestBody.size());
    } else {
        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
    }
 
    CURLcode code = curl_easy_perform(curl);
 
    if (code != CURLE_OK) {
        resp.status = 0;
        resp.body = "";
        resp.error = curl_easy_strerror(code);
    } else {
        long httpCode = 0;
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
        resp.status = (int)httpCode;
        resp.body = std::move(responseBody);
        resp.error.clear();
    }
 
    if (headerList) curl_slist_free_all(headerList);
    curl_easy_cleanup(curl);
 
    return resp;
}
 
std::string HttpClient::urlEncode(const std::string& value) {
    ensureCurlGlobalInit();
 
    CURL* curl = curl_easy_init();
    if (!curl) return "";
 
    char* enc = curl_easy_escape(curl, value.c_str(), (int)value.size());
    std::string out = enc ? enc : "";
    if (enc) curl_free(enc);
 
    curl_easy_cleanup(curl);
    return out;
}