Line data    Source code

       1             : #include "fd_quic_sandbox.h"
       2             : #include "../fd_quic_private.h"
       3             : #include "../templ/fd_quic_parse_util.h"
       4             : 
       5             : /* fd_quic_sandbox_capture_pkt captures a single outgoing packet sent by
       6             :    fd_quic. */
       7             : 
       8             : static void
       9             : fd_quic_sandbox_capture_pkt( fd_quic_sandbox_t *       sandbox,
      10          84 :                              fd_aio_pkt_info_t const * pkt ) {
      11             : 
      12          84 :   ulong            seq    = sandbox->pkt_seq_w;
      13          84 :   fd_frag_meta_t * mcache = sandbox->pkt_mcache;
      14          84 :   void *           dcache = sandbox->pkt_dcache;
      15          84 :   ulong            mtu    = sandbox->pkt_mtu;
      16          84 :   ulong            chunk  = sandbox->pkt_chunk;
      17          84 :   ulong            chunk0 = fd_dcache_compact_chunk0( sandbox, dcache );
      18          84 :   ulong            wmark  = fd_dcache_compact_wmark ( sandbox, dcache, mtu );
      19          84 :   ulong            depth  = fd_mcache_depth( mcache );
      20          84 :   ulong            sz     = pkt->buf_sz;
      21          84 :   uchar *          data   = fd_chunk_to_laddr( sandbox, chunk );
      22          84 :   ulong            ctl    = fd_frag_meta_ctl( /* orig */ 0, /* som */ 1, /* eom */ 1, /* err */ 0 );
      23          84 :   ulong            ts     = sandbox->wallclock;
      24             : 
      25          84 :   fd_memcpy( data, pkt->buf, sz );
      26          84 :   fd_mcache_publish( mcache, depth, seq, 0UL, chunk, sz, ctl, ts, ts );
      27             : 
      28          84 :   sandbox->pkt_seq_w = fd_seq_inc( seq, 1UL );
      29          84 :   sandbox->pkt_chunk = fd_dcache_compact_next( chunk, pkt->buf_sz, chunk0, wmark );
      30          84 : }
      31             : 
      32             : /* fd_quic_sandbox_aio_send implements fd_aio_send_func_t.  Called by
      33             :    the sandbox fd_quic to capture response packets into the sandbox
      34             :    capture ring. */
      35             : 
      36             : static int
      37             : fd_quic_sandbox_aio_send( void *                    ctx,
      38             :                           fd_aio_pkt_info_t const * batch,
      39             :                           ulong                     batch_cnt,
      40             :                           ulong *                   opt_batch_idx,
      41          84 :                           int                       flush ) {
      42             : 
      43          84 :   fd_quic_sandbox_t * sandbox = (fd_quic_sandbox_t *)ctx;
      44             : 
      45         168 :   for( ulong j=0UL; j<batch_cnt; j++ ) {
      46          84 :     fd_quic_sandbox_capture_pkt( sandbox, batch + j );
      47          84 :   }
      48             : 
      49          84 :   ulong _batch_idx[1];
      50          84 :   opt_batch_idx = opt_batch_idx ? opt_batch_idx : _batch_idx;
      51          84 :   *opt_batch_idx = batch_cnt;
      52             : 
      53          84 :   (void)flush;
      54          84 :   return FD_AIO_SUCCESS;
      55          84 : }
      56             : 
      57             : fd_frag_meta_t const *
      58           6 : fd_quic_sandbox_next_packet( fd_quic_sandbox_t * sandbox ) {
      59           6 :   fd_frag_meta_t * mcache = sandbox->pkt_mcache;
      60             : 
      61           6 :   ulong depth = fd_mcache_depth( mcache );
      62           6 :   ulong seq   = sandbox->pkt_seq_r;
      63           6 :   ulong mline = fd_mcache_line_idx( seq, depth );
      64             : 
      65           6 :   fd_frag_meta_t * frag = mcache + mline;
      66           6 :   if( FD_UNLIKELY( fd_seq_lt( frag->seq, seq ) ) ) return NULL;
      67           6 :   if( FD_UNLIKELY( fd_seq_gt( frag->seq, seq ) ) ) {
      68             :     /* Occurs if the fd_quic published 'depth' packets in succession
      69             :        without any reads via this function. */
      70           0 :     FD_LOG_WARNING(( "overrun detected, some captured packets were lost" ));
      71           0 :     seq = frag->seq;
      72           0 :   }
      73             : 
      74           6 :   sandbox->pkt_seq_r = fd_seq_inc( seq, 1UL );
      75             : 
      76           6 :   return frag;
      77           6 : }
      78             : 
      79             : uchar const fd_quic_sandbox_self_ed25519_keypair[64] =
      80             :   { /* private key */
      81             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      82             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      83             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      84             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      85             :     /* public key */
      86             :     0xdb, 0x99, 0x5f, 0xe2, 0x51, 0x69, 0xd1, 0x41,
      87             :     0xca, 0xb9, 0xbb, 0xba, 0x92, 0xba, 0xa0, 0x1f,
      88             :     0x9f, 0x2e, 0x1e, 0xce, 0x7d, 0xf4, 0xcb, 0x2a,
      89             :     0xc0, 0x51, 0x90, 0xf3, 0x7f, 0xcc, 0x1f, 0x9d };
      90             : 
      91             : 
      92             : uchar const fd_quic_sandbox_peer_ed25519_keypair[64] =
      93             :   { /* private key */
      94             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      95             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      96             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      97             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      98             :     /* public key */
      99             :     0x21, 0x52, 0xf8, 0xd1, 0x9b, 0x79, 0x1d, 0x24,
     100             :     0x45, 0x32, 0x42, 0xe1, 0x5f, 0x2e, 0xab, 0x6c,
     101             :     0xb7, 0xcf, 0xfa, 0x7b, 0x6a, 0x5e, 0xd3, 0x00,
     102             :     0x97, 0x96, 0x0e, 0x06, 0x98, 0x81, 0xdb, 0x12 };
     103             : 
     104             : uchar const fd_quic_sandbox_aes128_key[16] =
     105             :   { 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43,
     106             :     0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43 };
     107             : 
     108             : uchar const fd_quic_sandbox_aes128_iv[12] =
     109             :   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     110             :     0x00, 0x00, 0x00, 0x00 };
     111             : 
     112             : static ulong
     113    66396318 : fd_quic_sandbox_now_cb( void * context ) {
     114    66396318 :   fd_quic_sandbox_t * sandbox = context;
     115    66396318 :   return sandbox->wallclock;
     116    66396318 : }
     117             : 
     118             : ulong
     119          30 : fd_quic_sandbox_align( void ) {
     120          30 :   return fd_ulong_max( fd_ulong_max( fd_ulong_max( fd_ulong_max(
     121          30 :       alignof(fd_quic_sandbox_t),
     122          30 :       fd_quic_align() ),
     123          30 :       fd_mcache_align() ),
     124          30 :       fd_dcache_align() ),
     125          30 :       FD_CHUNK_ALIGN );
     126          30 : }
     127             : 
     128             : ulong
     129             : fd_quic_sandbox_footprint( fd_quic_limits_t const * quic_limits,
     130             :                            ulong                    pkt_cnt,
     131          12 :                            ulong                    mtu ) {
     132             : 
     133          12 :   ulong root_align = fd_quic_sandbox_align();
     134          12 :   ulong quic_fp    = fd_quic_footprint( quic_limits );
     135          12 :   ulong mcache_fp  = fd_mcache_footprint( pkt_cnt, 0UL );
     136          12 :   ulong dcache_fp  = fd_dcache_footprint( fd_dcache_req_data_sz( mtu, pkt_cnt, 1UL, 1 ), 0UL );
     137             : 
     138          12 :   if( FD_UNLIKELY( !quic_fp   ) ) return 0UL;
     139          12 :   if( FD_UNLIKELY( !mcache_fp ) ) return 0UL;
     140          12 :   if( FD_UNLIKELY( !dcache_fp ) ) return 0UL;
     141             : 
     142          12 :   ulong l = FD_LAYOUT_INIT;
     143          12 :   l = FD_LAYOUT_APPEND( l, root_align,        sizeof(fd_quic_sandbox_t) );
     144          12 :   l = FD_LAYOUT_APPEND( l, fd_quic_align(),   quic_fp                   );
     145          12 :   l = FD_LAYOUT_APPEND( l, fd_mcache_align(), mcache_fp                 );
     146          12 :   l = FD_LAYOUT_APPEND( l, fd_dcache_align(), dcache_fp                 );
     147          12 :   return FD_LAYOUT_FINI( l, root_align );
     148          12 : }
     149             : 
     150             : fd_quic_sandbox_t *
     151             : fd_quic_sandbox_new( void *                   mem,
     152             :                      fd_quic_limits_t const * quic_limits,
     153             :                      ulong                    pkt_cnt,
     154           6 :                      ulong                    mtu ) {
     155             : 
     156           6 :   if( FD_UNLIKELY( !mem ) ) {
     157           0 :     FD_LOG_WARNING(( "NULL mem" ));
     158           0 :     return NULL;
     159           0 :   }
     160             : 
     161           6 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)mem, fd_quic_sandbox_align() ) ) ) {
     162           0 :     FD_LOG_WARNING(( "misaligned mem" ));
     163           0 :     return NULL;
     164           0 :   }
     165             : 
     166           6 :   ulong fp = fd_quic_sandbox_footprint( quic_limits, pkt_cnt, mtu );
     167           6 :   if( FD_UNLIKELY( !fp ) ) {
     168           0 :     FD_LOG_WARNING(( "invalid params" ));
     169           0 :     return NULL;
     170           0 :   }
     171             : 
     172           6 :   ulong root_align     = fd_quic_sandbox_align();
     173           6 :   ulong quic_fp        = fd_quic_footprint( quic_limits );
     174           6 :   ulong mcache_fp      = fd_mcache_footprint( pkt_cnt, 0UL );
     175           6 :   ulong dcache_data_sz = fd_dcache_req_data_sz( mtu, pkt_cnt, 1UL, 1 );
     176           6 :   ulong dcache_fp      = fd_dcache_footprint( dcache_data_sz, 0UL );
     177             : 
     178           6 :   FD_SCRATCH_ALLOC_INIT( l, mem );
     179           6 :   fd_quic_sandbox_t * sandbox    = FD_SCRATCH_ALLOC_APPEND( l, root_align,        sizeof(fd_quic_sandbox_t) );
     180           6 :   void *              quic_mem   = FD_SCRATCH_ALLOC_APPEND( l, fd_quic_align(),   quic_fp                   );
     181           6 :   void *              mcache_mem = FD_SCRATCH_ALLOC_APPEND( l, fd_mcache_align(), mcache_fp                 );
     182           6 :   void *              dcache_mem = FD_SCRATCH_ALLOC_APPEND( l, fd_dcache_align(), dcache_fp                 );
     183           6 :   FD_SCRATCH_ALLOC_FINI( l, root_align );
     184             : 
     185           6 :   ulong seq0 = 0UL;  /* the first packet in the capture always has sequence number 0 */
     186             : 
     187           6 :   *sandbox = (fd_quic_sandbox_t) {
     188           6 :     .quic       = fd_quic_join  ( fd_quic_new( quic_mem, quic_limits ) ),
     189           6 :     .pkt_mcache = fd_mcache_join( fd_mcache_new( mcache_mem, pkt_cnt, 0UL, seq0 ) ),
     190           6 :     .pkt_dcache = fd_dcache_join( fd_dcache_new( dcache_mem, dcache_data_sz, 0UL ) ),
     191           6 :     .pkt_seq_r  = seq0,
     192           6 :     .pkt_mtu    = mtu
     193           6 :   };
     194           6 :   void * shmlog = (void *)( (ulong)sandbox->quic + sandbox->quic->layout.log_off );
     195           6 :   if( FD_UNLIKELY( !fd_quic_log_rx_join( sandbox->log_rx, shmlog ) ) ) {
     196           0 :     FD_LOG_CRIT(( "Failed to join the log of a newly created quic" ));
     197           0 :   }
     198             : 
     199           6 :   FD_COMPILER_MFENCE();
     200           6 :   sandbox->magic = FD_QUIC_SANDBOX_MAGIC;
     201           6 :   FD_COMPILER_MFENCE();
     202             : 
     203           6 :   return sandbox;
     204           6 : }
     205             : 
     206             : fd_quic_sandbox_t *
     207             : fd_quic_sandbox_init( fd_quic_sandbox_t * sandbox,
     208          42 :                       int                 role ) {
     209             : 
     210          42 :   fd_quic_t *        quic     = sandbox->quic;
     211          42 :   fd_quic_config_t * quic_cfg = &quic->config;
     212             : 
     213          42 :   quic_cfg->role                  = role;
     214          42 :   quic_cfg->idle_timeout          = FD_QUIC_SANDBOX_IDLE_TIMEOUT;
     215          42 :   quic_cfg->initial_rx_max_stream_data = 512UL; /* arbitrary */
     216          42 :   memcpy( quic_cfg->identity_public_key, fd_quic_sandbox_self_ed25519_keypair + 32, 32 );
     217          42 :   memset( &quic->metrics, 0, sizeof(fd_quic_metrics_t) );
     218             : 
     219          42 :   fd_aio_t aio_tx = {
     220          42 :     .send_func = fd_quic_sandbox_aio_send,
     221          42 :     .ctx       = sandbox
     222          42 :   };
     223          42 :   fd_quic_set_aio_net_tx( quic, &aio_tx );
     224             : 
     225          42 :   quic->cb.now_ctx = sandbox;
     226          42 :   quic->cb.now     = fd_quic_sandbox_now_cb;
     227             : 
     228          42 :   if( FD_UNLIKELY( !fd_quic_init( quic ) ) ) {
     229           0 :     FD_LOG_WARNING(( "fd_quic_init failed" ));
     230           0 :     return NULL;
     231           0 :   }
     232             : 
     233             :   /* Verify that the conn state counts start correct */
     234          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_INVALID ] == quic->limits.conn_cnt );
     235          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_HANDSHAKE ] == 0 );
     236          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_HANDSHAKE_COMPLETE ] == 0 );
     237          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_ACTIVE ] == 0 );
     238          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_PEER_CLOSE ] == 0 );
     239          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_ABORT ] == 0 );
     240          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_CLOSE_PENDING ] == 0 );
     241          42 :   FD_TEST( quic->metrics.conn_state_cnt[ FD_QUIC_CONN_STATE_DEAD ] == 0 );
     242             : 
     243             : 
     244          42 :   sandbox->wallclock = 0UL;
     245          42 :   sandbox->pkt_seq_r = 0UL;
     246          42 :   sandbox->pkt_seq_w = 0UL;
     247          42 :   sandbox->pkt_mcache[0].seq = ULONG_MAX;  /* mark first entry as unpublished */
     248          42 :   sandbox->pkt_chunk = fd_dcache_compact_chunk0( sandbox, sandbox->pkt_dcache );
     249             : 
     250             :   /* skip ahead the log seq no */
     251          42 :   fd_quic_log_tx_t * log_tx = fd_quic_get_state( quic )->log_tx;
     252          42 :   log_tx->seq += 4093; /* prime */
     253             : 
     254          42 :   return sandbox;
     255          42 : }
     256             : 
     257             : void *
     258           6 : fd_quic_sandbox_delete( fd_quic_sandbox_t * mem ) {
     259             : 
     260           6 :   if( FD_UNLIKELY( !mem ) ) {
     261           0 :     FD_LOG_WARNING(( "NULL mem" ));
     262           0 :     return NULL;
     263           0 :   }
     264             : 
     265           6 :   fd_quic_sandbox_t * sandbox = (fd_quic_sandbox_t *)mem;
     266           6 :   if( FD_UNLIKELY( sandbox->magic != FD_QUIC_SANDBOX_MAGIC ) ) {
     267           0 :     FD_LOG_WARNING(( "invalid magic" ));
     268           0 :     return NULL;
     269           0 :   }
     270             : 
     271           6 :   FD_COMPILER_MFENCE();
     272           6 :   sandbox->magic = 0UL;
     273           6 :   FD_COMPILER_MFENCE();
     274             : 
     275           6 :   fd_quic_delete  ( fd_quic_leave  ( sandbox->quic       ) );
     276           6 :   fd_mcache_delete( fd_mcache_leave( sandbox->pkt_mcache ) );
     277           6 :   fd_dcache_delete( fd_dcache_leave( sandbox->pkt_dcache ) );
     278             : 
     279           6 :   return mem;
     280           6 : }
     281             : 
     282             : fd_quic_conn_t *
     283             : fd_quic_sandbox_new_conn_established( fd_quic_sandbox_t * sandbox,
     284      300057 :                                       fd_rng_t *          rng ) {
     285             : 
     286      300057 :   fd_quic_t * quic = sandbox->quic;
     287             : 
     288             :   /* fd_quic_t conn IDs are always 8 bytes */
     289      300057 :   ulong             our_conn_id_u64 = fd_rng_ulong( rng );
     290             : 
     291             :   /* the peer may choose a conn ID size 1 to 16 bytes
     292             :      For now, pick 8 bytes too */
     293      300057 :   ulong             peer_conn_id_u64 = fd_rng_ulong( rng );
     294      300057 :   fd_quic_conn_id_t peer_conn_id     = fd_quic_conn_id_new( &peer_conn_id_u64, 8UL );
     295             : 
     296      300057 :   fd_quic_conn_t * conn = fd_quic_conn_create(
     297      300057 :       /* quic         */ quic,
     298      300057 :       /* our_conn_id  */ our_conn_id_u64,
     299      300057 :       /* peer_conn_id */ &peer_conn_id,
     300      300057 :       /* dst_ip_addr  */ FD_QUIC_SANDBOX_PEER_IP4,
     301      300057 :       /* dst_udp_addr */ FD_QUIC_SANDBOX_PEER_PORT,
     302      300057 :       /* src_ip_addr  */ FD_QUIC_SANDBOX_SELF_IP4,
     303      300057 :       /* src_udp_addr */ FD_QUIC_SANDBOX_SELF_PORT,
     304      300057 :       /* server       */ quic->config.role == FD_QUIC_ROLE_SERVER );
     305      300057 :   if( FD_UNLIKELY( !conn ) ) {
     306           0 :     FD_LOG_WARNING(( "fd_quic_conn_create failed" ));
     307           0 :     return NULL;
     308           0 :   }
     309             : 
     310      300057 :   conn->state       = FD_QUIC_CONN_STATE_ACTIVE;
     311      300057 :   conn->established = 1;
     312             : 
     313             :   /* Mock a completed handshake */
     314      300057 :   conn->handshake_complete = 1;
     315      300057 :   conn->peer_enc_level     = fd_quic_enc_level_appdata_id;
     316      300057 :   conn->keys_avail         = 1U<<fd_quic_enc_level_appdata_id;
     317             : 
     318      300057 :   conn->idle_timeout_ticks  = FD_QUIC_SANDBOX_IDLE_TIMEOUT;
     319      300057 :   conn->last_activity       = sandbox->wallclock;
     320             : 
     321             :   /* Reset flow control limits */
     322      300057 :   conn->tx_max_data           = 0UL;
     323      300057 :   conn->tx_tot_data           = 0UL;
     324      300057 :   conn->srx->rx_max_data      = 0UL;
     325      300057 :   conn->srx->rx_tot_data      = 0UL;
     326      300057 :   conn->srx->rx_max_data_ackd = 0UL;
     327      300057 :   conn->tx_initial_max_stream_data_uni = 0UL;
     328             : 
     329             :   /* TODO set a realistic packet number */
     330             : 
     331      300057 :   return conn;
     332      300057 : }
     333             : 
     334             : void
     335             : fd_quic_sandbox_send_frame( fd_quic_sandbox_t * sandbox,
     336             :                             fd_quic_conn_t *    conn,
     337             :                             fd_quic_pkt_t *     pkt_meta,
     338             :                             uchar const *       frame_ptr,
     339    66397785 :                             ulong               frame_sz ) {
     340             : 
     341             :   /* TODO consider crafting a real app packet instead of bypassing
     342             :           packet processing checks */
     343             : 
     344    66397785 :   fd_quic_t * quic = sandbox->quic;
     345             : 
     346             :   /* set pkt_type to FD_QUIC_PKT_TYPE_ONE_RTT as it allows all
     347             :    * frame types */
     348    66397785 :   uint pkt_type = FD_QUIC_PKT_TYPE_ONE_RTT;
     349             : 
     350    66397785 :   ulong rc = fd_quic_handle_v1_frame( quic, conn, pkt_meta, pkt_type, frame_ptr, frame_sz );
     351    66397785 :   if( FD_UNLIKELY( rc==FD_QUIC_PARSE_FAIL ) ) return;
     352    66397776 :   if( FD_UNLIKELY( rc==0UL || rc>frame_sz ) ) {
     353           0 :     FD_LOG_CRIT(( "Invalid fd_quic_handle_v1_frame return value (rc=%#lx frame_sz=%#lx)", rc, frame_sz ));
     354           0 :   }
     355             : 
     356    66397776 : }
     357             : 
     358             : void
     359             : fd_quic_sandbox_send_lone_frame( fd_quic_sandbox_t * sandbox,
     360             :                                  fd_quic_conn_t *    conn,
     361             :                                  uchar const *       frame,
     362    66397782 :                                  ulong               frame_sz ) {
     363             : 
     364    66397782 :   FD_TEST( frame_sz <= sandbox->pkt_mtu );
     365             : 
     366    66397782 :   ulong pkt_num = conn->exp_pkt_number[2]++;
     367             : 
     368    66397782 :   ulong quic_pkt_sz = frame_sz;  /* TODO mock some QUIC packetization overhead */
     369             : 
     370    66397782 :   fd_quic_pkt_t pkt_meta = {
     371    66397782 :     .ip4 = {{
     372    66397782 :       .verihl       = FD_IP4_VERIHL(4,5),
     373    66397782 :       .net_tot_len  = (ushort)( 20 + 8 + quic_pkt_sz ),
     374    66397782 :       .net_frag_off = 0x4000u, /* don't fragment */
     375    66397782 :       .ttl          = 64,
     376    66397782 :       .protocol     = FD_IP4_HDR_PROTOCOL_UDP,
     377    66397782 :     }},
     378    66397782 :     .udp = {{
     379    66397782 :       .net_sport = FD_QUIC_SANDBOX_PEER_PORT,
     380    66397782 :       .net_dport = FD_QUIC_SANDBOX_SELF_PORT,
     381    66397782 :       .net_len   = (ushort)( 8 + quic_pkt_sz ),
     382    66397782 :     }},
     383    66397782 :     .pkt_number = pkt_num,
     384    66397782 :     .rcv_time   = sandbox->wallclock,
     385    66397782 :     .enc_level  = fd_quic_enc_level_appdata_id,
     386    66397782 :   };
     387             : 
     388    66397782 :   fd_quic_sandbox_send_frame( sandbox, conn, &pkt_meta, frame, frame_sz );
     389             : 
     390    66397782 :   fd_quic_lazy_ack_pkt( sandbox->quic, conn, &pkt_meta );
     391             : 
     392             :   /* Synchronize log seq[0] from tx to rx */
     393    66397782 :   fd_quic_log_tx_seq_update( fd_quic_get_state( sandbox->quic )->log_tx );
     394    66397782 : }
     395             : 
     396             : void
     397             : fd_quic_sandbox_send_ping_pkt( fd_quic_sandbox_t * sandbox,
     398             :                                fd_quic_conn_t *    conn,
     399         210 :                                ulong               pktnum ) {
     400             : 
     401         210 :   uchar pkt_buf[ 256 ];
     402         210 :   pkt_buf[0] = fd_quic_one_rtt_h0( /* spin */         0,
     403         210 :                                    /* key_phase */    !!conn->key_phase,
     404         210 :                                    /* pktnum_len-1 */ 3 );
     405         210 :   memcpy( pkt_buf+1, &conn->our_conn_id, FD_QUIC_CONN_ID_SZ );
     406         210 :   uint pktnum_comp = fd_uint_bswap( (uint)( pktnum & UINT_MAX ) );
     407         210 :   memcpy( pkt_buf+9, &pktnum_comp, 4 );
     408         210 :   pkt_buf[13] = 0x01;  /* PING frame */
     409         210 :   memset( pkt_buf+14, 0, 18UL );
     410             : 
     411         210 :   fd_quic_crypto_keys_t * keys = &conn->keys[fd_quic_enc_level_appdata_id][0];
     412         210 :   ulong out_sz = 48UL;
     413         210 :   int crypt_res = fd_quic_crypto_encrypt( pkt_buf, &out_sz, pkt_buf, 13UL, pkt_buf+13, 19UL, keys, keys, pktnum );
     414         210 :   FD_TEST( crypt_res==FD_QUIC_SUCCESS );
     415             : 
     416         210 :   fd_quic_pkt_t pkt = {
     417         210 :     .ip4 = {{
     418         210 :       .verihl       = FD_IP4_VERIHL(4,5),
     419         210 :       .net_tot_len  = 28,
     420         210 :       .net_frag_off = 0x4000u, /* don't fragment */
     421         210 :       .ttl          = 64,
     422         210 :       .protocol     = FD_IP4_HDR_PROTOCOL_UDP,
     423         210 :     }},
     424         210 :     .udp = {{
     425         210 :       .net_sport = FD_QUIC_SANDBOX_PEER_PORT,
     426         210 :       .net_dport = FD_QUIC_SANDBOX_SELF_PORT,
     427         210 :       .net_len   = 8,
     428         210 :     }},
     429         210 :     .pkt_number = pktnum,
     430         210 :     .rcv_time   = sandbox->wallclock,
     431         210 :     .enc_level  = fd_quic_enc_level_appdata_id,
     432         210 :   };
     433             : 
     434         210 :   fd_quic_process_quic_packet_v1( sandbox->quic, &pkt, pkt_buf, out_sz );
     435         210 : }