#define DEMUX_MAX_MSGS_PER_CALL 32
-void ossl_quic_urxe_remove(QUIC_URXE_LIST *l, QUIC_URXE *e)
-{
- /* Must be in list currently. */
- assert((e->prev != NULL || l->head == e)
- && (e->next != NULL || l->tail == e));
-
- if (e->prev != NULL)
- e->prev->next = e->next;
- if (e->next != NULL)
- e->next->prev = e->prev;
-
- if (e == l->head)
- l->head = e->next;
- if (e == l->tail)
- l->tail = e->prev;
-
- e->next = e->prev = NULL;
-}
-
-void ossl_quic_urxe_insert_head(QUIC_URXE_LIST *l, QUIC_URXE *e)
-{
- /* Must not be in list. */
- assert(e->prev == NULL && e->next == NULL);
-
- if (l->head == NULL) {
- l->head = l->tail = e;
- e->next = e->prev = NULL;
- return;
- }
-
- l->head->prev = e;
- e->next = l->head;
- e->prev = NULL;
- l->head = e;
-}
-
-void ossl_quic_urxe_insert_tail(QUIC_URXE_LIST *l, QUIC_URXE *e)
-{
- /* Must not be in list. */
- assert(e->prev == NULL && e->next == NULL);
-
- if (l->tail == NULL) {
- l->head = l->tail = e;
- e->next = e->prev = NULL;
- return;
- }
-
- l->tail->next = e;
- e->prev = l->tail;
- e->next = NULL;
- l->tail = e;
-}
-
/* Structure used to track a given connection ID. */
typedef struct quic_demux_conn_st QUIC_DEMUX_CONN;
* unconsumed data). These are moved to the pending list as they are filled.
*/
QUIC_URXE_LIST urx_free;
- size_t num_urx_free;
/*
* List of URXEs which are filled with received encrypted data. These are
{
QUIC_URXE *e, *enext;
- for (e = l->head; e != NULL; e = enext) {
- enext = e->next;
+ for (e = ossl_list_urxe_head(l); e != NULL; e = enext) {
+ enext = ossl_list_urxe_next(e);
+ ossl_list_urxe_remove(l, e);
OPENSSL_free(e);
}
-
- l->head = l->tail = NULL;
}
void ossl_quic_demux_free(QUIC_DEMUX *demux)
if (e == NULL)
return NULL;
- e->prev = e->next = NULL;
+ ossl_list_urxe_init_elem(e);
e->alloc_len = alloc_len;
- e->data_len = 0;
+ e->data_len = 0;
return e;
}
{
QUIC_URXE *e;
- while (demux->num_urx_free < min_num_free) {
+ while (ossl_list_urxe_num(&demux->urx_free) < min_num_free) {
e = demux_alloc_urxe(demux->default_urxe_alloc_len);
if (e == NULL)
return 0;
- ossl_quic_urxe_insert_tail(&demux->urx_free, e);
- ++demux->num_urx_free;
+ ossl_list_urxe_insert_tail(&demux->urx_free, e);
}
return 1;
{
BIO_MSG msg[DEMUX_MAX_MSGS_PER_CALL];
size_t rd, i;
- QUIC_URXE *urxe = demux->urx_free.head, *unext;
+ QUIC_URXE *urxe = ossl_list_urxe_head(&demux->urx_free), *unext;
OSSL_TIME now;
/* This should never be called when we have any pending URXE. */
- assert(demux->urx_pending.head == NULL);
+ assert(ossl_list_urxe_head(&demux->urx_pending) == NULL);
if (demux->net_bio == NULL)
return 0;
* Opportunistically receive as many messages as possible in a single
* syscall, determined by how many free URXEs are available.
*/
- for (i = 0; i < (ossl_ssize_t)OSSL_NELEM(msg); ++i, urxe = urxe->next) {
+ for (i = 0; i < (ossl_ssize_t)OSSL_NELEM(msg);
+ ++i, urxe = ossl_list_urxe_next(urxe)) {
if (urxe == NULL) {
/* We need at least one URXE to receive into. */
if (!ossl_assert(i > 0))
now = demux->now != NULL ? demux->now(demux->now_arg) : ossl_time_zero();
- urxe = demux->urx_free.head;
+ urxe = ossl_list_urxe_head(&demux->urx_free);
for (i = 0; i < rd; ++i, urxe = unext) {
- unext = urxe->next;
+ unext = ossl_list_urxe_next(urxe);
/* Set URXE with actual length of received datagram. */
urxe->data_len = msg[i].data_len;
/* Time we received datagram. */
urxe->time = now;
/* Move from free list to pending list. */
- ossl_quic_urxe_remove(&demux->urx_free, urxe);
- --demux->num_urx_free;
- ossl_quic_urxe_insert_tail(&demux->urx_pending, urxe);
+ ossl_list_urxe_remove(&demux->urx_free, urxe);
+ ossl_list_urxe_insert_tail(&demux->urx_pending, urxe);
}
return 1;
QUIC_DEMUX_CONN *conn;
/* The next URXE we process should be at the head of the pending list. */
- if (!ossl_assert(e == demux->urx_pending.head))
+ if (!ossl_assert(e == ossl_list_urxe_head(&demux->urx_pending)))
return 0;
conn = demux_identify_conn(demux, e);
* We could not identify a connection. We will never be able to process
* this datagram, so get rid of it.
*/
- ossl_quic_urxe_remove(&demux->urx_pending, e);
- ossl_quic_urxe_insert_tail(&demux->urx_free, e);
- ++demux->num_urx_free;
+ ossl_list_urxe_remove(&demux->urx_pending, e);
+ ossl_list_urxe_insert_tail(&demux->urx_free, e);
return 1; /* keep processing pending URXEs */
}
* Remove from list and invoke callback. The URXE now belongs to the
* callback. (QUIC_DEMUX_CONN never has non-NULL cb.)
*/
- ossl_quic_urxe_remove(&demux->urx_pending, e);
+ ossl_list_urxe_remove(&demux->urx_pending, e);
conn->cb(e, conn->cb_arg);
return 1;
}
{
QUIC_URXE *e;
- while ((e = demux->urx_pending.head) != NULL)
+ while ((e = ossl_list_urxe_head(&demux->urx_pending)) != NULL)
if (!demux_process_pending_urxe(demux, e))
return 0;
{
int ret;
- if (demux->urx_pending.head == NULL) {
+ if (ossl_list_urxe_head(&demux->urx_pending) == NULL) {
ret = demux_ensure_free_urxe(demux, DEMUX_MAX_MSGS_PER_CALL);
if (ret != 1)
return 0;
/*
* If demux_recv returned successfully, we should always have something.
*/
- assert(demux->urx_pending.head != NULL);
+ assert(ossl_list_urxe_head(&demux->urx_pending) != NULL);
}
return demux_process_pending_urxl(demux);
if (ret != 1)
return 0;
- urxe = demux->urx_free.head;
+ urxe = ossl_list_urxe_head(&demux->urx_free);
if (buf_len > urxe->alloc_len)
return 0;
BIO_ADDR_clear(&urxe->local);
/* Move from free list to pending list. */
- ossl_quic_urxe_remove(&demux->urx_free, urxe);
- --demux->num_urx_free;
- ossl_quic_urxe_insert_tail(&demux->urx_pending, urxe);
+ ossl_list_urxe_remove(&demux->urx_free, urxe);
+ ossl_list_urxe_insert_tail(&demux->urx_pending, urxe);
return demux_process_pending_urxl(demux);
}
void ossl_quic_demux_release_urxe(QUIC_DEMUX *demux,
QUIC_URXE *e)
{
- assert(e->prev == NULL && e->next == NULL);
- ossl_quic_urxe_insert_tail(&demux->urx_free, e);
- ++demux->num_urx_free;
+ assert(ossl_list_urxe_prev(e) == NULL && ossl_list_urxe_next(e) == NULL);
+ ossl_list_urxe_insert_tail(&demux->urx_free, e);
}
#include "internal/quic_record_rx.h"
#include "quic_record_shared.h"
#include "internal/common.h"
+#include "internal/list.h"
#include "../ssl_local.h"
/*
typedef struct rxe_st RXE;
struct rxe_st {
- RXE *prev, *next;
+ OSSL_LIST_MEMBER(rxe, RXE);
size_t data_len, alloc_len;
/* Extra fields for per-packet information. */
*/
};
-typedef struct ossl_qrx_rxe_list_st {
- RXE *head, *tail;
-} RXE_LIST;
+DEFINE_LIST_OF(rxe, RXE);
+typedef OSSL_LIST(rxe) RXE_LIST;
static ossl_inline unsigned char *rxe_data(const RXE *e)
{
return (unsigned char *)(e + 1);
}
-static void rxe_remove(RXE_LIST *l, RXE *e)
-{
- if (e->prev != NULL)
- e->prev->next = e->next;
- if (e->next != NULL)
- e->next->prev = e->prev;
-
- if (e == l->head)
- l->head = e->next;
- if (e == l->tail)
- l->tail = e->prev;
-
- e->next = e->prev = NULL;
-}
-
-static void rxe_insert_tail(RXE_LIST *l, RXE *e)
-{
- if (l->tail == NULL) {
- l->head = l->tail = e;
- e->next = e->prev = NULL;
- return;
- }
-
- l->tail->next = e;
- e->prev = l->tail;
- e->next = NULL;
- l->tail = e;
-}
-
/*
* QRL
* ===
{
RXE *e, *enext;
- for (e = l->head; e != NULL; e = enext) {
- enext = e->next;
+ for (e = ossl_list_rxe_head(l); e != NULL; e = enext) {
+ enext = ossl_list_rxe_next(e);
+ ossl_list_rxe_remove(l, e);
OPENSSL_free(e);
}
-
- l->head = l->tail = NULL;
}
static void qrx_cleanup_urxl(OSSL_QRX *qrx, QUIC_URXE_LIST *l)
{
QUIC_URXE *e, *enext;
- for (e = l->head; e != NULL; e = enext) {
- enext = e->next;
+ for (e = ossl_list_urxe_head(l); e != NULL; e = enext) {
+ enext = ossl_list_urxe_next(e);
ossl_quic_demux_release_urxe(qrx->demux, e);
}
-
- l->head = l->tail = NULL;
}
void ossl_qrx_free(OSSL_QRX *qrx)
urxe->processed = 0;
urxe->hpr_removed = 0;
urxe->deferred = 0;
- ossl_quic_urxe_insert_tail(&qrx->urx_pending, urxe);
+ ossl_list_urxe_insert_tail(&qrx->urx_pending, urxe);
}
int ossl_qrx_add_dst_conn_id(OSSL_QRX *qrx,
{
QUIC_URXE *e;
- while ((e = qrx->urx_deferred.head) != NULL) {
- ossl_quic_urxe_remove(&qrx->urx_deferred, e);
- ossl_quic_urxe_insert_head(&qrx->urx_pending, e);
+ while ((e = ossl_list_urxe_head(&qrx->urx_deferred)) != NULL) {
+ ossl_list_urxe_remove(&qrx->urx_deferred, e);
+ ossl_list_urxe_insert_head(&qrx->urx_pending, e);
}
}
/* Returns 1 if there are one or more pending RXEs. */
int ossl_qrx_processed_read_pending(OSSL_QRX *qrx)
{
- return qrx->rx_pending.head != NULL;
+ return !ossl_list_rxe_is_empty(&qrx->rx_pending);
}
/* Returns 1 if there are yet-unprocessed packets. */
int ossl_qrx_unprocessed_read_pending(OSSL_QRX *qrx)
{
- return qrx->urx_pending.head != NULL || qrx->urx_deferred.head != NULL;
+ return !ossl_list_urxe_is_empty(&qrx->urx_pending)
+ || !ossl_list_urxe_is_empty(&qrx->urx_deferred);
}
/* Pop the next pending RXE. Returns NULL if no RXE is pending. */
static RXE *qrx_pop_pending_rxe(OSSL_QRX *qrx)
{
- RXE *rxe = qrx->rx_pending.head;
+ RXE *rxe = ossl_list_rxe_head(&qrx->rx_pending);
if (rxe == NULL)
return NULL;
- rxe_remove(&qrx->rx_pending, rxe);
+ ossl_list_rxe_remove(&qrx->rx_pending, rxe);
return rxe;
}
if (rxe == NULL)
return NULL;
- rxe->prev = rxe->next = NULL;
+ ossl_list_rxe_init_elem(rxe);
rxe->alloc_len = alloc_len;
rxe->data_len = 0;
return rxe;
{
RXE *rxe;
- if (qrx->rx_free.head != NULL)
- return qrx->rx_free.head;
+ if (ossl_list_rxe_head(&qrx->rx_free) != NULL)
+ return ossl_list_rxe_head(&qrx->rx_free);
rxe = qrx_alloc_rxe(alloc_len);
if (rxe == NULL)
return NULL;
- rxe_insert_tail(&qrx->rx_free, rxe);
+ ossl_list_rxe_insert_tail(&qrx->rx_free, rxe);
return rxe;
}
*/
static RXE *qrx_resize_rxe(RXE_LIST *rxl, RXE *rxe, size_t n)
{
- RXE *rxe2;
+ RXE *rxe2, *p;
/* Should never happen. */
if (rxe == NULL)
if (n >= SIZE_MAX - sizeof(RXE))
return NULL;
+ /* Remove the item from the list to avoid accessing freed memory */
+ p = ossl_list_rxe_prev(rxe);
+ ossl_list_rxe_remove(rxl, rxe);
+
/*
* NOTE: We do not clear old memory, although it does contain decrypted
* data.
*/
rxe2 = OPENSSL_realloc(rxe, sizeof(RXE) + n);
- if (rxe2 == NULL)
- /* original RXE is still intact unchanged */
- return NULL;
-
- if (rxe != rxe2) {
- if (rxl->head == rxe)
- rxl->head = rxe2;
- if (rxl->tail == rxe)
- rxl->tail = rxe2;
- if (rxe->prev != NULL)
- rxe->prev->next = rxe2;
- if (rxe->next != NULL)
- rxe->next->prev = rxe2;
+ if (rxe2 == NULL || rxe == rxe2) {
+ if (p == NULL)
+ ossl_list_rxe_insert_head(rxl, rxe);
+ else
+ ossl_list_rxe_insert_after(rxl, p, rxe);
+ return rxe2;
}
+ if (p == NULL)
+ ossl_list_rxe_insert_head(rxl, rxe2);
+ else
+ ossl_list_rxe_insert_after(rxl, p, rxe2);
+
rxe2->alloc_len = n;
return rxe2;
}
static void qrx_recycle_rxe(OSSL_QRX *qrx, RXE *rxe)
{
/* RXE should not be in any list */
- assert(rxe->prev == NULL && rxe->next == NULL);
- rxe_insert_tail(&qrx->rx_free, rxe);
+ assert(ossl_list_rxe_prev(rxe) == NULL && ossl_list_rxe_next(rxe) == NULL);
+ ossl_list_rxe_insert_tail(&qrx->rx_free, rxe);
}
/*
rxe->pn = QUIC_PN_INVALID;
/* Move RXE to pending. */
- rxe_remove(&qrx->rx_free, rxe);
- rxe_insert_tail(&qrx->rx_pending, rxe);
+ ossl_list_rxe_remove(&qrx->rx_free, rxe);
+ ossl_list_rxe_insert_tail(&qrx->rx_pending, rxe);
return 0; /* success, did not defer */
}
rxe->time = urxe->time;
/* Move RXE to pending. */
- rxe_remove(&qrx->rx_free, rxe);
- rxe_insert_tail(&qrx->rx_pending, rxe);
+ ossl_list_rxe_remove(&qrx->rx_free, rxe);
+ ossl_list_rxe_insert_tail(&qrx->rx_pending, rxe);
return 0; /* success, did not defer; not distinguished from failure */
cannot_decrypt:
int was_deferred;
/* The next URXE we process should be at the head of the pending list. */
- if (!ossl_assert(e == qrx->urx_pending.head))
+ if (!ossl_assert(e == ossl_list_urxe_head(&qrx->urx_pending)))
return 0;
/*
* Remove the URXE from the pending list and return it to
* either the free or deferred list.
*/
- ossl_quic_urxe_remove(&qrx->urx_pending, e);
+ ossl_list_urxe_remove(&qrx->urx_pending, e);
if (was_deferred > 0 &&
(e->deferred || qrx->num_deferred < qrx->max_deferred)) {
- ossl_quic_urxe_insert_tail(&qrx->urx_deferred, e);
+ ossl_list_urxe_insert_tail(&qrx->urx_deferred, e);
if (!e->deferred) {
e->deferred = 1;
++qrx->num_deferred;
{
QUIC_URXE *e;
- while ((e = qrx->urx_pending.head) != NULL)
+ while ((e = ossl_list_urxe_head(&qrx->urx_pending)) != NULL)
if (!qrx_process_one_urxe(qrx, e))
return 0;