mdl_net_curl.c

Go to the documentation of this file.

#include "mdl_net_curl.h"
 
#include <curl/curl.h>
#include <limits.h>
#include <string.h>
 
#include "mdl_net.h"
#include "mdl_net_curl_internal.h"
#include "mdl_net_internal.h"
#include "mdl_url_guard.h"
#include "ra8_attributes.h"

typedef enum : uint32_t {
  k_curl_max_redirects   = 5,     
  k_http_not_modified    = 304,   
  k_http_client_err_min  = 400,   
  k_http_not_found       = 404,   
  k_http_too_many_req    = 429,   
  k_http_server_err_min  = 500,   
  k_http_unavailable     = 503,   
  k_connect_timeout_ms   = 15000, 
  k_low_speed_bytes      = 64,    
  k_low_speed_secs       = 30,    
  k_origin_host_max      = 256,   
  k_request_header_max   = 256,   
  k_request_header_count = 2,     
} mdl_curl_limits_t;

typedef struct {
  struct curl_slist nodes[k_request_header_count]; 
  char               values[k_request_header_count][k_request_header_max];
  struct curl_slist* head;  
  size_t             count; 
} mdl_req_headers_t;

typedef struct {
  CURL*           curl;             
  bool            allow_private;    
  bool            allow_cross_host; 
  uint64_t        max_bytes;        
  const char*     proxy;            
  const char*     socks5;           
  mdl_net_bytes_t cookies;          
  mdl_net_bytes_t ca_pem;           
#if LIBCURL_VERSION_NUM >= 0x074D00
  struct curl_blob ca_blob; 
#endif
  char              origin_host[k_origin_host_max]; 
  mdl_req_headers_t request_headers;                
} mdl_curl_ctx_t;
 
static_assert(sizeof(mdl_curl_ctx_t) <= k_mdl_net_curl_storage_bytes,
              "mdl_net_curl_storage_t is too small for the private context");
static_assert(alignof(mdl_net_curl_storage_t) >= alignof(mdl_curl_ctx_t),
              "mdl_net_curl_storage_t is insufficiently aligned");

typedef struct {
  char retry_after[k_mdl_retry_after_max];   
  char etag[k_mdl_etag_max];                 
  char last_modified[k_mdl_last_mod_max];    
  char content_type[k_mdl_content_type_max]; 
} hdr_sink_t;

RA8_INTERNAL static char internal_ascii_lower(char c)
{
  if ((c >= 'A') && (c <= 'Z')) {
    return (char)(c - 'A' + 'a');
  }
  return c;
}

RA8_INTERNAL static bool internal_header_is(const char* line, size_t line_len, const char* prefix)
{
  size_t i = 0U;
  for (; (i < line_len) && (prefix[i] != '\0'); ++i) {
    if (internal_ascii_lower(line[i]) != prefix[i]) {
      return false;
    }
  }
  return prefix[i] == '\0';
}

RA8_INTERNAL static void
internal_header_value(const char* line, size_t line_len, char* out, size_t cap)
{
  size_t start = 0U;
  while ((start < line_len) && (line[start] != ':')) {
    ++start;
  }
  if (start < line_len) {
    ++start; /* skip the colon */
  }
  while ((start < line_len) && ((line[start] == ' ') || (line[start] == '\t'))) {
    ++start;
  }
  size_t end = line_len;
  while ((end > start) && ((line[end - 1U] == '\r') || (line[end - 1U] == '\n') ||
                           (line[end - 1U] == ' ') || (line[end - 1U] == '\t'))) {
    --end;
  }
  size_t n = end - start;
  if (n >= cap) {
    n = cap - 1U;
  }
  for (size_t i = 0U; i < n; ++i) {
    out[i] = line[start + i];
  }
  out[n] = '\0';
}

RA8_INTERNAL static size_t internal_on_header(char* buffer, size_t size, size_t nitems, void* user)
{
  if ((nitems != 0U) && (size > (SIZE_MAX / nitems))) {
    return 0U;
  }
  const size_t len  = size * nitems;
  hdr_sink_t*  sink = (hdr_sink_t*)user;
  if (sink == nullptr) {
    return len;
  }
  /* A new status line starts a fresh response (redirect chain): drop stale values. */
  if (internal_header_is(buffer, len, "http/")) {
    sink->retry_after[0]   = '\0';
    sink->etag[0]          = '\0';
    sink->last_modified[0] = '\0';
    sink->content_type[0]  = '\0';
  } else if (internal_header_is(buffer, len, "retry-after:")) {
    internal_header_value(buffer, len, sink->retry_after, sizeof(sink->retry_after));
  } else if (internal_header_is(buffer, len, "etag:")) {
    internal_header_value(buffer, len, sink->etag, sizeof(sink->etag));
  } else if (internal_header_is(buffer, len, "last-modified:")) {
    internal_header_value(buffer, len, sink->last_modified, sizeof(sink->last_modified));
  } else if (internal_header_is(buffer, len, "content-type:")) {
    internal_header_value(buffer, len, sink->content_type, sizeof(sink->content_type));
  }
  return len;
}
 
