Classes
struct	curl_easy_deleter
struct	curl_url_deleter
struct	curl_slist_deleter
struct	parsed_url
struct	allowed_authority
class	verified_body_file
class	staging_file
struct	receive_context
struct	progress_context

Typedefs
using	easy_handle = std::unique_ptr<CURL, curl_easy_deleter>
using	url_handle = std::unique_ptr<CURLU, curl_url_deleter>
using	header_list = std::unique_ptr<curl_slist, curl_slist_deleter>

Functions
void	curl_share_lock (CURL , const curl_lock_data, const curl_lock_access, void ) noexcept
void	curl_share_unlock (CURL , const curl_lock_data, void ) noexcept
void	initialize_curl ()
bool	is_control (const char character) noexcept
bool	valid_request_id (const std::string_view request_id)
std::string	artifact_id_for (const std::string_view request_id)
bool	valid_header_name (const std::string_view name)
std::string	ascii_lower (std::string value)
bool	valid_header (const http_header &header)
std::optional< std::string >	normalize_host (const std::string_view input)
std::optional< unsigned >	parse_port (const std::string_view text) noexcept
std::optional< parsed_url >	parse_url (const std::string &value, std::string &error)
std::optional< allowed_authority >	parse_allowed_authority (const std::string_view input)
bool	host_allowed (const parsed_url &url, const std::vector< std::string > &allowed_hosts, std::string &error)
std::optional< std::string >	resolve_redirect (const std::string &base, const std::string &location, std::string &error)
bool	path_begins_with (const std::filesystem::path &path, const std::filesystem::path &root)
bool	ensure_safe_parent (const std::filesystem::path &root, const std::filesystem::path &target, std::string &error)
bool	ensure_safe_existing_file (const std::filesystem::path &root, const std::filesystem::path &candidate, bool &unsafe, std::string &error)
std::size_t	body_read_callback (char destination, const std::size_t size, const std::size_t count, void user_data) noexcept
int	body_seek_callback (void *user_data, const curl_off_t offset, const int origin) noexcept
int	transfer_progress_callback (void *user_data, const curl_off_t download_total, const curl_off_t download_now, const curl_off_t upload_total, const curl_off_t upload_now) noexcept
bool	write_all (const int descriptor, const char *data, std::size_t size, std::string &error) noexcept
std::size_t	body_callback (char contents, const std::size_t size, const std::size_t count, void user_data) noexcept
std::string_view	trim_header_value (std::string_view value) noexcept
std::size_t	response_header_callback (char contents, const std::size_t size, const std::size_t count, void user_data) noexcept
bool	is_redirect_status (const long status) noexcept
bool	is_retryable_status (const long status) noexcept
bool	is_retryable_curl_status (const CURLcode status) noexcept
std::optional< std::chrono::milliseconds >	retry_after_delay (const std::vector< http_header > &headers)
std::chrono::milliseconds	retry_delay (const fetch_request_v1 &request, const std::size_t attempt, const std::vector< http_header > &headers)
long	timeout_milliseconds (const std::chrono::steady_clock::time_point deadline) noexcept
header_list	build_request_headers (const std::vector< http_header > &headers)
acquired_artifact_v1	fail_result (acquired_artifact_v1 result, const transport_status status, std::string message)
std::string	validation_message (const arachnespace::contracts::validation_result &validation)
std::string	rfc3339 (const std::chrono::system_clock::time_point time)
std::string_view	status_name (const transport_status status) noexcept
std::optional< std::string >	response_content_type (const std::vector< http_header > &headers)
bool	sensitive_header_name (const std::string_view name)
int	hexadecimal_value (const char character) noexcept
std::string	decode_query_name (const std::string_view name)
bool	sensitive_query_name (std::string name)
std::string	redact_url_query (const std::string &url)
std::string	receipt_safe_text (const std::string_view value)

Variables
constexpr std::size_t	maximum_header_bytes = 1024U * 1024U
constexpr std::size_t	maximum_response_headers = 1'024U
constexpr std::size_t	maximum_redirects = 20U
constexpr std::size_t	maximum_transport_attempts = 20U
constexpr std::size_t	maximum_url_bytes = 64U * 1024U
constexpr std::size_t	maximum_request_id_bytes = 128U
std::once_flag	curl_global_once
std::recursive_mutex	curl_share_mutex
CURLSH *	curl_connection_share = nullptr
std::atomic< std::uint64_t >	stage_sequence { 0 }

Typedef Documentation

◆ easy_handle

typedef std::unique_ptr< CURL, curl_easy_deleter > arachne::pheidippides::anonymous_namespace{transport.cpp}::easy_handle = std::unique_ptr<CURL, curl_easy_deleter>

Definition at line 77 of file transport.cpp.

◆ header_list

typedef std::unique_ptr< curl_slist, curl_slist_deleter > arachne::pheidippides::anonymous_namespace{transport.cpp}::header_list = std::unique_ptr<curl_slist, curl_slist_deleter>

Definition at line 79 of file transport.cpp.

◆ url_handle

typedef std::unique_ptr< CURLU, curl_url_deleter > arachne::pheidippides::anonymous_namespace{transport.cpp}::url_handle = std::unique_ptr<CURLU, curl_url_deleter>

Definition at line 78 of file transport.cpp.

Function Documentation

◆ artifact_id_for()

std::string arachne::pheidippides::anonymous_namespace{transport.cpp}::artifact_id_for ( const std::string_view request_id )

nodiscard

Definition at line 130 of file transport.cpp.

                                                     {
        constexpr std::string_view suffix = ".artifact";
        if (request_id.size() + suffix.size() <= maximum_request_id_bytes) {
            return std::string(request_id) + std::string(suffix);
        }
        return "artifact-" + crypto::sha256(request_id).substr(0, 32U);
    }

References maximum_request_id_bytes, and arachne::crypto::sha256().

Here is the call graph for this function:

◆ ascii_lower()

std::string arachne::pheidippides::anonymous_namespace{transport.cpp}::ascii_lower ( std::string value )

nodiscard

Definition at line 149 of file transport.cpp.

                                                         {
        std::ranges::transform(value, value.begin(), [](const char character) {
            return static_cast<char>(
                std::tolower(static_cast<unsigned char>(character))
            );
        });
        return value;
    }

Referenced by response_header_callback(), and sensitive_header_name().

Here is the caller graph for this function:

◆ body_callback()

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::body_callback	(	char *	contents,
		const std::size_t	size,
		const std::size_t	count,
		void *	user_data )

noexcept

Definition at line 869 of file transport.cpp.

               {
        auto& context = *static_cast<receive_context*>(user_data);
        if (size != 0
            && count > std::numeric_limits<std::size_t>::max() / size) {
            context.too_large = true;
            return 0;
        }
        const std::size_t total = size * count;
        if (total > context.max_bytes
            || context.byte_count > context.max_bytes - total) {
            context.too_large = true;
            return 0;
        }
        if (!write_all(
                context.descriptor, contents, total, context.write_error
            )) {
            context.write_failed = true;
            return 0;
        }
        try {
            context.hasher.update(std::as_bytes(std::span { contents, total }));
        } catch (const std::exception& exception) {
            context.write_failed = true;
            context.write_error = exception.what();
            return 0;
        }
        context.byte_count += total;
        return total;
    }

References arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::byte_count, arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::descriptor, arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::max_bytes, arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::too_large, write_all(), arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::write_error, and arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::write_failed.

Referenced by arachne::pheidippides::transport::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ body_read_callback()

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::body_read_callback	(	char *	destination,
		const std::size_t	size,
		const std::size_t	count,
		void *	user_data )

noexcept

Definition at line 661 of file transport.cpp.

               {
        auto& body = *static_cast<verified_body_file*>(user_data);
        if (size != 0
            && count > std::numeric_limits<std::size_t>::max() / size) {
            return CURL_READFUNC_ABORT;
        }
        return body.read(destination, size * count);
    }

References arachne::pheidippides::anonymous_namespace{transport.cpp}::verified_body_file::read().

Referenced by arachne::pheidippides::transport::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ body_seek_callback()

int arachne::pheidippides::anonymous_namespace{transport.cpp}::body_seek_callback	(	void *	user_data,
		const curl_off_t	offset,
		const int	origin )

noexcept

Definition at line 673 of file transport.cpp.

               {
        return static_cast<verified_body_file*>(user_data)->seek(
            offset, origin
        );
    }

References arachne::pheidippides::anonymous_namespace{transport.cpp}::verified_body_file::seek().

Referenced by arachne::pheidippides::transport::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_request_headers()

header_list arachne::pheidippides::anonymous_namespace{transport.cpp}::build_request_headers ( const std::vector< http_header > & headers )

nodiscard

Definition at line 1081 of file transport.cpp.

                                                                 {
        curl_slist* raw = nullptr;
        for (const auto& header : headers) {
            const std::string line = header.name + ":" + header.value;
            curl_slist* appended = curl_slist_append(raw, line.c_str());
            if (appended == nullptr) {
                curl_slist_free_all(raw);
                throw std::bad_alloc();
            }
            raw = appended;
        }
        return header_list(raw);
    }

◆ curl_share_lock()

void arachne::pheidippides::anonymous_namespace{transport.cpp}::curl_share_lock	(	CURL *	,
		const curl_lock_data	,
		const curl_lock_access	,
		void *	)

noexcept

Definition at line 49 of file transport.cpp.

               {
        curl_share_mutex.lock();
    }

References curl_share_mutex.

Referenced by initialize_curl().

Here is the caller graph for this function:

◆ curl_share_unlock()

void arachne::pheidippides::anonymous_namespace{transport.cpp}::curl_share_unlock	(	CURL *	,
		const curl_lock_data	,
		void *	)

noexcept

Definition at line 55 of file transport.cpp.

                                                                        {
        curl_share_mutex.unlock();
    }

References curl_share_mutex.

Referenced by initialize_curl().

Here is the caller graph for this function:

◆ decode_query_name()

std::string arachne::pheidippides::anonymous_namespace{transport.cpp}::decode_query_name ( const std::string_view name )

nodiscard

Definition at line 1205 of file transport.cpp.

                                                                         {
        std::string result;
        result.reserve(name.size());
        for (std::size_t index = 0; index < name.size(); ++index) {
            if (name[index] == '%' && index + 2U < name.size()) {
                const int high = hexadecimal_value(name[index + 1U]);
                const int low = hexadecimal_value(name[index + 2U]);
                if (high >= 0 && low >= 0) {
                    result.push_back(static_cast<char>(high * 16 + low));
                    index += 2U;
                    continue;
                }
            }
            result.push_back(name[index] == '+' ? ' ' : name[index]);
        }
        return result;
    }

◆ ensure_safe_existing_file()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::ensure_safe_existing_file	(	const std::filesystem::path &	root,
		const std::filesystem::path &	candidate,
		bool &	unsafe,
		std::string &	error )

nodiscard

Definition at line 447 of file transport.cpp.

      {
        unsafe = false;
        if (!path_begins_with(candidate, root)) {
            unsafe = true;
            error = "body artifact escapes the configured root";
            return false;
        }
        const std::filesystem::path relative
            = candidate.lexically_relative(root);
        std::filesystem::path current = root;
        std::size_t component_index = 0;
        const std::size_t component_count = static_cast<std::size_t>(
            std::distance(relative.begin(), relative.end())
        );
        for (const auto& component : relative) {
            ++component_index;
            current /= component;
            std::error_code ec;
            const auto state = std::filesystem::symlink_status(current, ec);
            if (ec || !std::filesystem::exists(state)) {
                error = "body artifact is missing or cannot be inspected";
                return false;
            }
            if (std::filesystem::is_symlink(state)) {
                unsafe = true;
                error = "body artifact path contains a symlink";
                return false;
            }
            const bool final_component = component_index == component_count;
            if ((!final_component && !std::filesystem::is_directory(state))
                || (final_component
                    && !std::filesystem::is_regular_file(state))) {
                error = "body artifact path has an unexpected file type";
                return false;
            }
        }
        return component_count != 0U;
    }

