httpp 0.4.0__tar.gz → 0.5.0__tar.gz

{httpp-0.4.0 → httpp-0.5.0}/.github/workflows/cmake.yml

@@ -18,7 +18,7 @@ jobs:
     - name: Checkout repository
       uses: actions/checkout@v6
       with:
-        submodules: true
+        submodules: recursive
 
     - name: Set up Python
       uses: actions/setup-python@v6
@@ -53,7 +53,7 @@ jobs:
     - name: Checkout repository
       uses: actions/checkout@v6
       with:
-        submodules: true
+        submodules: recursive
 
     - name: Setup cmake
       uses: jwlawson/actions-setup-cmake@v2

{httpp-0.4.0 → httpp-0.5.0}/.github/workflows/orchestrator.yml

@@ -79,6 +79,7 @@ jobs:
           prerelease: ${{ needs.init.outputs.is_tag == 'false' }}
           token: ${{ secrets.GITHUB_TOKEN }}
           files: dist/*
+          generate_release_notes: true
 
       - name: Publishing to PyPi
         uses: pypa/gh-action-pypi-publish@release/v1

{httpp-0.4.0 → httpp-0.5.0}/.github/workflows/wheels.yml

@@ -50,7 +50,7 @@ jobs:
     steps:
     - uses: actions/checkout@v6
       with:
-        submodules: true
+        submodules: recursive
 
     - name: Build wheels
       uses: pypa/cibuildwheel@v3.4.1

httpp-0.5.0/CMakeLists.txt

@@ -0,0 +1,173 @@
+cmake_minimum_required(VERSION 3.21)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
+include(DynamicVersion)
+
+extract_version_string(
+    HEADER_FILE ${CMAKE_CURRENT_LIST_DIR}/include/httpp.h
+    VERSION_PREFIX HTTPP_
+    OUTPUT_VAR PROJECT_VERSION
+)
+
+project(httpp LANGUAGES CXX VERSION ${PROJECT_VERSION})
+message(STATUS "Project: ${PROJECT_NAME}@v${PROJECT_VERSION}")
+include(Startup)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+include(Optimize)
+
+# Project options
+option(HTTPP_BUILD_TESTS "Build tests" ${PROJECT_IS_TOP_LEVEL})
+option(HTTPP_BUILD_PYTHON "Build Python bindings" ${PROJECT_IS_TOP_LEVEL})
+
+set(HTTPP_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+
+# --- httpp C++ core ---
+# httplib.h is vendored at src/third_party/cpp-httplib (a real committed
+# file, no system package). mbedtls is a git submodule at
+# src/third_party/mbedtls (also built from source, no system package).
+# Both are included only from src/core/*.cpp, never from a public
+# include/httpp/*.hpp header, and are compiled with hidden visibility so
+# they never leak into the httpp .so/.a's public symbols.
+file(GLOB HTTPP_CORE_SOURCES ${PROJECT_SOURCE_DIR}/src/core/*.cpp)
+
+# liburlparser (git submodule, built from source — no system package) does
+# the real URL parsing (scheme/host/port/path, IPv4/IPv6, PSL-aware). It is
+# linked PRIVATE into httpp_core, same as cpp-httplib: consumers of
+# <httpp/url.hpp> see only httpp::url, never urlparser::url directly.
+set(BUILD_PYTHON OFF CACHE BOOL "" FORCE)
+# Needed so liburlparser's static lib can be linked into httpp's shared
+# lib / the Cython extension module (which are themselves PIC).
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+add_subdirectory(${PROJECT_SOURCE_DIR}/src/third_party/liburlparser)
+
+# mbedtls (TLS support for HTTPS, via cpp-httplib's CPPHTTPLIB_MBEDTLS_SUPPORT).
+set(ENABLE_PROGRAMS OFF CACHE BOOL "" FORCE)
+set(ENABLE_TESTING OFF CACHE BOOL "" FORCE)
+set(MBEDTLS_FATAL_WARNINGS OFF CACHE BOOL "" FORCE)
+set(USE_STATIC_MBEDTLS_LIBRARY ON CACHE BOOL "" FORCE)
+set(USE_SHARED_MBEDTLS_LIBRARY OFF CACHE BOOL "" FORCE)
+# mbedtls's codegen'd sources (library/error.c,
+# tf-psa-crypto/core/psa_crypto_driver_wrappers_no_static.c, etc.) must
+# exist on disk before add_subdirectory() below runs. mbedtls generates
+# them itself via its own GEN_FILES option on Linux/macOS, but defaults
+# GEN_FILES OFF on any Windows host (assuming a release tarball with these
+# files already bundled). We build mbedtls from a git submodule, which
+# never has them on any platform, so we generate them ourselves here,
+# unconditionally, using mbedtls's own official scripts — the approach
+# mbedtls's maintainers recommend: https://github.com/Mbed-TLS/mbedtls/issues/10678.
+# Requires Python 3 and Perl on PATH (both are already required to build
+# mbedtls from a git checkout, per its own documentation).
+set(_httpp_mbedtls_dir ${PROJECT_SOURCE_DIR}/src/third_party/mbedtls)
+find_package(Python3 COMPONENTS Interpreter REQUIRED)
+execute_process(
+    COMMAND ${Python3_EXECUTABLE} framework/scripts/make_generated_files.py
+    WORKING_DIRECTORY ${_httpp_mbedtls_dir}/tf-psa-crypto
+    RESULT_VARIABLE _httpp_mbedtls_gen_result
+)
+if(NOT _httpp_mbedtls_gen_result EQUAL 0)
+    message(FATAL_ERROR "Failed to generate tf-psa-crypto sources (exit ${_httpp_mbedtls_gen_result})")
+endif()
+execute_process(
+    COMMAND ${Python3_EXECUTABLE} scripts/make_generated_files.py
+    WORKING_DIRECTORY ${_httpp_mbedtls_dir}
+    RESULT_VARIABLE _httpp_mbedtls_gen_result
+)
+if(NOT _httpp_mbedtls_gen_result EQUAL 0)
+    message(FATAL_ERROR "Failed to generate mbedtls sources (exit ${_httpp_mbedtls_gen_result})")
+endif()
+# mbedtls's own install() rules are unconditional unless this is forced ON
+# (its "am I a subproject" auto-detection doesn't reliably suppress them);
+# httpp links it in statically and never re-exports its headers/libs, so
+# nothing from mbedtls itself belongs in the installed wheel.
+set(DISABLE_PACKAGE_CONFIG_AND_INSTALL ON CACHE BOOL "" FORCE)
+add_subdirectory(${PROJECT_SOURCE_DIR}/src/third_party/mbedtls)
+
+add_library(httpp_core SHARED ${HTTPP_CORE_SOURCES})
+add_library(httpp::core ALIAS httpp_core)
+
+# Windows/MSVC dllexport-vs-dllimport: HTTPP_API (include/httpp/export.hpp)
+# resolves to __declspec(dllexport) only when HTTPP_BUILDING_DLL is defined.
+# It must be defined while compiling httpp_core's OWN translation units
+# (client.cpp/server.cpp/url.cpp) so the public classes are actually
+# exported from httpp_core.dll — and must NOT be defined for anyone
+# consuming the already-built DLL (they need dllimport instead), hence
+# PRIVATE, not PUBLIC/INTERFACE.
+target_compile_definitions(httpp_core PRIVATE HTTPP_BUILDING_DLL)
+
+set_target_properties(httpp_core PROPERTIES
+    POSITION_INDEPENDENT_CODE ON
+    CXX_VISIBILITY_PRESET hidden
+    VISIBILITY_INLINES_HIDDEN ON
+    MACOSX_RPATH ON
+    INSTALL_NAME_DIR "@rpath"
+)
+
+target_include_directories(httpp_core
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:httpp/include>
+)
+# SYSTEM: these are vendored/third-party headers we don't control (cpp-httplib,
+# indicators, etc.). Marking them SYSTEM tells the compiler their own internal
+# warnings (e.g. indicators.hpp's narrowing-conversion C4244/C4267 on MSVC)
+# aren't ours to fix and shouldn't surface under our own -Wall/-Wextra/-W4
+# below — without patching vendored code to silence its own warnings.
+target_include_directories(httpp_core SYSTEM PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/third_party/cpp-httplib
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/third_party
+)
+
+find_package(Threads REQUIRED)
+target_link_libraries(httpp_core PUBLIC Threads::Threads)
+target_link_libraries(httpp_core PRIVATE url::base)
+
+# HTTPS support: mbedtls is linked PRIVATE and CPPHTTPLIB_MBEDTLS_SUPPORT is
+# only ever defined in src/core/internal/httplib_common.hpp (never in a
+# public header), so consumers of httpp never need mbedtls on their own
+# include/link path — see that file for the shared httplib.h include.
+target_link_libraries(httpp_core PRIVATE mbedtls mbedx509)
+target_compile_definitions(httpp_core PRIVATE CPPHTTPLIB_MBEDTLS_SUPPORT)
+
+# macOS: cpp-httplib (src/third_party/cpp-httplib/httplib.h) reads the
+# system trust store via the Keychain APIs (CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN),
+# which pulls in CoreFoundation/Security symbols (e.g. SecTrustSettingsCopyCertificates).
+# These aren't linked by default and must be added explicitly, or the final
+# link of libhttpp_core.dylib fails with "symbol(s) not found for architecture".
+if(APPLE)
+    find_library(COREFOUNDATION_LIBRARY CoreFoundation REQUIRED)
+    find_library(SECURITY_LIBRARY Security REQUIRED)
+    target_link_libraries(httpp_core PRIVATE ${COREFOUNDATION_LIBRARY} ${SECURITY_LIBRARY})
+endif()
+
+target_compile_options(httpp_core PRIVATE
+    $<$<CXX_COMPILER_ID:MSVC>:/W4 /EHsc>
+    $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -Wpedantic>
+)
+
+apply_optimization_flags(httpp_core)
+
+if(HTTPP_BUILD_PYTHON OR DEFINED SKBUILD)
+    set(PYTHON_INSTALL_DIR ${CMAKE_BINARY_DIR}/python/install)
+    add_subdirectory(${PROJECT_SOURCE_DIR}/src/bindings/python)
+    if(DEFINED SKBUILD)
+        return()
+    endif()
+endif()
+
+# Installation
+install(TARGETS httpp_core
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+)
+install(DIRECTORY include DESTINATION .)
+
+# Tests
+if(HTTPP_BUILD_TESTS)
+    enable_testing()
+    set(CMAKE_CTEST_ARGUMENTS "--output-on-failure" "-V")
+    add_subdirectory(${PROJECT_SOURCE_DIR}/tests)
+endif()

{httpp-0.4.0 → httpp-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: httpp
-Version: 0.4.0
+Version: 0.5.0
 Summary: A Cython project with scikit-build
 Author-Email: Mohammad Raziei <mohammadraziei1375@gmail.com>
 License: MIT
@@ -61,7 +61,7 @@ pip install httpp
 ### Python
 
 ```python
-from httpp import Client, Server, DownloadFile, CurlRequest
+from httpp import Client, Server, DownloadFile, Request
 
 # client
 res = Client.fetch("http://example.com/")
@@ -76,7 +76,7 @@ srv.listen("0.0.0.0", 8000)
 DownloadFile("http://example.com/big.zip").output("big.zip").run()
 
 # a small curl-flavored request builder
-res = CurlRequest("http://example.com/api").method("POST").data("a=1").run()
+res = Request("http://example.com/api").method("POST").data("a=1").run()
 ```
 
 ### CLI
@@ -105,7 +105,7 @@ srv.listen("0.0.0.0", 8000);
 
 httpp::download_file("http://example.com/f.zip").output("f.zip").run();
 
-auto res2 = httpp::curl::request("http://example.com/api")
+auto res2 = httpp::client::request("http://example.com/api")
                 .method("POST")
                 .header("X-Token", "abc")
                 .data("a=1")
@@ -162,17 +162,22 @@ ctest --test-dir build --output-on-failure   # C++, Python, and CMake-integratio
 
 ## Status
 
-- [x] `httpp::client` — GET requests; `.fetch(url)` parses a full URL in one call
+- [x] `httpp::client` — GET requests (with optional headers), response
+      headers (`res.header("Content-Type")`); `.fetch(url)` parses a full
+      URL in one call. HTTP **and HTTPS** (mbedtls-backed).
 - [x] `httpp::server` — route handlers, static directory serving
-- [x] `httpp::curl` — a small curl-flavored fluent request builder (method/headers/data)
-- [x] `httpp::download_file` — fluent download builder with a terminal progress bar
-      (sync `.run()` and async `.run_async()`)
+- [x] `httpp::client::request` — a small curl-flavored fluent request
+      builder (method/headers/data/timeout/redirects), also over HTTPS
+- [x] `httpp::download_file` — fluent download builder with a terminal
+      progress bar (sync `.run()` and async `.run_async()`)
 - [x] `httpp::progress` — `bar` (tqdm-like) and `range` (trange-like)
 - [x] `httpp/curl_compat.h` — a `curl_easy_*` C API subset for migrating
-      existing libcurl code, built directly on `httpp::curl::request`
-- [x] CLI — `server`, `download`, `curl`, `install`/`uninstall`
-- [x] Python bindings for `Client`, `Server`, `DownloadFile`, `CurlRequest`
-- [ ] HTTPS
+      existing libcurl code, including response headers
+      (`CURLOPT_HEADERFUNCTION`) and `CURLINFO_CONTENT_TYPE`, built
+      directly on `httpp::client::request`
+- [x] CLI — `server`, `download`, `curl`, `install`/`uninstall`, `path`
+      (`httpp --cmake-dir` / `httpp path --include-dir`, etc.)
+- [x] Python bindings for `Client`, `Server`, `DownloadFile`, `Request`
 - [ ] Route handlers from Python (directory serving works today; custom
       routes are C++-only for now)
 

{httpp-0.4.0 → httpp-0.5.0}/README.md

@@ -36,7 +36,7 @@ pip install httpp
 ### Python
 
 ```python
-from httpp import Client, Server, DownloadFile, CurlRequest
+from httpp import Client, Server, DownloadFile, Request
 
 # client
 res = Client.fetch("http://example.com/")
@@ -51,7 +51,7 @@ srv.listen("0.0.0.0", 8000)
 DownloadFile("http://example.com/big.zip").output("big.zip").run()
 
 # a small curl-flavored request builder
-res = CurlRequest("http://example.com/api").method("POST").data("a=1").run()
+res = Request("http://example.com/api").method("POST").data("a=1").run()
 ```
 
 ### CLI
@@ -80,7 +80,7 @@ srv.listen("0.0.0.0", 8000);
 
 httpp::download_file("http://example.com/f.zip").output("f.zip").run();
 
-auto res2 = httpp::curl::request("http://example.com/api")
+auto res2 = httpp::client::request("http://example.com/api")
                 .method("POST")
                 .header("X-Token", "abc")
                 .data("a=1")
@@ -137,17 +137,22 @@ ctest --test-dir build --output-on-failure   # C++, Python, and CMake-integratio
 
 ## Status
 
-- [x] `httpp::client` — GET requests; `.fetch(url)` parses a full URL in one call
+- [x] `httpp::client` — GET requests (with optional headers), response
+      headers (`res.header("Content-Type")`); `.fetch(url)` parses a full
+      URL in one call. HTTP **and HTTPS** (mbedtls-backed).
 - [x] `httpp::server` — route handlers, static directory serving
-- [x] `httpp::curl` — a small curl-flavored fluent request builder (method/headers/data)
-- [x] `httpp::download_file` — fluent download builder with a terminal progress bar
-      (sync `.run()` and async `.run_async()`)
+- [x] `httpp::client::request` — a small curl-flavored fluent request
+      builder (method/headers/data/timeout/redirects), also over HTTPS
+- [x] `httpp::download_file` — fluent download builder with a terminal
+      progress bar (sync `.run()` and async `.run_async()`)
 - [x] `httpp::progress` — `bar` (tqdm-like) and `range` (trange-like)
 - [x] `httpp/curl_compat.h` — a `curl_easy_*` C API subset for migrating
-      existing libcurl code, built directly on `httpp::curl::request`
-- [x] CLI — `server`, `download`, `curl`, `install`/`uninstall`
-- [x] Python bindings for `Client`, `Server`, `DownloadFile`, `CurlRequest`
-- [ ] HTTPS
+      existing libcurl code, including response headers
+      (`CURLOPT_HEADERFUNCTION`) and `CURLINFO_CONTENT_TYPE`, built
+      directly on `httpp::client::request`
+- [x] CLI — `server`, `download`, `curl`, `install`/`uninstall`, `path`
+      (`httpp --cmake-dir` / `httpp path --include-dir`, etc.)
+- [x] Python bindings for `Client`, `Server`, `DownloadFile`, `Request`
 - [ ] Route handlers from Python (directory serving works today; custom
       routes are C++-only for now)
 

httpp-0.5.0/include/httpp/client.hpp

@@ -0,0 +1,114 @@
+#pragma once
+
+#include "httpp/export.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace httpp {
+
+struct response {
+    int status = 0;
+    std::string body;
+    std::vector<std::pair<std::string, std::string>> headers;
+
+    bool ok() const { return status >= 200 && status < 300; }
+
+    // HTTP header names are case-insensitive (RFC 7230); this looks up
+    // the first matching header and returns "" if it isn't present.
+    std::string header(const std::string& name) const {
+        auto ci_equal = [](const std::string& a, const std::string& b) {
+            return a.size() == b.size() &&
+                   std::equal(a.begin(), a.end(), b.begin(), [](unsigned char x, unsigned char y) {
+                       return std::tolower(x) == std::tolower(y);
+                   });
+        };
+        for (const auto& [key, value] : headers) {
+            if (ci_equal(key, name)) return value;
+        }
+        return "";
+    }
+};
+
+// Public API exposes no third-party types (no httplib.h here at all).
+// The real implementation (backed by vendored cpp-httplib + mbedtls for
+// HTTPS) lives in src/core/client.cpp and is hidden behind this pointer, so
+// neither httplib.h nor mbedtls ever leak into consumers of this header.
+class client {
+public:
+    // use_ssl selects httplib's SSLClient (mbedtls-backed) vs. its plain
+    // Client internally; both http:// and https:// URLs work through
+    // fetch()/client::request without the caller ever thinking about this.
+    explicit HTTPP_API client(const std::string& host, int port, bool use_ssl = false);
+    HTTPP_API ~client();
+
+    HTTPP_API client(client&&) noexcept;
+    HTTPP_API client& operator=(client&&) noexcept;
+    client(const client&) = delete;
+    client& operator=(const client&) = delete;
+
+    HTTPP_API response get(const std::string& path);
+    HTTPP_API response get(const std::string& path, const std::vector<std::pair<std::string, std::string>>& headers);
+
+    // Parse `full_url` (via httpp::url) and GET it in one call — handles
+    // http:// and https:// alike. No manual URL parsing needed by callers
+    // (e.g. the CLI's `download` command).
+    static HTTPP_API response fetch(const std::string& full_url);
+
+    // A small, curl-flavored fluent request builder for the less common
+    // cases (custom method, headers, a body) that get()/fetch() don't
+    // cover — the common cases only (-X/-H/-d equivalents), not a full
+    // HTTP-client-options kitchen sink. Also what httpp/curl_compat.h's
+    // `curl_easy_*` C API is built on (see src/core/curl_compat.cpp) — one
+    // implementation of "run an HTTP request" in httpp, not two.
+    //
+    // Nested under `client` (not a free `httpp::request`) because
+    // `httpp::request` is already the incoming-request struct passed to
+    // server route handlers (see httpp/server.hpp) — naming this
+    // `client::request` avoids that collision and reads naturally next to
+    // the class it's built on: httpp::client::request(url)....run()
+    class request {
+    public:
+        explicit HTTPP_API request(std::string url);
+        HTTPP_API ~request();
+
+        HTTPP_API request(request&&) noexcept;
+        HTTPP_API request& operator=(request&&) noexcept;
+        request(const request&) = delete;
+        request& operator=(const request&) = delete;
+
+        // -X METHOD (GET/POST/PUT/PATCH/DELETE). If never called, defaults
+        // to GET, unless data() was called, in which case it defaults to
+        // POST — matching curl's own behavior.
+        HTTPP_API request& method(std::string m);
+
+        // -H "Name: value"
+        HTTPP_API request& header(std::string name, std::string value);
+
+        // -d "body" (sets Content-Type to
+        // application/x-www-form-urlencoded unless content_type() overrides it)
+        HTTPP_API request& data(std::string body);
+
+        HTTPP_API request& content_type(std::string type);
+
+        // -m/--max-time (seconds), -L/--location
+        HTTPP_API request& timeout(long seconds);
+        HTTPP_API request& follow_redirects(bool enable = true);
+
+        HTTPP_API response run() const;
+
+    private:
+        struct impl;
+        std::unique_ptr<impl> impl_;
+    };
+
+private:
+    struct impl;
+    std::unique_ptr<impl> impl_;
+};
+
+} // namespace httpp

{httpp-0.4.0 → httpp-0.5.0}/include/httpp/curl.hpp

@@ -14,35 +14,35 @@ namespace httpp::curl {
 // plain request API this is built on). Backed by the same vendored
 // cpp-httplib as the rest of httpp, hidden behind this pointer (see
 // src/core/curl.cpp) and never exposed in this public header.
-class HTTPP_API request {
+class request {
 public:
-    explicit request(std::string url);
-    ~request();
+    explicit HTTPP_API request(std::string url);
+    HTTPP_API ~request();
 
-    request(request&&) noexcept;
-    request& operator=(request&&) noexcept;
+    HTTPP_API request(request&&) noexcept;
+    HTTPP_API request& operator=(request&&) noexcept;
     request(const request&) = delete;
     request& operator=(const request&) = delete;
 
     // -X METHOD (GET/POST/PUT/PATCH/DELETE). If never called, defaults to
     // GET, unless data() was called, in which case it defaults to POST —
     // matching curl's own behavior.
-    request& method(std::string m);
+    HTTPP_API request& method(std::string m);
 
     // -H "Name: value"
-    request& header(std::string name, std::string value);
+    HTTPP_API request& header(std::string name, std::string value);
 
     // -d "body" (sets Content-Type to application/x-www-form-urlencoded
     // unless content_type() overrides it)
-    request& data(std::string body);
+    HTTPP_API request& data(std::string body);
 
-    request& content_type(std::string type);
+    HTTPP_API request& content_type(std::string type);
 
     // -m/--max-time (seconds), -L/--location
-    request& timeout(long seconds);
-    request& follow_redirects(bool enable = true);
+    HTTPP_API request& timeout(long seconds);
+    HTTPP_API request& follow_redirects(bool enable = true);
 
-    response run() const;
+    HTTPP_API response run() const;
 
 private:
     struct impl;

{httpp-0.4.0 → httpp-0.5.0}/include/httpp/curl_compat.h

@@ -9,21 +9,22 @@
  *
  * This is NOT a full libcurl replacement: only the commonly used easy-API
  * subset below is implemented, and every curl_easy_setopt() call is
- * forwarded to (and reuses the exact same code as) httpp::curl::request
- * (see include/httpp/curl.hpp, src/core/curl_compat.cpp) — there is no
+ * forwarded to (and reuses the exact same code as) httpp::client::request
+ * (see include/httpp/client.hpp, src/core/curl_compat.cpp) — there is no
  * separate/duplicated HTTP implementation here.
  *
  * Covered: CURLOPT_URL, CURLOPT_CUSTOMREQUEST, CURLOPT_HTTPGET,
  * CURLOPT_POST, CURLOPT_POSTFIELDS(+SIZE), CURLOPT_HTTPHEADER,
- * CURLOPT_WRITEFUNCTION/DATA, CURLOPT_USERAGENT, CURLOPT_TIMEOUT,
- * CURLOPT_FOLLOWLOCATION, curl_slist_*, curl_easy_getinfo
- * (CURLINFO_RESPONSE_CODE), curl_easy_strerror, curl_global_init/cleanup.
+ * CURLOPT_WRITEFUNCTION/DATA, CURLOPT_HEADERFUNCTION/DATA,
+ * CURLOPT_USERAGENT, CURLOPT_TIMEOUT, CURLOPT_FOLLOWLOCATION, curl_slist_*,
+ * curl_easy_getinfo (CURLINFO_RESPONSE_CODE, CURLINFO_CONTENT_TYPE),
+ * curl_easy_strerror, curl_global_init/cleanup.
  *
  * NOT covered (no such option exists here — curl_easy_setopt() returns
  * CURLE_UNKNOWN_OPTION for anything not listed above): proxies, cookies,
  * TLS/certificate options, auth (basic/digest/bearer), multipart forms,
- * response header callbacks, multi/share handles, and everything else in
- * real libcurl's ~300 CURLOPT_* options.
+ * multi/share handles, and everything else in real libcurl's ~300
+ * CURLOPT_* options.
  */
 
 #include "httpp/export.hpp"
