/src/openssl33/ssl/quic/quic_cfq.c

Source
/*
 * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include "internal/quic_cfq.h"
#include "internal/numbers.h"

typedef struct quic_cfq_item_ex_st QUIC_CFQ_ITEM_EX;

struct quic_cfq_item_ex_st {
    QUIC_CFQ_ITEM public;
    QUIC_CFQ_ITEM_EX *prev, *next;
    unsigned char *encoded;
    cfq_free_cb *free_cb;
    void *free_cb_arg;
    uint64_t frame_type;
    size_t encoded_len;
    uint32_t priority, pn_space, flags;
    int state;
};

uint64_t ossl_quic_cfq_item_get_frame_type(const QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    return ex->frame_type;
}

const unsigned char *ossl_quic_cfq_item_get_encoded(const QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    return ex->encoded;
}

size_t ossl_quic_cfq_item_get_encoded_len(const QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    return ex->encoded_len;
}

int ossl_quic_cfq_item_get_state(const QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    return ex->state;
}

uint32_t ossl_quic_cfq_item_get_pn_space(const QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    return ex->pn_space;
}

int ossl_quic_cfq_item_is_unreliable(const QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    return (ex->flags & QUIC_CFQ_ITEM_FLAG_UNRELIABLE) != 0;
}

typedef struct quic_cfq_item_list_st {
    QUIC_CFQ_ITEM_EX *head, *tail;
} QUIC_CFQ_ITEM_LIST;

struct quic_cfq_st {
    /*
     * Invariant: A CFQ item is always in exactly one of these lists, never more
     * or less than one.
     *
     * Invariant: The list the CFQ item is determined exactly by the state field
     * of the item.
     */
    QUIC_CFQ_ITEM_LIST new_list, tx_list, free_list;
};

static int compare(const QUIC_CFQ_ITEM_EX *a, const QUIC_CFQ_ITEM_EX *b)
{
    if (a->pn_space < b->pn_space)
        return -1;
    else if (a->pn_space > b->pn_space)
        return 1;

    if (a->priority > b->priority)
        return -1;
    else if (a->priority < b->priority)
        return 1;

    return 0;
}

static void list_remove(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n)
{
    if (l->head == n)
        l->head = n->next;
    if (l->tail == n)
        l->tail = n->prev;
    if (n->prev != NULL)
        n->prev->next = n->next;
    if (n->next != NULL)
        n->next->prev = n->prev;
    n->prev = n->next = NULL;
}

static void list_insert_head(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n)
{
    n->next = l->head;
    n->prev = NULL;
    l->head = n;
    if (n->next != NULL)
        n->next->prev = n;
    if (l->tail == NULL)
        l->tail = n;
}

static void list_insert_tail(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n)
{
    n->prev = l->tail;
    n->next = NULL;
    l->tail = n;
    if (n->prev != NULL)
        n->prev->next = n;
    if (l->head == NULL)
        l->head = n;
}

static void list_insert_after(QUIC_CFQ_ITEM_LIST *l,
    QUIC_CFQ_ITEM_EX *ref,
    QUIC_CFQ_ITEM_EX *n)
{
    n->prev = ref;
    n->next = ref->next;
    if (ref->next != NULL)
        ref->next->prev = n;
    ref->next = n;
    if (l->tail == ref)
        l->tail = n;
}

static void list_insert_sorted(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n,
    int (*cmp)(const QUIC_CFQ_ITEM_EX *a,
        const QUIC_CFQ_ITEM_EX *b))
{
    QUIC_CFQ_ITEM_EX *p = l->head, *pprev = NULL;

    if (p == NULL) {
        l->head = l->tail = n;
        n->prev = n->next = NULL;
        return;
    }

    for (; p != NULL && cmp(p, n) < 0; pprev = p, p = p->next)
        ;

    if (p == NULL)
        list_insert_tail(l, n);
    else if (pprev == NULL)
        list_insert_head(l, n);
    else
        list_insert_after(l, pprev, n);
}

QUIC_CFQ *ossl_quic_cfq_new(void)
{
    QUIC_CFQ *cfq = OPENSSL_zalloc(sizeof(*cfq));

    if (cfq == NULL)
        return NULL;

    return cfq;
}

static void clear_item(QUIC_CFQ_ITEM_EX *item)
{
    if (item->free_cb != NULL) {
        item->free_cb(item->encoded, item->encoded_len, item->free_cb_arg);

        item->free_cb = NULL;
        item->encoded = NULL;
        item->encoded_len = 0;
    }

    item->state = -1;
}