References path_begins_with().

Referenced by arachne::pheidippides::anonymous_namespace{transport.cpp}::verified_body_file::open_and_verify().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ensure_safe_parent()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::ensure_safe_parent	(	const std::filesystem::path &	root,
		const std::filesystem::path &	target,
		std::string &	error )

nodiscard

Definition at line 399 of file transport.cpp.

      {
        const std::filesystem::path parent = target.parent_path();
        if (!path_begins_with(parent, root)) {
            error = "artifact parent escapes the configured root";
            return false;
        }
        const std::filesystem::path relative = parent.lexically_relative(root);
        std::filesystem::path current = root;
        for (const auto& component : relative) {
            if (component == ".") {
                continue;
            }
            current /= component;
            std::error_code ec;
            const auto state = std::filesystem::symlink_status(current, ec);
            if (ec && ec != std::errc::no_such_file_or_directory) {
                error = "cannot inspect artifact directory: " + ec.message();
                return false;
            }
            if (!ec && std::filesystem::exists(state)) {
                if (std::filesystem::is_symlink(state)
                    || !std::filesystem::is_directory(state)) {
                    error = "artifact directory component is not a real "
                            "directory";
                    return false;
                }
                continue;
            }
            ec.clear();
            if (!std::filesystem::create_directory(current, ec) && ec) {
                error = "cannot create artifact directory: " + ec.message();
                return false;
            }
        }
 
        std::error_code ec;
        const auto canonical_parent
            = std::filesystem::weakly_canonical(parent, ec);
        if (ec || !path_begins_with(canonical_parent, root)) {
            error = "artifact directory resolves outside the configured root";
            return false;
        }
        return true;
    }

References path_begins_with().

Here is the call graph for this function:

◆ fail_result()

acquired_artifact_v1 arachne::pheidippides::anonymous_namespace{transport.cpp}::fail_result	(	acquired_artifact_v1	result,
		const transport_status	status,
		std::string	message )

nodiscard

Definition at line 1095 of file transport.cpp.

      {
        result.status = status;
        result.error_message = std::move(message);
        result.completed_at = std::chrono::system_clock::now();
        return result;
    }

References arachne::pheidippides::acquired_artifact_v1::error_message, and arachne::pheidippides::acquired_artifact_v1::status.

◆ hexadecimal_value()

int arachne::pheidippides::anonymous_namespace{transport.cpp}::hexadecimal_value ( const char character )

nodiscardnoexcept

Definition at line 1192 of file transport.cpp.

                                                                       {
        if (character >= '0' && character <= '9') {
            return character - '0';
        }
        if (character >= 'a' && character <= 'f') {
            return character - 'a' + 10;
        }
        if (character >= 'A' && character <= 'F') {
            return character - 'A' + 10;
        }
        return -1;
    }

◆ host_allowed()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::host_allowed	(	const parsed_url &	url,
		const std::vector< std::string > &	allowed_hosts,
		std::string &	error )

nodiscard

Definition at line 328 of file transport.cpp.

      {
        if (allowed_hosts.empty()) {
            error = "allowed_hosts must contain at least one exact host";
            return false;
        }
        bool matched = false;
        const unsigned effective_port
            = url.port.value_or(url.scheme == "https" ? 443U : 80U);
        for (const std::string& candidate : allowed_hosts) {
            auto allowed = parse_allowed_authority(candidate);
            if (!allowed) {
                error = "allowed_hosts contains an invalid host";
                return false;
            }
            if (allowed->host == url.host
                && (!allowed->port || *allowed->port == effective_port)) {
                matched = true;
            }
        }
        if (matched) {
            return true;
        }
        error = "URL host is not permitted by allowed_hosts";
        return false;
    }

References arachne::pheidippides::anonymous_namespace{transport.cpp}::parsed_url::scheme.

◆ initialize_curl()

void arachne::pheidippides::anonymous_namespace{transport.cpp}::initialize_curl ( )

Definition at line 81 of file transport.cpp.

                           {
        std::call_once(curl_global_once, [] {
            const CURLcode result = curl_global_init(CURL_GLOBAL_DEFAULT);
            if (result != CURLE_OK) {
                throw std::runtime_error("curl_global_init failed");
            }
            curl_connection_share = curl_share_init();
            if (curl_connection_share == nullptr
                || curl_share_setopt(
                       curl_connection_share, CURLSHOPT_LOCKFUNC,
                       curl_share_lock
                   ) != CURLSHE_OK
                || curl_share_setopt(
                       curl_connection_share, CURLSHOPT_UNLOCKFUNC,
                       curl_share_unlock
                   ) != CURLSHE_OK
                || curl_share_setopt(
                       curl_connection_share, CURLSHOPT_SHARE,
                       CURL_LOCK_DATA_DNS
                   ) != CURLSHE_OK
                || curl_share_setopt(
                       curl_connection_share, CURLSHOPT_SHARE,
                       CURL_LOCK_DATA_CONNECT
                   ) != CURLSHE_OK) {
                throw std::runtime_error(
                    "cannot initialize the Pheidippides connection pool"
                );
            }
        });
    }

References curl_connection_share, curl_global_once, curl_share_lock(), and curl_share_unlock().

Referenced by arachne::pheidippides::transport::transport().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_control()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::is_control ( const char character )

