/* packet-gquic.c

 * Routines for (Google) Quick UDP Internet Connections dissection

 * Copyright 2013, Alexis La Goutte <alexis.lagoutte at gmail dot com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

/*

QUIC Wire Layout Specification : https://docs.google.com/document/d/1WJvyZflAO2pq77yOLbp9NsGjC1CHetAXV8I0fQe-B_U/

QUIC Crypto : https://docs.google.com/document/d/1g5nIXAIkN_Y-7XJW5K45IblHd_L2f5LTaDUDwvZ5L6g/

QUIC source code in Chromium : https://code.google.com/p/chromium/codesearch#chromium/src/net/quic/quic_utils.h&sq=package:chromium

*/

#include "config.h"

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/expert.h>

#include <epan/conversation.h>

#include <epan/tfs.h>

#include "packet-http2.h"

#include "packet-quic.h"

#include <wsutil/strtoi.h>

void proto_register_gquic(void);

void proto_reg_handoff_gquic(void);

static dissector_handle_t gquic_handle;

static dissector_handle_t tls13_handshake_handle;

static dissector_handle_t quic_handle;

static int proto_gquic;

static int hf_gquic_header_form;

static int hf_gquic_fixed_bit;

static int hf_gquic_long_packet_type;

static int hf_gquic_long_reserved;

static int hf_gquic_packet_number_length;

static int hf_gquic_dcil;

static int hf_gquic_scil;

static int hf_gquic_puflags;

static int hf_gquic_puflags_vrsn;

static int hf_gquic_puflags_rst;

static int hf_gquic_puflags_dnonce;

static int hf_gquic_puflags_cid;

static int hf_gquic_puflags_cid_old;

static int hf_gquic_puflags_pkn;

static int hf_gquic_puflags_mpth;

static int hf_gquic_puflags_rsv;

static int hf_gquic_cid;

static int hf_gquic_version;

static int hf_gquic_diversification_nonce;

static int hf_gquic_packet_number;

static int hf_gquic_prflags;

static int hf_gquic_prflags_entropy;

static int hf_gquic_prflags_fecg;

static int hf_gquic_prflags_fec;

static int hf_gquic_prflags_rsv;

static int hf_gquic_message_authentication_hash;

static int hf_gquic_frame;

static int hf_gquic_frame_type;

static int hf_gquic_frame_type_padding_length;

static int hf_gquic_frame_type_padding;

static int hf_gquic_frame_type_rsts_stream_id;

static int hf_gquic_frame_type_rsts_byte_offset;

static int hf_gquic_frame_type_rsts_error_code;

static int hf_gquic_frame_type_cc_error_code;

static int hf_gquic_frame_type_cc_reason_phrase_length;

static int hf_gquic_frame_type_cc_reason_phrase;

static int hf_gquic_frame_type_goaway_error_code;

static int hf_gquic_frame_type_goaway_last_good_stream_id;

static int hf_gquic_frame_type_goaway_reason_phrase_length;

static int hf_gquic_frame_type_goaway_reason_phrase;

static int hf_gquic_frame_type_wu_stream_id;

static int hf_gquic_frame_type_wu_byte_offset;

static int hf_gquic_frame_type_blocked_stream_id;

static int hf_gquic_frame_type_sw_send_entropy;

static int hf_gquic_frame_type_sw_least_unacked_delta;

static int hf_gquic_crypto_offset;

static int hf_gquic_crypto_length;

static int hf_gquic_crypto_crypto_data;

static int hf_gquic_frame_type_stream;

static int hf_gquic_frame_type_stream_f;

static int hf_gquic_frame_type_stream_d;

static int hf_gquic_frame_type_stream_ooo;

static int hf_gquic_frame_type_stream_ss;

/* ACK */

static int hf_gquic_frame_type_ack;

static int hf_gquic_frame_type_ack_n;

static int hf_gquic_frame_type_ack_u;

static int hf_gquic_frame_type_ack_t;

static int hf_gquic_frame_type_ack_ll;

static int hf_gquic_frame_type_ack_mm;

/* ACK Before Q034 */

static int hf_gquic_frame_type_ack_received_entropy;

static int hf_gquic_frame_type_ack_largest_observed;

static int hf_gquic_frame_type_ack_ack_delay_time;

static int hf_gquic_frame_type_ack_num_timestamp;

static int hf_gquic_frame_type_ack_delta_largest_observed;

static int hf_gquic_frame_type_ack_first_timestamp;

static int hf_gquic_frame_type_ack_time_since_previous_timestamp;

static int hf_gquic_frame_type_ack_num_ranges;

static int hf_gquic_frame_type_ack_missing_packet;

static int hf_gquic_frame_type_ack_range_length;

static int hf_gquic_frame_type_ack_num_revived;

static int hf_gquic_frame_type_ack_revived_packet;

/* ACK After Q034 */

static int hf_gquic_frame_type_ack_largest_acked;

static int hf_gquic_frame_type_ack_largest_acked_delta_time;

static int hf_gquic_frame_type_ack_num_blocks;

static int hf_gquic_frame_type_ack_first_ack_block_length;

static int hf_gquic_frame_type_ack_gap_to_next_block;

static int hf_gquic_frame_type_ack_ack_block_length;

static int hf_gquic_frame_type_ack_delta_largest_acked;

static int hf_gquic_frame_type_ack_time_since_largest_acked;

static int hf_gquic_stream_id;

static int hf_gquic_offset;

static int hf_gquic_data_len;

static int hf_gquic_tag;

static int hf_gquic_tags;

static int hf_gquic_tag_number;

static int hf_gquic_tag_value;

static int hf_gquic_tag_type;

static int hf_gquic_tag_offset_end;

static int hf_gquic_tag_length;

static int hf_gquic_tag_sni;

static int hf_gquic_tag_pad;

static int hf_gquic_tag_ver;

static int hf_gquic_tag_ccs;

static int hf_gquic_tag_pdmd;

static int hf_gquic_tag_uaid;

static int hf_gquic_tag_stk;

static int hf_gquic_tag_sno;

static int hf_gquic_tag_prof;

static int hf_gquic_tag_scfg;

static int hf_gquic_tag_scfg_number;

static int hf_gquic_tag_rrej;

static int hf_gquic_tag_crt;

static int hf_gquic_tag_aead;

static int hf_gquic_tag_scid;

static int hf_gquic_tag_pubs;

static int hf_gquic_tag_kexs;

static int hf_gquic_tag_obit;

static int hf_gquic_tag_expy;

static int hf_gquic_tag_nonc;

static int hf_gquic_tag_mspc;

static int hf_gquic_tag_tcid;

static int hf_gquic_tag_srbf;

static int hf_gquic_tag_icsl;

static int hf_gquic_tag_scls;

static int hf_gquic_tag_copt;

static int hf_gquic_tag_ccrt;

static int hf_gquic_tag_irtt;