static void free_list_items(QUIC_CFQ_ITEM_LIST *l)
{
    QUIC_CFQ_ITEM_EX *p, *pnext;

    for (p = l->head; p != NULL; p = pnext) {
        pnext = p->next;
        clear_item(p);
        OPENSSL_free(p);
    }
}

void ossl_quic_cfq_free(QUIC_CFQ *cfq)
{
    if (cfq == NULL)
        return;

    free_list_items(&cfq->new_list);
    free_list_items(&cfq->tx_list);
    free_list_items(&cfq->free_list);
    OPENSSL_free(cfq);
}

static QUIC_CFQ_ITEM_EX *cfq_get_free(QUIC_CFQ *cfq)
{
    QUIC_CFQ_ITEM_EX *item = cfq->free_list.head;

    if (item != NULL)
        return item;

    item = OPENSSL_zalloc(sizeof(*item));
    if (item == NULL)
        return NULL;

    item->state = -1;
    list_insert_tail(&cfq->free_list, item);
    return item;
}

QUIC_CFQ_ITEM *ossl_quic_cfq_add_frame(QUIC_CFQ *cfq,
    uint32_t priority,
    uint32_t pn_space,
    uint64_t frame_type,
    uint32_t flags,
    const unsigned char *encoded,
    size_t encoded_len,
    cfq_free_cb *free_cb,
    void *free_cb_arg)
{
    QUIC_CFQ_ITEM_EX *item = cfq_get_free(cfq);

    if (item == NULL)
        return NULL;

    item->priority = priority;
    item->frame_type = frame_type;
    item->pn_space = pn_space;
    item->encoded = (unsigned char *)encoded;
    item->encoded_len = encoded_len;
    item->free_cb = free_cb;
    item->free_cb_arg = free_cb_arg;

    item->state = QUIC_CFQ_STATE_NEW;
    item->flags = flags;
    list_remove(&cfq->free_list, item);
    list_insert_sorted(&cfq->new_list, item, compare);
    return &item->public;
}

void ossl_quic_cfq_mark_tx(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    switch (ex->state) {
    case QUIC_CFQ_STATE_NEW:
        list_remove(&cfq->new_list, ex);
        list_insert_tail(&cfq->tx_list, ex);
        ex->state = QUIC_CFQ_STATE_TX;
        break;
    case QUIC_CFQ_STATE_TX:
        break; /* nothing to do */
    default:
        assert(0); /* invalid state (e.g. in free state) */
        break;
    }
}

void ossl_quic_cfq_mark_lost(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item,
    uint32_t priority)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    if (ossl_quic_cfq_item_is_unreliable(item)) {
        ossl_quic_cfq_release(cfq, item);
        return;
    }

    switch (ex->state) {
    case QUIC_CFQ_STATE_NEW:
        if (priority != UINT32_MAX && priority != ex->priority) {
            list_remove(&cfq->new_list, ex);
            ex->priority = priority;
            list_insert_sorted(&cfq->new_list, ex, compare);
        }
        break; /* nothing to do */
    case QUIC_CFQ_STATE_TX:
        if (priority != UINT32_MAX)
            ex->priority = priority;
        list_remove(&cfq->tx_list, ex);
        list_insert_sorted(&cfq->new_list, ex, compare);
        ex->state = QUIC_CFQ_STATE_NEW;
        break;
    default:
        assert(0); /* invalid state (e.g. in free state) */
        break;
    }
}

/*
 * Releases a CFQ item. The item may be in either state (NEW or TX) prior to the
 * call. The QUIC_CFQ_ITEM pointer must not be used following this call.
 */
void ossl_quic_cfq_release(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    switch (ex->state) {
    case QUIC_CFQ_STATE_NEW:
        list_remove(&cfq->new_list, ex);
        list_insert_tail(&cfq->free_list, ex);
        clear_item(ex);
        break;
    case QUIC_CFQ_STATE_TX:
        list_remove(&cfq->tx_list, ex);
        list_insert_tail(&cfq->free_list, ex);
        clear_item(ex);
        break;
    default:
        assert(0); /* invalid state (e.g. in free state) */
        break;
    }
}

QUIC_CFQ_ITEM *ossl_quic_cfq_get_priority_head(const QUIC_CFQ *cfq,
    uint32_t pn_space)
{
    QUIC_CFQ_ITEM_EX *item = cfq->new_list.head;

    for (; item != NULL && item->pn_space != pn_space; item = item->next)
        ;

    if (item == NULL)
        return NULL;

    return &item->public;
}

