http_system.h

#ifndef SOURCEMETA_CORE_HTTP_SYSTEM_H_
#define SOURCEMETA_CORE_HTTP_SYSTEM_H_
 
#ifndef SOURCEMETA_CORE_HTTP_EXPORT
#include <sourcemeta/core/http_export.h>
#endif
 
#include <sourcemeta/core/crypto.h>
#include <sourcemeta/core/http_aws_sigv4.h>
#include <sourcemeta/core/http_method.h>
#include <sourcemeta/core/http_status.h>
#include <sourcemeta/core/http_syntax.h>
#include <sourcemeta/core/text.h>
 
#include <chrono>      // std::chrono::milliseconds, std::chrono::seconds
#include <cstddef>     // std::size_t
#include <optional>    // std::optional
#include <stdexcept>   // std::runtime_error
#include <string>      // std::string
#include <string_view> // std::string_view
#include <utility>     // std::move, std::pair
#include <variant>     // std::variant, std::visit
#include <vector>      // std::vector
 
namespace sourcemeta::core {
 
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251 4275)
#endif

struct HTTPResponse {
  HTTPStatus status{};
  std::vector<std::pair<std::string, std::string>> headers;
  std::string body;
  std::string url;
};

class SOURCEMETA_CORE_HTTP_EXPORT HTTPSystemBackendError
    : public std::runtime_error {
public:
  HTTPSystemBackendError(const std::string &message, std::string variable,
                         std::vector<std::string> paths)
      : std::runtime_error{message}, variable_{std::move(variable)},
        paths_{std::move(paths)} {}

  [[nodiscard]] auto variable() const noexcept -> const std::string & {
    return this->variable_;
  }

  [[nodiscard]] auto paths() const noexcept
      -> const std::vector<std::string> & {
    return this->paths_;
  }
 
private:
  std::string variable_;
  std::vector<std::string> paths_;
};

class SOURCEMETA_CORE_HTTP_EXPORT HTTPSystemRequest {
public:
  explicit HTTPSystemRequest(std::string url,
                             const HTTPMethod method = HTTPMethod::GET)
      : url_{std::move(url)}, method_{method} {}

  auto method(const HTTPMethod method) -> HTTPSystemRequest & {
    this->method_ = method;
    return *this;
  }

  struct HeaderValue {
    std::variant<std::string, SecureString> data;

    [[nodiscard]] auto bytes() const -> std::string_view {
      return std::visit(
          [](const auto &value) -> std::string_view { return value; },
          this->data);
    }
  };

  auto header(std::string name, std::string value) -> HTTPSystemRequest & {
    // RFC 9110 §5.5: "a recipient of CR, LF, or NUL within a field value MUST
    // either reject the message or replace each of those characters with SP",
    // so a header carrying one is not added as a header-injection defense
    if (http_field_line_has_forbidden_byte(name) ||
        http_field_line_has_forbidden_byte(value)) {
      return *this;
    }
 
    this->headers_.emplace_back(std::move(name),
                                HeaderValue{.data = std::move(value)});
    return *this;
  }

  auto header(std::string name, SecureString value) -> HTTPSystemRequest & {
    // RFC 9110 §5.5: "a recipient of CR, LF, or NUL within a field value MUST
    // either reject the message or replace each of those characters with SP",
    // so a header carrying one is not added as a header-injection defense
    if (http_field_line_has_forbidden_byte(name) ||
        http_field_line_has_forbidden_byte(value)) {
      return *this;
    }
 
    this->headers_.emplace_back(std::move(name),
                                HeaderValue{.data = std::move(value)});
    return *this;
  }

  [[nodiscard]] auto header(const std::string_view name) const
      -> std::optional<std::string_view> {
    for (const auto &[key, value] : this->headers_) {
      if (equals_ignore_case(key, name)) {
        return value.bytes();
      }
    }
 
    return std::nullopt;
  }

  [[nodiscard]] auto headers() const noexcept -> const auto & {
    return this->headers_;
  }

  auto body(std::string data, std::string content_type) -> HTTPSystemRequest & {
    // RFC 9110 §5.5: "a recipient of CR, LF, or NUL within a field value MUST
    // either reject the message or replace each of those characters with SP",
    // so a content type carrying one is refused, since a backend writes it
    // straight into the Content-Type field on the wire
    if (http_field_line_has_forbidden_byte(content_type)) {
      return *this;
    }
 
    this->body_ =
        Body{.data = std::move(data), .content_type = std::move(content_type)};
    return *this;
  }

  auto body(SecureString data, std::string content_type)
      -> HTTPSystemRequest & {
    // RFC 9110 §5.5: "a recipient of CR, LF, or NUL within a field value MUST
    // either reject the message or replace each of those characters with SP",
    // so a content type carrying one is refused, since a backend writes it
    // straight into the Content-Type field on the wire
    if (http_field_line_has_forbidden_byte(content_type)) {
      return *this;
    }
 
    this->body_ =
        Body{.data = std::move(data), .content_type = std::move(content_type)};
    return *this;
  }

  auto follow_redirects(const bool value) -> HTTPSystemRequest & {
    this->follow_redirects_ = value;
    return *this;
  }

  auto maximum_redirects(const std::size_t value) -> HTTPSystemRequest & {
    this->maximum_redirects_ = value;
    return *this;
  }

  auto timeout(const std::chrono::milliseconds value) -> HTTPSystemRequest & {
    this->timeout_ = value;
    return *this;
  }

  auto connect_timeout(const std::chrono::milliseconds value)
      -> HTTPSystemRequest & {
    this->connect_timeout_ = value;
    return *this;
  }

  auto maximum_response_size(const std::size_t value) -> HTTPSystemRequest & {
    this->maximum_response_size_ = value;
    return *this;
  }

  auto sign_aws_sigv4(const HTTPAWSCredentials &credentials,
                      const std::string_view region,
                      const std::string_view service,
                      const std::chrono::system_clock::time_point moment =
                          std::chrono::system_clock::now())
      -> HTTPSystemRequest &;

  [[nodiscard]] auto send() const -> HTTPResponse;
 
private:
  struct Body {
    // A plain body carries no secret and keeps the ordinary string storage,
    // while a body set from wiping storage stays in it, so the common request
    // pays nothing and a secret one is never copied into an ordinary string
    std::variant<std::string, SecureString> data;
    std::string content_type;
 
    [[nodiscard]] auto bytes() const -> std::string_view {
      return std::visit(
          [](const auto &value) -> std::string_view { return value; },
          this->data);
    }
  };
 
  std::string url_;
  HTTPMethod method_;
  std::vector<std::pair<std::string, HeaderValue>> headers_;
  std::optional<Body> body_;
  bool follow_redirects_{true};
  std::size_t maximum_redirects_{20};
  std::chrono::milliseconds timeout_{std::chrono::seconds{30}};
  std::optional<std::chrono::milliseconds> connect_timeout_;
  std::optional<std::size_t> maximum_response_size_;
};
 
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
 
} // namespace sourcemeta::core
 
#endif