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