/* Copyright (c) 2017 - 2022 LiteSpeed Technologies Inc. See LICENSE. */ /* * lsquic_parse_ietf_v1.c -- Parsing functions specific to IETF QUIC v1 */ #include #include #include #include #include #include #ifndef WIN32 #include #else #include #endif #include "lsquic_types.h" #include "lsquic_int_types.h" #include "lsquic_sizes.h" #include "lsquic_packet_common.h" #include "lsquic_packet_ietf.h" #include "lsquic_packet_in.h" #include "lsquic_packet_out.h" #include "lsquic_parse.h" #include "lsquic_parse_common.h" #include "lsquic_sfcw.h" #include "lsquic_varint.h" #include "lsquic_hq.h" #include "lsquic_hash.h" #include "lsquic_stream.h" #include "lsquic_mm.h" #include "lsquic_malo.h" #include "lsquic_version.h" #include "lsquic.h" #include "lsquic_byteswap.h" #include "lsquic_conn.h" #include "lsquic_enc_sess.h" #include "lsquic_trans_params.h" #include "lsquic_parse_ietf.h" #include "lsquic_qtags.h" #define LSQUIC_LOGGER_MODULE LSQLM_PARSE #include "lsquic_logger.h" #define CHECK_SPACE(need, pstart, pend) \ do { if ((intptr_t) (need) > ((pend) - (pstart))) { return -1; } } while (0) #define FRAME_TYPE_ACK_FREQUENCY 0xAF #define FRAME_TYPE_TIMESTAMP 0x2F5 #define MIN(a, b) ((a) < (b) ? (a) : (b)) static int ietf_v1_gen_one_varint (unsigned char *, size_t, unsigned char, uint64_t); static int ietf_v1_gen_two_varints (unsigned char *, size_t, unsigned char, uint64_t[2]); static void ietf_v1_parse_packet_in_finish (lsquic_packet_in_t *packet_in, struct packin_parse_state *state) { /* Packet number is set to an invalid value. The packet number must * be decrypted, which happens later. */ packet_in->pi_packno = 1ULL << 62; } /* Note: token size is not accounted for */ static size_t ietf_v1_packout_header_size_long_by_flags (const struct lsquic_conn *lconn, enum header_type header_type, enum packet_out_flags flags, size_t dcid_len) { size_t sz; enum packno_bits packno_bits; packno_bits = (flags >> POBIT_SHIFT) & 0x3; sz = 1 /* Type */ + 4 /* Version */ + 1 /* DCIL */ + dcid_len + 1 /* SCIL */ + CN_SCID(lconn)->len + (header_type == HETY_INITIAL) /* Token length */ + 2 /* Always use two bytes to encode payload length */ + iquic_packno_bits2len(packno_bits) ; return sz; } static size_t ietf_v1_packout_header_size_long_by_packet (const struct lsquic_conn *lconn, const struct lsquic_packet_out *packet_out) { size_t sz; unsigned token_len; /* Need intermediate value to quiet compiler warning */ enum packno_bits packno_bits; packno_bits = lsquic_packet_out_packno_bits(packet_out); sz = 1 /* Type */ + 4 /* Version */ + 1 /* DCIL */ + packet_out->po_path->np_dcid.len + 1 /* SCIL */ + CN_SCID(lconn)->len + (packet_out->po_header_type == HETY_INITIAL ? (token_len = packet_out->po_token_len, (1 << vint_val2bits(token_len)) + token_len) : 0) + 2 /* Always use two bytes to encode payload length */ + iquic_packno_bits2len(packno_bits) ; return sz; } static size_t ietf_v1_packout_header_size_short (enum packet_out_flags flags, size_t dcid_len) { enum packno_bits bits; size_t sz; bits = (flags >> POBIT_SHIFT) & 0x3; sz = 1 /* Type */ + (flags & PO_CONN_ID ? dcid_len : 0) + iquic_packno_bits2len(bits) ; return sz; } static size_t ietf_v1_packout_max_header_size (const struct lsquic_conn *lconn, enum packet_out_flags flags, size_t dcid_len, enum header_type header_type) { if ((lconn->cn_flags & LSCONN_HANDSHAKE_DONE) && header_type == HETY_SHORT) return ietf_v1_packout_header_size_short(flags, dcid_len); else return ietf_v1_packout_header_size_long_by_flags(lconn, header_type, flags, dcid_len); } /* [draft-ietf-quic-transport-17] Section-17.2 */ static const unsigned char header_type_to_bin[] = { [HETY_INITIAL] = 0x0, [HETY_0RTT] = 0x1, [HETY_HANDSHAKE] = 0x2, [HETY_RETRY] = 0x3, }; /* [draft-ietf-quic-v2] Section-3.2 */ static const unsigned char header_type_to_bin_v2[] = { [HETY_INITIAL] = 0x1, [HETY_0RTT] = 0x2, [HETY_HANDSHAKE] = 0x3, [HETY_RETRY] = 0x0, }; static unsigned write_packno (unsigned char *p, lsquic_packno_t packno, enum packno_bits bits) { unsigned char *const begin = p; switch (bits) { case IQUIC_PACKNO_LEN_4: *p++ = packno >> 24; /* fall through */ case IQUIC_PACKNO_LEN_3: *p++ = packno >> 16; /* fall through */ case IQUIC_PACKNO_LEN_2: *p++ = packno >> 8; /* fall through */ default: *p++ = packno; } return p - begin; } static int gen_long_pkt_header (const struct lsquic_conn *lconn, const struct lsquic_packet_out *packet_out, unsigned char *buf, size_t bufsz, unsigned *packno_off_p, unsigned *packno_len_p) { unsigned payload_len, bits; enum packno_bits packno_bits; lsquic_ver_tag_t ver_tag; unsigned char *p; unsigned token_len; size_t need; need = ietf_v1_packout_header_size_long_by_packet(lconn, packet_out); if (need > bufsz) { errno = EINVAL; return -1; } packno_bits = lsquic_packet_out_packno_bits(packet_out); p = buf; if (lconn->cn_version == LSQVER_I002) *p++ = 0xC0 | ( header_type_to_bin_v2[ packet_out->po_header_type ] << 4) | packno_bits ; else *p++ = 0xC0 | ( header_type_to_bin[ packet_out->po_header_type ] << 4) | packno_bits ; ver_tag = lsquic_ver2tag(lconn->cn_version); memcpy(p, &ver_tag, sizeof(ver_tag)); p += sizeof(ver_tag); *p++ = packet_out->po_path->np_dcid.len; memcpy(p, packet_out->po_path->np_dcid.idbuf, packet_out->po_path->np_dcid.len); p += packet_out->po_path->np_dcid.len; *p++ = CN_SCID(lconn)->len; memcpy(p, CN_SCID(lconn)->idbuf, CN_SCID(lconn)->len); p += CN_SCID(lconn)->len; if (HETY_INITIAL == packet_out->po_header_type) { token_len = packet_out->po_token_len; bits = vint_val2bits(token_len); vint_write(p, token_len, bits, 1 << bits); p += 1 << bits; memcpy(p, packet_out->po_token, token_len); p += token_len; } payload_len = packet_out->po_data_sz + lconn->cn_esf_c->esf_tag_len + iquic_packno_bits2len(packno_bits); bits = 1; /* Always use two bytes to encode payload length */ vint_write(p, payload_len, bits, 1 << bits); p += 1 << bits; *packno_off_p = p - buf; *packno_len_p = iquic_packno_bits2len(packno_bits); p += write_packno(p, packet_out->po_packno, packno_bits); return p - buf; } static int gen_short_pkt_header (const struct lsquic_conn *lconn, const struct lsquic_packet_out *packet_out, unsigned char *buf, size_t bufsz, unsigned *packno_off_p, unsigned *packno_len_p) { unsigned packno_len, cid_len, need; enum packno_bits packno_bits; packno_bits = lsquic_packet_out_packno_bits(packet_out); packno_len = iquic_packno_bits2len(packno_bits); cid_len = packet_out->po_flags & PO_CONN_ID ? packet_out->po_path->np_dcid.len : 0; need = 1 + cid_len + packno_len; if (need > bufsz) return -1; buf[0] = QUIC_BIT | (lsquic_packet_out_spin_bit(packet_out) << 5) | (lsquic_packet_out_square_bit(packet_out) << 4) | (lsquic_packet_out_loss_bit(packet_out) << 3) | (lsquic_packet_out_kp(packet_out) << 2) | packno_bits ; if (cid_len) memcpy(buf + 1, packet_out->po_path->np_dcid.idbuf, cid_len); (void) write_packno(buf + 1 + cid_len, packet_out->po_packno, packno_bits); *packno_off_p = 1 + cid_len; *packno_len_p = packno_len; return need; } static int ietf_v1_gen_reg_pkt_header (const struct lsquic_conn *lconn, const struct lsquic_packet_out *packet_out, unsigned char *buf, size_t bufsz, unsigned *packno_off, unsigned *packno_len) { if (packet_out->po_header_type == HETY_SHORT) return gen_short_pkt_header(lconn, packet_out, buf, bufsz, packno_off, packno_len); else return gen_long_pkt_header(lconn, packet_out, buf, bufsz, packno_off, packno_len); } static size_t ietf_v1_packout_size (const struct lsquic_conn *lconn, const struct lsquic_packet_out *packet_out) { size_t sz; if ((lconn->cn_flags & LSCONN_HANDSHAKE_DONE) && packet_out->po_header_type == HETY_SHORT) sz = ietf_v1_packout_header_size_short(packet_out->po_flags, packet_out->po_path->np_dcid.len); else sz = ietf_v1_packout_header_size_long_by_packet(lconn, packet_out); sz += packet_out->po_data_sz; sz += lconn->cn_esf_c->esf_tag_len; return sz; } static int ietf_v1_gen_stream_frame (unsigned char *buf, size_t buf_len, lsquic_stream_id_t stream_id, uint64_t offset, int fin, size_t size, gsf_read_f gsf_read, void *stream) { /* 0b00001XXX * 0x4 OFF * 0x2 LEN * 0x1 FIN */ unsigned sbits, obits, dbits; unsigned slen, olen, dlen; unsigned char *p = buf + 1; #if _MSC_VER obits = 0, dbits = 0; #endif assert(!!fin || !!size); /* We do not check that stream_id, offset, and size are smaller * than 2^62: this is not necessary, as this code will never generate * this many stream IDs, nor will it even transfer this much data. * The size is limited by our own code. */ sbits = vint_val2bits(stream_id); slen = 1 << sbits; if (offset) { obits = vint_val2bits(offset); olen = 1 << obits; } else olen = 0; if (!fin) { unsigned n_avail; size_t nr; n_avail = buf_len - (p + slen + olen - buf); /* If we cannot fill remaining buffer, we need to include data * length. */ if (size < n_avail) { dbits = vint_val2bits(size); dlen = 1 << dbits; n_avail -= dlen; if (size > n_avail) size = n_avail; } else { dlen = 0; size = n_avail; } CHECK_STREAM_SPACE(1 + olen + slen + dlen + + 1 /* We need to write at least 1 byte */, buf, buf + buf_len); vint_write(p, stream_id, sbits, slen); p += slen; if (olen) vint_write(p, offset, obits, olen); p += olen; /* Read as much as we can */ nr = gsf_read(stream, p + dlen, size, &fin); if (nr == 0) return 0; assert(nr <= size); if (dlen) vint_write(p, nr, dbits, dlen); p += dlen + nr; } else { dlen = 1 + slen + olen < buf_len; CHECK_STREAM_SPACE(1 + slen + olen + dlen, buf, buf + buf_len); vint_write(p, stream_id, sbits, slen); p += slen; if (olen) vint_write(p, offset, obits, olen); p += olen; if (dlen) *p++ = 0; } buf[0] = 0x08 | (!!olen << 2) | (!!dlen << 1) | (!!fin << 0) ; return p - buf; } int lsquic_ietf_v1_gen_crypto_frame (unsigned char *buf, unsigned char first_byte, size_t buf_len, lsquic_stream_id_t UNUSED_1, uint64_t offset, int UNUSED_2, size_t size, gsf_read_f gsf_read, void *stream) { unsigned char *const end = buf + buf_len; unsigned char *p; unsigned obits, dbits; unsigned olen, dlen; size_t nr, n_avail; int dummy_fin; obits = vint_val2bits(offset); olen = 1 << obits; dbits = vint_val2bits(size); dlen = 1 << dbits; CHECK_SPACE(1 + olen + dlen + (dlen > 0) /* We need to write at least 1 byte */, buf, end); n_avail = end - buf - 1 - olen - dlen; if (n_avail < size) size = n_avail; p = buf; *p++ = first_byte; vint_write(p, offset, obits, olen); p += olen; nr = gsf_read(stream, p + dlen, size, &dummy_fin); assert(nr != 0); /* This indicates error in the caller */ assert(nr <= size); /* This also indicates an error in the caller */ vint_write(p, nr, dbits, dlen); p += dlen + nr; return p - buf; } static int ietf_v1_gen_crypto_frame (unsigned char *buf, size_t buf_len, lsquic_stream_id_t stream_id, uint64_t offset, int fin, size_t size, gsf_read_f gsf_read, void *stream) { return lsquic_ietf_v1_gen_crypto_frame(buf, 0x6, buf_len, stream_id, offset, fin, size, gsf_read, stream); } static int ietf_v1_dec_stream_frame_size (unsigned char *p, size_t new_size) { /* 0b00001XXX * 0x4 OFF * 0x2 LEN * 0x1 FIN */ unsigned bits; const char type = *p++; if (!(type & 0x2)) return 1; /* Stream ID */ bits = *p >> 6; p += 1 << bits; if (type & 0x4) { /* Offset */ bits = *p >> 6; p += 1 << bits; } /* Write new size */ bits = *p >> 6; vint_write(p, new_size, bits, 1 << bits); return 0; } /* return parsed (used) buffer length */ static int ietf_v1_parse_stream_frame (const unsigned char *buf, size_t rem_packet_sz, struct stream_frame *stream_frame) { /* 0b00001XXX * 0x4 OFF * 0x2 LEN * 0x1 FIN */ const unsigned char *const pend = buf + rem_packet_sz; const unsigned char *p = buf; lsquic_stream_id_t stream_id; uint64_t offset, data_sz; int r; CHECK_SPACE(1, p, pend); const char type = *p++; r = vint_read(p, pend, &stream_id); if (r < 0) return -1; p += r; if (type & 0x4) { r = vint_read(p, pend, &offset); if (r < 0) return -1; p += r; } else offset = 0; if (type & 0x2) { r = vint_read(p, pend, &data_sz); if (r < 0) return -1; p += r; CHECK_SPACE(data_sz, p, pend); } else data_sz = pend - p; /* Largest offset cannot exceed this value and we MUST detect this error */ if (VINT_MAX_VALUE - offset < data_sz) return -1; stream_frame->stream_id = stream_id; stream_frame->data_frame.df_fin = type & 0x1; stream_frame->data_frame.df_offset = offset; stream_frame->data_frame.df_size = data_sz; stream_frame->data_frame.df_data = p; stream_frame->data_frame.df_read_off= 0; stream_frame->packet_in = NULL; assert(p <= pend); return p + data_sz - (unsigned char *) buf; } int lsquic_ietf_v1_parse_crypto_frame (const unsigned char *buf, size_t rem_packet_sz, struct stream_frame *stream_frame) { const unsigned char *const pend = buf + rem_packet_sz; const unsigned char *p = buf; uint64_t offset, data_sz; int r; CHECK_SPACE(1, p, pend); ++p; r = vint_read(p, pend, &offset); if (r < 0) return -1; p += r; r = vint_read(p, pend, &data_sz); if (r < 0) return -1; p += r; CHECK_SPACE(data_sz, p, pend); /* Largest offset cannot exceed this value and we MUST detect this error */ if (VINT_MAX_VALUE - offset < data_sz) return -1; stream_frame->stream_id = ~0ULL; /* Unset */ stream_frame->data_frame.df_fin = 0; stream_frame->data_frame.df_offset = offset; stream_frame->data_frame.df_size = data_sz; stream_frame->data_frame.df_data = p; stream_frame->data_frame.df_read_off= 0; stream_frame->packet_in = NULL; assert(p <= pend); return p + data_sz - (unsigned char *) buf; } static int ietf_v1_parse_crypto_frame (const unsigned char *buf, size_t rem_packet_sz, struct stream_frame *stream_frame) { if (rem_packet_sz > 0) { assert(0x06 == buf[0]); return lsquic_ietf_v1_parse_crypto_frame(buf, rem_packet_sz, stream_frame); } else return -1; } #if __GNUC__ # define UNLIKELY(cond) __builtin_expect(cond, 0) #else # define UNLIKELY(cond) cond #endif /* Bits 10 (2) is ECT(0); * bits 01 (1) is ECT(1). */ static const int ecnmap[4] = { 0, 2, 1, 3, }; static int ietf_v1_parse_ack_frame (const unsigned char *const buf, size_t buf_len, struct ack_info *ack, uint8_t exp) { const unsigned char *p = buf; const unsigned char *const end = buf + buf_len; uint64_t block_count, gap, block; enum ecn ecn; unsigned i; int r; ++p; r = vint_read(p, end, &ack->ranges[0].high); if (UNLIKELY(r < 0)) return -1; p += r; r = vint_read(p, end, &ack->lack_delta); if (UNLIKELY(r < 0)) return -1; p += r; ack->lack_delta <<= exp; r = vint_read(p, end, &block_count); if (UNLIKELY(r < 0)) return -1; p += r; r = vint_read(p, end, &block); if (UNLIKELY(r < 0)) return -1; ack->ranges[0].low = ack->ranges[0].high - block; if (UNLIKELY(ack->ranges[0].high < ack->ranges[0].low)) return -1; p += r; for (i = 1; i <= block_count; ++i) { r = vint_read(p, end, &gap); if (UNLIKELY(r < 0)) return -1; p += r; r = vint_read(p, end, &block); if (UNLIKELY(r < 0)) return -1; p += r; if (i < sizeof(ack->ranges) / sizeof(ack->ranges[0])) { ack->ranges[i].high = ack->ranges[i - 1].low - gap - 2; ack->ranges[i].low = ack->ranges[i].high - block; if (UNLIKELY(ack->ranges[i].high >= ack->ranges[i - 1].low || ack->ranges[i].high < ack->ranges[i].low)) return -1; } } if (i < sizeof(ack->ranges) / sizeof(ack->ranges[0])) { ack->flags = 0; ack->n_ranges = block_count + 1; } else { ack->flags = AI_TRUNCATED; ack->n_ranges = sizeof(ack->ranges) / sizeof(ack->ranges[0]); } if (0x03 == buf[0]) { for (ecn = 1; ecn <= 3; ++ecn) { r = vint_read(p, end, &ack->ecn_counts[ecnmap[ecn]]); if (UNLIKELY(r < 0)) return -1; p += r; } ack->flags |= AI_ECN; } return p - buf; } static unsigned ietf_v1_rst_frame_size (lsquic_stream_id_t stream_id, uint64_t error_code, uint64_t final_size) { return 1 /* Type */ + vint_size(stream_id) /* Stream ID (i) */ + vint_size(error_code) /* Application Error Code (i) */ + vint_size(final_size); /* Final Size (i) */ } static int ietf_v1_gen_rst_frame (unsigned char *buf, size_t buf_len, lsquic_stream_id_t stream_id, uint64_t final_size, uint64_t error_code) { unsigned vbits; unsigned char *p; if (buf_len < ietf_v1_rst_frame_size(stream_id, error_code, final_size)) return -1; p = buf; *p++ = 0x04; /* Stream ID (i) */ vbits = vint_val2bits(stream_id); vint_write(p, stream_id, vbits, 1 << vbits); p += 1 << vbits; /* Application Error Code (i) */ vbits = vint_val2bits(error_code); vint_write(p, error_code, vbits, 1 << vbits); p += 1 << vbits; /* Final Size (i) */ vbits = vint_val2bits(final_size); vint_write(p, final_size, vbits, 1 << vbits); p += 1 << vbits; return p - buf; } static int ietf_v1_parse_rst_frame (const unsigned char *buf, size_t buf_len, lsquic_stream_id_t *stream_id_p, uint64_t *final_size_p, uint64_t *error_code_p) { const unsigned char *p = buf + 1; const unsigned char *const end = buf + buf_len; uint64_t stream_id, final_size, error_code; int r; /* Stream ID (i) */ r = vint_read(p, end, &stream_id); if (r < 0) return r; p += r; /* Application Error Code (i) */ r = vint_read(p, end, &error_code); if (r < 0) return r; p += r; /* Final Size (i) */ r = vint_read(p, end, &final_size); if (r < 0) return r; p += r; *stream_id_p = stream_id; *final_size_p = final_size; *error_code_p = error_code; return p - buf; } static int ietf_v1_parse_stop_sending_frame (const unsigned char *buf, size_t buf_len, lsquic_stream_id_t *stream_id, uint64_t *error_code) { const unsigned char *p = buf + 1; const unsigned char *const end = buf + buf_len; int r; r = vint_read(p, end, stream_id); if (r < 0) return r; p += r; r = vint_read(p, end, error_code); if (r < 0) return r; p += r; return p - buf; } static int ietf_v1_gen_stop_sending_frame (unsigned char *buf, size_t len, lsquic_stream_id_t stream_id, uint64_t error_code) { return ietf_v1_gen_two_varints(buf, len, 0x05, (uint64_t[]){ stream_id, error_code, }); } static unsigned ietf_v1_stop_sending_frame_size (lsquic_stream_id_t val, uint64_t error_code) { return 1 + vint_size(val) + vint_size(error_code); } static int ietf_v1_parse_new_token_frame (const unsigned char *buf, size_t buf_len, const unsigned char **token, size_t *token_size_p) { uint64_t token_size; const unsigned char *p = buf + 1; const unsigned char *const end = buf + buf_len; int r; r = vint_read(p, end, &token_size); if (r < 0) return r; p += r; if (p + token_size > end) return -1; *token = p; p += token_size; *token_size_p = token_size; return p - buf; } static int ietf_v1_gen_ping_frame (unsigned char *buf, int buf_len) { if (buf_len > 0) { buf[0] = 0x01; return 1; } else return -1; } static size_t ietf_v1_connect_close_frame_size (int app_error, unsigned error_code, unsigned frame_type, size_t reason_len) { return 1 /* Type */ + (1 << vint_val2bits(error_code)) /* Error code */ + (app_error ? 0 : 1 << vint_val2bits(frame_type)) /* Frame type */ + (1 << vint_val2bits(reason_len)) /* Reason Phrase Length */ + reason_len ; } static int ietf_v1_gen_connect_close_frame (unsigned char *buf, size_t buf_len, int app_error, unsigned error_code, const char *reason, int reason_len) { size_t needed; unsigned bits_error, bits_reason; unsigned char *p; assert(!!reason == !!reason_len); bits_reason = vint_val2bits(reason_len); bits_error = vint_val2bits(error_code); needed = 1 /* Type */ + (1 << bits_error) + (app_error ? 0 : 1) /* Frame type */ /* TODO: frame type instead of just zero */ + (1 << bits_reason) + reason_len; if (buf_len < needed) return -1; p = buf; *p = 0x1C + !!app_error; ++p; vint_write(p, error_code, bits_error, 1 << bits_error); p += 1 << bits_error; if (!app_error) *p++ = 0; /* Frame type */ /* TODO */ vint_write(p, reason_len, bits_reason, 1 << bits_reason); p += 1 << bits_reason; if (reason_len) { memcpy(p, reason, reason_len); p += reason_len; } assert((unsigned) (p - buf) == needed); return p - buf; } static int ietf_v1_parse_connect_close_frame (const unsigned char *buf, size_t buf_len, int *app_error_p, uint64_t *error_code, uint16_t *reason_len, uint8_t *reason_offset) { const unsigned char *const pend = buf + buf_len; const unsigned char *p = buf + 1; uint64_t len; ptrdiff_t off; int app_error, r; r = vint_read(p, pend, error_code); if (r < 0) return -1; p += r; app_error = buf[0] == 0x1D; if (!app_error) { r = vint_read(p, pend, &len); if (r < 0) return -1; p += r; } r = vint_read(p, pend, &len); if (r < 0) return -1; if (len > UINT16_MAX) return -1; p += r; off = p - buf; if (buf_len < off + len) return -2; *app_error_p = app_error; *reason_len = len; *reason_offset = off; return off + len; } /* Returns number of bytes written or -1 on failure */ /* This function makes an assumption that there is at least one range */ static int ietf_v1_gen_ack_frame (unsigned char *outbuf, size_t outbuf_sz, gaf_rechist_first_f rechist_first, gaf_rechist_next_f rechist_next, gaf_rechist_largest_recv_f rechist_largest_recv, void *rechist, lsquic_time_t now, int *has_missing, lsquic_packno_t *largest_received, const uint64_t *ecn_counts) { unsigned char *block_count_p, *p = outbuf; unsigned char *const end = p + outbuf_sz; lsquic_time_t time_diff; lsquic_packno_t packno_diff, gap, prev_low, maxno, rsize; size_t sz; const struct lsquic_packno_range *range; unsigned a, b, c, addl_ack_blocks, ecn_needs; unsigned bits[4]; enum ecn ecn; #define AVAIL() (end - p) #define CHECKOUT(sz) do { \ if ((intptr_t) (sz) > AVAIL()) { \ errno = ENOBUFS; \ return -1; \ } \ } while (0) range = rechist_first(rechist); if (!range) { errno = EINVAL; return -1; } // LSQ_DEBUG("range [%"PRIu64" - %"PRIu64"]", range->high, range->low); time_diff = now - rechist_largest_recv(rechist); time_diff >>= TP_DEF_ACK_DELAY_EXP; maxno = range->high; packno_diff = maxno - range->low; a = vint_val2bits(maxno); b = vint_val2bits(time_diff); c = vint_val2bits(packno_diff); sz = 1 /* Type */ + (1 << a) /* Largest Acknowledged */ + (1 << b) /* ACK Delay */ + 1 /* ACK Block Count */ + (1 << c) /* ACK Blocks */ ; CHECKOUT(sz); if (ecn_counts) { for (ecn = 1; ecn <= 3; ++ecn) bits[ecn] = vint_val2bits(ecn_counts[ecn]); ecn_needs = (1 << bits[1]) + (1 << bits[2]) + (1 << bits[3]); } else ecn_needs = 0; *p = 0x02 + !!ecn_counts; ++p; vint_write(p, maxno, a, 1 << a); p += 1 << a; vint_write(p, time_diff, b, 1 << b); p += 1 << b; block_count_p = p; p += 1; /* Initial guess that we have fewer than 64 additional ACK Blocks */ vint_write(p, packno_diff, c, 1 << c); p += 1 << c; prev_low = range->low; addl_ack_blocks = 0; while ((range = rechist_next(rechist))) { // LSQ_DEBUG("range [%"PRIu64" - %"PRIu64"]", range->high, range->low); gap = prev_low - range->high - 1; rsize = range->high - range->low; a = vint_val2bits(gap - 1); b = vint_val2bits(rsize); if (ecn_needs + (1 << a) + (1 << b) > (unsigned)AVAIL()) break; if (addl_ack_blocks == VINT_MAX_ONE_BYTE) { memmove(block_count_p + 2, block_count_p + 1, p - block_count_p - 1); ++p; } vint_write(p, gap - 1, a, 1 << a); p += 1 << a; vint_write(p, rsize, b, 1 << b); p += 1 << b; ++addl_ack_blocks; prev_low = range->low; } /* Here we assume that addl_ack_blocks < (1 << 14), which is a safe * assumption to make. */ vint_write(block_count_p, addl_ack_blocks, addl_ack_blocks > VINT_MAX_ONE_BYTE, 1 + (addl_ack_blocks > VINT_MAX_ONE_BYTE)); if (ecn_counts) { assert(ecn_needs <= (unsigned)AVAIL()); for (ecn = 1; ecn <= 3; ++ecn) { vint_write(p, ecn_counts[ecnmap[ecn]], bits[ecnmap[ecn]], 1 << bits[ecnmap[ecn]]); p += 1 << bits[ecnmap[ecn]]; } } *has_missing = addl_ack_blocks > 0; *largest_received = maxno; return p - (unsigned char *) outbuf; #undef CHECKOUT #undef AVAIL } static size_t ietf_v1_calc_stream_frame_header_sz (lsquic_stream_id_t stream_id, uint64_t offset, unsigned data_sz) { if (offset) return 1 + (1 << vint_val2bits(stream_id)) + (1 << vint_val2bits(data_sz)) + (1 << vint_val2bits(offset)); else return 1 + (1 << vint_val2bits(data_sz)) + (1 << vint_val2bits(stream_id)); } /* [draft-ietf-quic-transport-24] Section 19.6 */ static size_t ietf_v1_calc_crypto_frame_header_sz (uint64_t offset, unsigned data_sz) { return 1 /* Frame type */ + (1 << vint_val2bits(offset)) + (1 << vint_val2bits(data_sz)) ; } static enum quic_frame_type ietf_v1_parse_frame_type (const unsigned char *buf, size_t len) { uint64_t val; int s; if (len > 0 && buf[0] < 0x40) return lsquic_iquic_byte2type[buf[0]]; s = vint_read(buf, buf + len, &val); if (s > 0 && (unsigned) s == (1u << vint_val2bits(val))) switch (val) { case FRAME_TYPE_ACK_FREQUENCY: return QUIC_FRAME_ACK_FREQUENCY; case FRAME_TYPE_TIMESTAMP: return QUIC_FRAME_TIMESTAMP; default: break; } return QUIC_FRAME_INVALID; } static unsigned ietf_v1_path_chal_frame_size (void) { return 1 + sizeof(uint64_t); } static int ietf_v1_gen_path_chal_frame (unsigned char *buf, size_t len, uint64_t chal) { if (len >= 1 + sizeof(chal)) { *buf = 0x1A; memcpy(buf + 1, &chal, sizeof(chal)); return 1 + sizeof(chal); } else return -1; } static int ietf_v1_parse_path_chal_frame (const unsigned char *buf, size_t len, uint64_t *chal) { if (len >= 9) { memcpy(chal, buf + 1, 8); return 9; } else return -1; } static unsigned ietf_v1_path_resp_frame_size (void) { return 1 + sizeof(uint64_t); } static int ietf_v1_gen_path_resp_frame (unsigned char *buf, size_t len, uint64_t resp) { if (len >= 1 + sizeof(resp)) { *buf = 0x1B; memcpy(buf + 1, &resp, sizeof(resp)); return 1 + sizeof(resp); } else return -1; } static int ietf_v1_parse_path_resp_frame (const unsigned char *buf, size_t len, uint64_t *resp) { return ietf_v1_parse_path_chal_frame(buf, len, resp); } static void ietf_v1_turn_on_fin (unsigned char *stream_frame_header) { *stream_frame_header |= 1; } static unsigned ietf_v1_packno_bits2len (enum packno_bits bits) { return iquic_packno_bits2len(bits); } static enum packno_bits ietf_v1_calc_packno_bits (lsquic_packno_t packno, lsquic_packno_t least_unacked, uint64_t n_in_flight) { uint64_t delta; unsigned bits; delta = packno - least_unacked; if (n_in_flight > delta) delta = n_in_flight; delta *= 4; bits = (delta >= (1ULL << 8)) + (delta >= (1ULL << 16)) + (delta >= (1ULL << 24)) ; return bits; } static int ietf_v1_parse_one_varint (const unsigned char *buf, size_t len, uint64_t *val) { int s; s = vint_read(buf + 1, buf + len, val); if (s >= 0) return 1 + s; else return s; } static int ietf_v1_gen_one_varint (unsigned char *buf, size_t len, unsigned char type, uint64_t val) { unsigned vbits; unsigned char *p; vbits = vint_val2bits(val); if (1u + (1u << vbits) > len) return -1; p = buf; *p++ = type; vint_write(p, val, vbits, 1 << vbits); p += 1 << vbits; return p - buf; } static int ietf_v1_gen_blocked_frame (unsigned char *buf, size_t buf_len, uint64_t off) { return ietf_v1_gen_one_varint(buf, buf_len, 0x14, off); } static int ietf_v1_parse_blocked_frame (const unsigned char *buf, size_t sz, uint64_t *off) { return ietf_v1_parse_one_varint(buf, sz, off); } static unsigned ietf_v1_blocked_frame_size (uint64_t off) { return 1 + vint_size(off); } static int ietf_v1_parse_max_data (const unsigned char *buf, size_t len, uint64_t *val) { return ietf_v1_parse_one_varint(buf, len, val); } static int ietf_v1_gen_max_data_frame (unsigned char *buf, size_t len, uint64_t val) { return ietf_v1_gen_one_varint(buf, len, 0x10, val); } static unsigned ietf_v1_max_data_frame_size (uint64_t val) { return 1 + vint_size(val); } static int ietf_v1_parse_retire_cid_frame (const unsigned char *buf, size_t len, uint64_t *val) { return ietf_v1_parse_one_varint(buf, len, val); } static int ietf_v1_gen_retire_cid_frame (unsigned char *buf, size_t len, uint64_t val) { return ietf_v1_gen_one_varint(buf, len, 0x19, val); } static size_t ietf_v1_retire_cid_frame_size (uint64_t val) { return 1 + vint_size(val); } static int ietf_v1_parse_new_conn_id (const unsigned char *buf, size_t len, uint64_t *seqno, uint64_t *retire_prior_to, lsquic_cid_t *cid, const unsigned char **reset_token) { const unsigned char *p = buf + 1; const unsigned char *const end = buf + len; unsigned char cid_len; int s; s = vint_read(p, end, seqno); if (s < 0) return s; p += s; s = vint_read(p, end, retire_prior_to); if (s < 0) return s; p += s; if (p >= end) return -1; cid_len = *p++; if (cid_len == 0 || cid_len > MAX_CID_LEN) return -2; if ((unsigned) (end - p) < cid_len + IQUIC_SRESET_TOKEN_SZ) return -1; cid->len = cid_len; memcpy(cid->idbuf, p, cid_len); p += cid_len; if (reset_token) *reset_token = p; p += IQUIC_SRESET_TOKEN_SZ; return p - buf; } /* Size of a frame that contains two varints */ static unsigned ietf_v1_two_varints_size (uint64_t vals[2]) { unsigned vbits[2]; vbits[0] = vint_val2bits(vals[0]); vbits[1] = vint_val2bits(vals[1]); return 1u + (1u << vbits[0]) + (1u << vbits[1]); } static int ietf_v1_gen_two_varints (unsigned char *buf, size_t len, unsigned char type, uint64_t vals[2]) { unsigned vbits[2]; unsigned char *p; vbits[0] = vint_val2bits(vals[0]); vbits[1] = vint_val2bits(vals[1]); if (1u + (1u << vbits[0]) + (1u << vbits[1]) > len) return -1; p = buf; *p++ = type; vint_write(p, vals[0], vbits[0], 1 << vbits[0]); p += 1 << vbits[0]; vint_write(p, vals[1], vbits[1], 1 << vbits[1]); p += 1 << vbits[1]; return p - buf; } static int ietf_v1_parse_two_varints (const unsigned char *buf, size_t len, uint64_t *vals[2]) { const unsigned char *p = buf; const unsigned char *const end = p + len; int s; if (len < 2) return -1; ++p; /* Type */ s = vint_read(p, end, vals[0]); if (s < 0) return s; p += s; s = vint_read(p, end, vals[1]); if (s < 0) return s; p += s; return p - buf; } /* vals[0] is the frame type */ static unsigned ietf_v1_frame_with_varints_size (unsigned n, uint64_t vals[]) { unsigned vbits, size; assert(n > 0); vbits = vint_val2bits(vals[0]); size = 1 << vbits; while (--n) { vbits = vint_val2bits(vals[n]); size += 1 << vbits; } return size; } /* vals[0] is the frame type */ static int ietf_v1_gen_frame_with_varints (unsigned char *buf, size_t len, unsigned count, uint64_t vals[]) { unsigned vbits, n; unsigned char *p; if (ietf_v1_frame_with_varints_size(count, vals) > len) return -1; p = buf; for (n = 0; n < count; ++n) { vbits = vint_val2bits(vals[n]); vint_write(p, vals[n], vbits, 1 << vbits); p += 1 << vbits; } return p - buf; } /* Frame type is checked when frame type is parsed. The only use here is * to calculate skip length. */ static int ietf_v1_parse_frame_with_varints (const unsigned char *buf, size_t len, const uint64_t frame_type, unsigned count, uint64_t *vals[]) { const unsigned char *p = buf; const unsigned char *const end = p + len; unsigned vbits, n; int s; vbits = vint_val2bits(frame_type); p += 1 << vbits; for (n = 0; n < count; ++n) { s = vint_read(p, end, vals[n]); if (s < 0) return s; p += s; } return p - buf; } static int ietf_v1_parse_stream_blocked_frame (const unsigned char *buf, size_t len, lsquic_stream_id_t *stream_id, uint64_t *offset) { return ietf_v1_parse_two_varints(buf, len, (uint64_t *[]) { stream_id, offset, }); } static unsigned ietf_v1_stream_blocked_frame_size (lsquic_stream_id_t stream_id, uint64_t off) { return ietf_v1_two_varints_size((uint64_t []) { stream_id, off, }); } static int ietf_v1_gen_streams_blocked_frame (unsigned char *buf, size_t len, enum stream_dir sd, uint64_t limit) { return ietf_v1_gen_one_varint(buf, len, 0x16 + (sd == SD_UNI), limit); } static int ietf_v1_parse_streams_blocked_frame (const unsigned char *buf, size_t len, enum stream_dir *sd, uint64_t *limit) { int s; s = ietf_v1_parse_one_varint(buf, len, limit); if (s > 0) { if (buf[0] == 0x16) *sd = SD_BIDI; else *sd = SD_UNI; } return s; } static unsigned ietf_v1_streams_blocked_frame_size (uint64_t limit) { return 1 + vint_size(limit); } static int ietf_v1_gen_stream_blocked_frame (unsigned char *buf, size_t len, lsquic_stream_id_t stream_id, uint64_t off) { return ietf_v1_gen_two_varints(buf, len, 0x15, (uint64_t[]){ stream_id, off, }); } static int ietf_v1_gen_max_stream_data_frame (unsigned char *buf, size_t len, lsquic_stream_id_t stream_id, uint64_t off) { return ietf_v1_gen_two_varints(buf, len, 0x11, (uint64_t[]){ stream_id, off, }); } static unsigned ietf_v1_max_stream_data_frame_size (lsquic_stream_id_t stream_id, uint64_t off) { return ietf_v1_two_varints_size((uint64_t []) { stream_id, off, }); } static int ietf_v1_parse_max_stream_data_frame (const unsigned char *buf, size_t len, lsquic_stream_id_t *stream_id, uint64_t *off) { return ietf_v1_parse_two_varints(buf, len, (uint64_t *[]){ stream_id, off, }); } static int ietf_v1_parse_max_streams_frame (const unsigned char *buf, size_t len, enum stream_dir *sd, uint64_t *max_streams) { int s; s = ietf_v1_parse_one_varint(buf, len, max_streams); if (s > 0) *sd = buf[0] == 0x12 ? SD_BIDI : SD_UNI; return s; } static int ietf_v1_gen_max_streams_frame (unsigned char *buf, size_t len, enum stream_dir sd, uint64_t limit) { return ietf_v1_gen_one_varint(buf, len, 0x12 + (sd == SD_UNI), limit); } static unsigned ietf_v1_max_streams_frame_size (uint64_t limit) { return 1 + vint_size(limit); } static size_t ietf_v1_new_token_frame_size (size_t token_sz) { unsigned bits; bits = vint_val2bits(token_sz); return 1 + (1 << bits) + token_sz; } static int ietf_v1_gen_new_token_frame (unsigned char *buf, size_t buf_sz, const unsigned char *token, size_t token_sz) { unsigned char *p; unsigned bits; bits = vint_val2bits(token_sz); if (buf_sz < 1 + (1 << bits) + token_sz) { errno = ENOBUFS; return -1; } p = buf; *p++ = 0x07; vint_write(p, token_sz, bits, 1 << bits); p += 1 << bits; memcpy(p, token, token_sz); p += token_sz; return p - buf; } static size_t ietf_v1_new_connection_id_frame_size (unsigned seqno, unsigned scid_len) { unsigned bits; bits = vint_val2bits(seqno); return 1 /* Frame Type */ + (1 << bits) /* Sequence Number */ + 1 /* Retire Prior To (we always set it to zero */ + 1 /* CID length */ + scid_len + IQUIC_SRESET_TOKEN_SZ; } static int ietf_v1_gen_new_connection_id_frame (unsigned char *buf, size_t buf_sz, unsigned seqno, const struct lsquic_cid *cid, const unsigned char *token, size_t token_sz) { unsigned char *p; unsigned bits; if (buf_sz < ietf_v1_new_connection_id_frame_size(seqno, cid->len)) return -1; p = buf; *p++ = 0x18; bits = vint_val2bits(seqno); vint_write(p, seqno, bits, 1 << bits); p += 1 << bits; *p++ = 0; /* Retire Prior To */ *p++ = cid->len; memcpy(p, cid->idbuf, cid->len); p += cid->len; memcpy(p, token, token_sz); p += token_sz; return p - buf; } /* [draft-ietf-quic-transport-17] Section-17.2 */ static const enum header_type bits2ht[4] = { [0] = HETY_INITIAL, [1] = HETY_0RTT, [2] = HETY_HANDSHAKE, [3] = HETY_RETRY, }; static const enum header_type bits2ht_v2[4] = { [0] = HETY_RETRY, [1] = HETY_INITIAL, [2] = HETY_0RTT, [3] = HETY_HANDSHAKE, }; #if LSQUIC_QIR /* Return true if the parsing function is to enforce the minimum DCID * length requirement as specified in IETF v1 and the I-Ds. */ static int enforce_initial_dcil (enum lsquic_version version) { return version != (enum lsquic_version) -1 && ((1 << version) & LSQUIC_IETF_VERSIONS); } #endif int lsquic_ietf_v1_parse_packet_in_long_begin (struct lsquic_packet_in *packet_in, size_t length, int is_server, unsigned cid_len, struct packin_parse_state *state) { const unsigned char *p = packet_in->pi_data; const unsigned char *const end = p + length; enum header_type header_type; unsigned dcil, scil; int r; unsigned char first_byte; uint64_t payload_len, token_len; if (length < 6) return -1; first_byte = *p++; if ((packet_in->pi_flags & PI_VER_PARSED) == 0) { packet_in->pi_version = lsquic_tag2ver_fast(p); packet_in->pi_flags |= PI_VER_PARSED; } p += 4; if (packet_in->pi_version != LSQVER_VERNEG) { if (packet_in->pi_version == LSQVER_I002) header_type = bits2ht_v2[ (first_byte >> 4) & 3 ]; else header_type = bits2ht[ (first_byte >> 4) & 3 ]; } else header_type = HETY_VERNEG; packet_in->pi_header_type = header_type; dcil = *p++; if (p + dcil >= end || dcil > MAX_CID_LEN) return -1; if (dcil) { memcpy(packet_in->pi_dcid.idbuf, p, dcil); packet_in->pi_flags |= PI_CONN_ID; p += dcil; } packet_in->pi_dcid.len = dcil; scil = *p++; if (p + scil > end || scil > MAX_CID_LEN) return -1; if (scil) { packet_in->pi_scid_off = p - packet_in->pi_data; p += scil; } packet_in->pi_scid_len = scil; switch (header_type) { case HETY_INITIAL: #if LSQUIC_QIR if (!enforce_initial_dcil(packet_in->pi_version)) { /* Count even zero-length DCID as having DCID */ packet_in->pi_flags |= PI_CONN_ID; } else #endif if (is_server && dcil < MIN_INITIAL_DCID_LEN) return -1; r = vint_read(p, end, &token_len); if (r < 0) return -1; if (token_len && !is_server) { /* From [draft-ietf-quic-transport-14]: * * Token Length: A variable-length integer specifying the * length of the Token field, in bytes. This value is zero * if no token is present. Initial packets sent by the * server MUST set the Token Length field to zero; clients * that receive an Initial packet with a non-zero Token * Length field MUST either discard the packet or generate * a connection error of type PROTOCOL_VIOLATION. */ return -1; } p += r; if (token_len) { if (token_len >= 1ull << (sizeof(packet_in->pi_token_size) * 8)) return -1; if (p + token_len > end) return -1; packet_in->pi_token = p - packet_in->pi_data; packet_in->pi_token_size = token_len; p += token_len; } /* fall-through */ case HETY_HANDSHAKE: case HETY_0RTT: if (p >= end) return -1; r = vint_read(p, end, &payload_len); if (r < 0) return -1; p += r; if (p - packet_in->pi_data + payload_len > length) return -1; length = p - packet_in->pi_data + payload_len; if (end - p < 4) return -1; state->pps_p = p - r; state->pps_nbytes = r; packet_in->pi_quic_ver = 1; break; case HETY_RETRY: if (p >= end) return -1; if (p /* [draft-ietf-quic-transport-25] Section 17.2.5 says that "a * client MUST discard a Retry packet with a zero-length Retry * Token field." We might as well do it here. */ + 1 /* Integrity tag length: */ + 16 > end) return -1; packet_in->pi_token = p - packet_in->pi_data; packet_in->pi_token_size = end - p - 16; /* Tag validation happens later */ p = end; length = end - packet_in->pi_data; state->pps_p = NULL; state->pps_nbytes = 0; packet_in->pi_quic_ver = 1; break; default: assert(header_type == HETY_VERNEG); if (p >= end || (3 & (uintptr_t) (end - p))) return -1; packet_in->pi_quic_ver = p - packet_in->pi_data; p = end; state->pps_p = NULL; state->pps_nbytes = 0; break; } packet_in->pi_header_sz = p - packet_in->pi_data; packet_in->pi_data_sz = length; packet_in->pi_nonce = 0; packet_in->pi_refcnt = 0; packet_in->pi_frame_types = 0; memset(&packet_in->pi_next, 0, sizeof(packet_in->pi_next)); packet_in->pi_refcnt = 0; packet_in->pi_received = 0; /* Packet number is set to an invalid value. The packet number must * be decrypted, which happens later. */ packet_in->pi_packno = 1ULL << 62; return 0; } /* Is this a valid Initial packet? We take the perspective of the server. */ int lsquic_is_valid_ietf_v1_or_Q046plus_hs_packet (const unsigned char *buf, size_t length, lsquic_ver_tag_t *tagp) { const unsigned char *p = buf; const unsigned char *const end = p + length; lsquic_ver_tag_t tag; enum header_type header_type; unsigned dcil, scil; int r; unsigned char first_byte; uint64_t payload_len, token_len, packet_len; if (length < 6) return 0; first_byte = *p++; if (*p != 0x6B) header_type = bits2ht[ (first_byte >> 4) & 3 ]; else header_type = bits2ht_v2[ (first_byte >> 4) & 3 ]; if (header_type != HETY_INITIAL) return 0; memcpy(&tag, p, 4); p += 4; switch (tag) { case 0: return 0; /* Client never sends version negotiation packets */ case TAG('Q', '0', '4', '6'): dcil = p[0] >> 4; if (dcil) dcil += 3; scil = p[0] & 0xF; if (scil) scil += 3; ++p; if (!(dcil == GQUIC_CID_LEN && scil == 0)) return 0; packet_len = first_byte & 3; if (end - p < (ptrdiff_t) (dcil + scil + packet_len)) return 0; break; case TAG('Q', '0', '5', '0'): dcil = *p++; if (dcil != 8) return 0; if (p + dcil + 1 >= end) return 0; p += dcil; scil = *p++; if (scil != 0) return 0; goto read_token; default: dcil = *p++; if (dcil < MIN_INITIAL_DCID_LEN || dcil > MAX_CID_LEN) return 0; if (p + dcil >= end) return 0; p += dcil; scil = *p++; if (p + scil > end || scil > MAX_CID_LEN) return 0; p += scil; read_token: r = vint_read(p, end, &token_len); if (r < 0) return 0; p += r; p += token_len; if (p >= end) return 0; r = vint_read(p, end, &payload_len); if (r < 0) return 0; p += r; if (p - buf + payload_len > length) return 0; if (end - p < 4) return 0; } *tagp = tag; return 1; } int lsquic_ietf_v1_parse_packet_in_short_begin (struct lsquic_packet_in *packet_in, size_t length, int is_server, unsigned cid_len, struct packin_parse_state *state) { unsigned char byte; unsigned header_sz; /* By the time this function has been called, we know length is non-zero */ byte = packet_in->pi_data[0]; /* [draft-ietf-quic-transport-17] Section 17.3 */ /* 01SRRKPP */ if (cid_len) { header_sz = 1 + cid_len; if (length < header_sz) return -1; memcpy(packet_in->pi_dcid.idbuf, packet_in->pi_data + 1, cid_len); packet_in->pi_dcid.len = cid_len; packet_in->pi_flags |= PI_CONN_ID; } else header_sz = 1; packet_in->pi_flags |= ((byte & 0x20) > 0) << PIBIT_SPIN_SHIFT; packet_in->pi_flags |= (byte & 3) << PIBIT_BITS_SHIFT; packet_in->pi_header_sz = header_sz; packet_in->pi_data_sz = length; packet_in->pi_quic_ver = 0; packet_in->pi_nonce = 0; packet_in->pi_refcnt = 0; packet_in->pi_frame_types = 0; memset(&packet_in->pi_next, 0, sizeof(packet_in->pi_next)); packet_in->pi_refcnt = 0; packet_in->pi_received = 0; /* This is so that Q046 works, ID-18 code does not use it */ state->pps_p = packet_in->pi_data + header_sz; state->pps_nbytes = 1 + (byte & 3); return 0; } #if __GNUC__ # define popcount __builtin_popcount #else static int popcount (unsigned v) { int count, i; for (i = 0, count = 0; i < sizeof(v) * 8; ++i) if (v & (1 << i)) ++count; return count; } #endif int lsquic_ietf_v1_gen_ver_nego_pkt (unsigned char *buf, size_t bufsz, const lsquic_cid_t *scid, const lsquic_cid_t *dcid, unsigned versions, uint8_t rand) { size_t need; int r; need = 1 /* Type */ + 4 /* Version */ + 1 /* DCIL */ + dcid->len + 1 /* SCIL */ + scid->len + popcount(versions) * 4; if (need > bufsz) return -1; *buf++ = 0x80 | QUIC_BIT | rand; memset(buf, 0, 4); buf += 4; /* From [draft-ietf-quic-transport-22], Section 17.2.1: * * The server MUST include the value from the Source Connection ID field * of the packet it receives in the Destination Connection ID field. * The value for Source Connection ID MUST be copied from the * Destination Connection ID of the received packet, which is initially * randomly selected by a client. Echoing both connection IDs gives * clients some assurance that the server received the packet and that * the Version Negotiation packet was not generated by an off-path * attacker. */ *buf++ = dcid->len; memcpy(buf, dcid->idbuf, dcid->len); buf += dcid->len; *buf++ = scid->len; memcpy(buf, scid->idbuf, scid->len); buf += scid->len; r = lsquic_gen_ver_tags(buf, bufsz - 1 - 4 - 2 - dcid->len - scid->len, versions); if (r < 0) return -1; assert((unsigned) r == popcount(versions) * 4u); return need; } static int ietf_v1_gen_handshake_done_frame (unsigned char *buf, size_t buf_len) { if (buf_len > 0) { *buf = 0x1E; return 1; } else return -1; } static int ietf_v1_parse_handshake_done_frame (const unsigned char *buf, size_t buf_len) { assert(buf[0] == 0x1E); assert(buf_len > 0); return 1; } static int ietf_v1_gen_ack_frequency_frame (unsigned char *buf, size_t buf_len, uint64_t seqno, uint64_t pack_tol, uint64_t upd_mad, int ignore) { int sz; sz = ietf_v1_gen_frame_with_varints(buf, buf_len, 4, (uint64_t[]){ FRAME_TYPE_ACK_FREQUENCY, seqno, pack_tol, upd_mad }); if (sz > 0 && (size_t) sz < buf_len) { buf[sz++] = !!ignore; return sz; } else return -1; } static int ietf_v1_parse_ack_frequency_frame (const unsigned char *buf, size_t buf_len, uint64_t *seqno, uint64_t *pack_tol, uint64_t *upd_mad, int *ignore) { int sz; sz = ietf_v1_parse_frame_with_varints(buf, buf_len, FRAME_TYPE_ACK_FREQUENCY, 3, (uint64_t *[]) { seqno, pack_tol, upd_mad }); if (sz > 0 && (size_t) sz < buf_len && buf[sz] < 2) { *ignore = buf[sz++]; return sz; } else return -1; } static unsigned ietf_v1_ack_frequency_frame_size (uint64_t seqno, uint64_t pack_tol, uint64_t upd_mad) { return 1 + ietf_v1_frame_with_varints_size(4, (uint64_t[]){ FRAME_TYPE_ACK_FREQUENCY, seqno, pack_tol, upd_mad }); } static unsigned ietf_v1_handshake_done_frame_size (void) { return 1; } static int ietf_v1_gen_timestamp_frame (unsigned char *buf, size_t buf_len, uint64_t timestamp) { return ietf_v1_gen_frame_with_varints(buf, buf_len, 2, (uint64_t[]){ FRAME_TYPE_TIMESTAMP, timestamp }); } static int ietf_v1_parse_timestamp_frame (const unsigned char *buf, size_t buf_len, uint64_t *timestamp) { return ietf_v1_parse_frame_with_varints(buf, buf_len, FRAME_TYPE_TIMESTAMP, 1, (uint64_t *[]) { timestamp }); } static int ietf_v1_parse_datagram_frame (const unsigned char *buf, size_t buf_len, const void **data, size_t *data_len) { uint64_t len; int s; /* Length and frame type have been checked already */ assert(buf_len > 0); assert(buf[0] == 0x30 || buf[0] == 0x31); if (buf[0] & 1) { s = vint_read(buf + 1, buf + buf_len, &len); if (s > 0 && 1 + s + len <= buf_len) { *data = buf + 1 + s; *data_len = len; return 1 + s + len; } else return -1; } else { *data = buf + 1; *data_len = buf_len - 1; return buf_len; } } static unsigned ietf_v1_datagram_frame_size (size_t sz) { return 1u + vint_size(sz) + sz; } static int ietf_v1_gen_datagram_frame (unsigned char *buf, size_t bufsz, size_t min_sz, size_t max_sz, ssize_t (*user_callback)(struct lsquic_conn *, void *, size_t), struct lsquic_conn *lconn) { unsigned bits, len_sz; ssize_t nw; /* We always generate length. A more efficient implementation would * complicate the API. */ if (min_sz) bits = vint_val2bits(min_sz); else bits = vint_val2bits(bufsz); len_sz = 1u << bits; if (1 + len_sz + min_sz > bufsz) { errno = ENOBUFS; return -1; } nw = user_callback(lconn, buf + 1 + len_sz, min_sz ? min_sz : MIN(bufsz - 1 - len_sz, max_sz)); if (nw >= 0) { buf[0] = 0x31; vint_write(&buf[1], (uint64_t) nw, bits, len_sz); return 1 + len_sz + nw; } else return -1; } const struct parse_funcs lsquic_parse_funcs_ietf_v1 = { .pf_gen_reg_pkt_header = ietf_v1_gen_reg_pkt_header, .pf_parse_packet_in_finish = ietf_v1_parse_packet_in_finish, .pf_gen_stream_frame = ietf_v1_gen_stream_frame, .pf_calc_stream_frame_header_sz = ietf_v1_calc_stream_frame_header_sz, .pf_parse_stream_frame = ietf_v1_parse_stream_frame, .pf_dec_stream_frame_size = ietf_v1_dec_stream_frame_size, .pf_parse_ack_frame = ietf_v1_parse_ack_frame, .pf_gen_ack_frame = ietf_v1_gen_ack_frame, .pf_gen_blocked_frame = ietf_v1_gen_blocked_frame, .pf_parse_blocked_frame = ietf_v1_parse_blocked_frame, .pf_blocked_frame_size = ietf_v1_blocked_frame_size, .pf_rst_frame_size = ietf_v1_rst_frame_size, .pf_gen_rst_frame = ietf_v1_gen_rst_frame, .pf_parse_rst_frame = ietf_v1_parse_rst_frame, .pf_connect_close_frame_size = ietf_v1_connect_close_frame_size, .pf_gen_connect_close_frame = ietf_v1_gen_connect_close_frame, .pf_parse_connect_close_frame = ietf_v1_parse_connect_close_frame, .pf_gen_ping_frame = ietf_v1_gen_ping_frame, .pf_parse_frame_type = ietf_v1_parse_frame_type, .pf_turn_on_fin = ietf_v1_turn_on_fin, .pf_packout_size = ietf_v1_packout_size, .pf_packout_max_header_size = ietf_v1_packout_max_header_size, .pf_path_chal_frame_size = ietf_v1_path_chal_frame_size, .pf_parse_path_chal_frame = ietf_v1_parse_path_chal_frame, .pf_gen_path_chal_frame = ietf_v1_gen_path_chal_frame, .pf_path_resp_frame_size = ietf_v1_path_resp_frame_size, .pf_gen_path_resp_frame = ietf_v1_gen_path_resp_frame, .pf_parse_path_resp_frame = ietf_v1_parse_path_resp_frame, .pf_calc_packno_bits = ietf_v1_calc_packno_bits, .pf_packno_bits2len = ietf_v1_packno_bits2len, .pf_gen_crypto_frame = ietf_v1_gen_crypto_frame, .pf_parse_crypto_frame = ietf_v1_parse_crypto_frame, .pf_calc_crypto_frame_header_sz = ietf_v1_calc_crypto_frame_header_sz, .pf_parse_max_data = ietf_v1_parse_max_data, .pf_gen_max_data_frame = ietf_v1_gen_max_data_frame, .pf_max_data_frame_size = ietf_v1_max_data_frame_size, .pf_parse_new_conn_id = ietf_v1_parse_new_conn_id, .pf_gen_stream_blocked_frame = ietf_v1_gen_stream_blocked_frame, .pf_parse_stream_blocked_frame = ietf_v1_parse_stream_blocked_frame, .pf_stream_blocked_frame_size = ietf_v1_stream_blocked_frame_size, .pf_gen_max_stream_data_frame = ietf_v1_gen_max_stream_data_frame, .pf_parse_max_stream_data_frame = ietf_v1_parse_max_stream_data_frame, .pf_max_stream_data_frame_size = ietf_v1_max_stream_data_frame_size, .pf_parse_stop_sending_frame = ietf_v1_parse_stop_sending_frame, .pf_gen_stop_sending_frame = ietf_v1_gen_stop_sending_frame, .pf_stop_sending_frame_size = ietf_v1_stop_sending_frame_size, .pf_parse_new_token_frame = ietf_v1_parse_new_token_frame, .pf_new_connection_id_frame_size = ietf_v1_new_connection_id_frame_size, .pf_gen_new_connection_id_frame = ietf_v1_gen_new_connection_id_frame, .pf_new_token_frame_size = ietf_v1_new_token_frame_size, .pf_gen_new_token_frame = ietf_v1_gen_new_token_frame, .pf_parse_retire_cid_frame = ietf_v1_parse_retire_cid_frame, .pf_gen_retire_cid_frame = ietf_v1_gen_retire_cid_frame, .pf_retire_cid_frame_size = ietf_v1_retire_cid_frame_size, .pf_gen_streams_blocked_frame = ietf_v1_gen_streams_blocked_frame, .pf_parse_streams_blocked_frame = ietf_v1_parse_streams_blocked_frame, .pf_streams_blocked_frame_size = ietf_v1_streams_blocked_frame_size, .pf_gen_max_streams_frame = ietf_v1_gen_max_streams_frame, .pf_parse_max_streams_frame = ietf_v1_parse_max_streams_frame, .pf_max_streams_frame_size = ietf_v1_max_streams_frame_size, .pf_gen_handshake_done_frame = ietf_v1_gen_handshake_done_frame, .pf_parse_handshake_done_frame = ietf_v1_parse_handshake_done_frame, .pf_handshake_done_frame_size = ietf_v1_handshake_done_frame_size, .pf_gen_ack_frequency_frame = ietf_v1_gen_ack_frequency_frame, .pf_parse_ack_frequency_frame = ietf_v1_parse_ack_frequency_frame, .pf_ack_frequency_frame_size = ietf_v1_ack_frequency_frame_size, .pf_gen_timestamp_frame = ietf_v1_gen_timestamp_frame, .pf_parse_timestamp_frame = ietf_v1_parse_timestamp_frame, .pf_parse_datagram_frame = ietf_v1_parse_datagram_frame, .pf_gen_datagram_frame = ietf_v1_gen_datagram_frame, .pf_datagram_frame_size = ietf_v1_datagram_frame_size, };