LCOV - code coverage report
Current view: top level - waltz/quic - fd_quic_conn.h (source / functions) Hit Total Coverage
Test: cov.lcov Lines: 16 44 36.4 %
Date: 2025-07-06 04:53:02 Functions: 2 144 1.4 %

          Line data    Source code
       1             : #ifndef HEADER_fd_src_waltz_quic_fd_quic_conn_h
       2             : #define HEADER_fd_src_waltz_quic_fd_quic_conn_h
       3             : 
       4             : #include "fd_quic.h"
       5             : #include "fd_quic_ack_tx.h"
       6             : #include "fd_quic_stream.h"
       7             : #include "fd_quic_conn_id.h"
       8             : #include "crypto/fd_quic_crypto_suites.h"
       9             : #include "fd_quic_pkt_meta.h"
      10             : #include "../fd_rtt_est.h"
      11             : 
      12      945876 : #define FD_QUIC_CONN_STATE_INVALID            0 /* dead object / freed */
      13      344415 : #define FD_QUIC_CONN_STATE_HANDSHAKE          1 /* currently doing handshaking with peer */
      14       90324 : #define FD_QUIC_CONN_STATE_HANDSHAKE_COMPLETE 2 /* handshake complete, confirming with peer */
      15    51000723 : #define FD_QUIC_CONN_STATE_ACTIVE             3 /* connection established - data may be transferred */
      16       42051 : #define FD_QUIC_CONN_STATE_PEER_CLOSE         4 /* peer requested close */
      17       12426 : #define FD_QUIC_CONN_STATE_ABORT              5 /* connection terminating due to error */
      18       42390 : #define FD_QUIC_CONN_STATE_CLOSE_PENDING      6 /* connection is closing */
      19    79589474 : #define FD_QUIC_CONN_STATE_DEAD               7 /* connection about to be freed */
      20             : 
      21             : #define FD_QUIC_REASON_CODES(X,SEP) \
      22           0 :   X(NO_ERROR                     , 0x00  , "No error"                                  ) SEP \
      23           0 :   X(INTERNAL_ERROR               , 0x01  , "Implementation error"                      ) SEP \
      24           0 :   X(CONNECTION_REFUSED           , 0x02  , "Server refuses a connection"               ) SEP \
      25           0 :   X(FLOW_CONTROL_ERROR           , 0x03  , "Flow control error"                        ) SEP \
      26           0 :   X(STREAM_LIMIT_ERROR           , 0x04  , "Too many streams opened"                   ) SEP \
      27           0 :   X(STREAM_STATE_ERROR           , 0x05  , "Frame received in invalid stream state"    ) SEP \
      28           0 :   X(FINAL_SIZE_ERROR             , 0x06  , "Change to final size"                      ) SEP \
      29           0 :   X(FRAME_ENCODING_ERROR         , 0x07  , "Frame encoding error"                      ) SEP \
      30           0 :   X(TRANSPORT_PARAMETER_ERROR    , 0x08  , "Error in transport parameters"             ) SEP \
      31           0 :   X(CONNECTION_ID_LIMIT_ERROR    , 0x09  , "Too many connection IDs received"          ) SEP \
      32           0 :   X(PROTOCOL_VIOLATION           , 0x0a  , "Generic protocol violation"                ) SEP \
      33           0 :   X(INVALID_TOKEN                , 0x0b  , "Invalid Token received"                    ) SEP \
      34           0 :   X(APPLICATION_ERROR            , 0x0c  , "Application error"                         ) SEP \
      35           0 :   X(CRYPTO_BUFFER_EXCEEDED       , 0x0d  , "CRYPTO data buffer overflowed"             ) SEP \
      36           0 :   X(KEY_UPDATE_ERROR             , 0x0e  , "Invalid packet protection update"          ) SEP \
      37           0 :   X(AEAD_LIMIT_REACHED           , 0x0f  , "Excessive use of packet protection keys"   ) SEP \
      38           0 :   X(NO_VIABLE_PATH               , 0x10  , "No viable network path exists"             ) SEP \
      39           0 :   X(CRYPTO_BASE                  , 0x100 , "0x0100-0x01ff CRYPTO_ERROR TLS alert code" ) SEP \
      40           0 :   X(HANDSHAKE_FAILURE            , 0x128 , "Handshake failed"                          )
      41             : 
      42             : enum {
      43             : # define COMMA ,
      44             : # define _(NAME,CODE,DESC) \
      45             :   FD_QUIC_CONN_REASON_##NAME = CODE
      46             :   FD_QUIC_REASON_CODES(_,COMMA)
      47             : # undef _
      48             : # undef COMMA
      49             : };
      50             : 
      51             : char const *
      52             : fd_quic_conn_reason_name( uint reason );
      53             : 
      54             : 
      55             : struct fd_quic_conn_stream_rx {
      56             :   ulong rx_hi_stream_id;    /* highest RX stream ID sent by peer + 4 */
      57             :   ulong rx_sup_stream_id;   /* highest allowed RX stream ID + 4 */
      58             : 
      59             :   ulong rx_max_data;        /* the limit on the number of bytes the peer is allowed to send to us */
      60             :   ulong rx_tot_data;        /* total of all bytes received across all streams and including implied bytes */
      61             :   ulong rx_max_data_ackd;   /* max max_data acked by peer */
      62             : 
      63             :   ulong rx_max_streams_unidir_ackd; /* value of MAX_STREAMS acked for UNIDIR */
      64             : 
      65             :   long  rx_streams_active;  /* FIXME: This is a user scratch field, not in use by fd_quic */
      66             : 
      67             :   /* FIXME add a TLB */
      68             : };
      69             : 
      70             : typedef struct fd_quic_conn_stream_rx fd_quic_conn_stream_rx_t;
      71             : 
      72             : struct fd_quic_conn {
      73             :   uint               conn_idx;            /* connection index */
      74             :                                           /* connections are sized at runtime */
      75             :                                           /* storing the index avoids a division */
      76             :   uint               conn_gen;            /* generation of this connection slot */
      77             : 
      78             :   fd_quic_t *        quic;
      79             :   void *             context;             /* user context */
      80             : 
      81             :   uint               server      : 1;     /* role from self POV: 0=client, 1=server */
      82             :   uint               established : 1;     /* used by clients to determine whether to
      83             :                                              switch the destination conn id used */
      84             :   uint               transport_params_set : 1;
      85             :   uint               called_conn_new : 1; /* whether we need to call conn_final on teardown */
      86             :   uint               visited : 1;         /* scratch bit, no strict definition */
      87             :   uint               key_phase : 1;
      88             :   uint               key_update : 1;
      89             : 
      90             :   /* Service queue dlist membership.  All active conns (state not INVALID)
      91             :      are in a service queue, FD_QUIC_SVC_TYPE_WAIT by default.
      92             :      Free conns (svc_type==UINT_MAX) are members of a singly linked list
      93             :      (only src_next set) */
      94             :   uint               svc_type;  /* FD_QUIC_SVC_{...} or UINT_MAX */
      95             :   uint               svc_prev;
      96             :   uint               svc_next;
      97             :   ulong              svc_time;  /* service may be delayed until this timestamp */
      98             : 
      99             :   ulong              our_conn_id;
     100             : 
     101             :   /* Save original retry_source_connection_id
     102             :    * This is used by clients to compare against the retry_source_connection_id
     103             :    * in the transport parameters as specified in rfc 9000 7.3 */
     104             :   fd_quic_conn_id_t  retry_src_conn_id;
     105             : 
     106             :   /* Host network endpoint. Used to determine src address and port */
     107             :   fd_quic_net_endpoint_t host;
     108             : 
     109             :   /* Peer network endpoints – have multiple connection ids and ip:port */
     110             :   /* TODO: footprint allows specifying conn_id_cnt but hardcoded limit used here */
     111             :   fd_quic_net_endpoint_t peer[1];
     112             :   fd_quic_conn_id_t      peer_cids[1]; /* FIXME support new/retire conn ID */
     113             : 
     114             :   /* initial source connection id */
     115             :   ulong              initial_source_conn_id;
     116             : 
     117             :   uint               tx_max_datagram_sz;  /* size of maximum datagram allowed by peer */
     118             : 
     119             :   /* handshake members */
     120             :   uint               handshake_complete  : 1; /* have we completed a successful handshake? */
     121             :   uint               handshake_done_send : 1; /* do we need to send handshake-done to peer? */
     122             :   uint               handshake_done_ackd : 1; /* was handshake_done ack'ed? */
     123             :   fd_quic_tls_hs_t * tls_hs;
     124             : 
     125             :   /* amount of handshake data already sent from head of queue */
     126             :   ulong hs_sent_bytes[4];
     127             : 
     128             :   /* amount of handshake data ack'ed by peer counted from head of queue */
     129             :   ulong hs_ackd_bytes[4];
     130             : 
     131             :   /* Keys for header and packet protection
     132             :        secrets:     Contains 'master' secrets used to derive other keys
     133             :        keys[e][d]:  Current pair of keys for each encryption level (e)
     134             :                     and direction (d==0 is incoming, d==1 is outgoing)
     135             :        new_keys[e]: App keys to use for the next key update.  Once app
     136             :                     keys are available these are always kept up-to-date
     137             :        keys_avail:  Bit set of available keys, LSB indexed by enc level */
     138             :   fd_quic_crypto_secrets_t secrets;
     139             :   fd_quic_crypto_keys_t    keys[FD_QUIC_NUM_ENC_LEVELS][2];
     140             :   fd_quic_crypto_keys_t    new_keys[2];
     141             :   uint                     keys_avail;
     142             : 
     143             :   fd_quic_stream_t         send_streams[1];      /* sentinel of list of streams needing action */
     144             :   fd_quic_stream_t         used_streams[1];      /* sentinel of list of used streams */
     145             :   /* invariant: an allocated stream must be in exactly one of the following lists:
     146             :      send_streams
     147             :      used_streams */
     148             : 
     149             :   /* stream id members */
     150             :   ulong tx_next_stream_id;  /* stream ID to be used for new stream */
     151             :   ulong tx_sup_stream_id;   /* highest allowed TX stream ID + 4 */
     152             : 
     153             :   fd_quic_stream_map_t *  stream_map;           /* map stream_id -> stream */
     154             : 
     155             :   /* packet number info
     156             :      each encryption level maps to a packet number space
     157             :      0-RTT and 1-RTT both map to APPLICATION
     158             :      pkt_number[j] represents the minimum acceptable packet number
     159             :        "expected packet number"
     160             :        packets with a number lower than this will be dropped */
     161             :   ulong exp_pkt_number[3]; /* different packet number spaces:
     162             :                                  INITIAL, HANDSHAKE and APPLICATION */
     163             :   ulong pkt_number[3];     /* tx packet number by pn space */
     164             :   ulong last_pkt_number[3]; /* last (highest) packet numer seen */
     165             : 
     166             :   ushort ipv4_id;           /* ipv4 id field */
     167             : 
     168             :   /* buffer to send next */
     169             :   /* must be at least FD_QUIC_MAX_UDP_PAYLOAD_SZ */
     170             :   uchar   tx_buf_conn[2048];
     171             :   uchar * tx_ptr; /* ptr to free space in tx_buf_conn */
     172             : 
     173             :   uint state;
     174             :   uint reason;     /* quic reason for closing. see FD_QUIC_CONN_REASON_* */
     175             :   uint app_reason; /* application reason for closing */
     176             : 
     177             :   fd_quic_ack_gen_t ack_gen[1];
     178             :   ulong             unacked_sz;  /* Number of received stream frame payload bytes pending ACK */
     179             :                                  /* Resets to zero when conn is rescheduled or ACKs are sent */
     180             : 
     181             :   fd_quic_pkt_meta_tracker_t pkt_meta_tracker;
     182             : 
     183             :   /* flow control */
     184             :   ulong                tx_max_data;        /* the limit on the number of bytes we are allowed
     185             :                                               to send to the peer across all streams */
     186             :                                            /* even if a bytes on a stream are not received,
     187             :                                               higher offsets received imply the usage of those bytes,
     188             :                                               and they count against the max */
     189             :   ulong                tx_tot_data;        /* total of all bytes received across all streams
     190             :                                               and including implied bytes */
     191             : 
     192             :   uint                 flags;
     193       12177 : # define FD_QUIC_CONN_FLAGS_MAX_DATA           (1u<<0u)
     194       42432 : # define FD_QUIC_CONN_FLAGS_CLOSE_SENT         (1u<<1u)
     195       12177 : # define FD_QUIC_CONN_FLAGS_MAX_STREAMS_UNIDIR (1u<<2u)
     196       36465 : # define FD_QUIC_CONN_FLAGS_PING               (1u<<4u)
     197       24363 : # define FD_QUIC_CONN_FLAGS_PING_SENT          (1u<<5u)
     198             : 
     199             :   /* max stream data per stream type */
     200             :   ulong                tx_initial_max_stream_data_uni;
     201             : 
     202             :   /* last tx packet num with max_data frame referring to this stream
     203             :      set to next_pkt_number to indicate a new max_data frame should be sent
     204             :      if we time out this packet (or possibly a later packet) we resend the frame
     205             :        and update this value */
     206             :   ulong                upd_pkt_number;
     207             : 
     208             :   /* highest peer encryption level */
     209             :   uchar                peer_enc_level;
     210             : 
     211             :   /* idle timeout arguments */
     212             :   ulong                idle_timeout_ticks;
     213             :   ulong                last_activity;
     214             :   ulong                last_ack;
     215             : 
     216             :   /* round trip time related members */
     217             :   fd_rtt_estimate_t rtt[1];
     218             :   float rtt_period_ticks;         /* bound on time between RTT measurements */
     219             :   float peer_ack_delay_scale;     /* convert ACK delay units to ticks */
     220             :   float peer_max_ack_delay_ticks; /* peer max ack delay in ticks */
     221             : 
     222             :   ulong token_len;
     223             :   uchar token[ FD_QUIC_RETRY_MAX_TOKEN_SZ ];
     224             : 
     225             :   fd_quic_conn_stream_rx_t srx[1];
     226             : 
     227             :   ulong used_pkt_meta;
     228             : };
     229             : 
     230             : inline static void
     231             : fd_quic_set_conn_state( fd_quic_conn_t * conn,
     232      709896 :                         uint             state ) {
     233      709896 :   conn->state = state;
     234      709896 : }
     235             : 
     236             : FD_PROTOTYPES_BEGIN
     237             : 
     238             : FD_FN_CONST static inline ulong
     239           0 : fd_quic_conn_uid( fd_quic_conn_t const * conn ) {
     240           0 :   return ( (ulong)conn->conn_idx << 32UL ) | ( (ulong)conn->conn_gen );
     241           0 : }
     242             : 
     243             : FD_FN_CONST static inline uint
     244           0 : fd_quic_conn_uid_idx( ulong conn_uid ) {
     245           0 :   return (uint)( conn_uid >> 32UL );
     246           0 : }
     247             : 
     248             : FD_FN_CONST static inline uint
     249           0 : fd_quic_conn_uid_gen( ulong conn_uid ) {
     250           0 :   return (uint)( conn_uid & 0xffffffffUL );
     251           0 : }
     252             : 
     253             : /* returns the alignment requirement of fd_quic_conn_t */
     254             : FD_FN_CONST ulong
     255             : fd_quic_conn_align( void );
     256             : 
     257             : /* returns the footprint of the connection object for given limits */
     258             : ulong
     259             : fd_quic_conn_footprint( fd_quic_limits_t const * );
     260             : 
     261             : /* called by fd_quic_new to initialize the connection objects
     262             :    used by fd_quic */
     263             : fd_quic_conn_t *
     264             : fd_quic_conn_new( void *                   mem,
     265             :                   fd_quic_t *              quic,
     266             :                   fd_quic_limits_t const * limits );
     267             : 
     268             : /* set the user-defined context value on the connection */
     269             : void
     270             : fd_quic_conn_set_context( fd_quic_conn_t * conn, void * context );
     271             : 
     272             : /* get the user-defined context value from a connection */
     273             : void *
     274             : fd_quic_conn_get_context( fd_quic_conn_t * conn );
     275             : 
     276             : FD_PROTOTYPES_END
     277             : 
     278             : #endif /* HEADER_fd_src_waltz_quic_fd_quic_conn_h */

Generated by: LCOV version 1.14