nodiscardnoexcept

Definition at line 112 of file transport.cpp.

                                                                 {
        const auto value = static_cast<unsigned char>(character);
        return value < 0x20U || value == 0x7fU;
    }

◆ is_redirect_status()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::is_redirect_status ( const long status )

nodiscardnoexcept

Definition at line 958 of file transport.cpp.

                                                                      {
        switch (status) {
        case 300:
        case 301:
        case 302:
        case 303:
        case 305:
        case 307:
        case 308:
            return true;
        default:
            return false;
        }
    }

Referenced by arachne::pheidippides::transport::execute().

Here is the caller graph for this function:

◆ is_retryable_curl_status()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::is_retryable_curl_status ( const CURLcode status )

nodiscardnoexcept

Definition at line 979 of file transport.cpp.

                                                             {
        switch (status) {
        case CURLE_COULDNT_RESOLVE_PROXY:
        case CURLE_COULDNT_RESOLVE_HOST:
        case CURLE_COULDNT_CONNECT:
        case CURLE_PARTIAL_FILE:
        case CURLE_HTTP2:
        case CURLE_WRITE_ERROR:
        case CURLE_UPLOAD_FAILED:
        case CURLE_READ_ERROR:
        case CURLE_OPERATION_TIMEDOUT:
        case CURLE_ABORTED_BY_CALLBACK:
        case CURLE_HTTP_POST_ERROR:
        case CURLE_RECV_ERROR:
        case CURLE_SEND_ERROR:
        case CURLE_GOT_NOTHING:
        case CURLE_AGAIN:
#ifdef CURLE_HTTP3
        case CURLE_HTTP3:
#endif
            return true;
        default:
            return false;
        }
    }

Referenced by arachne::pheidippides::transport::execute().

Here is the caller graph for this function:

◆ is_retryable_status()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::is_retryable_status ( const long status )

nodiscardnoexcept

Definition at line 973 of file transport.cpp.

                                                                       {
        return status == 408 || status == 425 || status == 429 || status == 500
            || status == 502 || status == 503 || status == 504;
    }

Referenced by arachne::pheidippides::transport::execute().

Here is the caller graph for this function:

◆ normalize_host()

std::optional< std::string > arachne::pheidippides::anonymous_namespace{transport.cpp}::normalize_host ( const std::string_view input )

nodiscard

Definition at line 168 of file transport.cpp.

                                               {
        if (input.empty() || input.find('\0') != std::string_view::npos
            || std::ranges::any_of(input, [](const char character) {
                   return std::isspace(static_cast<unsigned char>(character))
                       != 0;
               })) {
            return std::nullopt;
        }
        std::string host(input);
        if (host.size() >= 2U && host.front() == '[' && host.back() == ']') {
            host = host.substr(1U, host.size() - 2U);
        }
        if (!host.empty() && host.back() == '.') {
            host.pop_back();
        }
        if (host.empty() || host.find_first_of("/@?#") != std::string::npos
            || std::ranges::count(host, ':') == 1) {
            return std::nullopt;
        }
        return ascii_lower(std::move(host));
    }

◆ parse_allowed_authority()

std::optional< allowed_authority > arachne::pheidippides::anonymous_namespace{transport.cpp}::parse_allowed_authority ( const std::string_view input )

nodiscard

Definition at line 292 of file transport.cpp.

                                                        {
        std::string_view host = input;
        std::optional<unsigned> port;
        if (input.starts_with('[')) {
            const std::size_t closing = input.find(']');
            if (closing == std::string_view::npos) {
                return std::nullopt;
            }
            host = input.substr(0, closing + 1U);
            if (closing + 1U != input.size()) {
                if (input[closing + 1U] != ':') {
                    return std::nullopt;
                }
                port = parse_port(input.substr(closing + 2U));
                if (!port) {
                    return std::nullopt;
                }
            }
        } else if (std::ranges::count(input, ':') == 1) {
            const std::size_t colon = input.find(':');
            host = input.substr(0, colon);
            port = parse_port(input.substr(colon + 1U));
            if (!port) {
                return std::nullopt;
            }
        }
        auto normalized = normalize_host(host);
        if (!normalized) {
            return std::nullopt;
        }
        return allowed_authority {
            .host = std::move(*normalized),
            .port = port,
        };
    }

◆ parse_port()

std::optional< unsigned > arachne::pheidippides::anonymous_namespace{transport.cpp}::parse_port ( const std::string_view text )

nodiscardnoexcept

Definition at line 198 of file transport.cpp.

                                                   {
        if (text.empty()
            || !std::ranges::all_of(text, [](const char character) {
                   return character >= '0' && character <= '9';
               })) {
            return std::nullopt;
        }
        unsigned value = 0;
        for (const char character : text) {
            value = value * 10U
                + static_cast<unsigned>(character - static_cast<char>('0'));
            if (value > 65'535U) {
                return std::nullopt;
            }
        }
        return value == 0U ? std::nullopt : std::optional<unsigned> { value };
    }

◆ parse_url()

std::optional< parsed_url > arachne::pheidippides::anonymous_namespace{transport.cpp}::parse_url	(	const std::string &	value,
		std::string &	error )

nodiscard

Definition at line 217 of file transport.cpp.

                                                        {
        if (value.empty() || value.size() > maximum_url_bytes
            || value.find('\0') != std::string::npos) {
            error = "URL is empty, contains NUL, or exceeds the length limit";
            return std::nullopt;
        }
 
        url_handle parsed(curl_url());
        if (!parsed
            || curl_url_set(parsed.get(), CURLUPART_URL, value.c_str(), 0)
                != CURLUE_OK) {
            error = "URL is not an absolute HTTP or HTTPS URL";
            return std::nullopt;
        }
 
        auto get_part
            = [&](const CURLUPart part) -> std::optional<std::string> {
            char* raw = nullptr;
            const CURLUcode code
                = curl_url_get(parsed.get(), part, &raw, CURLU_NO_DEFAULT_PORT);
            if (code != CURLUE_OK || raw == nullptr) {
                return std::nullopt;
            }
            std::unique_ptr<char, decltype(&curl_free)> owned(raw, &curl_free);
            return std::string(raw);
        };
 
        auto scheme = get_part(CURLUPART_SCHEME);
        auto host = get_part(CURLUPART_HOST);
        auto port_text = get_part(CURLUPART_PORT);
        auto normalized = get_part(CURLUPART_URL);
        if (!scheme || !host || !normalized) {
            error = "URL must include a scheme and host";
            return std::nullopt;
        }
        *scheme = ascii_lower(std::move(*scheme));
        if (*scheme != "http" && *scheme != "https") {
            error = "only HTTP and HTTPS URLs are allowed";
            return std::nullopt;
        }
        auto normalized_host = normalize_host(*host);
        if (!normalized_host) {
            error = "URL host is invalid";
            return std::nullopt;
        }
        std::optional<unsigned> port;
        if (port_text) {
            port = parse_port(*port_text);
            if (!port) {
                error = "URL port is invalid";
                return std::nullopt;
            }
        }
        if (get_part(CURLUPART_USER) || get_part(CURLUPART_PASSWORD)) {
            error = "URL credentials are not allowed";
            return std::nullopt;
        }
        if (get_part(CURLUPART_FRAGMENT)) {
            error = "URL fragments are not allowed";
            return std::nullopt;
        }
        return parsed_url {
            .normalized_url = std::move(*normalized),
            .scheme = std::move(*scheme),
            .host = std::move(*normalized_host),
            .port = port,
        };
    }

◆ path_begins_with()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::path_begins_with	(	const std::filesystem::path &	path,
		const std::filesystem::path &	root )

nodiscard

Definition at line 385 of file transport.cpp.

      {
        auto path_iterator = path.begin();
        for (auto root_iterator = root.begin(); root_iterator != root.end();
             ++root_iterator, ++path_iterator) {
            if (path_iterator == path.end()
                || *path_iterator != *root_iterator) {
                return false;
            }
        }
        return true;
    }

Referenced by ensure_safe_existing_file(), and ensure_safe_parent().

Here is the caller graph for this function:

◆ receipt_safe_text()

std::string arachne::pheidippides::anonymous_namespace{transport.cpp}::receipt_safe_text ( const std::string_view value )

nodiscard

Definition at line 1274 of file transport.cpp.

                                                                          {
        constexpr std::string_view hexadecimal = "0123456789ABCDEF";
        std::string result;
        result.reserve(value.size());
        for (const char raw_character : value) {
            const auto character = static_cast<unsigned char>(raw_character);
            if (character >= 0x20U && character <= 0x7eU) {
                result.push_back(static_cast<char>(character));
            } else {
                result.push_back('%');
                result.push_back(hexadecimal[character >> 4U]);
                result.push_back(hexadecimal[character & 0x0fU]);
            }
        }
        return result;
    }

◆ redact_url_query()

std::string arachne::pheidippides::anonymous_namespace{transport.cpp}::redact_url_query ( const std::string & url )

nodiscard

Definition at line 1233 of file transport.cpp.

                                                                   {
        const std::size_t question = url.find('?');
        if (question == std::string::npos) {
            return url;
        }
        const std::size_t fragment = url.find('#', question + 1U);
        const std::size_t query_end
            = fragment == std::string::npos ? url.size() : fragment;
        std::string result = url.substr(0, question + 1U);
        std::string_view query(
            url.data() + question + 1U, query_end - question - 1U
        );
        bool first = true;
        while (!query.empty()) {
            const std::size_t ampersand = query.find('&');
            const std::string_view parameter = query.substr(0, ampersand);
            const std::size_t equals = parameter.find('=');
            const std::string name(parameter.substr(0, equals));
            if (!first) {
                result.push_back('&');
            }
            first = false;
            result += name;
            if (equals != std::string_view::npos) {
                result.push_back('=');
                result += sensitive_query_name(name)
                    ? "%5BREDACTED%5D"
                    : std::string(parameter.substr(equals + 1U));
            }
            if (ampersand == std::string_view::npos) {
                query = {};
            } else {
                query.remove_prefix(ampersand + 1U);
            }
        }
        if (fragment != std::string::npos) {
            result += url.substr(fragment);
        }
        return result;
    }

References sensitive_query_name().

Here is the call graph for this function:

◆ resolve_redirect()

std::optional< std::string > arachne::pheidippides::anonymous_namespace{transport.cpp}::resolve_redirect	(	const std::string &	base,
		const std::string &	location,
		std::string &	error )

nodiscard

Definition at line 357 of file transport.cpp.

      {
        if (location.empty() || location.find('\0') != std::string::npos) {
            error = "redirect Location is empty or invalid";
            return std::nullopt;
        }
        url_handle resolved(curl_url());
        if (!resolved
            || curl_url_set(resolved.get(), CURLUPART_URL, base.c_str(), 0)
                != CURLUE_OK
            || curl_url_set(resolved.get(), CURLUPART_URL, location.c_str(), 0)
                != CURLUE_OK) {
            error = "redirect Location could not be resolved";
            return std::nullopt;
        }
        char* raw = nullptr;
        if (curl_url_get(
                resolved.get(), CURLUPART_URL, &raw, CURLU_NO_DEFAULT_PORT
            ) != CURLUE_OK
            || raw == nullptr) {
            error = "redirect URL could not be serialized";
            return std::nullopt;
        }
        std::unique_ptr<char, decltype(&curl_free)> owned(raw, &curl_free);
        return std::string(raw);
    }

◆ response_content_type()