@@ -58,6 +59,8 @@ typedef enum {
     CURLOPT_HTTPHEADER,
     CURLOPT_WRITEFUNCTION,
     CURLOPT_WRITEDATA,
+    CURLOPT_HEADERFUNCTION,
+    CURLOPT_HEADERDATA,
     CURLOPT_USERAGENT,
     CURLOPT_TIMEOUT,
     CURLOPT_FOLLOWLOCATION,
@@ -65,10 +68,15 @@ typedef enum {
 } CURLoption;
 
 typedef enum {
-    CURLINFO_RESPONSE_CODE
+    CURLINFO_RESPONSE_CODE,
+    CURLINFO_CONTENT_TYPE /* returns const char*, or NULL if absent */
 } CURLINFO;
 
 typedef size_t (*curl_write_callback)(char* ptr, size_t size, size_t nmemb, void* userdata);
+/* Called once per response header line, formatted "Name: value\r\n" —
+ * matches real libcurl's curl_write_callback signature exactly, since
+ * that's what CURLOPT_HEADERFUNCTION expects there too. */
+typedef curl_write_callback curl_header_callback;
 
 struct curl_slist {
     char* data;

{httpp-0.4.0 → httpp-0.5.0}/include/httpp/download.hpp

@@ -7,7 +7,7 @@
 
 namespace httpp {
 
-struct HTTPP_API download_result {
+struct download_result {
     bool ok = false;
     int status = 0;
     std::string error;
@@ -27,16 +27,16 @@ HTTPP_API download_result download(const std::string& url,
 //
 //   auto fut = httpp::download_file(url).output(path).run_async();
 //   download_result res = fut.get();
-class HTTPP_API download_file {
+class download_file {
 public:
-    explicit download_file(std::string url);
+    explicit HTTPP_API download_file(std::string url);
 
-    download_file& output(std::string dest_path);
-    download_file& enable_progress(bool enable = true);
-    download_file& disable_progress();
+    HTTPP_API download_file& output(std::string dest_path);
+    HTTPP_API download_file& enable_progress(bool enable = true);
+    HTTPP_API download_file& disable_progress();
 
-    download_result run() const;
-    std::future<download_result> run_async() const;
+    HTTPP_API download_result run() const;
+    HTTPP_API std::future<download_result> run_async() const;
 
 private:
     std::string url_;

httpp-0.5.0/include/httpp/export.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+// Explicit export macro: with CXX_VISIBILITY_PRESET=hidden, nothing is
+// exported from libhttpp.so by default (this is what keeps the vendored
+// httplib symbols compiled into the .so out of the dynamic symbol table).
+// Public httpp classes/functions are marked HTTPP_API to opt back in.
+//
+// Convention: HTTPP_API goes on individual out-of-line member functions
+// (constructors, destructors, methods implemented in src/core/*.cpp), never
+// on the class/struct itself. Marking a whole class dllexport on MSVC
+// requires every member — including private ones — to have "dll-interface"
+// (MSVC warning C4251), which fires even for private std::string/std::vector
+// members and even for the std::unique_ptr<impl> of the pimpl pattern
+// itself. Exporting only the specific symbols that are actually implemented
+// in the DLL avoids this entirely: purely inline types (simple data structs
+// like httpp::response, httpp::request, httpp::download_result) need no
+// HTTPP_API at all, since nothing about them is compiled into the DLL.
+#if defined(_WIN32)
+#  if defined(HTTPP_BUILDING_DLL)
+#    define HTTPP_API __declspec(dllexport)
+#  else
+#    define HTTPP_API __declspec(dllimport)
+#  endif
+#else
+#  define HTTPP_API __attribute__((visibility("default")))
+#endif

{httpp-0.4.0 → httpp-0.5.0}/include/httpp/progress.hpp

@@ -13,23 +13,23 @@ namespace httpp::progress {
 // Backed by the vendored `indicators` library (src/third_party/indicators),
 // but that dependency is hidden behind this pointer (see
 // src/core/progressbar.cpp) and never appears in this public header.
-class HTTPP_API bar {
+class bar {
 public:
-    explicit bar(std::size_t total, std::string description = "");
-    ~bar();
+    explicit HTTPP_API bar(std::size_t total, std::string description = "");
+    HTTPP_API ~bar();
 
-    bar(bar&&) noexcept;
-    bar& operator=(bar&&) noexcept;
+    HTTPP_API bar(bar&&) noexcept;
+    HTTPP_API bar& operator=(bar&&) noexcept;
     bar(const bar&) = delete;
     bar& operator=(const bar&) = delete;
 
-    void update(std::size_t n = 1);          // advance by n
-    void set_progress(std::size_t current);  // set an absolute position
-    void finish();                           // jump to total and stop
+    HTTPP_API void update(std::size_t n = 1);          // advance by n
+    HTTPP_API void set_progress(std::size_t current);  // set an absolute position
+    HTTPP_API void finish();                           // jump to total and stop
 
-    std::size_t total() const;
-    std::size_t current() const;
-    bool is_finished() const;
+    HTTPP_API std::size_t total() const;
+    HTTPP_API std::size_t current() const;
+    HTTPP_API bool is_finished() const;
 
 private:
     struct impl;
@@ -40,7 +40,11 @@ private:
 // it by one on every step of the loop, e.g.:
 //
 //   for (auto i : httpp::progressbar::range(100, "working")) { ... }
-class HTTPP_API range {
+//
+// Entirely defined inline here (calls only bar's already-exported members),
+// so — unlike bar itself — this class needs no HTTPP_API at all: nothing
+// about it is compiled into the DLL for a consumer to link against.
+class range {
 public:
     explicit range(std::size_t total, std::string description = "")
         : total_(total), bar_(total, std::move(description)) {}