static int hf_gquic_tag_cfcw;

static int hf_gquic_tag_sfcw;

static int hf_gquic_tag_cetv;

static int hf_gquic_tag_xlct;

static int hf_gquic_tag_nonp;

static int hf_gquic_tag_csct;

static int hf_gquic_tag_ctim;

static int hf_gquic_tag_mids;

static int hf_gquic_tag_fhol;

static int hf_gquic_tag_sttl;

static int hf_gquic_tag_smhl;

static int hf_gquic_tag_tbkp;

static int hf_gquic_tag_mad0;

static int hf_gquic_tag_qlve;

static int hf_gquic_tag_cgst;

static int hf_gquic_tag_epid;

static int hf_gquic_tag_srst;

/* Public Reset Tags */

static int hf_gquic_tag_rnon;

static int hf_gquic_tag_rseq;

static int hf_gquic_tag_cadr_addr_type;

static int hf_gquic_tag_cadr_addr_ipv4;

static int hf_gquic_tag_cadr_addr_ipv6;

static int hf_gquic_tag_cadr_addr;

static int hf_gquic_tag_cadr_port;

static int hf_gquic_tag_unknown;

static int hf_gquic_padding;

static int hf_gquic_stream_data;

static int hf_gquic_payload;

#define QUIC_PORT_RANGE "80,443"

static bool g_gquic_debug;

static int ett_gquic;

static int ett_gquic_puflags;

static int ett_gquic_prflags;

static int ett_gquic_ft;

static int ett_gquic_ftflags;

static int ett_gquic_tag_value;

static expert_field ei_gquic_tag_undecoded;

static expert_field ei_gquic_tag_length;

static expert_field ei_gquic_tag_unknown;

static expert_field ei_gquic_version_invalid;

static expert_field ei_gquic_invalid_parameter;

static expert_field ei_gquic_length_invalid;

static expert_field ei_gquic_data_invalid;

static const value_string gquic_short_long_header_vals[] = {

    { 0, "Short Header" },

    { 1, "Long Header" },

    { 0, NULL }

};

static const value_string gquic_long_packet_type_vals[] = {

    { 0, "Initial" },

    { 2, "Handshake" },

    { 1, "0-RTT" },

    { 0, NULL }

};

static const value_string gquic_packet_number_lengths[] = {

    { 0, "1 bytes" },

    { 1, "2 bytes" },

    { 2, "3 bytes" },

    { 3, "4 bytes" },

    { 0, NULL }

};

static const value_string quic_cid_lengths[] = {

    { 0, "0 bytes" },

    { 5, "8 bytes" },

    { 0, NULL }

};

#define GQUIC_MIN_LENGTH 3

#define GQUIC_MAGIC2 0x513032

#define GQUIC_MAGIC3 0x513033

#define GQUIC_MAGIC4 0x513034

#define GQUIC_VERSION_Q046 0x51303436

/**************************************************************************/

/*                      Public Flags                                      */

/**************************************************************************/

#define PUFLAGS_VRSN    0x01

#define PUFLAGS_RST     0x02

#define PUFLAGS_DNONCE  0x04

#define PUFLAGS_CID     0x08

#define PUFLAGS_CID_OLD 0x0C

#define PUFLAGS_PKN     0x30

#define PUFLAGS_MPTH    0x40

#define PUFLAGS_RSV     0x80

static const true_false_string puflags_cid_tfs = {

    "8 Bytes",

    "0 Byte"

};

static const value_string puflags_cid_old_vals[] = {

    { 0, "0 Byte" },

    { 1, "1 Bytes" },

    { 2, "4 Bytes" },

    { 3, "8 Bytes" },

    { 0, NULL }

};

static const value_string puflags_pkn_vals[] = {

    { 0, "1 Byte" },

    { 1, "2 Bytes" },

    { 2, "4 Bytes" },

    { 3, "6 Bytes" },

    { 0, NULL }

};

/**************************************************************************/

/*                      Private Flags                                     */

/**************************************************************************/

#define PRFLAGS_ENTROPY 0x01

#define PRFLAGS_FECG    0x02

#define PRFLAGS_FEC     0x04

#define PRFLAGS_RSV     0xF8

/**************************************************************************/

/*                      Frame Type Regular                                */

/**************************************************************************/

#define FT_PADDING          0x00

#define FT_RST_STREAM       0x01

#define FT_CONNECTION_CLOSE 0x02

#define FT_GOAWAY           0x03

#define FT_WINDOW_UPDATE    0x04

#define FT_BLOCKED          0x05

#define FT_STOP_WAITING     0x06

#define FT_PING             0x07

/* CRYPTO is not a real GQUIC frame, but a QUIC one. Since some GQUIC flows

 * have this kind of frame, try handling it like all the others */

#define FT_CRYPTO           0x08

/**************************************************************************/

/*                      Frame Type Special                                */

/**************************************************************************/

#define FTFLAGS_SPECIAL     0xE0

#define FTFLAGS_STREAM      0x80

#define FTFLAGS_STREAM_F    0x40

#define FTFLAGS_STREAM_D    0x20

#define FTFLAGS_STREAM_OOO  0x1C

#define FTFLAGS_STREAM_SS   0x03

#define FTFLAGS_ACK         0x40

#define FTFLAGS_ACK_N       0x20

#define FTFLAGS_ACK_U       0x10

#define FTFLAGS_ACK_T       0x10

#define FTFLAGS_ACK_LL      0x0C

#define FTFLAGS_ACK_MM      0x03

static const range_string frame_type_vals[] = {

  { 0,0,         "PADDING" },

  { 1,1,         "RST_STREAM" },

  { 2,2,         "CONNECTION_CLOSE" },

  { 3,3,         "GOAWAY" },

  { 4,4,         "WINDOW_UPDATE" },

  { 5,5,         "BLOCKED" },

  { 6,6,         "STOP_WAITING" },

  { 7,7,         "PING" },

  { 8,8,         "CRYPTO" },

  { 9,31,        "Unknown" },

  { 32,63,       "CONGESTION_FEEDBACK (Special Frame Type)" },

  { 64,127,      "ACK (Special Frame Type)" },

  { 128,256,     "STREAM (Special Frame Type)" },

  { 0,0, NULL }

};

static const value_string len_offset_vals[] = {

    { 0, "0 Byte" },

    { 1, "2 Bytes" },

    { 2, "3 Bytes" },

    { 3, "4 Bytes" },

    { 4, "5 Bytes" },

    { 5, "6 Bytes" },

    { 6, "7 Bytes" },

    { 7, "8 Bytes" },

    { 0, NULL }

};

static const value_string len_stream_vals[] = {

    { 0, "1 Byte" },

    { 1, "2 Bytes" },

    { 2, "3 Bytes" },

    { 3, "4 Bytes" },

    { 0, NULL }

};

