ssl/quic/quic_txpim.c

   1 /*
   2  * Copyright 2022 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_txpim.h"
  11 #include <stdlib.h>
  12
  13 typedef struct quic_txpim_pkt_ex_st QUIC_TXPIM_PKT_EX;
  14
  15 struct quic_txpim_pkt_ex_st {
  16     QUIC_TXPIM_PKT              public;
  17     QUIC_TXPIM_PKT_EX          *prev, *next;
  18     QUIC_TXPIM_CHUNK           *chunks;
  19     size_t                      num_chunks, alloc_chunks;
  20     unsigned int                chunks_need_sort : 1;
  21 };
  22
  23 typedef struct quic_txpim_pkt_ex_list {
  24     QUIC_TXPIM_PKT_EX          *head, *tail;
  25 } QUIC_TXPIM_PKT_EX_LIST;
  26
  27 struct quic_txpim_st {
  28     QUIC_TXPIM_PKT_EX_LIST  free_list;
  29     size_t                  in_use;
  30 };
  31
  32 #define MAX_ALLOC_CHUNKS 512
  33
  34 QUIC_TXPIM *ossl_quic_txpim_new(void)
  35 {
  36     QUIC_TXPIM *txpim = OPENSSL_zalloc(sizeof(*txpim));
  37
  38     if (txpim == NULL)
  39         return NULL;
  40
  41     return txpim;
  42 }
  43
  44 static void free_list(QUIC_TXPIM_PKT_EX_LIST *l)
  45 {
  46     QUIC_TXPIM_PKT_EX *n, *nnext;
  47
  48     for (n = l->head; n != NULL; n = nnext) {
  49         nnext = n->next;
  50
  51         OPENSSL_free(n->chunks);
  52         OPENSSL_free(n);
  53     }
  54
  55     l->head = l->tail = NULL;
  56 }
  57
  58 void ossl_quic_txpim_free(QUIC_TXPIM *txpim)
  59 {
  60     if (txpim == NULL)
  61         return;
  62
  63     assert(txpim->in_use == 0);
  64     free_list(&txpim->free_list);
  65     OPENSSL_free(txpim);
  66 }
  67
  68 static void list_remove(QUIC_TXPIM_PKT_EX_LIST *l, QUIC_TXPIM_PKT_EX *n)
  69 {
  70     if (l->head == n)
  71         l->head = n->next;
  72     if (l->tail == n)
  73         l->tail = n->prev;
  74     if (n->prev != NULL)
  75         n->prev->next = n->next;
  76     if (n->next != NULL)
  77         n->next->prev = n->prev;
  78     n->prev = n->next = NULL;
  79 }
  80
  81 static void list_insert_tail(QUIC_TXPIM_PKT_EX_LIST *l, QUIC_TXPIM_PKT_EX *n)
  82 {
  83     n->prev = l->tail;
  84     n->next = NULL;
  85     l->tail = n;
  86     if (n->prev != NULL)
  87         n->prev->next = n;
  88     if (l->head == NULL)
  89         l->head = n;
  90 }
  91
  92 static QUIC_TXPIM_PKT_EX *txpim_get_free(QUIC_TXPIM *txpim)
  93 {
  94     QUIC_TXPIM_PKT_EX *ex = txpim->free_list.head;
  95
  96     if (ex != NULL)
  97         return ex;
  98
  99     ex = OPENSSL_zalloc(sizeof(*ex));
 100     if (ex == NULL)
 101         return NULL;
 102
 103     list_insert_tail(&txpim->free_list, ex);
 104     return ex;
 105 }
 106
 107 static void txpim_clear(QUIC_TXPIM_PKT_EX *ex)
 108 {
 109     memset(&ex->public.ackm_pkt, 0, sizeof(ex->public.ackm_pkt));
 110     ossl_quic_txpim_pkt_clear_chunks(&ex->public);
 111     ex->public.retx_head                   = NULL;
 112     ex->public.fifd                        = NULL;
 113     ex->public.had_handshake_done_frame    = 0;
 114     ex->public.had_max_data_frame          = 0;
 115     ex->public.had_max_streams_bidi_frame  = 0;
 116     ex->public.had_max_streams_uni_frame   = 0;
 117     ex->public.had_ack_frame               = 0;
 118     ex->public.had_conn_close              = 0;
 119 }
 120
 121 QUIC_TXPIM_PKT *ossl_quic_txpim_pkt_alloc(QUIC_TXPIM *txpim)
 122 {
 123     QUIC_TXPIM_PKT_EX *ex = txpim_get_free(txpim);
 124
 125     if (ex == NULL)
 126         return NULL;
 127
 128     txpim_clear(ex);
 129     list_remove(&txpim->free_list, ex);
 130     ++txpim->in_use;
 131     return &ex->public;
 132 }
 133
 134 void ossl_quic_txpim_pkt_release(QUIC_TXPIM *txpim, QUIC_TXPIM_PKT *fpkt)
 135 {
 136     QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt;
 137
 138     assert(txpim->in_use > 0);
 139     --txpim->in_use;
 140     list_insert_tail(&txpim->free_list, ex);
 141 }
 142
 143 void ossl_quic_txpim_pkt_add_cfq_item(QUIC_TXPIM_PKT *fpkt,
 144                                       QUIC_CFQ_ITEM *item)
 145 {
 146     item->pkt_next = fpkt->retx_head;
 147     item->pkt_prev = NULL;
 148     fpkt->retx_head = item;
 149 }
 150
 151 void ossl_quic_txpim_pkt_clear_chunks(QUIC_TXPIM_PKT *fpkt)
 152 {
 153     QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt;
 154
 155     ex->num_chunks = 0;
 156 }
 157
 158 int ossl_quic_txpim_pkt_append_chunk(QUIC_TXPIM_PKT *fpkt,
 159                                      const QUIC_TXPIM_CHUNK *chunk)
 160 {
 161     QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt;
 162     QUIC_TXPIM_CHUNK *new_chunk;
 163     size_t new_alloc_chunks = ex->alloc_chunks;
 164
 165     if (ex->num_chunks == ex->alloc_chunks) {
 166         new_alloc_chunks = (ex->alloc_chunks == 0) ? 4 : ex->alloc_chunks * 8 / 5;
 167         if (new_alloc_chunks > MAX_ALLOC_CHUNKS)
 168             new_alloc_chunks = MAX_ALLOC_CHUNKS;
 169         if (ex->num_chunks == new_alloc_chunks)
 170             return 0;
 171
 172         new_chunk = OPENSSL_realloc(ex->chunks,
 173                                     new_alloc_chunks * sizeof(QUIC_TXPIM_CHUNK));
 174         if (new_chunk == NULL)
 175             return 0;
 176
 177         ex->chunks          = new_chunk;
 178         ex->alloc_chunks    = new_alloc_chunks;
 179     }
 180
 181     ex->chunks[ex->num_chunks++]    = *chunk;
 182     ex->chunks_need_sort            = 1;
 183     return 1;
 184 }
 185
 186 static int compare(const void *a, const void *b)
 187 {
 188     const QUIC_TXPIM_CHUNK *ac = a, *bc = b;
 189
 190     if (ac->stream_id < bc->stream_id)
 191         return -1;
 192     else if (ac->stream_id > bc->stream_id)
 193         return 1;
 194
 195     if (ac->start < bc->start)
 196         return -1;
 197     else if (ac->start > bc->start)
 198         return 1;
 199
 200     return 0;
 201 }
 202
 203 const QUIC_TXPIM_CHUNK *ossl_quic_txpim_pkt_get_chunks(const QUIC_TXPIM_PKT *fpkt)
 204 {
 205     QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt;
 206
 207     if (ex->chunks_need_sort) {
 208         /*
 209          * List of chunks will generally be very small so there is no issue
 210          * simply sorting here.
 211          */
 212         qsort(ex->chunks, ex->num_chunks, sizeof(QUIC_TXPIM_CHUNK), compare);
 213         ex->chunks_need_sort = 0;
 214     }
 215
 216     return ex->chunks;
 217 }
 218
 219 size_t ossl_quic_txpim_pkt_get_num_chunks(const QUIC_TXPIM_PKT *fpkt)
 220 {
 221     QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt;
 222
 223     return ex->num_chunks;
 224 }
 225
 226 size_t ossl_quic_txpim_get_in_use(const QUIC_TXPIM *txpim)
 227 {
 228     return txpim->in_use;
 229 }