mirror of https://github.com/openssl/openssl.git
151 lines
4.6 KiB
C
151 lines
4.6 KiB
C
/*
|
|
* 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
|
|
*/
|
|
|
|
#ifndef OSSL_INTERNAL_PACKET_QUIC_H
|
|
# define OSSL_INTERNAL_PACKET_QUIC_H
|
|
# pragma once
|
|
|
|
# include "internal/packet.h"
|
|
# include "internal/quic_vlint.h"
|
|
|
|
# ifndef OPENSSL_NO_QUIC
|
|
/*
|
|
* Decodes a QUIC variable-length integer in |pkt| and stores the result in
|
|
* |data|.
|
|
*/
|
|
__owur static ossl_inline int PACKET_get_quic_vlint(PACKET *pkt,
|
|
uint64_t *data)
|
|
{
|
|
size_t enclen;
|
|
|
|
if (PACKET_remaining(pkt) < 1)
|
|
return 0;
|
|
|
|
enclen = ossl_quic_vlint_decode_len(*pkt->curr);
|
|
|
|
if (PACKET_remaining(pkt) < enclen)
|
|
return 0;
|
|
|
|
*data = ossl_quic_vlint_decode_unchecked(pkt->curr);
|
|
packet_forward(pkt, enclen);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Decodes a QUIC variable-length integer in |pkt| and stores the result in
|
|
* |data|. Unlike PACKET_get_quic_vlint, this does not advance the current
|
|
* position. If was_minimal is non-NULL, *was_minimal is set to 1 if the integer
|
|
* was encoded using the minimal possible number of bytes and 0 otherwise.
|
|
*/
|
|
__owur static ossl_inline int PACKET_peek_quic_vlint_ex(PACKET *pkt,
|
|
uint64_t *data,
|
|
int *was_minimal)
|
|
{
|
|
size_t enclen;
|
|
|
|
if (PACKET_remaining(pkt) < 1)
|
|
return 0;
|
|
|
|
enclen = ossl_quic_vlint_decode_len(*pkt->curr);
|
|
|
|
if (PACKET_remaining(pkt) < enclen)
|
|
return 0;
|
|
|
|
*data = ossl_quic_vlint_decode_unchecked(pkt->curr);
|
|
|
|
if (was_minimal != NULL)
|
|
*was_minimal = (enclen == ossl_quic_vlint_encode_len(*data));
|
|
|
|
return 1;
|
|
}
|
|
|
|
__owur static ossl_inline int PACKET_peek_quic_vlint(PACKET *pkt,
|
|
uint64_t *data)
|
|
{
|
|
return PACKET_peek_quic_vlint_ex(pkt, data, NULL);
|
|
}
|
|
|
|
/*
|
|
* Skips over a QUIC variable-length integer in |pkt| without decoding it.
|
|
*/
|
|
__owur static ossl_inline int PACKET_skip_quic_vlint(PACKET *pkt)
|
|
{
|
|
size_t enclen;
|
|
|
|
if (PACKET_remaining(pkt) < 1)
|
|
return 0;
|
|
|
|
enclen = ossl_quic_vlint_decode_len(*pkt->curr);
|
|
|
|
if (PACKET_remaining(pkt) < enclen)
|
|
return 0;
|
|
|
|
packet_forward(pkt, enclen);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Reads a variable-length vector prefixed with a QUIC variable-length integer
|
|
* denoting the length, and stores the contents in |subpkt|. |pkt| can equal
|
|
* |subpkt|. Data is not copied: the |subpkt| packet will share its underlying
|
|
* buffer with the original |pkt|, so data wrapped by |pkt| must outlive the
|
|
* |subpkt|. Upon failure, the original |pkt| and |subpkt| are not modified.
|
|
*/
|
|
__owur static ossl_inline int PACKET_get_quic_length_prefixed(PACKET *pkt,
|
|
PACKET *subpkt)
|
|
{
|
|
uint64_t length;
|
|
const unsigned char *data;
|
|
PACKET tmp = *pkt;
|
|
|
|
if (!PACKET_get_quic_vlint(&tmp, &length) ||
|
|
length > SIZE_MAX ||
|
|
!PACKET_get_bytes(&tmp, &data, (size_t)length)) {
|
|
return 0;
|
|
}
|
|
|
|
*pkt = tmp;
|
|
subpkt->curr = data;
|
|
subpkt->remaining = (size_t)length;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Starts a QUIC sub-packet headed by a QUIC variable-length integer. A 4-byte
|
|
* representation is used.
|
|
*/
|
|
__owur int WPACKET_start_quic_sub_packet(WPACKET *pkt);
|
|
|
|
/*
|
|
* Starts a QUIC sub-packet headed by a QUIC variable-length integer. max_len
|
|
* specifies the upper bound for the sub-packet size at the time the sub-packet
|
|
* is closed, which determines the encoding size for the variable-length
|
|
* integer header. max_len can be a precise figure or a worst-case bound
|
|
* if a precise figure is not available.
|
|
*/
|
|
__owur int WPACKET_start_quic_sub_packet_bound(WPACKET *pkt, size_t max_len);
|
|
|
|
/*
|
|
* Allocates a QUIC sub-packet with exactly len bytes of payload, headed by a
|
|
* QUIC variable-length integer. The pointer to the payload buffer is output and
|
|
* must be filled by the caller. This function assures optimal selection of
|
|
* variable-length integer encoding length.
|
|
*/
|
|
__owur int WPACKET_quic_sub_allocate_bytes(WPACKET *pkt, size_t len,
|
|
unsigned char **bytes);
|
|
|
|
/*
|
|
* Write a QUIC variable-length integer to the packet.
|
|
*/
|
|
__owur int WPACKET_quic_write_vlint(WPACKET *pkt, uint64_t v);
|
|
|
|
# endif /* OPENSSL_NO_QUIC */
|
|
#endif /* OSSL_INTERNAL_PACKET_QUIC_H */
|