static const true_false_string len_data_vals = {

    "2 Bytes",

    "0 Byte"

};

static const value_string len_largest_observed_vals[] = {

    { 0, "1 Byte" },

    { 1, "2 Bytes" },

    { 2, "4 Bytes" },

    { 3, "6 Bytes" },

    { 0, NULL }

};

static const value_string len_missing_packet_vals[] = {

    { 0, "1 Byte" },

    { 1, "2 Bytes" },

    { 2, "4 Bytes" },

    { 3, "6 Bytes" },

    { 0, NULL }

};

/**************************************************************************/

/*                      Message tag                                       */

/**************************************************************************/

#define MTAG_CHLO 0x43484C4F

#define MTAG_SHLO 0x53484C4F

#define MTAG_REJ  0x52454A00

#define MTAG_PRST 0x50525354

static const value_string message_tag_vals[] = {

    { MTAG_CHLO, "Client Hello" },

    { MTAG_SHLO, "Server Hello" },

    { MTAG_REJ, "Rejection" },

    { MTAG_PRST, "Public Reset" },

    { 0, NULL }

};

/**************************************************************************/

/*                      Tag                                               */

/**************************************************************************/

/* See https://chromium.googlesource.com/chromium/src.git/+/master/net/third_party/quic/core/crypto/crypto_protocol.h */

#define TAG_PAD  0x50414400

#define TAG_SNI  0x534E4900

#define TAG_VER  0x56455200

#define TAG_CCS  0x43435300

#define TAG_UAID 0x55414944

#define TAG_PDMD 0x50444d44

#define TAG_STK  0x53544b00

#define TAG_SNO  0x534E4F00

#define TAG_PROF 0x50524F46

#define TAG_SCFG 0x53434647

#define TAG_RREJ 0x5252454A

#define TAG_CRT  0x435254FF

#define TAG_AEAD 0x41454144

#define TAG_SCID 0x53434944

#define TAG_PUBS 0x50554253

#define TAG_KEXS 0x4B455853

#define TAG_OBIT 0x4F424954

#define TAG_EXPY 0x45585059

#define TAG_NONC 0x4E4F4E43

#define TAG_MSPC 0x4D535043

#define TAG_TCID 0x54434944

#define TAG_SRBF 0x53524246

#define TAG_ICSL 0x4943534C

#define TAG_SCLS 0x53434C53

#define TAG_COPT 0x434F5054

#define TAG_CCRT 0x43435254

#define TAG_IRTT 0x49525454

#define TAG_CFCW 0x43464357

#define TAG_SFCW 0x53464357

#define TAG_CETV 0x43455456

#define TAG_XLCT 0x584C4354

#define TAG_NONP 0x4E4F4E50

#define TAG_CSCT 0x43534354

#define TAG_CTIM 0x4354494D

#define TAG_MIDS 0x4D494453

#define TAG_FHOL 0x46484F4C

#define TAG_STTL 0x5354544C

#define TAG_SMHL 0x534D484C

#define TAG_TBKP 0x54424B50

#define TAG_MAD0 0x4d414400

#define TAG_QLVE 0x514C5645

#define TAG_CGST 0x43475354

#define TAG_EPID 0x45504944

#define TAG_SRST 0x53525354

/* Public Reset Tag */

#define TAG_RNON 0x524E4F4E

#define TAG_RSEQ 0x52534551

#define TAG_CADR 0x43414452

static const value_string tag_vals[] = {

    { TAG_PAD, "Padding" },

    { TAG_SNI, "Server Name Indication" },

    { TAG_VER, "Version" },

    { TAG_CCS, "Common Certificate Sets" },

    { TAG_UAID, "Client's User Agent ID" },

    { TAG_PDMD, "Proof Demand" },

    { TAG_STK, "Source Address Token" },

    { TAG_SNO, "Server nonce" },

    { TAG_PROF, "Proof (Signature)" },

    { TAG_SCFG, "Server Config" },

    { TAG_RREJ, "Reasons for server sending" },

    { TAG_CRT, "Certificate chain" },

    { TAG_AEAD, "Authenticated encryption algorithms" },

    { TAG_SCID, "Server config ID" },

    { TAG_PUBS, "Public value" },

    { TAG_KEXS, "Key exchange algorithms" },

    { TAG_OBIT, "Server Orbit" },

    { TAG_EXPY, "Expiry" },

    { TAG_NONC, "Client Nonce" },

    { TAG_MSPC, "Max streams per connection" },

    { TAG_TCID, "Connection ID truncation" },

    { TAG_SRBF, "Socket receive buffer" },

    { TAG_ICSL, "Idle connection state" },

    { TAG_SCLS, "Silently close on timeout" },

    { TAG_COPT, "Connection options" },

    { TAG_CCRT, "Cached certificates" },

    { TAG_IRTT, "Estimated initial RTT" },

    { TAG_CFCW, "Initial session/connection" },

    { TAG_SFCW, "Initial stream flow control" },

    { TAG_CETV, "Client encrypted tag-value" },

    { TAG_XLCT, "Expected leaf certificate" },

    { TAG_NONP, "Client Proof Nonce" },

    { TAG_CSCT, "Signed cert timestamp (RFC6962) of leaf cert" },

    { TAG_CTIM, "Client Timestamp" },

    { TAG_MIDS, "Max incoming dynamic streams" },

    { TAG_FHOL, "Force Head Of Line blocking" },

    { TAG_STTL, "Server Config TTL" },

    { TAG_SMHL, "Support Max Header List (size)" },

    { TAG_TBKP, "Token Binding Key Params" },

    { TAG_MAD0, "Max Ack Delay (IETF QUIC)" },

    { TAG_QLVE, "Legacy Version Encapsulation" },

    { TAG_CGST, "Congestion Control Feedback Type" },

    { TAG_EPID, "Endpoint Identifier" },

    { TAG_SRST, "Stateless Reset Token" },

    { TAG_RNON, "Public Reset Nonce Proof" },

    { TAG_RSEQ, "Rejected Packet Number" },

    { TAG_CADR, "Client Address" },

    { 0, NULL }

};

/**************************************************************************/

/*                      AEAD Tag                                          */

/**************************************************************************/

#define AEAD_AESG  0x41455347

#define AEAD_S20P  0x53323050

#define AEAD_CC12  0x43433132

static const value_string tag_aead_vals[] = {

    { AEAD_AESG, "AES-GCM with a 12-byte tag and IV" },

    { AEAD_S20P, "Salsa20 with Poly1305" },

    { AEAD_CC12, "ChaCha12 with Poly1305" },

    { 0, NULL }

};

/**************************************************************************/

/*                      KEXS Tag                                          */

/**************************************************************************/

#define KEXS_C255  0x43323535

#define KEXS_P256  0x50323536

static const value_string tag_kexs_vals[] = {

    { KEXS_C255, "Curve25519" },

    { KEXS_P256, "P-256" },

    { 0, NULL }

};

