include/internal/packet_quic.h

   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 #ifndef OSSL_INTERNAL_PACKET_QUIC_H
  11 # define OSSL_INTERNAL_PACKET_QUIC_H
  12 # pragma once
  13
  14 # include "internal/packet.h"
  15 # include "internal/quic_vlint.h"
  16
  17 # ifndef OPENSSL_NO_QUIC
  18 /*
  19  * Decodes a QUIC variable-length integer in |pkt| and stores the result in
  20  * |data|.
  21  */
  22 __owur static ossl_inline int PACKET_get_quic_vlint(PACKET *pkt,
  23                                                     uint64_t *data)
  24 {
  25     size_t enclen;
  26
  27     if (PACKET_remaining(pkt) < 1)
  28         return 0;
  29
  30     enclen = ossl_quic_vlint_decode_len(*pkt->curr);
  31
  32     if (PACKET_remaining(pkt) < enclen)
  33         return 0;
  34
  35     *data = ossl_quic_vlint_decode_unchecked(pkt->curr);
  36     packet_forward(pkt, enclen);
  37     return 1;
  38 }
  39
  40 /*
  41  * Decodes a QUIC variable-length integer in |pkt| and stores the result in
  42  * |data|. Unlike PACKET_get_quic_vlint, this does not advance the current
  43  * position. If was_minimal is non-NULL, *was_minimal is set to 1 if the integer
  44  * was encoded using the minimal possible number of bytes and 0 otherwise.
  45  */
  46 __owur static ossl_inline int PACKET_peek_quic_vlint_ex(PACKET *pkt,
  47                                                         uint64_t *data,
  48                                                         int *was_minimal)
  49 {
  50     size_t enclen;
  51
  52     if (PACKET_remaining(pkt) < 1)
  53         return 0;
  54
  55     enclen = ossl_quic_vlint_decode_len(*pkt->curr);
  56
  57     if (PACKET_remaining(pkt) < enclen)
  58         return 0;
  59
  60     *data = ossl_quic_vlint_decode_unchecked(pkt->curr);
  61
  62     if (was_minimal != NULL)
  63         *was_minimal = (enclen == ossl_quic_vlint_encode_len(*data));
  64
  65     return 1;
  66 }
  67
  68 __owur static ossl_inline int PACKET_peek_quic_vlint(PACKET *pkt,
  69                                                      uint64_t *data)
  70 {
  71     return PACKET_peek_quic_vlint_ex(pkt, data, NULL);
  72 }
  73
  74 /*
  75  * Skips over a QUIC variable-length integer in |pkt| without decoding it.
  76  */
  77 __owur static ossl_inline int PACKET_skip_quic_vlint(PACKET *pkt)
  78 {
  79     size_t enclen;
  80
  81     if (PACKET_remaining(pkt) < 1)
  82         return 0;
  83
  84     enclen = ossl_quic_vlint_decode_len(*pkt->curr);
  85
  86     if (PACKET_remaining(pkt) < enclen)
  87         return 0;
  88
  89     packet_forward(pkt, enclen);
  90     return 1;
  91 }
  92
  93 /*
  94  * Reads a variable-length vector prefixed with a QUIC variable-length integer
  95  * denoting the length, and stores the contents in |subpkt|. |pkt| can equal
  96  * |subpkt|. Data is not copied: the |subpkt| packet will share its underlying
  97  * buffer with the original |pkt|, so data wrapped by |pkt| must outlive the
  98  * |subpkt|. Upon failure, the original |pkt| and |subpkt| are not modified.
  99  */
 100 __owur static ossl_inline int PACKET_get_quic_length_prefixed(PACKET *pkt,
 101                                                               PACKET *subpkt)
 102 {
 103     uint64_t length;
 104     const unsigned char *data;
 105     PACKET tmp = *pkt;
 106
 107     if (!PACKET_get_quic_vlint(&tmp, &length) ||
 108         length > SIZE_MAX ||
 109         !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
 110         return 0;
 111     }
 112
 113     *pkt = tmp;
 114     subpkt->curr = data;
 115     subpkt->remaining = (size_t)length;
 116
 117     return 1;
 118 }
 119
 120 /*
 121  * Starts a QUIC sub-packet headed by a QUIC variable-length integer. A 4-byte
 122  * representation is used.
 123  */
 124 __owur int WPACKET_start_quic_sub_packet(WPACKET *pkt);
 125
 126 /*
 127  * Starts a QUIC sub-packet headed by a QUIC variable-length integer. max_len
 128  * specifies the upper bound for the sub-packet size at the time the sub-packet
 129  * is closed, which determines the encoding size for the variable-length
 130  * integer header. max_len can be a precise figure or a worst-case bound
 131  * if a precise figure is not available.
 132  */
 133 __owur int WPACKET_start_quic_sub_packet_bound(WPACKET *pkt, size_t max_len);
 134
 135 /*
 136  * Allocates a QUIC sub-packet with exactly len bytes of payload, headed by a
 137  * QUIC variable-length integer. The pointer to the payload buffer is output and
 138  * must be filled by the caller. This function assures optimal selection of
 139  * variable-length integer encoding length.
 140  */
 141 __owur int WPACKET_quic_sub_allocate_bytes(WPACKET *pkt, size_t len,
 142                                            unsigned char **bytes);
 143
 144 /*
 145  * Write a QUIC variable-length integer to the packet.
 146  */
 147 __owur int WPACKET_quic_write_vlint(WPACKET *pkt, uint64_t v);
 148
 149 # endif                         /* OPENSSL_NO_QUIC */
 150 #endif                          /* OSSL_INTERNAL_PACKET_QUIC_H */