http_syntax.h

#ifndef SOURCEMETA_CORE_HTTP_SYNTAX_H_
#define SOURCEMETA_CORE_HTTP_SYNTAX_H_
 
#ifndef SOURCEMETA_CORE_HTTP_EXPORT
#include <sourcemeta/core/http_export.h>
#endif
 
#include <sourcemeta/core/text.h>
 
#include <cstddef>     // std::size_t
#include <optional>    // std::optional
#include <string>      // std::string
#include <string_view> // std::string_view
 
namespace sourcemeta::core {

inline auto http_is_ows(const char character) noexcept -> bool {
  return character == ' ' || character == '\t';
}

inline auto http_is_tchar(const char character) noexcept -> bool {
  switch (character) {
    case '!':
    case '#':
    case '$':
    case '%':
    case '&':
    case '\'':
    case '*':
    case '+':
    case '-':
    case '.':
    case '^':
    case '_':
    case '`':
    case '|':
    case '~':
      return true;
    default:
      return is_alphanum(character);
  }
}

inline auto http_is_b64token_char(const char character) noexcept -> bool {
  return is_alphanum(character) || character == '-' || character == '.' ||
         character == '_' || character == '~' || character == '+' ||
         character == '/';
}

inline auto http_is_b64token(const std::string_view value) noexcept -> bool {
  std::size_t position{0};
  while (position < value.size() && http_is_b64token_char(value[position])) {
    position += 1;
  }
 
  if (position == 0) {
    return false;
  }
 
  while (position < value.size()) {
    if (value[position] != '=') {
      return false;
    }
 
    position += 1;
  }
 
  return true;
}

inline auto http_is_token(const std::string_view value) noexcept -> bool {
  if (value.empty()) {
    return false;
  }
 
  for (const auto character : value) {
    if (!http_is_tchar(character)) {
      return false;
    }
  }
 
  return true;
}

inline auto http_encode_quoted_string(const std::string_view value,
                                      std::string &sink) -> bool {
  for (const auto character : value) {
    const auto byte{static_cast<unsigned char>(character)};
    // RFC 9110 Section 5.6.4: qdtext and quoted-pair admit HTAB, SP through
    // VCHAR, and obs-text, so every other control character (CR and LF among
    // them) makes the value unencodable
    if (byte != 0x09 && (byte < 0x20 || byte == 0x7F)) {
      return false;
    }
  }
 
  sink.push_back('"');
  for (const auto character : value) {
    if (character == '"' || character == '\\') {
      sink.push_back('\\');
    }
 
    sink.push_back(character);
  }
 
  sink.push_back('"');
  return true;
}

inline auto
http_field_line_has_forbidden_byte(const std::string_view value) noexcept
    -> bool {
  // RFC 9110 Section 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
  // before further processing or forwarding of that message", so a field
  // carrying one is refused as a header-injection defense
  for (const auto character : value) {
    if (character == '\r' || character == '\n' || character == '\0') {
      return true;
    }
  }
 
  return false;
}

inline auto http_trim_leading_ows(std::string_view value) noexcept
    -> std::string_view {
  while (!value.empty() && http_is_ows(value.front())) {
    value.remove_prefix(1);
  }
 
  return value;
}

inline auto http_trim_trailing_ows(std::string_view value) noexcept
    -> std::string_view {
  while (!value.empty() && http_is_ows(value.back())) {
    value.remove_suffix(1);
  }
 
  return value;
}

SOURCEMETA_CORE_HTTP_EXPORT
auto http_scan_quoted_string(const std::string_view input,
                             const std::size_t position, std::string &storage,
                             std::string_view &value)
    -> std::optional<std::size_t>;
 
} // namespace sourcemeta::core
 
#endif