/**************************************************************************/

/*                      Client Address Type                               */

/**************************************************************************/

static const value_string cadr_type_vals[] = {

    { 2, "IPv4" },

    { 10, "IPv6" },

    { 0, NULL }

};

/**************************************************************************/

/*                      Error Code                                        */

/**************************************************************************/

/* See https://chromium.googlesource.com/chromium/src.git/+/master/net/third_party/quic/core/quic_error_codes.h */

enum QuicErrorCode {

    QUIC_NO_ERROR = 0,

    /* Connection has reached an invalid state. */

    QUIC_INTERNAL_ERROR = 1,

    /* There were data frames after the a fin or reset. */

    QUIC_STREAM_DATA_AFTER_TERMINATION = 2,

    /* Control frame is malformed. */

    QUIC_INVALID_PACKET_HEADER = 3,

    /* Frame data is malformed. */

    QUIC_INVALID_FRAME_DATA = 4,

    /* The packet contained no payload. */

    QUIC_MISSING_PAYLOAD = 48,

    /* FEC data is malformed. */

    QUIC_INVALID_FEC_DATA = 5,

    /* STREAM frame data is malformed. */

    QUIC_INVALID_STREAM_DATA = 46,

    /* STREAM frame data overlaps with buffered data. */

    QUIC_OVERLAPPING_STREAM_DATA = 87,

    /* STREAM frame data is not encrypted. */

    QUIC_UNENCRYPTED_STREAM_DATA = 61,

    /* Attempt to send unencrypted STREAM frame. */

    QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA = 88,

    /* Received a frame which is likely the result of memory corruption. */

    QUIC_MAYBE_CORRUPTED_MEMORY = 89,

    /* FEC frame data is not encrypted. */

    QUIC_UNENCRYPTED_FEC_DATA = 77,

    /* RST_STREAM frame data is malformed. */

    QUIC_INVALID_RST_STREAM_DATA = 6,

    /* CONNECTION_CLOSE frame data is malformed. */

    QUIC_INVALID_CONNECTION_CLOSE_DATA = 7,

    /* GOAWAY frame data is malformed. */

    QUIC_INVALID_GOAWAY_DATA = 8,

    /* WINDOW_UPDATE frame data is malformed. */

    QUIC_INVALID_WINDOW_UPDATE_DATA = 57,

    /* BLOCKED frame data is malformed. */

    QUIC_INVALID_BLOCKED_DATA = 58,

    /* STOP_WAITING frame data is malformed. */

    QUIC_INVALID_STOP_WAITING_DATA = 60,

    /* PATH_CLOSE frame data is malformed. */

    QUIC_INVALID_PATH_CLOSE_DATA = 78,

    /* ACK frame data is malformed. */

    QUIC_INVALID_ACK_DATA = 9,

    /* deprecated: */

    QUIC_INVALID_CONGESTION_FEEDBACK_DATA = 47,

    /* Version negotiation packet is malformed. */

    QUIC_INVALID_VERSION_NEGOTIATION_PACKET = 10,

    /* Public RST packet is malformed. */

    QUIC_INVALID_PUBLIC_RST_PACKET = 11,

    /* There was an error decrypting. */

    QUIC_DECRYPTION_FAILURE = 12,

    /* There was an error encrypting. */

    QUIC_ENCRYPTION_FAILURE = 13,

    /* The packet exceeded kMaxPacketSize. */

    QUIC_PACKET_TOO_LARGE = 14,

    /* Data was sent for a stream which did not exist. */

    QUIC_PACKET_FOR_NONEXISTENT_STREAM = 15,

    /* The peer is going away.   May be a client or server. */

    QUIC_PEER_GOING_AWAY = 16,

    /* A stream ID was invalid. */

    QUIC_INVALID_STREAM_ID = 17,

    /* A priority was invalid. */

    QUIC_INVALID_PRIORITY = 49,

    /* Too many streams already open. */

    QUIC_TOO_MANY_OPEN_STREAMS = 18,

    /* The peer created too many available streams. */

    QUIC_TOO_MANY_AVAILABLE_STREAMS = 76,

    /* The peer must send a FIN/RST for each stream, and has not been doing so. */

    QUIC_TOO_MANY_UNFINISHED_STREAMS = 66,

    /* Received public reset for this connection. */

    QUIC_PUBLIC_RESET = 19,

    /* Invalid protocol version. */

    QUIC_INVALID_VERSION = 20,

    /* deprecated: */

    QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED = 21,

    /* The Header ID for a stream was too far from the previous. */

    QUIC_INVALID_HEADER_ID = 22,

    /* Negotiable parameter received during handshake had invalid value. */

    QUIC_INVALID_NEGOTIATED_VALUE = 23,

    /* There was an error decompressing data. */

    QUIC_DECOMPRESSION_FAILURE = 24,

    /* We hit our prenegotiated (or default) timeout */

    QUIC_CONNECTION_TIMED_OUT = 25,

    /* We hit our overall connection timeout */

    QUIC_CONNECTION_OVERALL_TIMED_OUT = 67,

    /* There was an error encountered migrating addresses */

    QUIC_ERROR_MIGRATING_ADDRESS = 26,

    /* There was an error encountered migrating port only. */

    QUIC_ERROR_MIGRATING_PORT = 86,

    /* There was an error while writing to the socket. */

    QUIC_PACKET_WRITE_ERROR = 27,

    /* There was an error while reading from the socket. */

    QUIC_PACKET_READ_ERROR = 51,

    /* We received a STREAM_FRAME with no data and no fin flag set. */

    QUIC_INVALID_STREAM_FRAME = 50,

    /* We received invalid data on the headers stream. */

    QUIC_INVALID_HEADERS_STREAM_DATA = 56,

    /* Invalid data on the headers stream received because of decompression failure. */

    QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE = 97,

    /* The peer received too much data, violating flow control. */

    QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA = 59,

    /* The peer sent too much data, violating flow control. */

    QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA = 63,

    /* The peer received an invalid flow control window. */

    QUIC_FLOW_CONTROL_INVALID_WINDOW = 64,

    /* The connection has been IP pooled into an existing connection. */

    QUIC_CONNECTION_IP_POOLED = 62,

    /* The connection has too many outstanding sent packets. */

    QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS = 68,

    /* The connection has too many outstanding received packets. */

    QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS = 69,

    /* The quic connection job to load server config is cancelled. */

    QUIC_CONNECTION_CANCELLED = 70,

    /* Disabled QUIC because of high packet loss rate. */

    QUIC_BAD_PACKET_LOSS_RATE = 71,

    /* Disabled QUIC because of too many PUBLIC_RESETs post handshake. */

    QUIC_PUBLIC_RESETS_POST_HANDSHAKE = 73,

    /* Disabled QUIC because of too many timeouts with streams open. */

