mdl_net.c

Go to the documentation of this file.

#include "mdl_net.h"
 
#include <stddef.h>
#include <string.h>
 
#include "mdl_net_internal.h"
#include "ra8_attributes.h"

typedef enum : long {
  k_mdl_http_client_error = 400L, 
  k_mdl_http_too_many     = 429L, 
  k_mdl_http_server_error = 500L, 
  k_mdl_http_unavailable  = 503L, 
} mdl_http_status_t;
 
RA8_PRIV ra8_err_t priv_mdl_net_classify_http(long status)
{
  if ((status == k_mdl_http_too_many) || (status == k_mdl_http_unavailable)) {
    return k_ra8_err_busy;
  }
  if (status >= k_mdl_http_server_error) {
    return k_ra8_fail;
  }
  if (status >= k_mdl_http_client_error) {
    return k_ra8_err_not_found;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_resp_reset(mdl_net_resp_t* resp)
{
  if (resp != nullptr) {
    memset(resp, 0, sizeof(*resp));
  }
}
 
ra8_err_t mdl_net_provider_open(const mdl_net_provider_t* provider,
                                const mdl_net_policy_t*   policy,
                                mdl_net_iface_t*          out_net)
{
  if (out_net == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  *out_net = (mdl_net_iface_t){};
  if ((provider == nullptr) || (provider->open == nullptr) || (policy == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  return provider->open(provider->ctx, policy, out_net);
}
 
ra8_err_t mdl_net_get_buf(mdl_net_iface_t*     net,
                          const char*          url,
                          const mdl_net_req_t* req,
                          char*                buf,
                          size_t               cap,
                          size_t*              out_len,
                          mdl_net_resp_t*      resp)
{
  internal_resp_reset(resp);
  if (net == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if ((net->vtable == nullptr) || (url == nullptr) || (req == nullptr) || (buf == nullptr) ||
      (cap == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  return net->vtable->get_buf(net->ctx, url, req, buf, cap, out_len, resp);
}
 
ra8_err_t mdl_net_get_body(mdl_net_iface_t*     net,
                           const char*          url,
                           const mdl_net_req_t* req,
                           mdl_net_body_sink_t* sink,
                           size_t*              out_len,
                           mdl_net_resp_t*      resp)
{
  internal_resp_reset(resp);
  if (net == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if ((net->vtable == nullptr) || (net->vtable->get_body == nullptr) || (url == nullptr) ||
      (req == nullptr) || (sink == nullptr) || (sink->reset == nullptr) ||
      (sink->write == nullptr) || (sink->ctx == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t reset = sink->reset(sink->ctx);
  if (reset != k_ra8_ok) {
    return reset;
  }
  return net->vtable->get_body(net->ctx, url, req, sink, out_len, resp);
}
 
void mdl_net_destroy(mdl_net_iface_t* net)
{
  if (net == nullptr) {
    return;
  }
  if ((net->vtable != nullptr) && (net->vtable->destroy != nullptr)) {
    net->vtable->destroy(net->ctx);
  }
  *net = (mdl_net_iface_t){};
}