RA8_PRIV size_t priv_mdl_net_curl_buf_write(char* data, size_t size, size_t nmemb, void* user)
{
  buf_sink_t* sink = (buf_sink_t*)user;
  if ((nmemb != 0U) && (size > (SIZE_MAX / nmemb))) {
    return 0U;
  }
  const size_t bytes = size * nmemb;
  if (sink == nullptr) {
    return 0U;
  }
  if ((sink->len > sink->cap) || (bytes > (sink->cap - sink->len))) {
    sink->overflow = true;
    return 0U; /* Signals libcurl to abort the transfer. */
  }
  memcpy(sink->buf + sink->len, data, bytes);
  sink->len += bytes;
  return nmemb;
}
 
RA8_PRIV size_t priv_mdl_net_curl_body_write(char* data, size_t size, size_t nmemb, void* user)
{
  mdl_net_curl_body_state_t* sink = (mdl_net_curl_body_state_t*)user;
  if ((sink == nullptr) || (sink->sink == nullptr) || (sink->sink->write == nullptr) ||
      (sink->sink->ctx == nullptr)) {
    return 0U;
  }
  if ((nmemb != 0U) && (size > (SIZE_MAX / nmemb))) {
    sink->overflow = true;
    return 0U;
  }
  const size_t bytes = size * nmemb;
  if ((bytes > (size_t)UINT32_MAX) || mdl_size_exceeds(sink->written, (uint64_t)bytes, sink->cap)) {
    sink->overflow = true;
    return 0U;
  }
  uint32_t        written = 0U;
  const ra8_err_t error =
    sink->sink->write(sink->sink->ctx, (const uint8_t*)data, (uint32_t)bytes, &written);
  if ((error != k_ra8_ok) || (written != (uint32_t)bytes)) {
    sink->sink_error = (error != k_ra8_ok) ? error : k_ra8_err_invalid_state;
    return 0U;
  }
  sink->written += (uint64_t)written;
  return bytes;
}

RA8_INTERNAL static bool internal_redirect_host_ok(mdl_curl_ctx_t* net)
{
  if (net->allow_cross_host || (net->origin_host[0] == '\0')) {
    return true;
  }
  char* eff = nullptr;
  if ((curl_easy_getinfo(net->curl, CURLINFO_EFFECTIVE_URL, &eff) != CURLE_OK) ||
      (eff == nullptr)) {
    return false; /* Security decision cannot be made: fail closed. */
  }
  char host[k_origin_host_max];
  if (!mdl_url_host(eff, host, sizeof(host))) {
    return false;
  }
  return strcmp(host, net->origin_host) == 0;
}
 
/* The libcurl CURLOPT_PREREQFUNCTION ABI fixes these parameter types as
 * non-const `char*`; conn_local_ip is unused here but cannot be re-qualified. */
RA8_INTERNAL static int internal_on_prereq(
  void* clientp,
  char* conn_primary_ip,
  char*
    conn_local_ip, // NOLINT(readability-non-const-parameter) -- libcurl prereq callback ABI fixes char*.
  int conn_primary_port,
  int conn_local_port)
{
  (void)conn_local_ip;
  (void)conn_primary_port;
  (void)conn_local_port;
  mdl_curl_ctx_t* net = (mdl_curl_ctx_t*)clientp;
  if (net == nullptr) {
    return CURL_PREREQFUNC_ABORT;
  }
  const mdl_addr_class_t cls = mdl_classify_ip(conn_primary_ip);
  if (!mdl_addr_is_fetchable(cls, net->allow_private)) {
    return CURL_PREREQFUNC_ABORT;
  }
  if (!internal_redirect_host_ok(net)) {
    return CURL_PREREQFUNC_ABORT;
  }
  return CURL_PREREQFUNC_OK;
}

RA8_INTERNAL static bool internal_ok_code(CURLcode code)
{
  return code == CURLE_OK;
}