    QUIC_TIMEOUTS_WITH_OPEN_STREAMS = 74,

    /* Closed because we failed to serialize a packet. */

    QUIC_FAILED_TO_SERIALIZE_PACKET = 75,

    /* QUIC timed out after too many RTOs. */

    QUIC_TOO_MANY_RTOS = 85,

    /* Crypto errors. */

    /* Handshake failed. */

    QUIC_HANDSHAKE_FAILED = 28,

    /* Handshake message contained out of order tags. */

    QUIC_CRYPTO_TAGS_OUT_OF_ORDER = 29,

    /* Handshake message contained too many entries. */

    QUIC_CRYPTO_TOO_MANY_ENTRIES = 30,

    /* Handshake message contained an invalid value length. */

    QUIC_CRYPTO_INVALID_VALUE_LENGTH = 31,

    /* A crypto message was received after the handshake was complete. */

    QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE = 32,

    /* A crypto message was received with an illegal message tag. */

    QUIC_INVALID_CRYPTO_MESSAGE_TYPE = 33,

    /* A crypto message was received with an illegal parameter. */

    QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER = 34,

    /* An invalid channel id signature was supplied. */

    QUIC_INVALID_CHANNEL_ID_SIGNATURE = 52,

    /* A crypto message was received with a mandatory parameter missing. */

    QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND = 35,

    /* A crypto message was received with a parameter that has no overlap

       with the local parameter. */

    QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP = 36,

    /* A crypto message was received that contained a parameter with too few

       values. */

    QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND = 37,

    /* A demand for an unsupport proof type was received. */

    QUIC_UNSUPPORTED_PROOF_DEMAND = 94,

    /* An internal error occurred in crypto processing. */

    QUIC_CRYPTO_INTERNAL_ERROR = 38,

    /* A crypto handshake message specified an unsupported version. */

    QUIC_CRYPTO_VERSION_NOT_SUPPORTED = 39,

    /* A crypto handshake message resulted in a stateless reject. */

    QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT = 72,

    /* There was no intersection between the crypto primitives supported by the

       peer and ourselves. */

    QUIC_CRYPTO_NO_SUPPORT = 40,

    /* The server rejected our client hello messages too many times. */

    QUIC_CRYPTO_TOO_MANY_REJECTS = 41,

    /* The client rejected the server's certificate chain or signature. */

    QUIC_PROOF_INVALID = 42,

    /* A crypto message was received with a duplicate tag. */

    QUIC_CRYPTO_DUPLICATE_TAG = 43,

    /* A crypto message was received with the wrong encryption level (i.e. it

       should have been encrypted but was not. ) */

    QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT = 44,

    /* The server config for a server has expired. */

    QUIC_CRYPTO_SERVER_CONFIG_EXPIRED = 45,

    /* We failed to setup the symmetric keys for a connection. */

    QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED = 53,

    /* A handshake message arrived, but we are still validating the

       previous handshake message. */

    QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO = 54,

    /* A server config update arrived before the handshake is complete. */

    QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE = 65,

    /* CHLO cannot fit in one packet. */

    QUIC_CRYPTO_CHLO_TOO_LARGE = 90,

    /* This connection involved a version negotiation which appears to have been

       tampered with. */

    QUIC_VERSION_NEGOTIATION_MISMATCH = 55,

    /* Multipath is not enabled, but a packet with multipath flag on is received. */

    QUIC_BAD_MULTIPATH_FLAG = 79,

    /* A path is supposed to exist but does not. */

    QUIC_MULTIPATH_PATH_DOES_NOT_EXIST = 91,

    /* A path is supposed to be active but is not. */

    QUIC_MULTIPATH_PATH_NOT_ACTIVE = 92,

    /* IP address changed causing connection close. */

    QUIC_IP_ADDRESS_CHANGED = 80,

    /* Connection migration errors. */

    /* Network changed, but connection had no migratable streams. */

    QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS = 81,

    /* Connection changed networks too many times. */

    QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES = 82,

    /* Connection migration was attempted, but there was no new network to migrate to. */

    QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK = 83,

    /* Network changed, but connection had one or more non-migratable streams. */

    QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM = 84,

    /* Network changed, but connection migration was disabled by config. */

    QUIC_CONNECTION_MIGRATION_DISABLED_BY_CONFIG = 99,

    /* Network changed, but error was encountered on the alternative network. */

    QUIC_CONNECTION_MIGRATION_INTERNAL_ERROR = 100,

    /* Stream frames arrived too discontiguously so that stream sequencer buffer maintains too many gaps. */

    QUIC_TOO_MANY_FRAME_GAPS = 93,

    /* Sequencer buffer get into weird state where continuing read/write will lead

       to crash. */

    QUIC_STREAM_SEQUENCER_INVALID_STATE = 95,

    /* Connection closed because of server hits max number of sessions allowed. */

    QUIC_TOO_MANY_SESSIONS_ON_SERVER = 96,

    /* Receive a RST_STREAM with offset larger than kMaxStreamLength. */

    QUIC_STREAM_LENGTH_OVERFLOW = 98,

    /* No error. Used as bound while iterating. */

    QUIC_LAST_ERROR = 101

};

