srvloop.h

Go to the documentation of this file.

#ifndef WIRED_SRVLOOP_SRVLOOP_H
#define WIRED_SRVLOOP_SRVLOOP_H
 
#include "app/http3/core/h3/control.h"
#include "app/http3/core/h3/priority.h"
#include "app/http3/core/h3settings/control_settings.h"
#include "app/http3/request/h3reqdrive/request_drive.h"
#include "app/http3/server/h3srv/state.h"
#include "app/http3/server/srvloop/body_window.h"
#include "common/bytes/span/span.h"
#include "tls/ext/stp/server_tp.h"
#include "tls/handshake/roles/server/server.h"
#include "transport/conn/pnspace/pnspaces/recv_spaces.h"
#include "transport/packet/frame/frame/connctl.h"
#include "transport/packet/frame/frame/ncid.h"
#include "transport/recovery/detect/recovery/ackpolicy.h"


#define WIRED_SRVLOOP_MAX_ACK_DELAY_MS 25

#define WIRED_SRVLOOP_NCID_RX 4

#define WIRED_SRVLOOP_PATH_RX 2

typedef int (*wired_srvloop_handler)(
    void*                       ctx,
    const wired_h3reqdrive_req* req,
    u64                         offset,
    wired_obuf*                 body_out,
    const char**                content_type,
    int*                        more,
    u64*                        total_size);

typedef int (*wired_srvloop_on_body)(
    void*                       ctx,
    const wired_h3reqdrive_req* req,
    u64                         stream_id,
    wired_span                  chunk,
    int                         fin);

#ifndef WIRED_SRVLOOP_MAX_STREAMS
#define WIRED_SRVLOOP_MAX_STREAMS 40
#endif

static inline u64 wired_srvloop_stream_limit(u64 configured) {
  u64 v = configured ? configured : STP_DEFAULT_MAX_STREAMS_BIDI;
  return v > WIRED_SRVLOOP_MAX_STREAMS ? WIRED_SRVLOOP_MAX_STREAMS : v;
}

typedef struct {
  int in_use;               
  u64 stream_id;            
  wired_h3reqdrive_req req; 
  u8 req_scratch[WIRED_H3_MAX_FIELD_SECTION];
  /* RFC 9000 2.2: this stream reassembled across datagrams. curl splits one
   * request's HEADERS and DATA into separate STREAM frames in separate 1-RTT
   * packets; each frame's data is written at its offset here and the request
   * is decoded only once FIN arrives. A byte past the window
   * is past the stream's credit (req_over, flow_control_violation). */
  u8  req_buf[BODYWIN_CAP]; 
  usz req_len;              
  u8  req_fin;              
  int req_done;             
  int req_incomplete;
  u8 req_wrap[2080];
  h3_priority priority;
  int req_over;
  u8 qpack_settled;
  bodywin body;
} wired_srvloop_stream_slot;

#define WIRED_SRVLOOP_MAX_PENDING_PRIORITY 8

typedef struct {
  int         in_use;    
  u64         stream_id; 
  h3_priority priority;  
} wired_srvloop_pending_priority;

#define WIRED_SRVLOOP_CTRL_BUF_CAP 512

typedef struct {
  u8  buf[WIRED_SRVLOOP_CTRL_BUF_CAP]; 
  u64 base;                            
  usz len;       
  usz parsed;    
  u8  open;      
  u64 stream_id; 
} wired_srvloop_ctrl_stream;

#ifndef WIRED_SRVLOOP_MAX_WT_STREAMS
#define WIRED_SRVLOOP_MAX_WT_STREAMS 24
#endif

#ifndef WIRED_SRVLOOP_WT_BUF_CAP
#define WIRED_SRVLOOP_WT_BUF_CAP 49152
#endif
 
/* The advertised per-stream window (STP_DEFAULT_STREAM_DATA_LOCAL,
 * server_tp.h) is a promise to buffer that many bytes past delivery, and
 * both WT directions land in exactly this capacity's reassembly window --
 * so the two must stay equal (see WIRED_SRVLOOP_WT_BUF_CAP's comment
 * above for the failure mode when they drift). server_tp.c itself cannot
 * see this macro (tls sits below app), but this header already includes
 * server_tp.h, so the check lives here instead; test_server_tp_ids_and_
 * values (server_tp_test.c) still pins the actual encoded TP bytes, which
 * this assert does not exercise. */
_Static_assert(
    STP_DEFAULT_STREAM_DATA_LOCAL == WIRED_SRVLOOP_WT_BUF_CAP,
    "the advertised stream window must match the reassembly buffer it backs");

#define WIRED_SRVLOOP_WT_MAX_RANGES 8