std::optional< std::string > arachne::pheidippides::anonymous_namespace{transport.cpp}::response_content_type ( const std::vector< http_header > & headers )

nodiscard

Definition at line 1173 of file transport.cpp.

                                                                 {
        for (const auto& header : headers) {
            if (ascii_lower(header.name) == "content-type"
                && !header.value.empty()) {
                return header.value;
            }
        }
        return std::nullopt;
    }

◆ response_header_callback()

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::response_header_callback	(	char *	contents,
		const std::size_t	size,
		const std::size_t	count,
		void *	user_data )

noexcept

Definition at line 915 of file transport.cpp.

               {
        auto& context = *static_cast<receive_context*>(user_data);
        if (size != 0
            && count > std::numeric_limits<std::size_t>::max() / size) {
            context.headers_too_large = true;
            return 0;
        }
        const std::size_t total = size * count;
        if (total > maximum_header_bytes
            || context.header_bytes > maximum_header_bytes - total) {
            context.headers_too_large = true;
            return 0;
        }
        context.header_bytes += total;
        const std::string_view line(contents, total);
        if (line.starts_with("HTTP/")) {
            context.headers.clear();
            context.location.clear();
            return total;
        }
        const std::size_t colon = line.find(':');
        if (colon == std::string_view::npos) {
            return total;
        }
        http_header header {
            .name = std::string(line.substr(0, colon)),
            .value = std::string(trim_header_value(line.substr(colon + 1U))),
        };
        if (!valid_header_name(header.name)) {
            return total;
        }
        if (ascii_lower(header.name) == "location") {
            context.location = header.value;
        }
        if (context.headers.size() < maximum_response_headers) {
            context.headers.emplace_back(std::move(header));
        }
        return total;
    }

References ascii_lower(), arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::header_bytes, arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::headers_too_large, arachne::pheidippides::anonymous_namespace{transport.cpp}::receive_context::location, maximum_header_bytes, maximum_response_headers, arachne::pheidippides::http_header::name, and arachne::pheidippides::http_header::value.

Referenced by arachne::pheidippides::transport::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ retry_after_delay()

std::optional< std::chrono::milliseconds > arachne::pheidippides::anonymous_namespace{transport.cpp}::retry_after_delay ( const std::vector< http_header > & headers )

nodiscard