static const value_string error_code_vals[] = {

    { QUIC_NO_ERROR, "There was no error" },

    { QUIC_INTERNAL_ERROR, "Connection has reached an invalid state" },

    { QUIC_STREAM_DATA_AFTER_TERMINATION, "There were data frames after the a fin or reset" },

    { QUIC_INVALID_PACKET_HEADER, "Control frame is malformed" },

    { QUIC_INVALID_FRAME_DATA, "Frame data is malformed" },

    { QUIC_INVALID_FEC_DATA, "FEC data is malformed" },

    { QUIC_INVALID_RST_STREAM_DATA, "RST_STREAM frame data is malformed" },

    { QUIC_INVALID_CONNECTION_CLOSE_DATA, "CONNECTION_CLOSE frame data is malformed" },

    { QUIC_INVALID_GOAWAY_DATA, "GOAWAY frame data is malformed" },

    { QUIC_INVALID_ACK_DATA, "ACK frame data is malformed" },

    { QUIC_INVALID_VERSION_NEGOTIATION_PACKET, "Version negotiation packet is malformed" },

    { QUIC_INVALID_PUBLIC_RST_PACKET, "Public RST packet is malformed" },

    { QUIC_DECRYPTION_FAILURE, "There was an error decrypting" },

    { QUIC_ENCRYPTION_FAILURE, "There was an error encrypting" },

    { QUIC_PACKET_TOO_LARGE, "The packet exceeded kMaxPacketSize" },

    { QUIC_PACKET_FOR_NONEXISTENT_STREAM, "Data was sent for a stream which did not exist" },

    { QUIC_PEER_GOING_AWAY, "The peer is going away. May be a client or server" },

    { QUIC_INVALID_STREAM_ID, "A stream ID was invalid" },

    { QUIC_TOO_MANY_OPEN_STREAMS, "Too many streams already open" },

    { QUIC_PUBLIC_RESET, "Received public reset for this connection" },

    { QUIC_INVALID_VERSION, "Invalid protocol version" },

    { QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED, "Stream RST before Headers decompressed (Deprecated)" },

    { QUIC_INVALID_HEADER_ID, "The Header ID for a stream was too far from the previous" },

    { QUIC_INVALID_NEGOTIATED_VALUE, "Negotiable parameter received during handshake had invalid value" },

    { QUIC_DECOMPRESSION_FAILURE, "There was an error decompressing data" },

    { QUIC_CONNECTION_TIMED_OUT, "We hit our prenegotiated (or default) timeout" },

    { QUIC_ERROR_MIGRATING_ADDRESS, "There was an error encountered migrating addresses" },

    { QUIC_PACKET_WRITE_ERROR, "There was an error while writing to the socket" },

    { QUIC_HANDSHAKE_FAILED, "Handshake failed" },

    { QUIC_CRYPTO_TAGS_OUT_OF_ORDER, "Handshake message contained out of order tags" },

    { QUIC_CRYPTO_TOO_MANY_ENTRIES, "Handshake message contained too many entries" },

    { QUIC_CRYPTO_INVALID_VALUE_LENGTH, "Handshake message contained an invalid value length" },

    { QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE, "A crypto message was received after the handshake was complete" },

    { QUIC_INVALID_CRYPTO_MESSAGE_TYPE, "A crypto message was received with an illegal message tag" },

    { QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, "A crypto message was received with an illegal parameter" },

    { QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND, "A crypto message was received with a mandatory parameter missing" },

    { QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP, "A crypto message was received with a parameter that has no overlap with the local parameter" },

    { QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND, "A crypto message was received that contained a parameter with too few values" },

    { QUIC_CRYPTO_INTERNAL_ERROR, "An internal error occurred in crypto processing" },

    { QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "A crypto handshake message specified an unsupported version" },

    { QUIC_CRYPTO_NO_SUPPORT, "There was no intersection between the crypto primitives supported by the peer and ourselves" },

    { QUIC_CRYPTO_TOO_MANY_REJECTS, "The server rejected our client hello messages too many times" },

    { QUIC_PROOF_INVALID, "The client rejected the server's certificate chain or signature" },

    { QUIC_CRYPTO_DUPLICATE_TAG, "A crypto message was received with a duplicate tag" },

    { QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT, "A crypto message was received with the wrong encryption level (i.e. it should have been encrypted but was not" },

    { QUIC_CRYPTO_SERVER_CONFIG_EXPIRED, "The server config for a server has expired" },

    { QUIC_INVALID_STREAM_DATA, "STREAM frame data is malformed" },

    { QUIC_INVALID_CONGESTION_FEEDBACK_DATA, "Invalid congestion Feedback data (Deprecated)" },

    { QUIC_MISSING_PAYLOAD, "The packet contained no payload" },

    { QUIC_INVALID_PRIORITY, "A priority was invalid" },

    { QUIC_INVALID_STREAM_FRAME, "We received a STREAM_FRAME with no data and no fin flag set" },

    { QUIC_PACKET_READ_ERROR, "There was an error while reading from the socket" },

    { QUIC_INVALID_CHANNEL_ID_SIGNATURE, "An invalid channel id signature was supplied" },

    { QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED, "We failed to setup the symmetric keys for a connection" },

    { QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO, "A handshake message arrived, but we are still validating the previous handshake message" },

    { QUIC_VERSION_NEGOTIATION_MISMATCH, "This connection involved a version negotiation which appears to have been tampered with" },

    { QUIC_INVALID_HEADERS_STREAM_DATA, "We received invalid data on the headers stream" },

    { QUIC_INVALID_WINDOW_UPDATE_DATA, "WINDOW_UPDATE frame data is malformed" },

    { QUIC_INVALID_BLOCKED_DATA, "BLOCKED frame data is malformed" },

    { QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, "The peer received too much data, violating flow control" },

    { QUIC_INVALID_STOP_WAITING_DATA, "STOP_WAITING frame data is malformed" },

    { QUIC_UNENCRYPTED_STREAM_DATA, "STREAM frame data is not encrypted" },

    { QUIC_CONNECTION_IP_POOLED, "The connection has been IP pooled into an existing connection" },

    { QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA, "The peer sent too much data, violating flow control" },

    { QUIC_FLOW_CONTROL_INVALID_WINDOW, "The peer received an invalid flow control window" },

    { QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE, "A server config update arrived before the handshake is complete" },

    { QUIC_TOO_MANY_UNFINISHED_STREAMS, "The peer must send a FIN/RST for each stream, and has not been doing so" },

    { QUIC_CONNECTION_OVERALL_TIMED_OUT, "We hit our overall connection timeout" },

    { QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS, "The connection has too many outstanding sent packets" },

    { QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS, "The connection has too many outstanding received packets" },

    { QUIC_CONNECTION_CANCELLED, "The quic connection job to load server config is cancelled" },

    { QUIC_BAD_PACKET_LOSS_RATE, "Disabled QUIC because of high packet loss rate" },

    { QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, "A crypto handshake message resulted in a stateless reject" },

    { QUIC_PUBLIC_RESETS_POST_HANDSHAKE, "Disabled QUIC because of too many PUBLIC_RESETs post handshake" },

    { QUIC_TIMEOUTS_WITH_OPEN_STREAMS, "Disabled QUIC because of too many timeouts with streams open" },

    { QUIC_FAILED_TO_SERIALIZE_PACKET, "Closed because we failed to serialize a packet" },

    { QUIC_TOO_MANY_AVAILABLE_STREAMS, "The peer created too many available streams" },

    { QUIC_UNENCRYPTED_FEC_DATA, "FEC frame data is not encrypted" },

    { QUIC_INVALID_PATH_CLOSE_DATA, "PATH_CLOSE frame data is malformed" },

    { QUIC_BAD_MULTIPATH_FLAG, "Multipath is not enabled, but a packet with multipath flag on is received" },

    { QUIC_IP_ADDRESS_CHANGED, "IP address changed causing connection close" },

    { QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS, "Network changed, but connection had no migratable stream" },

    { QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES, "Connection changed networks too many times" },

    { QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK, "Connection migration was attempted, but there was no new network to migrate to" },

    { QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM, "Network changed, but connection had one or more non-migratable streams" },

    { QUIC_TOO_MANY_RTOS, "QUIC timed out after too many RTOs" },

    { QUIC_ERROR_MIGRATING_PORT, "There was an error encountered migrating port only" },

    { QUIC_OVERLAPPING_STREAM_DATA, "STREAM frame data overlaps with buffered data" },

    { QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA, "Attempt to send unencrypted STREAM frame" },

    { QUIC_MAYBE_CORRUPTED_MEMORY, "Received a frame which is likely the result of memory corruption" },

    { QUIC_CRYPTO_CHLO_TOO_LARGE, "CHLO cannot fit in one packet" },

    { QUIC_MULTIPATH_PATH_DOES_NOT_EXIST, "A path is supposed to exist but does not" },

    { QUIC_MULTIPATH_PATH_NOT_ACTIVE, "A path is supposed to be active but is not" },

    { QUIC_TOO_MANY_FRAME_GAPS, "Stream frames arrived too discontiguously so that stream sequencer buffer maintains too many gaps" },

    { QUIC_UNSUPPORTED_PROOF_DEMAND, "A demand for an unsupport proof type was received" },

    { QUIC_STREAM_SEQUENCER_INVALID_STATE, "Sequencer buffer get into weird state where continuing read/write will lead to crash" },

    { QUIC_TOO_MANY_SESSIONS_ON_SERVER, "Connection closed because of server hits max number of sessions allowed" },

    { QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE, "Invalid data on the headers stream received because of decompression failure" },

    { QUIC_STREAM_LENGTH_OVERFLOW, "Receive a RST_STREAM with offset larger than kMaxStreamLength" },

    { QUIC_CONNECTION_MIGRATION_DISABLED_BY_CONFIG, "Network changed, but connection migration was disabled by config" },

    { QUIC_CONNECTION_MIGRATION_INTERNAL_ERROR, "Network changed, but error was encountered on the alternative network" },

    { QUIC_LAST_ERROR, "No error. Used as bound while iterating" },

    { 0, NULL }

};