RA8_INTERNAL static ra8_err_t internal_apply_security_opts(CURL* curl, mdl_curl_ctx_t* net)
{
  const bool using_proxy = ((net->socks5 != nullptr) && (net->socks5[0] != '\0')) ||
                           ((net->proxy != nullptr) && (net->proxy[0] != '\0'));
  /* CURLOPT_PREREQFUNCTION sees the proxy peer, not the proxy's resolution of
   * the target. Requiring the explicit private-host escape hatch avoids
   * presenting the default policy as an SSRF guarantee it cannot provide. */
  if (using_proxy && !net->allow_private) {
    return k_ra8_fail;
  }
  bool proxy_ok = true;
  if ((net->socks5 != nullptr) && (net->socks5[0] != '\0')) {
    proxy_ok =
      internal_ok_code(curl_easy_setopt(curl, CURLOPT_PROXY, net->socks5)) &&
      internal_ok_code(curl_easy_setopt(curl, CURLOPT_PROXYTYPE, (long)CURLPROXY_SOCKS5_HOSTNAME));
  } else if ((net->proxy != nullptr) && (net->proxy[0] != '\0')) {
    proxy_ok = internal_ok_code(curl_easy_setopt(curl, CURLOPT_PROXY, net->proxy));
  } else {
    proxy_ok = internal_ok_code(curl_easy_setopt(curl, CURLOPT_PROXY, ""));
  }
 
#if LIBCURL_VERSION_NUM >= 0x074D00
  struct curl_blob* ca_blob = &net->ca_blob;
#else
  struct curl_blob* ca_blob = nullptr;
#endif
  const ra8_err_t ca_error = priv_mdl_net_curl_apply_ca_blob(curl, &net->ca_pem, ca_blob);
  if (ca_error != k_ra8_ok) {
    return ca_error;
  }
  const bool options_ok =
    proxy_ok && internal_ok_code(curl_easy_setopt(curl, CURLOPT_PROTOCOLS_STR, "http,https")) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS_STR, "http,https")) &&
    /* Defaults are correct today; assert them so the guarantee is in code. */
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_NETRC, (long)CURL_NETRC_IGNORED)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_MAXREDIRS, (long)k_curl_max_redirects)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_PREREQFUNCTION, internal_on_prereq)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_PREREQDATA, net));
  return options_ok ? k_ra8_ok : k_ra8_fail;
}

RA8_INTERNAL static ra8_err_t internal_apply_behavior_opts(CURL* curl, const mdl_curl_ctx_t* net)
{
  const bool options_ok =
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "")) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, internal_on_header)) &&
    internal_ok_code(
      curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, (long)k_connect_timeout_ms)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, (long)k_low_speed_bytes)) &&
    internal_ok_code(curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, (long)k_low_speed_secs));
  return options_ok ? priv_mdl_net_curl_apply_cookies(curl, &net->cookies) : k_ra8_fail;
}

RA8_INTERNAL static bool
internal_append_req_header(mdl_req_headers_t* headers, const char* name, const char* value)
{
  if (headers->count >= (size_t)k_request_header_count) {
    return false;
  }
  const size_t i = headers->count;
  const int    n =
    __builtin_snprintf(headers->values[i], sizeof(headers->values[i]), "%s: %s", name, value);
  if ((n < 0) || ((size_t)n >= sizeof(headers->values[i]))) {
    return false;
  }
  headers->nodes[i].data = headers->values[i];
  headers->nodes[i].next = nullptr;
  if (i == 0U) {
    headers->head = &headers->nodes[i];
  } else {
    headers->nodes[i - 1U].next = &headers->nodes[i];
  }
  headers->count += 1U;
  return true;
}