typedef struct {
  u64 base; 
  u64 range_lo[WIRED_SRVLOOP_WT_MAX_RANGES]; 
  u64 range_hi[WIRED_SRVLOOP_WT_MAX_RANGES]; 
  usz range_n;  
  usz frontier; 
  u64 dropped_bytes;
} wired_srvloop_wt_window;

typedef struct {
  int in_use;    
  u64 stream_id; 
  usz sig_len;
  u8 sig[16];
  u8 sig_have;    
  u8 sig_pending; 
  wired_srvloop_wt_window win; 
  u8  buf[WIRED_SRVLOOP_WT_BUF_CAP];
  u8  fin;     
  u64 fin_off; 
  int offered;
  int wt_session_slot;
  u64 delivered_len;
  int fin_delivered;
  u64 credit_advertised;
  int credit_hold;
} wired_srvloop_wt_stream_slot;

#define WIRED_SRVLOOP_MAX_WT_UNI_STREAMS 9

static inline u64 wired_srvloop_uni_stream_limit(void) {
  return WIRED_SRVLOOP_MAX_WT_UNI_STREAMS;
}

typedef struct {
  int in_use;    
  u64 stream_id; 
  usz type_len;
  u8 sig[16];
  u8 sig_have;
  u8                      sig_pending;
  wired_srvloop_wt_window win; 
  u8  buf[WIRED_SRVLOOP_WT_BUF_CAP];
  u8  fin;     
  u64 fin_off; 
  int offered;
  int wt_session_slot;
  u64 delivered_len;
  int fin_delivered;
  u64 credit_advertised;
  int credit_hold;
} wired_srvloop_wt_uni_stream_slot;

#define WIRED_SRVLOOP_MAX_RX_DATAGRAMS 256

#define WIRED_SRVLOOP_RX_DATAGRAM_CAP 1200

typedef struct {
  u8  buf[WIRED_SRVLOOP_RX_DATAGRAM_CAP]; 
  usz len;                                
} wired_srvloop_rx_datagram;

typedef struct {
  u64 floor;  
  u64 bm[16]; 
} wired_srvloop_closed;

#define WIRED_SRVLOOP_RESET_Q                                           \
  ((usz)2 * (WIRED_SRVLOOP_MAX_STREAMS + WIRED_SRVLOOP_MAX_WT_STREAMS + \
             WIRED_SRVLOOP_MAX_WT_UNI_STREAMS))

typedef struct {
  u64 stream_id;  
  u64 error_code; 
  int is_stop;    
} wired_srvloop_reset;

void wired_srvloop_closed_mark(wired_srvloop_closed* w, u64 stream_id);

int wired_srvloop_closed_has(const wired_srvloop_closed* w, u64 stream_id);

// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
typedef struct {
  wired_h3srv_state h3; 
  u8 cli_scid[20];      
  u8 cli_scid_len;      
  u8 spare_cid[20];
  u8 spare_cid_len;
  u8 spare_cid_token[16];
  u8  spare_cid_in_tp;
  u64 tx_pn;     
  u64 hs_tx_pn;  
  u64 app_rx_pn; 
  u64 app_rx_hi;
  int app_rx_seen; 
  u64 np_hi;
  int np_seen;
  int step_np_new;
  int drop_newer;
  u64 hs_rx_pn; 
  u64 hs_rx_hi;
  int hs_rx_seen; 
  pnspaces_recv ack_recv;
  ackpolicy     app_ack_policy; 
  ackpolicy     hs_ack_policy;  
  u8 ack_defer;
  u64 now_ms;
  int hs_done_sent; 
  int ticket_sent;  
  u8 confirm_frames[320];
  u16 confirm_frames_len;
  wired_srvloop_handler
        on_request; 
  void* req_ctx;    
  wired_srvloop_stream_slot streams[WIRED_SRVLOOP_MAX_STREAMS];
  wired_srvloop_closed req_closed;
  wired_srvloop_wt_stream_slot wt_streams[WIRED_SRVLOOP_MAX_WT_STREAMS];
  wired_srvloop_wt_uni_stream_slot
      wt_uni_streams[WIRED_SRVLOOP_MAX_WT_UNI_STREAMS];
  int                  got_request;
  wired_h3reqdrive_req req; 
  u64 req_stream_id;        
  u8  done_slots[WIRED_SRVLOOP_MAX_STREAMS];
  usz done_n; 
  u8  incomplete_slots[WIRED_SRVLOOP_MAX_STREAMS];
  usz incomplete_n; 
  u64 malformed_slots;
  u8  frame_unexpected_slots[WIRED_SRVLOOP_MAX_STREAMS];
  usz frame_unexpected_n; 
  int peer_closed;        
  u64 reset_slots;
  usz reset_slotless_n;
  int resp_external; 
  u64 ack_lo[32]; 
  u64 ack_hi[32]; 
  usz ack_n;      
  u8  ecn_ack_seen;    
  u64 ecn_ack_largest; 
  u64 ecn_ack_ect0;    
  u64 ecn_ack_ect1;    
  u64 ecn_ack_ce;      
  wired_srvloop_rx_datagram rx_datagrams[WIRED_SRVLOOP_MAX_RX_DATAGRAMS];
  usz rx_datagram_n;
  u64 we_advertised_max_datagram;
  int datagram_violation;
  u64 closed_stream_id;
  int closed_stream_seen; 
  u64 max_data_seen;
  int max_data_seen_flag; 
  u64 max_stream_data_stream_id[WIRED_SRVLOOP_MAX_STREAMS];
  u64 max_stream_data_value[WIRED_SRVLOOP_MAX_STREAMS];
  usz max_stream_data_n;
  wired_srvloop_closed wt_uni_closed;
  wired_srvloop_closed uni_typed;
  int streams_blocked_seen_flag;
  int streams_blocked_uni_seen_flag;
  u64 max_streams_uni_seen;
  int max_streams_uni_seen_flag; 
  u8 path_challenge_rx_data[WIRED_SRVLOOP_PATH_RX][PATH_DATA];
  usz path_challenge_rx_n;
  u8  path_response_data[PATH_DATA];
  int path_response_seen_flag; 
  ncid_frame ncid_rx[WIRED_SRVLOOP_NCID_RX];
  usz ncid_rx_n;
  int ncid_malformed;
  u64 ecn_ect0;
  u64 ecn_ect1;
  u64 ecn_ce;
  wired_srvloop_pending_priority
      pending_priority[WIRED_SRVLOOP_MAX_PENDING_PRIORITY];
  wired_srvloop_ctrl_stream ctrl;
  h3_control peer_ctrl;
  u64 peer_wt_initial[3];
  u16 priupdate_violation;
  u16 qpack_stream_violation;
  int wt_signal_mid_stream_violation;
  wired_srvloop_reset peer_resets[WIRED_SRVLOOP_RESET_Q];
  usz                 peer_reset_n; 
  u32 peer_reset_count;
  const char* qlog_path;
  u64         qlog_group; 
  u64 req_next_id;
  wired_srvloop_on_body on_body;
  int req_frame_error;
  int ctrl_overflow;
  int flow_control_violation;
  u64 req_body_released;
  u64 wt_refused[WIRED_SRVLOOP_MAX_STREAMS];
  usz wt_refused_n;
  int wt_refused_overflow;
  u64 peer_stream_limit[2];
  usz ctrl_settings_len;
} wired_srvloop;

void wired_srvloop_set_handler(
    wired_srvloop* l, wired_srvloop_handler cb, void* ctx);

int wired_srvloop_init(wired_srvloop* l, const u8* cli_scid, u8 cli_scid_len);

int wired_srvloop_slot_for(wired_srvloop* l, u64 stream_id);

void wired_srvloop_priority_apply(
    wired_srvloop* l, u64 stream_id, const h3_priority* p);

int wired_srvloop_priority_of(
    const wired_srvloop* l, u64 stream_id, h3_priority* out);

void wired_srvloop_slot_release(wired_srvloop* l, u64 stream_id);

int wired_srvloop_wt_slot_find(const wired_srvloop* l, u64 stream_id);

int wired_srvloop_wt_slot_claim(wired_srvloop* l, u64 stream_id);

int wired_srvloop_wt_uni_slot_find(const wired_srvloop* l, u64 stream_id);

int wired_srvloop_wt_uni_slot_claim(wired_srvloop* l, u64 stream_id);

int wired_srvloop_wt_slot_claim_local(wired_srvloop* l, u64 stream_id);

void wired_srvloop_wt_refuse(wired_srvloop* l, u64 stream_id);

void wired_srvloop_wt_slot_release(wired_srvloop* l, u64 stream_id);

void wired_srvloop_wt_uni_slot_release(wired_srvloop* l, u64 stream_id);

void wired_srvloop_wt_window_accept(
    wired_srvloop_wt_window* win,
    u64                      abs_off,
    usz                      n,
    usz*                     rel_off,
    usz*                     accepted_n);

void wired_srvloop_wt_window_slide(
    wired_srvloop_wt_window* win, u8* buf, usz cap, u64 delivered_to);

typedef struct {
  wired_srvloop* l; 
  wired_server*  s; 
} wired_srvloop_conn;

int wired_srvloop_step(
    const wired_srvloop_conn* conn, wired_mspan dgram, wired_obuf* out);

void wired_srvloop_ecn_note(wired_srvloop* l, u8 ecn);
 
#endif