static value_string_ext error_code_vals_ext = VALUE_STRING_EXT_INIT(error_code_vals);

/**************************************************************************/

/*                      RST Stream Error Code                             */

/**************************************************************************/

/* See https://chromium.googlesource.com/chromium/src.git/+/master/net/third_party/quic/core/quic_error_codes.h (enum QuicRstStreamErrorCode) */

enum QuicRstStreamErrorCode {

  /* Complete response has been sent, sending a RST to ask the other endpoint to stop sending request data without discarding the response. */

  QUIC_STREAM_NO_ERROR = 0,

  /* There was some error which halted stream processing.*/

  QUIC_ERROR_PROCESSING_STREAM,

  /* We got two fin or reset offsets which did not match.*/

  QUIC_MULTIPLE_TERMINATION_OFFSETS,

  /* We got bad payload and can not respond to it at the protocol level. */

  QUIC_BAD_APPLICATION_PAYLOAD,

  /* Stream closed due to connection error. No reset frame is sent when this happens. */

  QUIC_STREAM_CONNECTION_ERROR,

  /* GoAway frame sent. No more stream can be created. */

  QUIC_STREAM_PEER_GOING_AWAY,

  /* The stream has been cancelled. */

  QUIC_STREAM_CANCELLED,

  /* Closing stream locally, sending a RST to allow for proper flow control accounting. Sent in response to a RST from the peer. */

  QUIC_RST_ACKNOWLEDGEMENT,

  /* Receiver refused to create the stream (because its limit on open streams has been reached).  The sender should retry the request later (using another stream). */

  QUIC_REFUSED_STREAM,

  /* Invalid URL in PUSH_PROMISE request header. */

  QUIC_INVALID_PROMISE_URL,

  /* Server is not authoritative for this URL. */

  QUIC_UNAUTHORIZED_PROMISE_URL,

  /* Can't have more than one active PUSH_PROMISE per URL. */

  QUIC_DUPLICATE_PROMISE_URL,

  /* Vary check failed. */

  QUIC_PROMISE_VARY_MISMATCH,

  /* Only GET and HEAD methods allowed. */

  QUIC_INVALID_PROMISE_METHOD,

  /* The push stream is unclaimed and timed out. */

  QUIC_PUSH_STREAM_TIMED_OUT,

  /* Received headers were too large. */

  QUIC_HEADERS_TOO_LARGE,

  /* The data is not likely arrive in time. */

  QUIC_STREAM_TTL_EXPIRED,

  /* No error. Used as bound while iterating. */

  QUIC_STREAM_LAST_ERROR,

};

static const value_string rststream_error_code_vals[] = {

    { QUIC_STREAM_NO_ERROR, "Complete response has been sent, sending a RST to ask the other endpoint to stop sending request data without discarding the response." },

    { QUIC_ERROR_PROCESSING_STREAM, "There was some error which halted stream processing" },

    { QUIC_MULTIPLE_TERMINATION_OFFSETS, "We got two fin or reset offsets which did not match" },

    { QUIC_BAD_APPLICATION_PAYLOAD, "We got bad payload and can not respond to it at the protocol level" },

    { QUIC_STREAM_CONNECTION_ERROR, "Stream closed due to connection error. No reset frame is sent when this happens" },

    { QUIC_STREAM_PEER_GOING_AWAY, "GoAway frame sent. No more stream can be created" },

    { QUIC_STREAM_CANCELLED, "The stream has been cancelled" },

    { QUIC_RST_ACKNOWLEDGEMENT, "Closing stream locally, sending a RST to allow for proper flow control accounting. Sent in response to a RST from the peer" },

    { QUIC_REFUSED_STREAM, "Receiver refused to create the stream (because its limit on open streams has been reached). The sender should retry the request later (using another stream)" },

    { QUIC_INVALID_PROMISE_URL, "Invalid URL in PUSH_PROMISE request header" },

    { QUIC_UNAUTHORIZED_PROMISE_URL, "Server is not authoritative for this URL" },

    { QUIC_DUPLICATE_PROMISE_URL, "Can't have more than one active PUSH_PROMISE per URL" },

    { QUIC_PROMISE_VARY_MISMATCH, "Vary check failed" },

    { QUIC_INVALID_PROMISE_METHOD, "Only GET and HEAD methods allowed" },

    { QUIC_PUSH_STREAM_TIMED_OUT, "The push stream is unclaimed and timed out" },

    { QUIC_HEADERS_TOO_LARGE, "Received headers were too large" },

    { QUIC_STREAM_TTL_EXPIRED, "The data is not likely arrive in time" },

    { QUIC_STREAM_LAST_ERROR, "No error. Used as bound while iterating" },

    { 0, NULL }

};

static value_string_ext rststream_error_code_vals_ext = VALUE_STRING_EXT_INIT(rststream_error_code_vals);

/**************************************************************************/

/*                      Handshake Failure Reason                          */

/**************************************************************************/

/* See https://chromium.googlesource.com/chromium/src.git/+/master/net/third_party/quic/core/crypto/crypto_handshake.h */

enum HandshakeFailureReason {

    HANDSHAKE_OK = 0,