RA8_INTERNAL static bool internal_build_req_headers(const mdl_net_req_t* req,
                                                    mdl_req_headers_t*   headers)
{
  *headers = (mdl_req_headers_t){};
  if ((req != nullptr) && (req->if_none_match != nullptr) && (req->if_none_match[0] != '\0')) {
    if (!internal_append_req_header(headers, "If-None-Match", req->if_none_match)) {
      return false;
    }
  }
  if ((req != nullptr) && (req->if_modified_since != nullptr) &&
      (req->if_modified_since[0] != '\0')) {
    if (!internal_append_req_header(headers, "If-Modified-Since", req->if_modified_since)) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool
internal_apply_req(mdl_curl_ctx_t* net, const char* url, const mdl_net_req_t* req)
{
  if (!mdl_url_host(url, net->origin_host, sizeof(net->origin_host))) {
    net->origin_host[0] = '\0';
    return false;
  }
  CURL* curl = net->curl;
  bool  ok = internal_ok_code(curl_easy_setopt(curl, CURLOPT_URL, url)) &&
             internal_ok_code(curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, (long)req->timeout_ms)) &&
             /* CURLOPT_REFERER with NULL clears any prior value -- what we want. */
             internal_ok_code(curl_easy_setopt(curl, CURLOPT_REFERER, req->referer));
  if (ok && (req->user_agent != nullptr)) {
    ok = internal_ok_code(curl_easy_setopt(curl, CURLOPT_USERAGENT, req->user_agent));
  }
  return ok;
}

RA8_INTERNAL static void internal_release_req_headers(CURL* curl, const mdl_req_headers_t* headers)
{
  if (headers->head == nullptr) {
    return;
  }
  struct curl_slist* const no_headers = nullptr;
  (void)curl_easy_setopt(curl, CURLOPT_HTTPHEADER, no_headers);
}
 
RA8_PRIV ra8_err_t priv_mdl_net_curl_classify(CURLcode code, bool overflow, long status)
{
  if (overflow) {
    return k_ra8_err_no_mem;
  }
  if (code == CURLE_OPERATION_TIMEDOUT) {
    return k_ra8_err_timeout;
  }
  if (code != CURLE_OK) {
    return k_ra8_fail;
  }
  return priv_mdl_net_classify_http(status);
}

RA8_INTERNAL static ra8_err_t internal_finish_transfer(CURL*             curl,
                                                       CURLcode          code,
                                                       bool              overflow,
                                                       const hdr_sink_t* hdr,
                                                       mdl_net_resp_t*   resp)
{
  long status = 0;
  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status);
  if (resp != nullptr) {
    resp->status = status;
    (void)__builtin_snprintf(resp->retry_after, sizeof(resp->retry_after), "%s", hdr->retry_after);
    (void)__builtin_snprintf(resp->etag, sizeof(resp->etag), "%s", hdr->etag);
    (void)__builtin_snprintf(resp->last_modified,
                             sizeof(resp->last_modified),
                             "%s",
                             hdr->last_modified);
    (void)
      __builtin_snprintf(resp->content_type, sizeof(resp->content_type), "%s", hdr->content_type);
  }
  return priv_mdl_net_curl_classify(code, overflow, status);
}

RA8_INTERNAL static ra8_err_t internal_curl_get_buf(void*                ctx,
                                                    const char*          url,
                                                    const mdl_net_req_t* req,
                                                    char*                buf,
                                                    size_t               cap,
                                                    size_t*              out_len,
                                                    mdl_net_resp_t*      resp)
{
  mdl_curl_ctx_t* net = (mdl_curl_ctx_t*)ctx;
  if (!mdl_url_scheme_allowed(url)) {
    return k_ra8_err_invalid_arg; /* refuse file://, gopher://, ... before curl */
  }
 
  if (!internal_build_req_headers(req, &net->request_headers)) {
    return k_ra8_err_invalid_size;
  }
  struct curl_slist* const req_headers = net->request_headers.head;
  buf_sink_t               sink        = {.buf = buf, .cap = cap, .len = 0U, .overflow = false};
  hdr_sink_t               hdr         = {};
  if (!internal_apply_req(net, url, req) ||
      !internal_ok_code(curl_easy_setopt(net->curl, CURLOPT_HTTPHEADER, req_headers)) ||
      !internal_ok_code(curl_easy_setopt(net->curl, CURLOPT_HEADERDATA, &hdr)) ||
      !internal_ok_code(
        curl_easy_setopt(net->curl, CURLOPT_WRITEFUNCTION, priv_mdl_net_curl_buf_write)) ||
      !internal_ok_code(curl_easy_setopt(net->curl, CURLOPT_WRITEDATA, &sink))) {
    internal_release_req_headers(net->curl, &net->request_headers);
    return k_ra8_fail;
  }
 
  const CURLcode  code = curl_easy_perform(net->curl);
  const ra8_err_t rc   = internal_finish_transfer(net->curl, code, sink.overflow, &hdr, resp);
  internal_release_req_headers(net->curl, &net->request_headers);
  if (rc != k_ra8_ok) {
    return rc;
  }
 
  if (sink.len < cap) {
    buf[sink.len] = '\0'; /* NUL-terminate when room remains. */
  }
  if (out_len != nullptr) {
    *out_len = sink.len;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_curl_get_body(void*                ctx,
                                                     const char*          url,
                                                     const mdl_net_req_t* req,
                                                     mdl_net_body_sink_t* sink,
                                                     size_t*              out_len,
                                                     mdl_net_resp_t*      resp)
{
  mdl_curl_ctx_t* net = (mdl_curl_ctx_t*)ctx;
  if (!mdl_url_scheme_allowed(url)) {
    return k_ra8_err_invalid_arg;
  }
 
  if (!internal_build_req_headers(req, &net->request_headers)) {
    return k_ra8_err_invalid_size;
  }
  struct curl_slist* const  req_headers = net->request_headers.head;
  mdl_net_curl_body_state_t body        = {.sink       = sink,
                                           .written    = 0U,
                                           .cap        = net->max_bytes,
                                           .sink_error = k_ra8_ok,
                                           .overflow   = false};
  hdr_sink_t                hdr         = {};
  /* MAXFILESIZE_LARGE checks an advertised Content-Length up front; 0 disables
   * it, exactly as cap == 0 disables the callback check below. */
  if (!internal_apply_req(net, url, req) ||
      !internal_ok_code(curl_easy_setopt(net->curl, CURLOPT_HTTPHEADER, req_headers)) ||
      !internal_ok_code(curl_easy_setopt(net->curl, CURLOPT_HEADERDATA, &hdr)) ||
      !internal_ok_code(
        curl_easy_setopt(net->curl, CURLOPT_MAXFILESIZE_LARGE, (curl_off_t)net->max_bytes)) ||
      !internal_ok_code(
        curl_easy_setopt(net->curl, CURLOPT_WRITEFUNCTION, priv_mdl_net_curl_body_write)) ||
      !internal_ok_code(curl_easy_setopt(net->curl, CURLOPT_WRITEDATA, &body))) {
    internal_release_req_headers(net->curl, &net->request_headers);
    return k_ra8_fail;
  }
 
  const CURLcode code = curl_easy_perform(net->curl);
  ra8_err_t      rc   = internal_finish_transfer(net->curl, code, body.overflow, &hdr, resp);
  internal_release_req_headers(net->curl, &net->request_headers);
  if (!body.overflow && (body.sink_error != k_ra8_ok)) {
    rc = body.sink_error;
  }
  if ((rc == k_ra8_ok) && (out_len != nullptr)) {
    *out_len = (size_t)body.written;
  }
  return rc;
}

RA8_INTERNAL static void internal_curl_destroy(void* ctx)
{
  mdl_curl_ctx_t* net = (mdl_curl_ctx_t*)ctx;
  if (net == nullptr) {
    return;
  }
  if (net->curl != nullptr) {
    curl_easy_cleanup(net->curl);
  }
  *net = (mdl_curl_ctx_t){};
}

static const mdl_net_vtable_t s_curl_vtable = {
  .get_buf  = internal_curl_get_buf,
  .get_body = internal_curl_get_body,
  .destroy  = internal_curl_destroy,
};
 
ra8_err_t mdl_net_curl_init(mdl_net_iface_t*        net,
                            mdl_net_curl_storage_t* storage,
                            const mdl_net_policy_t* policy)
{
  if ((net == nullptr) || (storage == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  *net                       = (mdl_net_iface_t){};
  *storage                   = (mdl_net_curl_storage_t){};
  static bool s_global_ready = false;
  if (!s_global_ready) {
    if (curl_global_init(CURL_GLOBAL_DEFAULT) != CURLE_OK) {
      return k_ra8_fail;
    }
    s_global_ready = true;
  }
 
  mdl_curl_ctx_t* ctx = (mdl_curl_ctx_t*)storage->bytes;
  if (policy != nullptr) {
    ctx->allow_private    = policy->allow_private_hosts;
    ctx->allow_cross_host = policy->allow_cross_host_redirect;
    ctx->max_bytes        = policy->max_response_bytes;
    ctx->proxy            = policy->proxy;
    ctx->socks5           = policy->socks5;
    ctx->cookies          = policy->cookies;
    ctx->ca_pem           = policy->ca_pem;
  }
  ctx->curl = curl_easy_init();
  if (ctx->curl == nullptr) {
    return k_ra8_fail;
  }
  ra8_err_t init_error = internal_apply_security_opts(ctx->curl, ctx);
  if (init_error == k_ra8_ok) {
    init_error = internal_apply_behavior_opts(ctx->curl, ctx);
  }
  if (init_error != k_ra8_ok) {
    curl_easy_cleanup(ctx->curl);
    *ctx = (mdl_curl_ctx_t){};
    return init_error;
  }
  net->vtable = &s_curl_vtable;
  net->ctx    = ctx;
  return k_ra8_ok;
}