mdl_net.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_err.h"

typedef struct {
  const char* user_agent;        
  const char* referer;           
  const char* if_none_match;     
  const char* if_modified_since; 
  uint32_t    timeout_ms;        
} mdl_net_req_t;

typedef struct {
  const uint8_t* data;   
  size_t         length; 
} mdl_net_bytes_t;

typedef struct {
  bool            allow_private_hosts;       
  bool            allow_cross_host_redirect; 
  uint64_t        max_response_bytes;        
  const char*     proxy;                     
  const char*     socks5;                    
  mdl_net_bytes_t cookies;                   
  mdl_net_bytes_t ca_pem;                    
} mdl_net_policy_t;

typedef enum : uint16_t {
  k_mdl_retry_after_max  = 64U,  
  k_mdl_etag_max         = 128U, 
  k_mdl_last_mod_max     = 64U,  
  k_mdl_content_type_max = 128U, 
} mdl_net_resp_size_t;

typedef struct {
  long status;                               
  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]; 
} mdl_net_resp_t;

typedef ra8_err_t (*mdl_net_body_reset_fn)(void* ctx);

typedef ra8_err_t (*mdl_net_body_write_fn)(void*          ctx,
                                           const uint8_t* bytes,
                                           uint32_t       length,
                                           uint32_t*      out_written);

typedef struct {
  mdl_net_body_reset_fn reset; 
  mdl_net_body_write_fn write; 
  void*                 ctx;   
} mdl_net_body_sink_t;

typedef struct {
  ra8_err_t (*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);

  ra8_err_t (*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);

  void (*destroy)(void* ctx);
} mdl_net_vtable_t;

typedef struct mdl_net_iface {
  const mdl_net_vtable_t* vtable; 
  void*                   ctx;    
} mdl_net_iface_t;

typedef struct mdl_net_provider {
  void* ctx; 
  ra8_err_t (*open)(void* ctx, const mdl_net_policy_t* policy, mdl_net_iface_t* out_net);
} mdl_net_provider_t;

[[nodiscard]] 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);

void mdl_net_destroy(mdl_net_iface_t* 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);

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);