    /* Failure reasons for an invalid client nonce in CHLO. */

    /* The default error value for nonce verification failures from strike register (covers old strike registers and unknown failures). */

    CLIENT_NONCE_UNKNOWN_FAILURE = 1,

    /* Client nonce had incorrect length. */

    CLIENT_NONCE_INVALID_FAILURE = 2,

    /* Client nonce is not unique. */

    CLIENT_NONCE_NOT_UNIQUE_FAILURE = 3,

    /* Client orbit is invalid or incorrect. */

    CLIENT_NONCE_INVALID_ORBIT_FAILURE = 4,

    /* Client nonce's timestamp is not in the strike register's valid time range. */

    CLIENT_NONCE_INVALID_TIME_FAILURE = 5,

    /* Strike register's RPC call timed out, client nonce couldn't be verified. */

    CLIENT_NONCE_STRIKE_REGISTER_TIMEOUT = 6,

    /* Strike register is down, client nonce couldn't be verified. */

    CLIENT_NONCE_STRIKE_REGISTER_FAILURE = 7,

    /* Failure reasons for an invalid server nonce in CHLO. */

    /* Unbox of server nonce failed. */

    SERVER_NONCE_DECRYPTION_FAILURE = 8,

    /* Decrypted server nonce had incorrect length. */

    SERVER_NONCE_INVALID_FAILURE = 9,

    /* Server nonce is not unique. */

    SERVER_NONCE_NOT_UNIQUE_FAILURE = 10,

    /* Server nonce's timestamp is not in the strike register's valid time range. */

    SERVER_NONCE_INVALID_TIME_FAILURE = 11,

    /* The server requires handshake confirmation. */

    SERVER_NONCE_REQUIRED_FAILURE = 20,

    /* Failure reasons for an invalid server config in CHLO. */

    /* Missing Server config id (kSCID) tag. */

    SERVER_CONFIG_INCHOATE_HELLO_FAILURE = 12,

    /* Couldn't find the Server config id (kSCID). */

    SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE = 13,

    /* Failure reasons for an invalid source-address token. */

    /* Missing Source-address token (kSourceAddressTokenTag) tag. */

    SOURCE_ADDRESS_TOKEN_INVALID_FAILURE = 14,

    /* Unbox of Source-address token failed. */

    SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE = 15,

    /* Couldn't parse the unbox'ed Source-address token. */

    SOURCE_ADDRESS_TOKEN_PARSE_FAILURE = 16,

    /* Source-address token is for a different IP address. */

    SOURCE_ADDRESS_TOKEN_DIFFERENT_IP_ADDRESS_FAILURE = 17,

    /* The source-address token has a timestamp in the future. */

    SOURCE_ADDRESS_TOKEN_CLOCK_SKEW_FAILURE = 18,

    /* The source-address token has expired. */

    SOURCE_ADDRESS_TOKEN_EXPIRED_FAILURE = 19,

    /* The expected leaf certificate hash could not be validated. */

    INVALID_EXPECTED_LEAF_CERTIFICATE = 21,

    MAX_FAILURE_REASON = 22

};

static const value_string handshake_failure_reason_vals[] = {

    { HANDSHAKE_OK, "Handshake OK" },

    { CLIENT_NONCE_UNKNOWN_FAILURE, "The default error value for nonce verification failures from strike register (covers old strike registers and unknown failures)" },

    { CLIENT_NONCE_INVALID_FAILURE, "Client nonce had incorrect length" },

    { CLIENT_NONCE_NOT_UNIQUE_FAILURE, "Client nonce is not unique" },

    { CLIENT_NONCE_INVALID_ORBIT_FAILURE, "Client orbit is invalid or incorrect" },

    { CLIENT_NONCE_INVALID_TIME_FAILURE, "Client nonce's timestamp is not in the strike register's valid time range" },

    { CLIENT_NONCE_STRIKE_REGISTER_TIMEOUT, "Strike register's RPC call timed out, client nonce couldn't be verified" },

    { CLIENT_NONCE_STRIKE_REGISTER_FAILURE, "Strike register is down, client nonce couldn't be verified" },

    { SERVER_NONCE_DECRYPTION_FAILURE, "Unbox of server nonce failed" },

    { SERVER_NONCE_INVALID_FAILURE, "Decrypted server nonce had incorrect length" },

    { SERVER_NONCE_NOT_UNIQUE_FAILURE, "Server nonce is not unique" },

    { SERVER_NONCE_INVALID_TIME_FAILURE, "Server nonce's timestamp is not in the strike register's valid time range" },

    { SERVER_CONFIG_INCHOATE_HELLO_FAILURE, "Missing Server config id (kSCID) tag" },

    { SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE, "Couldn't find the Server config id (kSCID)" },

    { SOURCE_ADDRESS_TOKEN_INVALID_FAILURE, "Missing Source-address token (kSourceAddressTokenTag) tag" },

    { SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE, "Unbox of Source-address token failed" },

    { SOURCE_ADDRESS_TOKEN_PARSE_FAILURE, "Couldn't parse the unbox'ed Source-address token" },

    { SOURCE_ADDRESS_TOKEN_DIFFERENT_IP_ADDRESS_FAILURE, "Source-address token is for a different IP address" },

    { SOURCE_ADDRESS_TOKEN_CLOCK_SKEW_FAILURE, "The source-address token has a timestamp in the future" },

    { SOURCE_ADDRESS_TOKEN_EXPIRED_FAILURE, "The source-address token has expired" },

    { SERVER_NONCE_REQUIRED_FAILURE, "The server requires handshake confirmation" },

    { INVALID_EXPECTED_LEAF_CERTIFICATE, "The expected leaf certificate hash could not be validated" },

    { 0, NULL }

};

static value_string_ext handshake_failure_reason_vals_ext = VALUE_STRING_EXT_INIT(handshake_failure_reason_vals);

static uint32_t get_len_offset(uint8_t frame_type){

    switch((frame_type & FTFLAGS_STREAM_OOO) >> 2){

        case 0:

            return 0;

        break;

        case 1:

            return 2;

        break;

        case 2:

            return 3;

        break;

        case 3:

            return 4;

        break;

        case 4:

            return 5;

        break;

        case 5:

            return 6;

        break;

        case 6:

            return 7;

        break;

        case 7:

            return 8;

        break;

        default:

        break;

    }

    return 0;

}

static uint32_t get_len_stream(uint8_t frame_type){

    switch(frame_type & FTFLAGS_STREAM_SS){

        case 0:

            return 1;

        break;

        case 1:

            return 2;

        break;

        case 2:

            return 3;

        break;

        case 3:

            return 4;

        break;

        default:

        break;

    }

    return 1;

}

static uint32_t get_len_largest_observed(uint8_t frame_type){

    switch((frame_type & FTFLAGS_ACK_LL) >> 2){

        case 0:

            return 1;

        break;