Definition at line 1006 of file transport.cpp.

                                                             {
        for (const auto& header : headers) {
            if (ascii_lower(header.name) != "retry-after") {
                continue;
            }
            std::uint64_t seconds = 0;
            const char* begin = header.value.data();
            const char* end = begin + header.value.size();
            const auto parsed = std::from_chars(begin, end, seconds);
            if (parsed.ec == std::errc {} && parsed.ptr == end) {
                constexpr std::uint64_t maximum_seconds = 3'600U;
                return std::chrono::milliseconds(
                    std::min(seconds, maximum_seconds) * 1'000U
                );
            }
            const std::time_t date
                = curl_getdate(header.value.c_str(), nullptr);
            if (date >= 0) {
                const std::time_t now = std::time(nullptr);
                const auto delay = std::max<std::time_t>(0, date - now);
                return std::chrono::milliseconds(
                    std::min<std::time_t>(delay, 3'600) * 1'000
                );
            }
            return std::nullopt;
        }
        return std::nullopt;
    }

◆ retry_delay()

std::chrono::milliseconds arachne::pheidippides::anonymous_namespace{transport.cpp}::retry_delay	(	const fetch_request_v1 &	request,
		const std::size_t	attempt,
		const std::vector< http_header > &	headers )

nodiscard

Definition at line 1035 of file transport.cpp.

      {
        if (request.respect_retry_after) {
            if (const auto provided = retry_after_delay(headers)) {
                return std::min(*provided, request.maximum_retry_delay);
            }
        }
        std::int64_t delay = request.initial_retry_delay.count();
        for (std::size_t power = 1; power < attempt; ++power) {
            if (delay >= request.maximum_retry_delay.count() / 2) {
                delay = request.maximum_retry_delay.count();
                break;
            }
            delay *= 2;
        }
        delay = std::min(delay, request.maximum_retry_delay.count());
        const std::string jitter_seed
            = request.request_id + ":" + std::to_string(attempt);
        const std::string digest = crypto::sha256(jitter_seed);
        unsigned jitter_value = 0;
        static_cast<void>(
            std::from_chars(digest.data(), digest.data() + 4, jitter_value, 16)
        );
        const std::int64_t per_mille
            = 800 + static_cast<std::int64_t>(jitter_value % 401U);
        return std::chrono::milliseconds(delay * per_mille / 1'000);
    }

References arachne::pheidippides::fetch_request_v1::request_id, arachne::pheidippides::fetch_request_v1::respect_retry_after, and arachne::crypto::sha256().

Here is the call graph for this function:

◆ rfc3339()

std::string arachne::pheidippides::anonymous_namespace{transport.cpp}::rfc3339 ( const std::chrono::system_clock::time_point time )

nodiscard

Definition at line 1121 of file transport.cpp.

                                                        {
        const std::time_t converted
            = std::chrono::system_clock::to_time_t(time);
        std::tm utc {};
        if (::gmtime_r(&converted, &utc) == nullptr) {
            throw std::runtime_error("cannot format transport timestamp");
        }
        std::ostringstream output;
        output << std::put_time(&utc, "%Y-%m-%dT%H:%M:%SZ");
        return output.str();
    }

◆ sensitive_header_name()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::sensitive_header_name ( const std::string_view name )

nodiscard

Definition at line 1183 of file transport.cpp.

                                                                        {
        const std::string lowered = ascii_lower(std::string(name));
        return lowered == "authorization" || lowered == "proxy-authorization"
            || lowered == "cookie" || lowered == "set-cookie"
            || lowered == "x-api-key" || lowered == "api-key"
            || lowered == "x-goog-api-key" || lowered == "x-auth-token"
            || lowered == "x-access-token" || lowered == "private-token";
    }

References ascii_lower().

Here is the call graph for this function:

◆ sensitive_query_name()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::sensitive_query_name ( std::string name )

nodiscard

Definition at line 1223 of file transport.cpp.

                                                            {
        name = ascii_lower(decode_query_name(name));
        return name.contains("token") || name.contains("secret")
            || name.contains("password") || name.contains("signature")
            || name.contains("credential") || name.contains("api_key")
            || name.contains("apikey") || name.contains("access_key")
            || name == "key" || name == "auth" || name == "sig"
            || name.starts_with("x-amz-");
    }

Referenced by redact_url_query().

Here is the caller graph for this function:

◆ status_name()

std::string_view arachne::pheidippides::anonymous_namespace{transport.cpp}::status_name ( const transport_status status )

nodiscardnoexcept

Definition at line 1134 of file transport.cpp.

                                                        {
        switch (status) {
        case transport_status::delivered:
            return "delivered";
        case transport_status::invalid_request:
            return "invalid_request";
        case transport_status::unsafe_artifact_ref:
            return "unsafe_artifact_ref";
        case transport_status::disallowed_host:
            return "disallowed_host";
        case transport_status::redirect_rejected:
            return "redirect_rejected";
        case transport_status::redirect_limit_exceeded:
            return "redirect_limit_exceeded";
        case transport_status::timed_out:
            return "timed_out";
        case transport_status::response_too_large:
            return "response_too_large";
        case transport_status::network_error:
            return "network_error";
        case transport_status::storage_error:
            return "storage_error";
        case transport_status::artifact_exists:
            return "artifact_exists";
        case transport_status::door_policy_rejected:
            return "door_policy_rejected";
        case transport_status::cache_miss:
            return "cache_miss";
        case transport_status::checksum_mismatch:
            return "checksum_mismatch";
        case transport_status::retry_budget_exhausted:
            return "retry_budget_exhausted";
        case transport_status::admission_timeout:
            return "admission_timeout";
        }
        return "unknown_transport_status";
    }

◆ timeout_milliseconds()

long arachne::pheidippides::anonymous_namespace{transport.cpp}::timeout_milliseconds ( const std::chrono::steady_clock::time_point deadline )

nodiscardnoexcept

Definition at line 1065 of file transport.cpp.

               {
        const auto remaining
            = std::chrono::duration_cast<std::chrono::milliseconds>(
                deadline - std::chrono::steady_clock::now()
            );
        if (remaining.count() <= 0) {
            return 0;
        }
        return static_cast<long>(std::min<std::int64_t>(
            remaining.count(), std::numeric_limits<long>::max()
        ));
    }

◆ transfer_progress_callback()

int arachne::pheidippides::anonymous_namespace{transport.cpp}::transfer_progress_callback	(	void *	user_data,
		const curl_off_t	download_total,
		const curl_off_t	download_now,
		const curl_off_t	upload_total,
		const curl_off_t	upload_now )

noexcept

Definition at line 812 of file transport.cpp.

               {
        auto& progress = *static_cast<progress_context*>(user_data);
        const auto now = std::chrono::steady_clock::now();
        if (download_now != progress.downloaded) {
            progress.downloaded = download_now;
            progress.last_download_progress = now;
        }
        if (upload_now != progress.uploaded) {
            progress.uploaded = upload_now;
            progress.last_upload_progress = now;
        }
        const bool download_complete
            = download_total > 0 && download_now >= download_total;
        const bool upload_complete = !progress.upload_expected
            || (upload_total > 0 && upload_now >= upload_total);
        if (upload_complete && !download_complete
            && now - progress.last_download_progress > progress.read_timeout) {
            progress.read_timed_out = true;
            return 1;
        }
        if (!upload_complete
            && now - progress.last_upload_progress > progress.write_timeout) {
            progress.write_timed_out = true;
            return 1;
        }
        return 0;
    }

References arachne::pheidippides::anonymous_namespace{transport.cpp}::progress_context::downloaded, arachne::pheidippides::anonymous_namespace{transport.cpp}::progress_context::read_timed_out, arachne::pheidippides::anonymous_namespace{transport.cpp}::progress_context::upload_expected, arachne::pheidippides::anonymous_namespace{transport.cpp}::progress_context::uploaded, and arachne::pheidippides::anonymous_namespace{transport.cpp}::progress_context::write_timed_out.

Referenced by arachne::pheidippides::transport::execute().

Here is the caller graph for this function:

◆ trim_header_value()

std::string_view arachne::pheidippides::anonymous_namespace{transport.cpp}::trim_header_value ( std::string_view value )

nodiscardnoexcept

Definition at line 903 of file transport.cpp.

                                                     {
        while (!value.empty()
               && (value.back() == '\r' || value.back() == '\n')) {
            value.remove_suffix(1U);
        }
        while (!value.empty()
               && (value.front() == ' ' || value.front() == '\t')) {
            value.remove_prefix(1U);
        }
        return value;
    }

◆ valid_header()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::valid_header ( const http_header & header )

nodiscard

Definition at line 158 of file transport.cpp.

                                                               {
        return valid_header_name(header.name)
            && ascii_lower(header.name) != "host"
            && std::ranges::none_of(header.value, [](const char character) {
                   return character == '\0' || character == '\r'
                       || character == '\n';
               });
    }

◆ valid_header_name()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::valid_header_name ( const std::string_view name )

nodiscard

Definition at line 138 of file transport.cpp.

                                                                    {
        if (name.empty()) {
            return false;
        }
        constexpr std::string_view separators = "()<>@,;:\\\"/[]?={} \t";
        return std::ranges::none_of(name, [&](const char character) {
            return is_control(character)
                || separators.find(character) != std::string_view::npos;
        });
    }

◆ valid_request_id()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::valid_request_id ( const std::string_view request_id )

nodiscard

Definition at line 117 of file transport.cpp.

                                                                         {
        if (request_id.empty() || request_id.size() > maximum_request_id_bytes
            || std::isalnum(static_cast<unsigned char>(request_id.front()))
                == 0) {
            return false;
        }
        return std::ranges::all_of(request_id.substr(1), [](const char value) {
            return std::isalnum(static_cast<unsigned char>(value)) != 0
                || value == '.' || value == '_' || value == ':' || value == '-';
        });
    }

References maximum_request_id_bytes.

◆ validation_message()

std::string arachne::pheidippides::anonymous_namespace{transport.cpp}::validation_message ( const arachnespace::contracts::validation_result & validation )

nodiscard

Definition at line 1105 of file transport.cpp.

      {
        std::ostringstream message;
        message << "invalid fetch_request_v1 contract";
        for (const auto& diagnostic : validation.diagnostics) {
            message << "; "
                    << (diagnostic.instance_path.empty()
                            ? std::string_view { "/" }
                            : std::string_view { diagnostic.instance_path })
                    << " [" << diagnostic.code << "] " << diagnostic.message;
        }
        return message.str();
    }

◆ write_all()

bool arachne::pheidippides::anonymous_namespace{transport.cpp}::write_all	(	const int	descriptor,
		const char *	data,
		std::size_t	size,
		std::string &	error )

nodiscardnoexcept

Definition at line 844 of file transport.cpp.

               {
        while (size != 0) {
            const ssize_t written = ::write(descriptor, data, size);
            if (written < 0) {
                if (errno == EINTR) {
                    continue;
                }
                error = std::string("artifact write failed: ")
                    + std::strerror(errno);
                return false;
            }
            if (written == 0) {
                error = "artifact write made no progress";
                return false;
            }
            const auto amount = static_cast<std::size_t>(written);
            data += amount;
            size -= amount;
        }
        return true;
    }

Referenced by body_callback().

Here is the caller graph for this function:

Variable Documentation

◆ curl_connection_share

CURLSH * arachne::pheidippides::anonymous_namespace{transport.cpp}::curl_connection_share = nullptr

Definition at line 46 of file transport.cpp.

Referenced by arachne::pheidippides::transport::execute(), and initialize_curl().

◆ curl_global_once

std::once_flag arachne::pheidippides::anonymous_namespace{transport.cpp}::curl_global_once

Definition at line 44 of file transport.cpp.

Referenced by initialize_curl().

◆ curl_share_mutex

std::recursive_mutex arachne::pheidippides::anonymous_namespace{transport.cpp}::curl_share_mutex

Definition at line 45 of file transport.cpp.

Referenced by curl_share_lock(), and curl_share_unlock().

◆ maximum_header_bytes

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::maximum_header_bytes = 1024U * 1024U

constexpr

Definition at line 37 of file transport.cpp.

Referenced by response_header_callback().

◆ maximum_redirects

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::maximum_redirects = 20U

constexpr

Definition at line 39 of file transport.cpp.

Referenced by arachne::pheidippides::transport::execute().

◆ maximum_request_id_bytes

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::maximum_request_id_bytes = 128U

constexpr

Definition at line 42 of file transport.cpp.

Referenced by artifact_id_for(), and valid_request_id().

◆ maximum_response_headers

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::maximum_response_headers = 1'024U

constexpr

Definition at line 38 of file transport.cpp.

Referenced by response_header_callback().

◆ maximum_transport_attempts

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::maximum_transport_attempts = 20U

constexpr

Definition at line 40 of file transport.cpp.

Referenced by arachne::pheidippides::transport::execute().

◆ maximum_url_bytes

std::size_t arachne::pheidippides::anonymous_namespace{transport.cpp}::maximum_url_bytes = 64U * 1024U

constexpr

Definition at line 41 of file transport.cpp.

◆ stage_sequence

std::atomic< std::uint64_t > arachne::pheidippides::anonymous_namespace{transport.cpp}::stage_sequence { 0 }

Definition at line 47 of file transport.cpp.

47{ 0 };

Referenced by arachne::pheidippides::anonymous_namespace{transport.cpp}::staging_file::staging_file().

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ easy_handle

◆ header_list

◆ url_handle

Function Documentation

◆ artifact_id_for()

◆ ascii_lower()

◆ body_callback()

◆ body_read_callback()

◆ body_seek_callback()

◆ build_request_headers()

◆ curl_share_lock()

◆ curl_share_unlock()

◆ decode_query_name()

◆ ensure_safe_existing_file()

◆ ensure_safe_parent()

◆ fail_result()

◆ hexadecimal_value()

◆ host_allowed()

◆ initialize_curl()

◆ is_control()

◆ is_redirect_status()

◆ is_retryable_curl_status()

◆ is_retryable_status()

◆ normalize_host()

◆ parse_allowed_authority()

◆ parse_port()

◆ parse_url()

◆ path_begins_with()

◆ receipt_safe_text()

◆ redact_url_query()

◆ resolve_redirect()

◆ response_content_type()

◆ response_header_callback()

◆ retry_after_delay()

◆ retry_delay()

◆ rfc3339()

◆ sensitive_header_name()

◆ sensitive_query_name()

◆ status_name()

◆ timeout_milliseconds()

◆ transfer_progress_callback()

◆ trim_header_value()

◆ valid_header()

◆ valid_header_name()

◆ valid_request_id()

◆ validation_message()

◆ write_all()

Variable Documentation

◆ curl_connection_share

◆ curl_global_once

◆ curl_share_mutex

◆ maximum_header_bytes

◆ maximum_redirects

◆ maximum_request_id_bytes

◆ maximum_response_headers

◆ maximum_transport_attempts

◆ maximum_url_bytes

◆ stage_sequence