QUIC_CFQ_ITEM *ossl_quic_cfq_item_get_priority_next(const QUIC_CFQ_ITEM *item,
    uint32_t pn_space)
{
    QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;

    if (ex == NULL)
        return NULL;

    ex = ex->next;

    for (; ex != NULL && ex->pn_space != pn_space; ex = ex->next)
        ;

    if (ex == NULL)
        return NULL; /* ubsan */

    return &ex->public;
}

Coverage Report

Created: 2026-02-14 07:20

Line	Count	Source
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 "internal/quic_cfq.h"
11		#include "internal/numbers.h"
12
13		typedef struct quic_cfq_item_ex_st QUIC_CFQ_ITEM_EX;
14
15		struct quic_cfq_item_ex_st {
16		QUIC_CFQ_ITEM public;
17		QUIC_CFQ_ITEM_EX prev, next;
18		unsigned char *encoded;
19		cfq_free_cb *free_cb;
20		void *free_cb_arg;
21		uint64_t frame_type;
22		size_t encoded_len;
23		uint32_t priority, pn_space, flags;
24		int state;
25		};
26
27		uint64_t ossl_quic_cfq_item_get_frame_type(const QUIC_CFQ_ITEM *item)
28	224M	{
29	224M	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
30
31	224M	return ex->frame_type;
32	224M	}
33
34		const unsigned char ossl_quic_cfq_item_get_encoded(const QUIC_CFQ_ITEM item)
35	215M	{
36	215M	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
37
38	215M	return ex->encoded;
39	215M	}
40
41		size_t ossl_quic_cfq_item_get_encoded_len(const QUIC_CFQ_ITEM *item)
42	215M	{
43	215M	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
44
45	215M	return ex->encoded_len;
46	215M	}
47
48		int ossl_quic_cfq_item_get_state(const QUIC_CFQ_ITEM *item)
49	0	{
50	0	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
51
52	0	return ex->state;
53	0	}
54
55		uint32_t ossl_quic_cfq_item_get_pn_space(const QUIC_CFQ_ITEM *item)
56	0	{
57	0	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
58
59	0	return ex->pn_space;
60	0	}
61
62		int ossl_quic_cfq_item_is_unreliable(const QUIC_CFQ_ITEM *item)
63	54.5k	{
64	54.5k	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
65
66	54.5k	return (ex->flags & QUIC_CFQ_ITEM_FLAG_UNRELIABLE) != 0;
67	54.5k	}
68
69		typedef struct quic_cfq_item_list_st {
70		QUIC_CFQ_ITEM_EX head, tail;
71		} QUIC_CFQ_ITEM_LIST;
72
73		struct quic_cfq_st {
74		/*
75		* Invariant: A CFQ item is always in exactly one of these lists, never more
76		* or less than one.
77		*
78		* Invariant: The list the CFQ item is determined exactly by the state field
79		* of the item.
80		*/
81		QUIC_CFQ_ITEM_LIST new_list, tx_list, free_list;
82		};
83
84		static int compare(const QUIC_CFQ_ITEM_EX a, const QUIC_CFQ_ITEM_EX b)
85	456k	{
86	456k	if (a->pn_space < b->pn_space)
87	0	return -1;
88	456k	else if (a->pn_space > b->pn_space)
89	0	return 1;
90
91	456k	if (a->priority > b->priority)
92	190k	return -1;
93	265k	else if (a->priority < b->priority)
94	1.52k	return 1;
95
96	264k	return 0;
97	456k	}
98
99		static void list_remove(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n)
100	779k	{
101	779k	if (l->head == n)
102	529k	l->head = n->next;
103	779k	if (l->tail == n)
104	405k	l->tail = n->prev;
105	779k	if (n->prev != NULL)
106	250k	n->prev->next = n->next;
107	779k	if (n->next != NULL)
108	373k	n->next->prev = n->prev;
109	779k	n->prev = n->next = NULL;
110	779k	}
111
112		static void list_insert_head(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n)
113	175k	{
114	175k	n->next = l->head;
115	175k	n->prev = NULL;
116	175k	l->head = n;
117	175k	if (n->next != NULL)
118	175k	n->next->prev = n;
119	175k	if (l->tail == NULL)
120	0	l->tail = n;
121	175k	}
122
123		static void list_insert_tail(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n)
124	749k	{
125	749k	n->prev = l->tail;
126	749k	n->next = NULL;
127	749k	l->tail = n;
128	749k	if (n->prev != NULL)
129	489k	n->prev->next = n;
130	749k	if (l->head == NULL)
131	259k	l->head = n;
132	749k	}
133
134		static void list_insert_after(QUIC_CFQ_ITEM_LIST *l,
135		QUIC_CFQ_ITEM_EX *ref,
136		QUIC_CFQ_ITEM_EX *n)
137	90.6k	{
138	90.6k	n->prev = ref;
139	90.6k	n->next = ref->next;
140	90.6k	if (ref->next != NULL)
141	90.6k	ref->next->prev = n;
142	90.6k	ref->next = n;
143	90.6k	if (l->tail == ref)
144	0	l->tail = n;
145	90.6k	}
146
147		static void list_insert_sorted(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n,
148		int (cmp)(const QUIC_CFQ_ITEM_EX a,
149		const QUIC_CFQ_ITEM_EX *b))
150	279k	{
151	279k	QUIC_CFQ_ITEM_EX p = l->head, pprev = NULL;
152
153	279k	if (p == NULL) {
154	10.9k	l->head = l->tail = n;
155	10.9k	n->prev = n->next = NULL;
156	10.9k	return;
157	10.9k	}
158
159	458k	for (; p != NULL && cmp(p, n) < 0; pprev = p, p = p->next)
160	190k	;
161
162	268k	if (p == NULL)
163	2.18k	list_insert_tail(l, n);
164	265k	else if (pprev == NULL)
165	175k	list_insert_head(l, n);
166	90.6k	else
167	90.6k	list_insert_after(l, pprev, n);
168	268k	}
169
170		QUIC_CFQ *ossl_quic_cfq_new(void)
171	51.3k	{
172	51.3k	QUIC_CFQ cfq = OPENSSL_zalloc(sizeof(cfq));
173
174	51.3k	if (cfq == NULL)
175	0	return NULL;
176
177	51.3k	return cfq;
178	51.3k	}
179
180		static void clear_item(QUIC_CFQ_ITEM_EX *item)
181	494k	{
182	494k	if (item->free_cb != NULL) {
183	272k	item->free_cb(item->encoded, item->encoded_len, item->free_cb_arg);
184
185	272k	item->free_cb = NULL;
186	272k	item->encoded = NULL;
187	272k	item->encoded_len = 0;
188	272k	}
189
190	494k	item->state = -1;
191	494k	}
192
193		static void free_list_items(QUIC_CFQ_ITEM_LIST *l)
194	154k	{
195	154k	QUIC_CFQ_ITEM_EX p, pnext;
196
197	401k	for (p = l->head; p != NULL; p = pnext) {
198	247k	pnext = p->next;
199	247k	clear_item(p);
200	247k	OPENSSL_free(p);
201	247k	}
202	154k	}
203
204		void ossl_quic_cfq_free(QUIC_CFQ *cfq)
205	51.3k	{
206	51.3k	if (cfq == NULL)
207	0	return;
208
209	51.3k	free_list_items(&cfq->new_list);
210	51.3k	free_list_items(&cfq->tx_list);
211	51.3k	free_list_items(&cfq->free_list);
212	51.3k	OPENSSL_free(cfq);
213	51.3k	}
214
215		static QUIC_CFQ_ITEM_EX cfq_get_free(QUIC_CFQ cfq)
216	272k	{
217	272k	QUIC_CFQ_ITEM_EX *item = cfq->free_list.head;
218
219	272k	if (item != NULL)
220	25.9k	return item;
221
222	247k	item = OPENSSL_zalloc(sizeof(*item));
223	247k	if (item == NULL)
224	0	return NULL;
225
226	247k	item->state = -1;
227	247k	list_insert_tail(&cfq->free_list, item);
228	247k	return item;
229	247k	}
230
231		QUIC_CFQ_ITEM ossl_quic_cfq_add_frame(QUIC_CFQ cfq,
232		uint32_t priority,
233		uint32_t pn_space,
234		uint64_t frame_type,
235		uint32_t flags,
236		const unsigned char *encoded,
237		size_t encoded_len,
238		cfq_free_cb *free_cb,
239		void *free_cb_arg)
240	272k	{
241	272k	QUIC_CFQ_ITEM_EX *item = cfq_get_free(cfq);
242
243	272k	if (item == NULL)
244	0	return NULL;
245
246	272k	item->priority = priority;
247	272k	item->frame_type = frame_type;
248	272k	item->pn_space = pn_space;
249	272k	item->encoded = (unsigned char *)encoded;
250	272k	item->encoded_len = encoded_len;
251	272k	item->free_cb = free_cb;
252	272k	item->free_cb_arg = free_cb_arg;
253
254	272k	item->state = QUIC_CFQ_STATE_NEW;
255	272k	item->flags = flags;
256	272k	list_remove(&cfq->free_list, item);
257	272k	list_insert_sorted(&cfq->new_list, item, compare);
258	272k	return &item->public;
259	272k	}
260
261		void ossl_quic_cfq_mark_tx(QUIC_CFQ cfq, QUIC_CFQ_ITEM item)
262	253k	{
263	253k	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
264
265	253k	switch (ex->state) {
266	253k	case QUIC_CFQ_STATE_NEW:
267	253k	list_remove(&cfq->new_list, ex);
268	253k	list_insert_tail(&cfq->tx_list, ex);
269	253k	ex->state = QUIC_CFQ_STATE_TX;
270	253k	break;
271	0	case QUIC_CFQ_STATE_TX:
272	0	break; /* nothing to do */
273	0	default:
274	0	assert(0); /* invalid state (e.g. in free state) */
275	0	break;
276	253k	}
277	253k	}
278
279		void ossl_quic_cfq_mark_lost(QUIC_CFQ cfq, QUIC_CFQ_ITEM item,
280		uint32_t priority)
281	54.5k	{
282	54.5k	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
283
284	54.5k	if (ossl_quic_cfq_item_is_unreliable(item)) {
285	48.5k	ossl_quic_cfq_release(cfq, item);
286	48.5k	return;
287	48.5k	}
288
289	6.02k	switch (ex->state) {
290	0	case QUIC_CFQ_STATE_NEW:
291	0	if (priority != UINT32_MAX && priority != ex->priority) {
292	0	list_remove(&cfq->new_list, ex);
293	0	ex->priority = priority;
294	0	list_insert_sorted(&cfq->new_list, ex, compare);
295	0	}
296	0	break; /* nothing to do */
297	6.02k	case QUIC_CFQ_STATE_TX:
298	6.02k	if (priority != UINT32_MAX)
299	0	ex->priority = priority;
300	6.02k	list_remove(&cfq->tx_list, ex);
301	6.02k	list_insert_sorted(&cfq->new_list, ex, compare);
302	6.02k	ex->state = QUIC_CFQ_STATE_NEW;
303	6.02k	break;
304	0	default:
305	0	assert(0); /* invalid state (e.g. in free state) */
306	0	break;
307	6.02k	}
308	6.02k	}
309
310		/*
311		* Releases a CFQ item. The item may be in either state (NEW or TX) prior to the
312		* call. The QUIC_CFQ_ITEM pointer must not be used following this call.
313		*/
314		void ossl_quic_cfq_release(QUIC_CFQ cfq, QUIC_CFQ_ITEM item)
315	247k	{
316	247k	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
317
318	247k	switch (ex->state) {
319	0	case QUIC_CFQ_STATE_NEW:
320	0	list_remove(&cfq->new_list, ex);
321	0	list_insert_tail(&cfq->free_list, ex);
322	0	clear_item(ex);
323	0	break;
324	247k	case QUIC_CFQ_STATE_TX:
325	247k	list_remove(&cfq->tx_list, ex);
326	247k	list_insert_tail(&cfq->free_list, ex);
327	247k	clear_item(ex);
328	247k	break;
329	0	default:
330	0	assert(0); /* invalid state (e.g. in free state) */
331	0	break;
332	247k	}
333	247k	}
334
335		QUIC_CFQ_ITEM ossl_quic_cfq_get_priority_head(const QUIC_CFQ cfq,
336		uint32_t pn_space)
337	76.4M	{
338	76.4M	QUIC_CFQ_ITEM_EX *item = cfq->new_list.head;
339
340	161M	for (; item != NULL && item->pn_space != pn_space; item = item->next)
341	85.3M	;
342
343	76.4M	if (item == NULL)
344	74.1M	return NULL;
345
346	2.39M	return &item->public;
347	76.4M	}
348
349		QUIC_CFQ_ITEM ossl_quic_cfq_item_get_priority_next(const QUIC_CFQ_ITEM item,
350		uint32_t pn_space)
351	224M	{
352	224M	QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item;
353
354	224M	if (ex == NULL)
355	0	return NULL;
356
357	224M	ex = ex->next;
358
359	224M	for (; ex != NULL && ex->pn_space != pn_space; ex = ex->next)
360	0	;
361
362	224M	if (ex == NULL)
363	2.39M	return NULL; /* ubsan */
364
365	221M	return &ex->public;
366	224M	}