srvrun.h

Go to the documentation of this file.

#ifndef WIRED_SRVRUN_SRVRUN_H
#define WIRED_SRVRUN_SRVRUN_H
 
#include "app/http3/server/srvboot/srvboot.h"
#include "app/http3/server/srvinbox/srvinbox.h"
#include "app/http3/server/srvloop/srvloop.h"
#include "app/http3/server/srvxdp/srvxdp.h"
#include "app/qpack/qpack/field.h"
#include "app/webtransport/capsule/wtcapsule/wtcapsule.h"
#include "app/webtransport/session/session/session.h"


typedef struct wired_srvrun_env wired_srvrun_env;

typedef void (*wired_wt_on_datagram)(
    void* app_ctx, wired_wt_session* s, wired_span data);

typedef void (*wired_wt_on_stream_data)(
    void*             app_ctx,
    wired_wt_session* s,
    u64               stream_id,
    wired_span        data,
    int               fin);

typedef void (*wired_wt_on_stream_reset)(
    void*             app_ctx,
    wired_wt_session* s,
    u64               stream_id,
    int               mapped,
    u32               app_error_code);

typedef void (*wired_wt_on_session)(
    void* app_ctx, wired_wt_session* s, wired_span path, wired_span protocol);

typedef void (*wired_wt_on_session_close)(void* app_ctx, wired_wt_session* s);

typedef void (*wired_wt_on_session_draining)(
    void* app_ctx, wired_wt_session* s);

typedef void (*wired_rawq_on_session)(
    void* app_ctx, wired_wt_session* s, wired_span alpn);

typedef struct {
  u16       status;       
  const u8* location;     
  usz       location_len; 
} wired_wt_resource_decision;

typedef void (*wired_wt_resource_check)(
    void*                       app_ctx,
    wired_span                  authority,
    wired_span                  path,
    wired_wt_resource_decision* out);

typedef void (*wired_srvrun_on_step)(void* ctx, u64 now_ms);

#define WIRED_HTTP_MAX_FIELDS 8

typedef qpack_field wired_http_field;

typedef struct {
  const wired_h3reqdrive_req* req;
  u64 offset;
  wired_obuf* body;
  u16 status;
  const char* content_type;
  wired_http_field fields[WIRED_HTTP_MAX_FIELDS];
  usz field_count;
  int more;
  u64 total_size;
} wired_http_exchange;

#define WIRED_HTTP_FIELD_BYTES_MAX 384

typedef int (*wired_http_handler)(void* ctx, wired_http_exchange* x);

typedef struct {
  wired_srvloop_handler cb;  
  void*                 ctx; 
  wired_http_handler http;
  wired_srvloop_on_body on_body;
} wired_srvrun_handler;

typedef struct {
  const char* qlog_path;   
  const char* keylog_path; 
  const char* cert_path;   
  const char* key_path;    
  int cc_algo;
} wired_srvrun_obs;

int wired_server_run(
    u16                  port,
    wired_srvboot_id*    id,
    wired_srvrun_handler h,
    wired_srvrun_obs     obs);

typedef struct {
  int busy_poll; 
  int so_busy_poll_us; 
  wired_wt_on_datagram wt_on_datagram;
  void* wt_datagram_ctx; 
  wired_wt_on_stream_data wt_on_stream_data;
  void* wt_stream_data_ctx;  
  int   so_prefer_busy_poll; 
  int so_busy_poll_budget;   
  int incoming_cpu;
  wired_srvxdp* xdp;
  int no_signal_handlers;
  int core_id;
  const char* wt_protocols;
  wired_wt_on_session wt_on_session;
  void*               wt_session_ctx; 
  int force_retry;
  wired_wt_resource_check wt_resource_check;
  void* wt_resource_ctx; 
  wired_wt_on_stream_reset wt_on_stream_reset;
  void* wt_stream_reset_ctx; 
  wired_wt_on_session_close wt_on_session_close;
  void* wt_session_close_ctx; 
  wired_srvrun_on_step on_step;
  void*                on_step_ctx; 
  int (*wt_origin_check)(void* ctx, wired_span origin, wired_span authority);
  void* wt_origin_ctx; 
  wired_wt_on_session_draining wt_on_session_draining;
  void* wt_session_draining_ctx; 
  wired_rawq_on_session raw_on_session;
  void* raw_session_ctx;
} wired_srvrun_opt;

int wired_server_run_opt(
    u16                     port,
    wired_srvboot_id*       id,
    wired_srvrun_handler    h,
    wired_srvrun_obs        obs,
    const wired_srvrun_opt* opt);

usz wired_srvrun_env_size(void);

void wired_srvrun_env_init(wired_srvrun_env* env);

typedef struct {
  u64 sessions;  
  u64 streams;   
  u64 datagrams; 
} wired_srvrun_wt_usage;

void wired_srvrun_env_wt_usage(
    const wired_srvrun_env* env, wired_srvrun_wt_usage* out);

int wired_srvrun_serve_env(
    wired_srvrun_env*       env,
    u16                     port,
    wired_srvboot_id*       id,
    wired_srvrun_handler    h,
    wired_srvrun_obs        obs,
    const wired_srvrun_opt* opt);

int* wired_srvrun_shutdown_word(void);

int wired_server_broadcast_datagram(wired_span data);

int wired_server_broadcast_datagram_ring(wired_span data);

i64 wired_server_wt_open_uni(wired_wt_session* s, wired_span payload);

i64 wired_server_wt_open_bidi(wired_wt_session* s, wired_span payload);

int wired_server_wt_stream_reply(
    wired_wt_session* s, u64 stream_id, wired_span payload);

i64 wired_server_wt_open_uni_stream(wired_wt_session* s, wired_span payload);

i64 wired_server_wt_open_bidi_stream(wired_wt_session* s, wired_span payload);

int wired_server_wt_stream_reply_open(
    wired_wt_session* s, u64 stream_id, wired_span payload);

int wired_server_wt_stream_send(
    wired_wt_session* s, u64 stream_id, wired_span payload, int fin);

int wired_server_wt_stream_priority(
    wired_wt_session* s, u64 stream_id, u8 urgency);

typedef struct {
  u8 urgency;
  u16 fine;
  u64 flow;
  u64 order;
  u64 tie;
} wired_wt_sched;

int wired_server_wt_stream_schedule(
    wired_wt_session* s, u64 stream_id, const wired_wt_sched* k);

u64 wired_server_wt_est_kbps(wired_wt_session* s);

int wired_server_wt_stream_fin(wired_wt_session* s, u64 stream_id);

int wired_server_wt_stream_hold(wired_wt_session* s, u64 stream_id, int hold);

int wired_server_wt_stream_reset(
    wired_wt_session* s, u64 stream_id, u32 error_code);

int wired_server_wt_stream_stop(
    wired_wt_session* s, u64 stream_id, u32 error_code);

int wired_server_wt_stream_inflight(wired_wt_session* s, u64 stream_id);

int wired_server_wt_send_datagram_to(wired_wt_session* s, wired_span payload);

int wired_server_wt_close_session(
    wired_wt_session* s, u32 app_error_code, wired_span message);

int wired_server_wt_drain_session(wired_wt_session* s);

int wired_server_session_is_raw(wired_wt_session* s);

typedef struct {
  usz sessions;         
  usz sessions_cap;     
  usz peer_streams;     
  usz peer_streams_cap; 
} wired_wt_occupancy;

int wired_server_wt_occupancy(wired_wt_occupancy* out);

void wired_srvrun_broadcast_register(
    int                  index,
    int                  n_total,
    wired_srvinbox_ring* inbox_row,
    wired_srvrun_env*    env);

void wired_srvrun_broadcast_unregister(void);
 
#endif