quic_ackm_test.c@ 108206

Last change on this file since 108206 was 108206, checked in by vboxsync, 3 months ago
openssl-3.3.2: Exported all files to OSE and removed .scm-settings bugref:10757
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.6 KB

Line
1	/*
2	* Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
3	*
4	* Licensed under the Apache License 2.0 (the "License"). You may not use
5	* this file except in compliance with the License. You can obtain a copy
6	* in the file LICENSE in the source distribution or at
7	* https://www.openssl.org/source/license.html
8	*/
9
10	#include "testutil.h"
11	#include <openssl/ssl.h>
12	#include "internal/quic_ackm.h"
13	#include "internal/quic_cc.h"
14
15	static OSSL_TIME fake_time = {0};
16
17	#define TIME_BASE (ossl_ticks2time(123 * OSSL_TIME_SECOND))
18
19	static OSSL_TIME fake_now(void *arg)
20	{
21	return fake_time;
22	}
23
24	struct pkt_info {
25	OSSL_ACKM_TX_PKT *pkt;
26	int lost, acked, discarded;
27	};
28
29	static void on_lost(void *arg)
30	{
31	struct pkt_info *info = arg;
32	++info->lost;
33	}
34
35	static void on_acked(void *arg)
36	{
37	struct pkt_info *info = arg;
38	++info->acked;
39	}
40
41	static void on_discarded(void *arg)
42	{
43	struct pkt_info *info = arg;
44	++info->discarded;
45	}
46
47	struct helper {
48	OSSL_ACKM *ackm;
49	struct pkt_info *pkts;
50	size_t num_pkts;
51	OSSL_CC_DATA *ccdata;
52	OSSL_STATM statm;
53	int have_statm;
54	};
55
56	static void helper_destroy(struct helper *h)
57	{
58	size_t i;
59
60	if (h->ackm != NULL) {
61	ossl_ackm_free(h->ackm);
62	h->ackm = NULL;
63	}
64
65	if (h->ccdata != NULL) {
66	ossl_cc_dummy_method.free(h->ccdata);
67	h->ccdata = NULL;
68	}
69
70	if (h->have_statm) {
71	ossl_statm_destroy(&h->statm);
72	h->have_statm = 0;
73	}
74
75	if (h->pkts != NULL) {
76	for (i = 0; i < h->num_pkts; ++i) {
77	OPENSSL_free(h->pkts[i].pkt);
78	h->pkts[i].pkt = NULL;
79	}
80
81	OPENSSL_free(h->pkts);
82	h->pkts = NULL;
83	}
84	}
85
86	static int helper_init(struct helper *h, size_t num_pkts)
87	{
88	int rc = 0;
89
90	memset(h, 0, sizeof(*h));
91
92	fake_time = TIME_BASE;
93
94	/* Initialise statistics tracker. */
95	if (!TEST_int_eq(ossl_statm_init(&h->statm), 1))
96	goto err;
97
98	h->have_statm = 1;
99
100	/* Initialise congestion controller. */
101	h->ccdata = ossl_cc_dummy_method.new(fake_now, NULL);
102	if (!TEST_ptr(h->ccdata))
103	goto err;
104
105	/* Initialise ACK manager. */
106	h->ackm = ossl_ackm_new(fake_now, NULL, &h->statm,
107	&ossl_cc_dummy_method, h->ccdata);
108	if (!TEST_ptr(h->ackm))
109	goto err;
110
111	/* Allocate our array of packet information. */
112	h->num_pkts = num_pkts;
113	if (num_pkts > 0) {
114	h->pkts = OPENSSL_zalloc(sizeof(struct pkt_info) * num_pkts);
115	if (!TEST_ptr(h->pkts))
116	goto err;
117	} else {
118	h->pkts = NULL;
119	}
120
121	rc = 1;
122	err:
123	if (rc == 0)
124	helper_destroy(h);
125
126	return rc;
127	}
128
129	static const QUIC_PN linear_20[] = {
130	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
131	};
132
133	static const QUIC_PN high_linear_20[] = {
134	1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008,
135	1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
136	1018, 1019
137	};
138
139	/*
140	* TX ACK (Packet Threshold) Test Cases
141	* ******************************************************************
142	*/
143	struct tx_ack_test_case {
144	const QUIC_PN *pn_table;
145	size_t pn_table_len;
146	const OSSL_QUIC_ACK_RANGE *ack_ranges;
147	size_t num_ack_ranges;
148	const char expect_ack; / 1=ack, 2=lost, 4=discarded */
149	};
150
151	#define DEFINE_TX_ACK_CASE(n, pntable) \
152	static const struct tx_ack_test_case tx_ack_case_##n = { \
153	(pntable), OSSL_NELEM(pntable), \
154	tx_ack_range_##n, OSSL_NELEM(tx_ack_range_##n), \
155	tx_ack_expect_##n \
156	}
157
158	/* One range, partial coverage of space */
159	static const OSSL_QUIC_ACK_RANGE tx_ack_range_1[] = {
160	{ 0, 10 },
161	};
162	static const char tx_ack_expect_1[] = {
163	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
164	};
165	DEFINE_TX_ACK_CASE(1, linear_20);
166
167	/* Two ranges, partial coverage of space, overlapping by 1 */
168	static const OSSL_QUIC_ACK_RANGE tx_ack_range_2[] = {
169	{ 5, 10 }, { 0, 5 }
170	};
171	static const char tx_ack_expect_2[] = {
172	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
173	};
174	DEFINE_TX_ACK_CASE(2, linear_20);
175
176	/* Two ranges, partial coverage of space, together contiguous */
177	static const OSSL_QUIC_ACK_RANGE tx_ack_range_3[] = {
178	{ 6, 10 }, { 0, 5 }
179	};
180	static const char tx_ack_expect_3[] = {
181	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
182	};
183	DEFINE_TX_ACK_CASE(3, linear_20);
184
185	/*
186	* Two ranges, partial coverage of space, non-contiguous by 1
187	* Causes inferred loss due to packet threshold being exceeded.
188	*/
189	static const OSSL_QUIC_ACK_RANGE tx_ack_range_4[] = {
190	{ 7, 10 }, { 0, 5 }
191	};
192	static const char tx_ack_expect_4[] = {
193	1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
194	};
195	DEFINE_TX_ACK_CASE(4, linear_20);
196
197	/*
198	* Two ranges, partial coverage of space, non-contiguous by 2
199	* Causes inferred loss due to packet threshold being exceeded.
200	*/
201	static const OSSL_QUIC_ACK_RANGE tx_ack_range_5[] = {
202	{ 7, 10 }, { 0, 4 }
203	};
204	static const char tx_ack_expect_5[] = {
205	1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
206	};
207	DEFINE_TX_ACK_CASE(5, linear_20);
208
209	/* One range, covering entire space */
210	static const OSSL_QUIC_ACK_RANGE tx_ack_range_6[] = {
211	{ 0, 20 },
212	};
213	static const char tx_ack_expect_6[] = {
214	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
215	};
216	DEFINE_TX_ACK_CASE(6, linear_20);
217
218	/* One range, covering more space than exists */
219	static const OSSL_QUIC_ACK_RANGE tx_ack_range_7[] = {
220	{ 0, 30 },
221	};
222	static const char tx_ack_expect_7[] = {
223	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
224	};
225	DEFINE_TX_ACK_CASE(7, linear_20);
226
227	/* One range, covering nothing (too high) */
228	static const OSSL_QUIC_ACK_RANGE tx_ack_range_8[] = {
229	{ 21, 30 },
230	};
231	static const char tx_ack_expect_8[] = {
232	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
233	};
234	DEFINE_TX_ACK_CASE(8, linear_20);
235
236	/* One range, covering nothing (too low) */
237	static const OSSL_QUIC_ACK_RANGE tx_ack_range_9[] = {
238	{ 0, 999 },
239	};
240	static const char tx_ack_expect_9[] = {
241	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
242	};
243	DEFINE_TX_ACK_CASE(9, high_linear_20);
244
245	/* One single packet at start of PN set */
246	static const OSSL_QUIC_ACK_RANGE tx_ack_range_10[] = {
247	{ 0, 0 },
248	};
249	static const char tx_ack_expect_10[] = {
250	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
251	};
252	DEFINE_TX_ACK_CASE(10, linear_20);
253
254	/*
255	* One single packet in middle of PN set
256	* Causes inferred loss of one packet due to packet threshold being exceeded,
257	* but several other previous packets survive as they are under the threshold.
258	*/
259	static const OSSL_QUIC_ACK_RANGE tx_ack_range_11[] = {
260	{ 3, 3 },
261	};
262	static const char tx_ack_expect_11[] = {
263	2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
264	};
265	DEFINE_TX_ACK_CASE(11, linear_20);
266
267	/*
268	* One single packet at end of PN set
269	* Causes inferred loss due to packet threshold being exceeded.
270	*/
271	static const OSSL_QUIC_ACK_RANGE tx_ack_range_12[] = {
272	{ 19, 19 },
273	};
274	static const char tx_ack_expect_12[] = {
275	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 1
276	};
277	DEFINE_TX_ACK_CASE(12, linear_20);
278
279	/*
280	* Mixed straddling
281	* Causes inferred loss due to packet threshold being exceeded.
282	*/
283	static const OSSL_QUIC_ACK_RANGE tx_ack_range_13[] = {
284	{ 1008, 1008 }, { 1004, 1005 }, { 1001, 1002 }
285	};
286	static const char tx_ack_expect_13[] = {
287	2, 1, 1, 2, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
288	};
289	DEFINE_TX_ACK_CASE(13, high_linear_20);
290
291	static const struct tx_ack_test_case *const tx_ack_cases[] = {
292	&tx_ack_case_1,
293	&tx_ack_case_2,
294	&tx_ack_case_3,
295	&tx_ack_case_4,
296	&tx_ack_case_5,
297	&tx_ack_case_6,
298	&tx_ack_case_7,
299	&tx_ack_case_8,
300	&tx_ack_case_9,
301	&tx_ack_case_10,
302	&tx_ack_case_11,
303	&tx_ack_case_12,
304	&tx_ack_case_13,
305	};
306
307	enum {
308	MODE_ACK, MODE_DISCARD, MODE_PTO, MODE_NUM
309	};
310
311	static int test_probe_counts(const OSSL_ACKM_PROBE_INFO *p,
312	uint32_t anti_deadlock_handshake,
313	uint32_t anti_deadlock_initial,
314	uint32_t pto_initial,
315	uint32_t pto_handshake,
316	uint32_t pto_app)
317	{
318	if (!TEST_uint_eq(p->anti_deadlock_handshake, anti_deadlock_handshake))
319	return 0;
320	if (!TEST_uint_eq(p->anti_deadlock_initial, anti_deadlock_initial))
321	return 0;
322	if (!TEST_uint_eq(p->pto[QUIC_PN_SPACE_INITIAL], pto_initial))
323	return 0;
324	if (!TEST_uint_eq(p->pto[QUIC_PN_SPACE_HANDSHAKE], pto_handshake))
325	return 0;
326	if (!TEST_uint_eq(p->pto[QUIC_PN_SPACE_APP], pto_app))
327	return 0;
328	return 1;
329	}
330
331	static void on_loss_detection_deadline_callback(OSSL_TIME deadline, void *arg)
332	{
333	(OSSL_TIME )arg = deadline;
334	}
335
336	static int test_tx_ack_case_actual(int tidx, int space, int mode)
337	{
338	int testresult = 0;
339	struct helper h;
340	size_t i;
341	OSSL_ACKM_TX_PKT *tx;
342	const struct tx_ack_test_case *c = tx_ack_cases[tidx];
343	OSSL_QUIC_FRAME_ACK ack = {0};
344	OSSL_TIME loss_detection_deadline = ossl_time_zero();
345
346	/* Cannot discard app space, so skip this */
347	if (mode == MODE_DISCARD && space == QUIC_PN_SPACE_APP) {
348	TEST_skip("skipping test for app space");
349	return 1;
350	}
351
352	if (!TEST_int_eq(helper_init(&h, c->pn_table_len), 1))
353	goto err;
354
355	/* Arm callback. */
356	ossl_ackm_set_loss_detection_deadline_callback(h.ackm,
357	on_loss_detection_deadline_callback,
358	&loss_detection_deadline);
359
360	/* Allocate TX packet structures. */
361	for (i = 0; i < c->pn_table_len; ++i) {
362	h.pkts[i].pkt = tx = OPENSSL_zalloc(sizeof(*tx));
363	if (!TEST_ptr(tx))
364	goto err;
365
366	tx->pkt_num = c->pn_table[i];
367	tx->pkt_space = space;
368	tx->is_inflight = 1;
369	tx->is_ack_eliciting = 1;
370	tx->num_bytes = 123;
371	tx->largest_acked = QUIC_PN_INVALID;
372	tx->on_lost = on_lost;
373	tx->on_acked = on_acked;
374	tx->on_discarded = on_discarded;
375	tx->cb_arg = &h.pkts[i];
376
377	tx->time = fake_time;
378
379	if (!TEST_int_eq(ossl_ackm_on_tx_packet(h.ackm, tx), 1))
380	goto err;
381	}
382
383	if (mode == MODE_DISCARD) {
384	/* Try discarding. */
385	if (!TEST_int_eq(ossl_ackm_on_pkt_space_discarded(h.ackm, space), 1))
386	goto err;
387
388	/* Check all discard callbacks were called. */
389	for (i = 0; i < c->pn_table_len; ++i) {
390	if (!TEST_int_eq(h.pkts[i].acked, 0))
391	goto err;
392	if (!TEST_int_eq(h.pkts[i].lost, 0))
393	goto err;
394	if (!TEST_int_eq(h.pkts[i].discarded, 1))
395	goto err;
396	}
397	} else if (mode == MODE_ACK) {
398	/* Try acknowledging. */
399	ack.ack_ranges = (OSSL_QUIC_ACK_RANGE *)c->ack_ranges;
400	ack.num_ack_ranges = c->num_ack_ranges;
401	if (!TEST_int_eq(ossl_ackm_on_rx_ack_frame(h.ackm, &ack, space, fake_time), 1))
402	goto err;
403
404	/* Check correct ranges were acknowledged. */
405	for (i = 0; i < c->pn_table_len; ++i) {
406	if (!TEST_int_eq(h.pkts[i].acked,
407	(c->expect_ack[i] & 1) != 0 ? 1 : 0))
408	goto err;
409	if (!TEST_int_eq(h.pkts[i].lost,
410	(c->expect_ack[i] & 2) != 0 ? 1 : 0))
411	goto err;
412	if (!TEST_int_eq(h.pkts[i].discarded,
413	(c->expect_ack[i] & 4) != 0 ? 1 : 0))
414	goto err;
415	}
416	} else if (mode == MODE_PTO) {
417	OSSL_TIME deadline = ossl_ackm_get_loss_detection_deadline(h.ackm);
418	OSSL_ACKM_PROBE_INFO probe;
419
420	if (!TEST_int_eq(ossl_time_compare(deadline, loss_detection_deadline), 0))
421	goto err;
422
423	/* We should have a PTO deadline. */
424	if (!TEST_int_gt(ossl_time_compare(deadline, fake_time), 0))
425	goto err;
426
427	/* Should not have any probe requests yet. */
428	probe = *ossl_ackm_get0_probe_request(h.ackm);
429	if (!TEST_int_eq(test_probe_counts(&probe, 0, 0, 0, 0, 0), 1))
430	goto err;
431
432	/*
433	* If in app space, confirm handshake, as this is necessary to enable
434	* app space PTO probe requests.
435	*/
436	if (space == QUIC_PN_SPACE_APP)
437	if (!TEST_int_eq(ossl_ackm_on_handshake_confirmed(h.ackm), 1))
438	goto err;
439
440	/* Advance to the PTO deadline. */
441	fake_time = ossl_time_add(deadline, ossl_ticks2time(1));
442
443	if (!TEST_int_eq(ossl_ackm_on_timeout(h.ackm), 1))
444	goto err;
445
446	/* Should have a probe request. Not cleared by first call. */
447	for (i = 0; i < 3; ++i) {
448	probe = *ossl_ackm_get0_probe_request(h.ackm);
449	if (i > 0)
450	memset(ossl_ackm_get0_probe_request(h.ackm), 0, sizeof(probe));
451
452	if (i == 2) {
453	if (!TEST_int_eq(test_probe_counts(&probe, 0, 0, 0, 0, 0), 1))
454	goto err;
455	} else {
456	if (!TEST_int_eq(test_probe_counts(&probe, 0, 0,
457	space == QUIC_PN_SPACE_INITIAL,
458	space == QUIC_PN_SPACE_HANDSHAKE,
459	space == QUIC_PN_SPACE_APP), 1))
460	goto err;
461	}
462	}
463
464	} else
465	goto err;
466
467	testresult = 1;
468	err:
469	helper_destroy(&h);
470	return testresult;
471	}
472
473	/*
474	* TX ACK (Time Threshold) Test
475	* ******************************************************************
476	*/
477	enum {
478	TX_ACK_TIME_OP_END,
479	TX_ACK_TIME_OP_PKT, /* TX packets */
480	TX_ACK_TIME_OP_ACK, /* Synthesise incoming ACK of single PN range */
481	TX_ACK_TIME_OP_EXPECT /* Ack/loss assertion */
482	};
483
484	struct tx_ack_time_op {
485	int kind;
486	uint64_t time_advance; /* all ops */
487	QUIC_PN pn; /* PKT, ACK */
488	size_t num_pn; /* PKT, ACK */
489	const char expect; / 1=ack, 2=lost, 4=discarded */
490	};
491
492	#define TX_OP_PKT(advance, pn, num_pn) \
493	{ TX_ACK_TIME_OP_PKT, (advance) * OSSL_TIME_MS, (pn), (num_pn), NULL },
494	#define TX_OP_ACK(advance, pn, num_pn) \
495	{ TX_ACK_TIME_OP_ACK, (advance) * OSSL_TIME_MS, (pn), (num_pn), NULL },
496	#define TX_OP_EXPECT(expect) \
497	{ TX_ACK_TIME_OP_EXPECT, 0, 0, 0, (expect) },
498	#define TX_OP_END { TX_ACK_TIME_OP_END }
499
500	static const char tx_ack_time_script_1_expect[] = {
501	2, 1
502	};
503
504	static const struct tx_ack_time_op tx_ack_time_script_1[] = {
505	TX_OP_PKT ( 0, 0, 1)
506	TX_OP_PKT (3600000, 1, 1)
507	TX_OP_ACK ( 1000, 1, 1)
508	TX_OP_EXPECT(tx_ack_time_script_1_expect)
509	TX_OP_END
510	};
511
512	static const struct tx_ack_time_op *const tx_ack_time_scripts[] = {
513	tx_ack_time_script_1,
514	};
515
516	static int test_tx_ack_time_script(int tidx)
517	{
518	int testresult = 0;
519	struct helper h;
520	OSSL_ACKM_TX_PKT *tx = NULL;
521	OSSL_QUIC_FRAME_ACK ack = {0};
522	OSSL_QUIC_ACK_RANGE ack_range = {0};
523	size_t i, num_pkts = 0, pkt_idx = 0;
524	const struct tx_ack_time_op script = tx_ack_time_scripts[tidx], s;
525
526	/* Calculate number of packets. */
527	for (s = script; s->kind != TX_ACK_TIME_OP_END; ++s)
528	if (s->kind == TX_ACK_TIME_OP_PKT)
529	num_pkts += s->num_pn;
530
531	/* Initialise ACK manager and packet structures. */
532	if (!TEST_int_eq(helper_init(&h, num_pkts), 1))
533	goto err;
534
535	for (i = 0; i < num_pkts; ++i) {
536	h.pkts[i].pkt = tx = OPENSSL_zalloc(sizeof(*tx));
537	if (!TEST_ptr(tx))
538	goto err;
539	}
540
541	/* Run script. */
542	for (s = script; s->kind != TX_ACK_TIME_OP_END; ++s)
543	switch (s->kind) {
544	case TX_ACK_TIME_OP_PKT:
545	for (i = 0; i < s->num_pn; ++i) {
546	tx = h.pkts[pkt_idx + i].pkt;
547
548	tx->pkt_num = s->pn + i;
549	tx->pkt_space = QUIC_PN_SPACE_INITIAL;
550	tx->num_bytes = 123;
551	tx->largest_acked = QUIC_PN_INVALID;
552	tx->is_inflight = 1;
553	tx->is_ack_eliciting = 1;
554	tx->on_lost = on_lost;
555	tx->on_acked = on_acked;
556	tx->on_discarded = on_discarded;
557	tx->cb_arg = &h.pkts[pkt_idx + i];
558
559	fake_time = ossl_time_add(fake_time,
560	ossl_ticks2time(s->time_advance));
561	tx->time = fake_time;
562
563	if (!TEST_int_eq(ossl_ackm_on_tx_packet(h.ackm, tx), 1))
564	goto err;
565	}
566
567	pkt_idx += s->num_pn;
568	break;
569
570	case TX_ACK_TIME_OP_ACK:
571	ack.ack_ranges = &ack_range;
572	ack.num_ack_ranges = 1;
573
574	ack_range.start = s->pn;
575	ack_range.end = s->pn + s->num_pn;
576
577	fake_time = ossl_time_add(fake_time,
578	ossl_ticks2time(s->time_advance));
579
580	if (!TEST_int_eq(ossl_ackm_on_rx_ack_frame(h.ackm, &ack,
581	QUIC_PN_SPACE_INITIAL,
582	fake_time), 1))
583	goto err;
584
585	break;
586
587	case TX_ACK_TIME_OP_EXPECT:
588	for (i = 0; i < num_pkts; ++i) {
589	if (!TEST_int_eq(h.pkts[i].acked,
590	(s->expect[i] & 1) != 0 ? 1 : 0))
591	goto err;
592	if (!TEST_int_eq(h.pkts[i].lost,
593	(s->expect[i] & 2) != 0 ? 1 : 0))
594	goto err;
595	if (!TEST_int_eq(h.pkts[i].discarded,
596	(s->expect[i] & 4) != 0 ? 1 : 0))
597	goto err;
598	}
599
600	break;
601	}
602
603	testresult = 1;
604	err:
605	helper_destroy(&h);
606	return testresult;
607	}
608
609	/*
610	* RX ACK Test
611	* ******************************************************************
612	*/
613	enum {
614	RX_OPK_END,
615	RX_OPK_PKT, /* RX packet */
616	RX_OPK_CHECK_UNPROC, /* check PNs unprocessable */
617	RX_OPK_CHECK_PROC, /* check PNs processable */
618	RX_OPK_CHECK_STATE, /* check is_desired/deadline */
619	RX_OPK_CHECK_ACKS, /* check ACK ranges */
620	RX_OPK_TX, /* TX packet */
621	RX_OPK_RX_ACK, /* RX ACK frame */
622	RX_OPK_SKIP_IF_PN_SPACE /* skip for a given PN space */
623	};
624
625	struct rx_test_op {
626	int kind;
627	uint64_t time_advance;
628
629	QUIC_PN pn; /* PKT, CHECK_(UN)PROC, TX, RX_ACK */
630	size_t num_pn; /* PKT, CHECK_(UN)PROC, TX, RX_ACK */
631
632	char expect_desired; /* CHECK_STATE */
633	char expect_deadline; /* CHECK_STATE */
634
635	const OSSL_QUIC_ACK_RANGE ack_ranges; / CHECK_ACKS */
636	size_t num_ack_ranges; /* CHECK_ACKS */
637
638	QUIC_PN largest_acked; /* TX */
639	};
640
641	#define RX_OP_PKT(advance, pn, num_pn) \
642	{ \
643	RX_OPK_PKT, (advance) * OSSL_TIME_MS, (pn), (num_pn), \
644	0, 0, NULL, 0, 0 \
645	},
646
647	#define RX_OP_CHECK_UNPROC(advance, pn, num_pn) \
648	{ \
649	RX_OPK_CHECK_UNPROC, (advance) * OSSL_TIME_MS, (pn), (num_pn),\
650	0, 0, NULL, 0, 0 \
651	},
652
653	#define RX_OP_CHECK_PROC(advance, pn, num_pn) \
654	{ \
655	RX_OPK_CHECK_PROC, (advance) * OSSL_TIME_MS, (pn), (num_pn), \
656	0, 0, NULL, 0, 0 \
657	},
658
659	#define RX_OP_CHECK_STATE(advance, expect_desired, expect_deadline) \
660	{ \
661	RX_OPK_CHECK_STATE, (advance) * OSSL_TIME_MS, 0, 0, \
662	(expect_desired), (expect_deadline), NULL, 0, 0 \
663	},
664
665	#define RX_OP_CHECK_ACKS(advance, ack_ranges) \
666	{ \
667	RX_OPK_CHECK_ACKS, (advance) * OSSL_TIME_MS, 0, 0, \
668	0, 0, (ack_ranges), OSSL_NELEM(ack_ranges), 0 \
669	},
670
671	#define RX_OP_CHECK_NO_ACKS(advance) \
672	{ \
673	RX_OPK_CHECK_ACKS, (advance) * OSSL_TIME_MS, 0, 0, \
674	0, 0, NULL, 0, 0 \
675	},
676
677	#define RX_OP_TX(advance, pn, largest_acked) \
678	{ \
679	RX_OPK_TX, (advance) * OSSL_TIME_MS, (pn), 1, \
680	0, 0, NULL, 0, (largest_acked) \
681	},
682
683	#define RX_OP_RX_ACK(advance, pn, num_pn) \
684	{ \
685	RX_OPK_RX_ACK, (advance) * OSSL_TIME_MS, (pn), (num_pn), \
686	0, 0, NULL, 0, 0 \
687	},
688
689	#define RX_OP_SKIP_IF_PN_SPACE(pn_space) \
690	{ \
691	RX_OPK_SKIP_IF_PN_SPACE, 0, (pn_space), 0, \
692	0, 0, NULL, 0, 0 \
693	},
694
695	#define RX_OP_END \
696	{ RX_OPK_END }
697
698	/* RX 1. Simple Test with ACK Desired (Packet Threshold, Exactly) */
699	static const OSSL_QUIC_ACK_RANGE rx_ack_ranges_1a[] = {
700	{ 0, 1 }
701	};
702
703	static const struct rx_test_op rx_script_1[] = {
704	RX_OP_CHECK_STATE (0, 0, 0) /* no threshold yet */
705	RX_OP_CHECK_PROC (0, 0, 3)
706
707	RX_OP_PKT (0, 0, 2) /* two packets, threshold */
708	RX_OP_CHECK_UNPROC (0, 0, 2)
709	RX_OP_CHECK_PROC (0, 2, 1)
710	RX_OP_CHECK_STATE (0, 1, 0) /* threshold met, immediate */
711	RX_OP_CHECK_ACKS (0, rx_ack_ranges_1a)
712
713	/* At this point we would generate e.g. a packet with an ACK. */
714	RX_OP_TX (0, 0, 1) /* ACKs both */
715	RX_OP_CHECK_ACKS (0, rx_ack_ranges_1a) /* not provably ACKed yet */
716	RX_OP_RX_ACK (0, 0, 1) /* TX'd packet is ACK'd */
717
718	RX_OP_CHECK_NO_ACKS (0) /* nothing more to ACK */
719	RX_OP_CHECK_UNPROC (0, 0, 2) /* still unprocessable */
720	RX_OP_CHECK_PROC (0, 2, 1) /* still processable */
721
722	RX_OP_END
723	};
724
725	/* RX 2. Simple Test with ACK Not Yet Desired (Packet Threshold) (1-RTT) */
726	static const OSSL_QUIC_ACK_RANGE rx_ack_ranges_2a[] = {
727	{ 0, 0 }
728	};
729
730	static const OSSL_QUIC_ACK_RANGE rx_ack_ranges_2b[] = {
731	{ 0, 2 }
732	};
733
734	static const struct rx_test_op rx_script_2[] = {
735	/*
736	* We skip this for INITIAL/HANDSHAKE and use a separate version
737	* (rx_script_4) for those spaces as those spaces should not delay ACK
738	* generation, so a different RX_OP_CHECK_STATE test is needed.
739	*/
740	RX_OP_SKIP_IF_PN_SPACE(QUIC_PN_SPACE_INITIAL)
741	RX_OP_SKIP_IF_PN_SPACE(QUIC_PN_SPACE_HANDSHAKE)
742
743	RX_OP_CHECK_STATE (0, 0, 0) /* no threshold yet */
744	RX_OP_CHECK_PROC (0, 0, 3)
745
746	/* First packet always generates an ACK so get it out of the way. */
747	RX_OP_PKT (0, 0, 1)
748	RX_OP_CHECK_UNPROC (0, 0, 1)
749	RX_OP_CHECK_PROC (0, 1, 1)
750	RX_OP_CHECK_STATE (0, 1, 0) /* first packet always causes ACK */
751	RX_OP_CHECK_ACKS (0, rx_ack_ranges_2a) /* clears packet counter */
752	RX_OP_CHECK_STATE (0, 0, 0) /* desired state should have been cleared */
753
754	/* Second packet should not cause ACK-desired state */
755	RX_OP_PKT (0, 1, 1) /* just one packet, threshold is 2 */
756	RX_OP_CHECK_UNPROC (0, 0, 2)
757	RX_OP_CHECK_PROC (0, 2, 1)
758	RX_OP_CHECK_STATE (0, 0, 1) /* threshold not yet met, so deadline */
759	/* Don't check ACKs here, as it would reset our threshold counter. */
760
761	/* Now receive a second packet, triggering the threshold */
762	RX_OP_PKT (0, 2, 1) /* second packet meets threshold */
763	RX_OP_CHECK_UNPROC (0, 0, 3)
764	RX_OP_CHECK_PROC (0, 3, 1)
765	RX_OP_CHECK_STATE (0, 1, 0) /* desired immediately */
766	RX_OP_CHECK_ACKS (0, rx_ack_ranges_2b)
767
768	/* At this point we would generate e.g. a packet with an ACK. */
769	RX_OP_TX (0, 0, 2) /* ACKs all */
770	RX_OP_CHECK_ACKS (0, rx_ack_ranges_2b) /* not provably ACKed yet */
771	RX_OP_RX_ACK (0, 0, 1) /* TX'd packet is ACK'd */
772
773	RX_OP_CHECK_NO_ACKS (0) /* nothing more to ACK */
774	RX_OP_CHECK_UNPROC (0, 0, 3) /* still unprocessable */
775	RX_OP_CHECK_PROC (0, 3, 1) /* still processable */
776
777	RX_OP_END
778	};
779
780	/* RX 3. Simple Test with ACK Desired (Packet Threshold, Multiple Watermarks) */
781	static const OSSL_QUIC_ACK_RANGE rx_ack_ranges_3a[] = {
782	{ 0, 0 }
783	};
784
785	static const OSSL_QUIC_ACK_RANGE rx_ack_ranges_3b[] = {
786	{ 0, 10 }
787	};
788
789	static const OSSL_QUIC_ACK_RANGE rx_ack_ranges_3c[] = {
790	{ 6, 10 }
791	};
792
793	static const struct rx_test_op rx_script_3[] = {
794	RX_OP_CHECK_STATE (0, 0, 0) /* no threshold yet */
795	RX_OP_CHECK_PROC (0, 0, 11)
796
797	/* First packet always generates an ACK so get it out of the way. */
798	RX_OP_PKT (0, 0, 1)
799	RX_OP_CHECK_UNPROC (0, 0, 1)
800	RX_OP_CHECK_PROC (0, 1, 1)
801	RX_OP_CHECK_STATE (0, 1, 0) /* first packet always causes ACK */
802	RX_OP_CHECK_ACKS (0, rx_ack_ranges_3a) /* clears packet counter */
803	RX_OP_CHECK_STATE (0, 0, 0) /* desired state should have been cleared */
804
805	/* Generate ten packets, exceeding the threshold. */
806	RX_OP_PKT (0, 1, 10) /* ten packets, threshold is 2 */
807	RX_OP_CHECK_UNPROC (0, 0, 11)
808	RX_OP_CHECK_PROC (0, 11, 1)
809	RX_OP_CHECK_STATE (0, 1, 0) /* threshold met, immediate */
810	RX_OP_CHECK_ACKS (0, rx_ack_ranges_3b)
811
812	/*
813	* Test TX'ing a packet which doesn't ACK anything.
814	*/
815	RX_OP_TX (0, 0, QUIC_PN_INVALID)
816	RX_OP_RX_ACK (0, 0, 1)
817
818	/*
819	* At this point we would generate a packet with an ACK immediately.
820	* TX a packet which when ACKed makes [0,5] provably ACKed.
821	*/
822	RX_OP_TX (0, 1, 5)
823	RX_OP_CHECK_ACKS (0, rx_ack_ranges_3b) /* not provably ACKed yet */
824	RX_OP_RX_ACK (0, 1, 1)
825
826	RX_OP_CHECK_ACKS (0, rx_ack_ranges_3c) /* provably ACKed now gone */
827	RX_OP_CHECK_UNPROC (0, 0, 11) /* still unprocessable */
828	RX_OP_CHECK_PROC (0, 11, 1) /* still processable */
829
830	/*
831	* Now TX another packet which provably ACKs the rest when ACKed.
832	*/
833	RX_OP_TX (0, 2, 10)
834	RX_OP_CHECK_ACKS (0, rx_ack_ranges_3c) /* not provably ACKed yet */
835	RX_OP_RX_ACK (0, 2, 1)
836
837	RX_OP_CHECK_NO_ACKS (0) /* provably ACKed now gone */
838	RX_OP_CHECK_UNPROC (0, 0, 11) /* still unprocessable */
839	RX_OP_CHECK_PROC (0, 11, 1) /* still processable */
840
841	RX_OP_END
842	};
843
844	/*
845	* RX 4. Simple Test with ACK Not Yet Desired (Packet Threshold)
846	* (Initial/Handshake)
847	*/
848	static const OSSL_QUIC_ACK_RANGE rx_ack_ranges_4a[] = {
849	{ 0, 1 }
850	};
851
852	static const struct rx_test_op rx_script_4[] = {
853	/* The application PN space is tested in rx_script_2. */
854	RX_OP_SKIP_IF_PN_SPACE(QUIC_PN_SPACE_APP)
855
856	RX_OP_CHECK_STATE (0, 0, 0) /* no threshold yet */
857	RX_OP_CHECK_PROC (0, 0, 3)
858
859	/* First packet always generates an ACK so get it out of the way. */
860	RX_OP_PKT (0, 0, 1)
861	RX_OP_CHECK_UNPROC (0, 0, 1)
862	RX_OP_CHECK_PROC (0, 1, 1)
863	RX_OP_CHECK_STATE (0, 1, 0) /* first packet always causes ACK */
864	RX_OP_CHECK_ACKS (0, rx_ack_ranges_2a) /* clears packet counter */
865	RX_OP_CHECK_STATE (0, 0, 0) /* desired state should have been cleared */
866
867	/*
868	* Second packet should cause ACK-desired state because we are
869	* INITIAL/HANDSHAKE (RFC 9000 s. 13.2.1)
870	*/
871	RX_OP_PKT (0, 1, 1) /* just one packet, threshold is 2 */
872	RX_OP_CHECK_UNPROC (0, 0, 2)
873	RX_OP_CHECK_PROC (0, 2, 1)
874	RX_OP_CHECK_STATE (0, 1, 1)
875	RX_OP_CHECK_ACKS (0, rx_ack_ranges_4a)
876	RX_OP_CHECK_STATE (0, 0, 0) /* desired state should have been cleared */
877
878	/* At this point we would generate e.g. a packet with an ACK. */
879	RX_OP_TX (0, 0, 1) /* ACKs all */
880	RX_OP_CHECK_ACKS (0, rx_ack_ranges_4a) /* not provably ACKed yet */
881	RX_OP_RX_ACK (0, 0, 1) /* TX'd packet is ACK'd */
882
883	RX_OP_CHECK_NO_ACKS (0) /* nothing more to ACK */
884	RX_OP_CHECK_UNPROC (0, 0, 2) /* still unprocessable */
885	RX_OP_CHECK_PROC (0, 2, 1) /* still processable */
886
887	RX_OP_END
888	};
889
890	static const struct rx_test_op *const rx_test_scripts[] = {
891	rx_script_1,
892	rx_script_2,
893	rx_script_3,
894	rx_script_4
895	};
896
897	static void on_ack_deadline_callback(OSSL_TIME deadline,
898	int pkt_space, void *arg)
899	{
900	((OSSL_TIME *)arg)[pkt_space] = deadline;
901	}
902
903	static int test_rx_ack_actual(int tidx, int space)
904	{
905	int testresult = 0;
906	struct helper h;
907	const struct rx_test_op script = rx_test_scripts[tidx], s;
908	size_t i, num_tx = 0, txi = 0;
909	const OSSL_QUIC_FRAME_ACK *ack;
910	OSSL_QUIC_FRAME_ACK rx_ack = {0};
911	OSSL_QUIC_ACK_RANGE rx_ack_range = {0};
912	struct pkt_info *pkts = NULL;
913	OSSL_ACKM_TX_PKT txs = NULL, tx;
914	OSSL_TIME ack_deadline[QUIC_PN_SPACE_NUM];
915	size_t opn = 0;
916
917	for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
918	ack_deadline[i] = ossl_time_infinite();
919
920	/* Initialise ACK manager. */
921	if (!TEST_int_eq(helper_init(&h, 0), 1))
922	goto err;
923
924	/* Arm callback for testing. */
925	ossl_ackm_set_ack_deadline_callback(h.ackm, on_ack_deadline_callback,
926	ack_deadline);
927
928	/*
929	* Determine how many packets we are TXing, and therefore how many packet
930	* structures we need.
931	*/
932	for (s = script; s->kind != RX_OPK_END; ++s)
933	if (s->kind == RX_OPK_TX)
934	num_tx += s->num_pn;
935
936	/* Allocate packet information structures. */
937	txs = OPENSSL_zalloc(sizeof(txs) num_tx);
938	if (!TEST_ptr(txs))
939	goto err;
940
941	pkts = OPENSSL_zalloc(sizeof(pkts) num_tx);
942	if (!TEST_ptr(pkts))
943	goto err;
944
945	/* Run script. */
946	for (s = script; s->kind != RX_OPK_END; ++s, ++opn) {
947	fake_time = ossl_time_add(fake_time,
948	ossl_ticks2time(s->time_advance));
949	switch (s->kind) {
950	case RX_OPK_PKT:
951	for (i = 0; i < s->num_pn; ++i) {
952	OSSL_ACKM_RX_PKT pkt = {0};
953
954	pkt.pkt_num = s->pn + i;
955	pkt.time = fake_time;
956	pkt.pkt_space = space;
957	pkt.is_ack_eliciting = 1;
958
959	/* The packet should be processable before we feed it. */
960	if (!TEST_int_eq(ossl_ackm_is_rx_pn_processable(h.ackm,
961	pkt.pkt_num,
962	pkt.pkt_space), 1))
963	goto err;
964
965	if (!TEST_int_eq(ossl_ackm_on_rx_packet(h.ackm, &pkt), 1))
966	goto err;
967	}
968
969	break;
970
971	case RX_OPK_CHECK_UNPROC:
972	case RX_OPK_CHECK_PROC:
973	for (i = 0; i < s->num_pn; ++i)
974	if (!TEST_int_eq(ossl_ackm_is_rx_pn_processable(h.ackm,
975	s->pn + i, space),
976	(s->kind == RX_OPK_CHECK_PROC)))
977	goto err;
978
979	break;
980
981	case RX_OPK_CHECK_STATE:
982	if (!TEST_int_eq(ossl_ackm_is_ack_desired(h.ackm, space),
983	s->expect_desired))
984	goto err;
985
986	if (!TEST_int_eq(!ossl_time_is_infinite(ossl_ackm_get_ack_deadline(h.ackm, space))
987	&& !ossl_time_is_zero(ossl_ackm_get_ack_deadline(h.ackm, space)),
988	s->expect_deadline))
989	goto err;
990
991	for (i = 0; i < QUIC_PN_SPACE_NUM; ++i) {
992	if (i != (size_t)space
993	&& !TEST_true(ossl_time_is_infinite(ossl_ackm_get_ack_deadline(h.ackm, i))))
994	goto err;
995
996	if (!TEST_int_eq(ossl_time_compare(ossl_ackm_get_ack_deadline(h.ackm, i),
997	ack_deadline[i]), 0))
998	goto err;
999	}
1000
1001	break;
1002
1003	case RX_OPK_CHECK_ACKS:
1004	ack = ossl_ackm_get_ack_frame(h.ackm, space);
1005
1006	/* Should always be able to get an ACK frame. */
1007	if (!TEST_ptr(ack))
1008	goto err;
1009
1010	if (!TEST_size_t_eq(ack->num_ack_ranges, s->num_ack_ranges))
1011	goto err;
1012
1013	for (i = 0; i < ack->num_ack_ranges; ++i) {
1014	if (!TEST_uint64_t_eq(ack->ack_ranges[i].start,
1015	s->ack_ranges[i].start))
1016	goto err;
1017	if (!TEST_uint64_t_eq(ack->ack_ranges[i].end,
1018	s->ack_ranges[i].end))
1019	goto err;
1020	}
1021
1022	break;
1023
1024	case RX_OPK_TX:
1025	pkts[txi].pkt = tx = &txs[txi];
1026
1027	tx->pkt_num = s->pn;
1028	tx->pkt_space = space;
1029	tx->num_bytes = 123;
1030	tx->largest_acked = s->largest_acked;
1031	tx->is_inflight = 1;
1032	tx->is_ack_eliciting = 1;
1033	tx->on_lost = on_lost;
1034	tx->on_acked = on_acked;
1035	tx->on_discarded = on_discarded;
1036	tx->cb_arg = &pkts[txi];
1037	tx->time = fake_time;
1038
1039	if (!TEST_int_eq(ossl_ackm_on_tx_packet(h.ackm, tx), 1))
1040	goto err;
1041
1042	++txi;
1043	break;
1044
1045	case RX_OPK_RX_ACK:
1046	rx_ack.ack_ranges = &rx_ack_range;
1047	rx_ack.num_ack_ranges = 1;
1048
1049	rx_ack_range.start = s->pn;
1050	rx_ack_range.end = s->pn + s->num_pn - 1;
1051
1052	if (!TEST_int_eq(ossl_ackm_on_rx_ack_frame(h.ackm, &rx_ack,
1053	space, fake_time), 1))
1054	goto err;
1055
1056	break;
1057
1058	case RX_OPK_SKIP_IF_PN_SPACE:
1059	if (space == (int)s->pn) {
1060	testresult = 1;
1061	goto err;
1062	}
1063
1064	break;
1065
1066	default:
1067	goto err;
1068	}
1069	}
1070
1071	testresult = 1;
1072	err:
1073	if (!testresult)
1074	TEST_error("error in ACKM RX script %d, op %zu", tidx + 1, opn + 1);
1075
1076	helper_destroy(&h);
1077	OPENSSL_free(pkts);
1078	OPENSSL_free(txs);
1079	return testresult;
1080	}
1081
1082	/*
1083	* Driver
1084	* ******************************************************************
1085	*/
1086	static int test_tx_ack_case(int idx)
1087	{
1088	int tidx, space;
1089
1090	tidx = idx % OSSL_NELEM(tx_ack_cases);
1091	idx /= OSSL_NELEM(tx_ack_cases);
1092
1093	space = idx % QUIC_PN_SPACE_NUM;
1094	idx /= QUIC_PN_SPACE_NUM;
1095
1096	return test_tx_ack_case_actual(tidx, space, idx);
1097	}
1098
1099	static int test_rx_ack(int idx)
1100	{
1101	int tidx;
1102
1103	tidx = idx % OSSL_NELEM(rx_test_scripts);
1104	idx /= OSSL_NELEM(rx_test_scripts);
1105
1106	return test_rx_ack_actual(tidx, idx);
1107	}
1108
1109	int setup_tests(void)
1110	{
1111	ADD_ALL_TESTS(test_tx_ack_case,
1112	OSSL_NELEM(tx_ack_cases) * MODE_NUM * QUIC_PN_SPACE_NUM);
1113	ADD_ALL_TESTS(test_tx_ack_time_script, OSSL_NELEM(tx_ack_time_scripts));
1114	ADD_ALL_TESTS(test_rx_ack, OSSL_NELEM(rx_test_scripts) * QUIC_PN_SPACE_NUM);
1115	return 1;
1116	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.3.2/test/quic_ackm_test.c@ 108206

Download in other formats: