One Level Up Top Level

src/event/quic/ngx_event_quic_transport.c - nginx source code

Global variables defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Nginx, Inc.
  4. */


  7. #include <ngx_config.h>
  8. #include <ngx_core.h>
  9. #include <ngx_event.h>
  10. #include <ngx_event_quic_connection.h>


  13. ‌#define NGX_QUIC_LONG_DCID_LEN_OFFSET  5
  14. ‌#define NGX_QUIC_LONG_DCID_OFFSET      6
  15. ‌#define NGX_QUIC_SHORT_DCID_OFFSET     1

  17. ‌#define NGX_QUIC_STREAM_FRAME_FIN      0x01
  18. ‌#define NGX_QUIC_STREAM_FRAME_LEN      0x02
  19. ‌#define NGX_QUIC_STREAM_FRAME_OFF      0x04


  22. #if (NGX_HAVE_NONALIGNED)

  24. ‌#define ngx_quic_parse_uint16(p)  ntohs(*(uint16_t *) (p))
  25. ‌#define ngx_quic_parse_uint32(p)  ntohl(*(uint32_t *) (p))

  27. ‌#define ngx_quic_write_uint16  ngx_quic_write_uint16_aligned
  28. ‌#define ngx_quic_write_uint32  ngx_quic_write_uint32_aligned

  30. #else

  32. ‌#define ngx_quic_parse_uint16(p)  ((p)[0] << 8 | (p)[1])
  33. ‌#define ngx_quic_parse_uint32(p)                                              \
  34.     ((uint32_t) (p)[0] << 24 | (p)[1] << 16 | (p)[2] << 8 | (p)[3])

  36. ‌#define ngx_quic_write_uint16(p, s)                                           \
  37.     ((p)[0] = (u_char) ((s) >> 8),                                            \
  38.      (p)[1] = (u_char)  (s),                                                  \
  39.      (p) + sizeof(uint16_t))

  41. ‌#define ngx_quic_write_uint32(p, s)                                           \
  42.     ((p)[0] = (u_char) ((s) >> 24),                                           \
  43.      (p)[1] = (u_char) ((s) >> 16),                                           \
  44.      (p)[2] = (u_char) ((s) >> 8),                                            \
  45.      (p)[3] = (u_char)  (s),                                                  \
  46.      (p) + sizeof(uint32_t))

  48. #endif

  50. ‌#define ngx_quic_write_uint64(p, s)                                           \
  51.     ((p)[0] = (u_char) ((s) >> 56),                                           \
  52.      (p)[1] = (u_char) ((s) >> 48),                                           \
  53.      (p)[2] = (u_char) ((s) >> 40),                                           \
  54.      (p)[3] = (u_char) ((s) >> 32),                                           \
  55.      (p)[4] = (u_char) ((s) >> 24),                                           \
  56.      (p)[5] = (u_char) ((s) >> 16),                                           \
  57.      (p)[6] = (u_char) ((s) >> 8),                                            \
  58.      (p)[7] = (u_char)  (s),                                                  \
  59.      (p) + sizeof(uint64_t))

  61. ‌#define ngx_quic_write_uint24(p, s)                                           \
  62.     ((p)[0] = (u_char) ((s) >> 16),                                           \
  63.      (p)[1] = (u_char) ((s) >> 8),                                            \
  64.      (p)[2] = (u_char)  (s),                                                  \
  65.      (p) + 3)

  67. ‌#define ngx_quic_write_uint16_aligned(p, s)                                   \
  68.     (*(uint16_t *) (p) = htons((uint16_t) (s)), (p) + sizeof(uint16_t))

  70. ‌#define ngx_quic_write_uint32_aligned(p, s)                                   \
  71.     (*(uint32_t *) (p) = htonl((uint32_t) (s)), (p) + sizeof(uint32_t))

  73. ‌#define ngx_quic_build_int_set(p, value, len, bits)                           \
  74.     (*(p)++ = ((value >> ((len) * 8)) & 0xff) | ((bits) << 6))


  77. static u_char *ngx_quic_parse_int(u_char *pos, u_char *end, uint64_t *out);
  78. static ngx_uint_t ngx_quic_varint_len(uint64_t value);
  79. static void ngx_quic_build_int(u_char **pos, uint64_t value);

  81. static u_char *ngx_quic_read_uint8(u_char *pos, u_char *end, uint8_t *value);
  82. static u_char *ngx_quic_read_uint32(u_char *pos, u_char *end, uint32_t *value);
  83. static u_char *ngx_quic_read_bytes(u_char *pos, u_char *end, size_t len,
  84.     u_char **out);
  85. static u_char *ngx_quic_copy_bytes(u_char *pos, u_char *end, size_t len,
  86.     u_char *dst);

  88. static ngx_int_t ngx_quic_parse_short_header(ngx_quic_header_t *pkt,
  89.     size_t dcid_len);
  90. static ngx_int_t ngx_quic_parse_long_header(ngx_quic_header_t *pkt);
  91. static ngx_int_t ngx_quic_supported_version(uint32_t version);
  92. static ngx_int_t ngx_quic_parse_long_header_v1(ngx_quic_header_t *pkt);

  94. static size_t ngx_quic_create_long_header(ngx_quic_header_t *pkt, u_char *out,
  95.     u_char **pnp);
  96. static size_t ngx_quic_create_short_header(ngx_quic_header_t *pkt, u_char *out,
  97.     u_char **pnp);

  99. static ngx_int_t ngx_quic_frame_allowed(ngx_quic_header_t *pkt,
  100.     ngx_uint_t frame_type);
  101. static size_t ngx_quic_create_ping(u_char *p);
  102. static size_t ngx_quic_create_ack(u_char *p, ngx_quic_ack_frame_t *ack,
  103.     ngx_chain_t *ranges);
  104. static size_t ngx_quic_create_reset_stream(u_char *p,
  105.     ngx_quic_reset_stream_frame_t *rs);
  106. static size_t ngx_quic_create_stop_sending(u_char *p,
  107.     ngx_quic_stop_sending_frame_t *ss);
  108. static size_t ngx_quic_create_crypto(u_char *p,
  109.     ngx_quic_crypto_frame_t *crypto, ngx_chain_t *data);
  110. static size_t ngx_quic_create_hs_done(u_char *p);
  111. static size_t ngx_quic_create_new_token(u_char *p,
  112.     ngx_quic_new_token_frame_t *token, ngx_chain_t *data);
  113. static size_t ngx_quic_create_stream(u_char *p, ngx_quic_stream_frame_t *sf,
  114.     ngx_chain_t *data);
  115. static size_t ngx_quic_create_max_streams(u_char *p,
  116.     ngx_quic_max_streams_frame_t *ms);
  117. static size_t ngx_quic_create_max_stream_data(u_char *p,
  118.     ngx_quic_max_stream_data_frame_t *ms);
  119. static size_t ngx_quic_create_max_data(u_char *p,
  120.     ngx_quic_max_data_frame_t *md);
  121. static size_t ngx_quic_create_path_challenge(u_char *p,
  122.     ngx_quic_path_challenge_frame_t *pc);
  123. static size_t ngx_quic_create_path_response(u_char *p,
  124.     ngx_quic_path_challenge_frame_t *pc);
  125. static size_t ngx_quic_create_new_connection_id(u_char *p,
  126.     ngx_quic_new_conn_id_frame_t *rcid);
  127. static size_t ngx_quic_create_retire_connection_id(u_char *p,
  128.     ngx_quic_retire_cid_frame_t *rcid);
  129. static size_t ngx_quic_create_close(u_char *p, ngx_quic_frame_t *f);

  131. static ngx_int_t ngx_quic_parse_transport_param(u_char *p, u_char *end,
  132.     uint16_t id, ngx_quic_tp_t *dst);


  135. ‌uint32_t  ngx_quic_versions[] = {
  136.     /* QUICv1 */
  137.     0x00000001,
  138. };

  140. ‌#define NGX_QUIC_NVERSIONS \
  141.     (sizeof(ngx_quic_versions) / sizeof(ngx_quic_versions[0]))


  144. static ngx_inline u_char *
  145. ‌ngx_quic_parse_int(u_char *pos, u_char *end, uint64_t *out)
  146. {
  147.     u_char      *p;
  148.     uint64_t     value;
  149.     ngx_uint_t   len;

  151.     if (pos >= end) {
  152.         return NULL;
  153.     }

  155.     p = pos;
  156.     len = 1 << (*p >> 6);

  158.     value = *p++ & 0x3f;

  160.     if ((size_t)(end - p) < (len - 1)) {
  161.         return NULL;
  162.     }

  164.     while (--len) {
  165.         value = (value << 8) + *p++;
  166.     }

  168.     *out = value;

  170.     return p;
  171. }


  174. static ngx_inline u_char *
  175. ‌ngx_quic_read_uint8(u_char *pos, u_char *end, uint8_t *value)
  176. {
  177.     if ((size_t)(end - pos) < 1) {
  178.         return NULL;
  179.     }

  181.     *value = *pos;

  183.     return pos + 1;
  184. }


  187. static ngx_inline u_char *
  188. ‌ngx_quic_read_uint32(u_char *pos, u_char *end, uint32_t *value)
  189. {
  190.     if ((size_t)(end - pos) < sizeof(uint32_t)) {
  191.         return NULL;
  192.     }

  194.     *value = ngx_quic_parse_uint32(pos);

  196.     return pos + sizeof(uint32_t);
  197. }


  200. static ngx_inline u_char *
  201. ‌ngx_quic_read_bytes(u_char *pos, u_char *end, size_t len, u_char **out)
  202. {
  203.     if ((size_t)(end - pos) < len) {
  204.         return NULL;
  205.     }

  207.     *out = pos;

  209.     return pos + len;
  210. }


  213. static u_char *
  214. ‌ngx_quic_copy_bytes(u_char *pos, u_char *end, size_t len, u_char *dst)
  215. {
  216.     if ((size_t)(end - pos) < len) {
  217.         return NULL;
  218.     }

  220.     ngx_memcpy(dst, pos, len);

  222.     return pos + len;
  223. }


  226. static ngx_inline ngx_uint_t
  227. ‌ngx_quic_varint_len(uint64_t value)
  228. {
  229.     if (value < (1 << 6)) {
  230.         return 1;
  231.     }

  233.     if (value < (1 << 14)) {
  234.         return 2;
  235.     }

  237.     if (value < (1 << 30)) {
  238.         return 4;
  239.     }

  241.     return 8;
  242. }


  245. static ngx_inline void
  246. ‌ngx_quic_build_int(u_char **pos, uint64_t value)
  247. {
  248.     u_char  *p;

  250.     p = *pos;

  252.     if (value < (1 << 6)) {
  253.         ngx_quic_build_int_set(p, value, 0, 0);

  255.     } else if (value < (1 << 14)) {
  256.         ngx_quic_build_int_set(p, value, 1, 1);
  257.         ngx_quic_build_int_set(p, value, 0, 0);

  259.     } else if (value < (1 << 30)) {
  260.         ngx_quic_build_int_set(p, value, 3, 2);
  261.         ngx_quic_build_int_set(p, value, 2, 0);
  262.         ngx_quic_build_int_set(p, value, 1, 0);
  263.         ngx_quic_build_int_set(p, value, 0, 0);

  265.     } else {
  266.         ngx_quic_build_int_set(p, value, 7, 3);
  267.         ngx_quic_build_int_set(p, value, 6, 0);
  268.         ngx_quic_build_int_set(p, value, 5, 0);
  269.         ngx_quic_build_int_set(p, value, 4, 0);
  270.         ngx_quic_build_int_set(p, value, 3, 0);
  271.         ngx_quic_build_int_set(p, value, 2, 0);
  272.         ngx_quic_build_int_set(p, value, 1, 0);
  273.         ngx_quic_build_int_set(p, value, 0, 0);
  274.     }

  276.     *pos = p;
  277. }


  280. ngx_int_t
  281. ‌ngx_quic_parse_packet(ngx_quic_header_t *pkt)
  282. {
  283.     if (!ngx_quic_long_pkt(pkt->flags)) {
  284.         pkt->level = ssl_encryption_application;

  286.         if (ngx_quic_parse_short_header(pkt, NGX_QUIC_SERVER_CID_LEN) != NGX_OK)
  287.         {
  288.             return NGX_ERROR;
  289.         }

  291.         return NGX_OK;
  292.     }

  294.     if (ngx_quic_parse_long_header(pkt) != NGX_OK) {
  295.         return NGX_ERROR;
  296.     }

  298.     if (!ngx_quic_supported_version(pkt->version)) {
  299.         return NGX_ABORT;
  300.     }

  302.     if (ngx_quic_parse_long_header_v1(pkt) != NGX_OK) {
  303.         return NGX_ERROR;
  304.     }

  306.     return NGX_OK;
  307. }


  310. static ngx_int_t
  311. ‌ngx_quic_parse_short_header(ngx_quic_header_t *pkt, size_t dcid_len)
  312. {
  313.     u_char  *p, *end;

  315.     p = pkt->raw->pos;
  316.     end = pkt->data + pkt->len;

  318.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, pkt->log, 0,
  319.                    "quic packet rx short flags:%xd", pkt->flags);

  321.     if (!(pkt->flags & NGX_QUIC_PKT_FIXED_BIT)) {
  322.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic fixed bit is not set");
  323.         return NGX_ERROR;
  324.     }

  326.     pkt->dcid.len = dcid_len;

  328.     p = ngx_quic_read_bytes(p, end, dcid_len, &pkt->dcid.data);
  329.     if (p == NULL) {
  330.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  331.                       "quic packet is too small to read dcid");
  332.         return NGX_ERROR;
  333.     }

  335.     pkt->raw->pos = p;

  337.     return NGX_OK;
  338. }


  341. static ngx_int_t
  342. ‌ngx_quic_parse_long_header(ngx_quic_header_t *pkt)
  343. {
  344.     u_char   *p, *end;
  345.     uint8_t   idlen;

  347.     p = pkt->raw->pos;
  348.     end = pkt->data + pkt->len;

  350.     p = ngx_quic_read_uint32(p, end, &pkt->version);
  351.     if (p == NULL) {
  352.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  353.                       "quic packet is too small to read version");
  354.         return NGX_ERROR;
  355.     }

  357.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pkt->log, 0,
  358.                    "quic packet rx long flags:%xd version:%xD",
  359.                    pkt->flags, pkt->version);

  361.     if (!(pkt->flags & NGX_QUIC_PKT_FIXED_BIT)) {
  362.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic fixed bit is not set");
  363.         return NGX_ERROR;
  364.     }

  366.     p = ngx_quic_read_uint8(p, end, &idlen);
  367.     if (p == NULL) {
  368.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  369.                       "quic packet is too small to read dcid len");
  370.         return NGX_ERROR;
  371.     }

  373.     if (idlen > NGX_QUIC_CID_LEN_MAX) {
  374.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  375.                       "quic packet dcid is too long");
  376.         return NGX_ERROR;
  377.     }

  379.     pkt->dcid.len = idlen;

  381.     p = ngx_quic_read_bytes(p, end, idlen, &pkt->dcid.data);
  382.     if (p == NULL) {
  383.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  384.                       "quic packet is too small to read dcid");
  385.         return NGX_ERROR;
  386.     }

  388.     p = ngx_quic_read_uint8(p, end, &idlen);
  389.     if (p == NULL) {
  390.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  391.                       "quic packet is too small to read scid len");
  392.         return NGX_ERROR;
  393.     }

  395.     if (idlen > NGX_QUIC_CID_LEN_MAX) {
  396.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  397.                       "quic packet scid is too long");
  398.         return NGX_ERROR;
  399.     }

  401.     pkt->scid.len = idlen;

  403.     p = ngx_quic_read_bytes(p, end, idlen, &pkt->scid.data);
  404.     if (p == NULL) {
  405.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  406.                       "quic packet is too small to read scid");
  407.         return NGX_ERROR;
  408.     }

  410.     pkt->raw->pos = p;

  412.     return NGX_OK;
  413. }


  416. static ngx_int_t
  417. ‌ngx_quic_supported_version(uint32_t version)
  418. {
  419.     ngx_uint_t  i;

  421.     for (i = 0; i < NGX_QUIC_NVERSIONS; i++) {
  422.         if (ngx_quic_versions[i] == version) {
  423.             return 1;
  424.         }
  425.     }

  427.     return 0;
  428. }


  431. static ngx_int_t
  432. ‌ngx_quic_parse_long_header_v1(ngx_quic_header_t *pkt)
  433. {
  434.     u_char    *p, *end;
  435.     uint64_t   varint;

  437.     p = pkt->raw->pos;
  438.     end = pkt->raw->last;

  440.     pkt->log->action = "parsing quic long header";

  442.     if (ngx_quic_pkt_in(pkt->flags)) {

  444.         if (pkt->len < NGX_QUIC_MIN_INITIAL_SIZE) {
  445.             ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  446.                           "quic UDP datagram is too small for initial packet");
  447.             return NGX_DECLINED;
  448.         }

  450.         p = ngx_quic_parse_int(p, end, &varint);
  451.         if (p == NULL) {
  452.             ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  453.                           "quic failed to parse token length");
  454.             return NGX_ERROR;
  455.         }

  457.         pkt->token.len = varint;

  459.         p = ngx_quic_read_bytes(p, end, pkt->token.len, &pkt->token.data);
  460.         if (p == NULL) {
  461.             ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  462.                           "quic packet too small to read token data");
  463.             return NGX_ERROR;
  464.         }

  466.         pkt->level = ssl_encryption_initial;

  468.     } else if (ngx_quic_pkt_zrtt(pkt->flags)) {
  469.         pkt->level = ssl_encryption_early_data;

  471.     } else if (ngx_quic_pkt_hs(pkt->flags)) {
  472.         pkt->level = ssl_encryption_handshake;

  474.     } else {
  475.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  476.                       "quic bad packet type");
  477.         return NGX_DECLINED;
  478.     }

  480.     p = ngx_quic_parse_int(p, end, &varint);
  481.     if (p == NULL) {
  482.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic bad packet length");
  483.         return NGX_ERROR;
  484.     }

  486.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pkt->log, 0,
  487.                    "quic packet rx %s len:%uL",
  488.                    ngx_quic_level_name(pkt->level), varint);

  490.     if (varint > (uint64_t) ((pkt->data + pkt->len) - p)) {
  491.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic truncated %s packet",
  492.                       ngx_quic_level_name(pkt->level));
  493.         return NGX_ERROR;
  494.     }

  496.     pkt->raw->pos = p;
  497.     pkt->len = p + varint - pkt->data;

  499.     return NGX_OK;
  500. }


  503. ngx_int_t
  504. ‌ngx_quic_get_packet_dcid(ngx_log_t *log, u_char *data, size_t n,
  505.     ngx_str_t *dcid)
  506. {
  507.     size_t  len, offset;

  509.     if (n == 0) {
  510.         goto failed;
  511.     }

  513.     if (ngx_quic_long_pkt(*data)) {
  514.         if (n < NGX_QUIC_LONG_DCID_LEN_OFFSET + 1) {
  515.             goto failed;
  516.         }

  518.         len = data[NGX_QUIC_LONG_DCID_LEN_OFFSET];
  519.         offset = NGX_QUIC_LONG_DCID_OFFSET;

  521.     } else {
  522.         len = NGX_QUIC_SERVER_CID_LEN;
  523.         offset = NGX_QUIC_SHORT_DCID_OFFSET;
  524.     }

  526.     if (n < len + offset) {
  527.         goto failed;
  528.     }

  530.     dcid->len = len;
  531.     dcid->data = &data[offset];

  533.     return NGX_OK;

  535. failed:

  537.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, log, 0, "quic malformed packet");

  539.     return NGX_ERROR;
  540. }


  543. size_t
  544. ‌ngx_quic_create_version_negotiation(ngx_quic_header_t *pkt, u_char *out)
  545. {
  546.     u_char      *p, *start;
  547.     ngx_uint_t   i;

  549.     p = start = out;

  551.     *p++ = pkt->flags;

  553.     /*
  554.      * The Version field of a Version Negotiation packet
  555.      * MUST be set to 0x00000000
  556.      */
  557.     p = ngx_quic_write_uint32(p, 0);

  559.     *p++ = pkt->dcid.len;
  560.     p = ngx_cpymem(p, pkt->dcid.data, pkt->dcid.len);

  562.     *p++ = pkt->scid.len;
  563.     p = ngx_cpymem(p, pkt->scid.data, pkt->scid.len);

  565.     for (i = 0; i < NGX_QUIC_NVERSIONS; i++) {
  566.         p = ngx_quic_write_uint32(p, ngx_quic_versions[i]);
  567.     }

  569.     return p - start;
  570. }


  573. /* returns the amount of payload quic packet of "pkt_len" size may fit or 0 */
  574. size_t
  575. ‌ngx_quic_payload_size(ngx_quic_header_t *pkt, size_t pkt_len)
  576. {
  577.     size_t  len;

  579.     if (ngx_quic_short_pkt(pkt->flags)) {

  581.         len = 1 + pkt->dcid.len + pkt->num_len + NGX_QUIC_TAG_LEN;
  582.         if (len > pkt_len) {
  583.             return 0;
  584.         }

  586.         return pkt_len - len;
  587.     }

  589.     /* flags, version, dcid and scid with lengths and zero-length token */
  590.     len = 5 + 2 + pkt->dcid.len + pkt->scid.len
  591.           + (pkt->level == ssl_encryption_initial ? 1 : 0);

  593.     if (len > pkt_len) {
  594.         return 0;
  595.     }

  597.     /* (pkt_len - len) is 'remainder' packet length (see RFC 9000, 17.2) */
  598.     len += ngx_quic_varint_len(pkt_len - len)
  599.            + pkt->num_len + NGX_QUIC_TAG_LEN;

  601.     if (len > pkt_len) {
  602.         return 0;
  603.     }

  605.     return pkt_len - len;
  606. }


  609. size_t
  610. ‌ngx_quic_create_header(ngx_quic_header_t *pkt, u_char *out, u_char **pnp)
  611. {
  612.     return ngx_quic_short_pkt(pkt->flags)
  613.            ? ngx_quic_create_short_header(pkt, out, pnp)
  614.            : ngx_quic_create_long_header(pkt, out, pnp);
  615. }


  618. static size_t
  619. ‌ngx_quic_create_long_header(ngx_quic_header_t *pkt, u_char *out,
  620.     u_char **pnp)
  621. {
  622.     size_t   rem_len;
  623.     u_char  *p, *start;

  625.     rem_len = pkt->num_len + pkt->payload.len + NGX_QUIC_TAG_LEN;

  627.     if (out == NULL) {
  628.         return 5 + 2 + pkt->dcid.len + pkt->scid.len
  629.                + ngx_quic_varint_len(rem_len) + pkt->num_len
  630.                + (pkt->level == ssl_encryption_initial ? 1 : 0);
  631.     }

  633.     p = start = out;

  635.     *p++ = pkt->flags;

  637.     p = ngx_quic_write_uint32(p, pkt->version);

  639.     *p++ = pkt->dcid.len;
  640.     p = ngx_cpymem(p, pkt->dcid.data, pkt->dcid.len);

  642.     *p++ = pkt->scid.len;
  643.     p = ngx_cpymem(p, pkt->scid.data, pkt->scid.len);

  645.     if (pkt->level == ssl_encryption_initial) {
  646.         ngx_quic_build_int(&p, 0);
  647.     }

  649.     ngx_quic_build_int(&p, rem_len);

  651.     *pnp = p;

  653.     switch (pkt->num_len) {
  654.     case 1:
  655.         *p++ = pkt->trunc;
  656.         break;
  657.     case 2:
  658.         p = ngx_quic_write_uint16(p, pkt->trunc);
  659.         break;
  660.     case 3:
  661.         p = ngx_quic_write_uint24(p, pkt->trunc);
  662.         break;
  663.     case 4:
  664.         p = ngx_quic_write_uint32(p, pkt->trunc);
  665.         break;
  666.     }

  668.     return p - start;
  669. }


  672. static size_t
  673. ‌ngx_quic_create_short_header(ngx_quic_header_t *pkt, u_char *out,
  674.     u_char **pnp)
  675. {
  676.     u_char  *p, *start;

  678.     if (out == NULL) {
  679.         return 1 + pkt->dcid.len + pkt->num_len;
  680.     }

  682.     p = start = out;

  684.     *p++ = pkt->flags;

  686.     p = ngx_cpymem(p, pkt->dcid.data, pkt->dcid.len);

  688.     *pnp = p;

  690.     switch (pkt->num_len) {
  691.     case 1:
  692.         *p++ = pkt->trunc;
  693.         break;
  694.     case 2:
  695.         p = ngx_quic_write_uint16(p, pkt->trunc);
  696.         break;
  697.     case 3:
  698.         p = ngx_quic_write_uint24(p, pkt->trunc);
  699.         break;
  700.     case 4:
  701.         p = ngx_quic_write_uint32(p, pkt->trunc);
  702.         break;
  703.     }

  705.     return p - start;
  706. }


  709. size_t
  710. ‌ngx_quic_create_retry_itag(ngx_quic_header_t *pkt, u_char *out,
  711.     u_char **start)
  712. {
  713.     u_char  *p;

  715.     p = out;

  717.     *p++ = pkt->odcid.len;
  718.     p = ngx_cpymem(p, pkt->odcid.data, pkt->odcid.len);

  720.     *start = p;

  722.     *p++ = 0xff;

  724.     p = ngx_quic_write_uint32(p, pkt->version);

  726.     *p++ = pkt->dcid.len;
  727.     p = ngx_cpymem(p, pkt->dcid.data, pkt->dcid.len);

  729.     *p++ = pkt->scid.len;
  730.     p = ngx_cpymem(p, pkt->scid.data, pkt->scid.len);

  732.     p = ngx_cpymem(p, pkt->token.data, pkt->token.len);

  734.     return p - out;
  735. }


  738. ssize_t
  739. ‌ngx_quic_parse_frame(ngx_quic_header_t *pkt, u_char *start, u_char *end,
  740.     ngx_quic_frame_t *f)
  741. {
  742.     u_char      *p;
  743.     uint64_t     varint;
  744.     ngx_buf_t   *b;
  745.     ngx_uint_t   i;

  747.     b = f->data->buf;

  749.     p = start;

  751.     p = ngx_quic_parse_int(p, end, &varint);
  752.     if (p == NULL) {
  753.         pkt->error = NGX_QUIC_ERR_FRAME_ENCODING_ERROR;
  754.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  755.                       "quic failed to obtain quic frame type");
  756.         return NGX_ERROR;
  757.     }

  759.     if (varint > NGX_QUIC_FT_LAST) {
  760.         pkt->error = NGX_QUIC_ERR_FRAME_ENCODING_ERROR;
  761.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  762.                       "quic unknown frame type 0x%xL", varint);
  763.         return NGX_ERROR;
  764.     }

  766.     f->type = varint;

  768.     if (ngx_quic_frame_allowed(pkt, f->type) != NGX_OK) {
  769.         pkt->error = NGX_QUIC_ERR_PROTOCOL_VIOLATION;
  770.         return NGX_ERROR;
  771.     }

  773.     switch (f->type) {

  775.     case NGX_QUIC_FT_CRYPTO:

  777.         p = ngx_quic_parse_int(p, end, &f->u.crypto.offset);
  778.         if (p == NULL) {
  779.             goto error;
  780.         }

  782.         p = ngx_quic_parse_int(p, end, &f->u.crypto.length);
  783.         if (p == NULL) {
  784.             goto error;
  785.         }

  787.         p = ngx_quic_read_bytes(p, end, f->u.crypto.length, &b->pos);
  788.         if (p == NULL) {
  789.             goto error;
  790.         }

  792.         b->last = p;

  794.         break;

  796.     case NGX_QUIC_FT_PADDING:

  798.         while (p < end && *p == NGX_QUIC_FT_PADDING) {
  799.             p++;
  800.         }

  802.         break;

  804.     case NGX_QUIC_FT_ACK:
  805.     case NGX_QUIC_FT_ACK_ECN:

  807.         p = ngx_quic_parse_int(p, end, &f->u.ack.largest);
  808.         if (p == NULL) {
  809.             goto error;
  810.         }

  812.         p = ngx_quic_parse_int(p, end, &f->u.ack.delay);
  813.         if (p == NULL) {
  814.             goto error;
  815.         }

  817.         p = ngx_quic_parse_int(p, end, &f->u.ack.range_count);
  818.         if (p == NULL) {
  819.             goto error;
  820.         }

  822.         p = ngx_quic_parse_int(p, end, &f->u.ack.first_range);
  823.         if (p == NULL) {
  824.             goto error;
  825.         }

  827.         b->pos = p;

  829.         /* process all ranges to get bounds, values are ignored */
  830.         for (i = 0; i < f->u.ack.range_count; i++) {

  832.             p = ngx_quic_parse_int(p, end, &varint);
  833.             if (p == NULL) {
  834.                 goto error;
  835.             }

  837.             p = ngx_quic_parse_int(p, end, &varint);
  838.             if (p == NULL) {
  839.                 goto error;
  840.             }
  841.         }

  843.         b->last = p;

  845.         f->u.ack.ranges_length = b->last - b->pos;

  847.         if (f->type == NGX_QUIC_FT_ACK_ECN) {

  849.             p = ngx_quic_parse_int(p, end, &f->u.ack.ect0);
  850.             if (p == NULL) {
  851.                 goto error;
  852.             }

  854.             p = ngx_quic_parse_int(p, end, &f->u.ack.ect1);
  855.             if (p == NULL) {
  856.                 goto error;
  857.             }

  859.             p = ngx_quic_parse_int(p, end, &f->u.ack.ce);
  860.             if (p == NULL) {
  861.                 goto error;
  862.             }

  864.             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, pkt->log, 0,
  865.                            "quic ACK ECN counters ect0:%uL ect1:%uL ce:%uL",
  866.                            f->u.ack.ect0, f->u.ack.ect1, f->u.ack.ce);
  867.         }

  869.         break;

  871.     case NGX_QUIC_FT_PING:
  872.         break;

  874.     case NGX_QUIC_FT_NEW_CONNECTION_ID:

  876.         p = ngx_quic_parse_int(p, end, &f->u.ncid.seqnum);
  877.         if (p == NULL) {
  878.             goto error;
  879.         }

  881.         p = ngx_quic_parse_int(p, end, &f->u.ncid.retire);
  882.         if (p == NULL) {
  883.             goto error;
  884.         }

  886.         if (f->u.ncid.retire > f->u.ncid.seqnum) {
  887.             goto error;
  888.         }

  890.         p = ngx_quic_read_uint8(p, end, &f->u.ncid.len);
  891.         if (p == NULL) {
  892.             goto error;
  893.         }

  895.         if (f->u.ncid.len < 1 || f->u.ncid.len > NGX_QUIC_CID_LEN_MAX) {
  896.             goto error;
  897.         }

  899.         p = ngx_quic_copy_bytes(p, end, f->u.ncid.len, f->u.ncid.cid);
  900.         if (p == NULL) {
  901.             goto error;
  902.         }

  904.         p = ngx_quic_copy_bytes(p, end, NGX_QUIC_SR_TOKEN_LEN, f->u.ncid.srt);
  905.         if (p == NULL) {
  906.             goto error;
  907.         }

  909.         break;

  911.     case NGX_QUIC_FT_RETIRE_CONNECTION_ID:

  913.         p = ngx_quic_parse_int(p, end, &f->u.retire_cid.sequence_number);
  914.         if (p == NULL) {
  915.             goto error;
  916.         }

  918.         break;

  920.     case NGX_QUIC_FT_CONNECTION_CLOSE:
  921.     case NGX_QUIC_FT_CONNECTION_CLOSE_APP:

  923.         p = ngx_quic_parse_int(p, end, &f->u.close.error_code);
  924.         if (p == NULL) {
  925.             goto error;
  926.         }

  928.         if (f->type == NGX_QUIC_FT_CONNECTION_CLOSE) {
  929.             p = ngx_quic_parse_int(p, end, &f->u.close.frame_type);
  930.             if (p == NULL) {
  931.                 goto error;
  932.             }
  933.         }

  935.         p = ngx_quic_parse_int(p, end, &varint);
  936.         if (p == NULL) {
  937.             goto error;
  938.         }

  940.         f->u.close.reason.len = varint;

  942.         p = ngx_quic_read_bytes(p, end, f->u.close.reason.len,
  943.                                 &f->u.close.reason.data);
  944.         if (p == NULL) {
  945.             goto error;
  946.         }

  948.         break;

  950.     case NGX_QUIC_FT_STREAM:
  951.     case NGX_QUIC_FT_STREAM1:
  952.     case NGX_QUIC_FT_STREAM2:
  953.     case NGX_QUIC_FT_STREAM3:
  954.     case NGX_QUIC_FT_STREAM4:
  955.     case NGX_QUIC_FT_STREAM5:
  956.     case NGX_QUIC_FT_STREAM6:
  957.     case NGX_QUIC_FT_STREAM7:

  959.         f->u.stream.fin = (f->type & NGX_QUIC_STREAM_FRAME_FIN) ? 1 : 0;

  961.         p = ngx_quic_parse_int(p, end, &f->u.stream.stream_id);
  962.         if (p == NULL) {
  963.             goto error;
  964.         }

  966.         if (f->type & NGX_QUIC_STREAM_FRAME_OFF) {
  967.             f->u.stream.off = 1;

  969.             p = ngx_quic_parse_int(p, end, &f->u.stream.offset);
  970.             if (p == NULL) {
  971.                 goto error;
  972.             }

  974.         } else {
  975.             f->u.stream.off = 0;
  976.             f->u.stream.offset = 0;
  977.         }

  979.         if (f->type & NGX_QUIC_STREAM_FRAME_LEN) {
  980.             f->u.stream.len = 1;

  982.             p = ngx_quic_parse_int(p, end, &f->u.stream.length);
  983.             if (p == NULL) {
  984.                 goto error;
  985.             }

  987.         } else {
  988.             f->u.stream.len = 0;
  989.             f->u.stream.length = end - p; /* up to packet end */
  990.         }

  992.         p = ngx_quic_read_bytes(p, end, f->u.stream.length, &b->pos);
  993.         if (p == NULL) {
  994.             goto error;
  995.         }

  997.         b->last = p;

  999.         f->type = NGX_QUIC_FT_STREAM;
  1000.         break;

  1002.     case NGX_QUIC_FT_MAX_DATA:

  1004.         p = ngx_quic_parse_int(p, end, &f->u.max_data.max_data);
  1005.         if (p == NULL) {
  1006.             goto error;
  1007.         }

  1009.         break;

  1011.     case NGX_QUIC_FT_RESET_STREAM:

  1013.         p = ngx_quic_parse_int(p, end, &f->u.reset_stream.id);
  1014.         if (p == NULL) {
  1015.             goto error;
  1016.         }

  1018.         p = ngx_quic_parse_int(p, end, &f->u.reset_stream.error_code);
  1019.         if (p == NULL) {
  1020.             goto error;
  1021.         }

  1023.         p = ngx_quic_parse_int(p, end, &f->u.reset_stream.final_size);
  1024.         if (p == NULL) {
  1025.             goto error;
  1026.         }

  1028.         break;

  1030.     case NGX_QUIC_FT_STOP_SENDING:

  1032.         p = ngx_quic_parse_int(p, end, &f->u.stop_sending.id);
  1033.         if (p == NULL) {
  1034.             goto error;
  1035.         }

  1037.         p = ngx_quic_parse_int(p, end, &f->u.stop_sending.error_code);
  1038.         if (p == NULL) {
  1039.             goto error;
  1040.         }

  1042.         break;

  1044.     case NGX_QUIC_FT_STREAMS_BLOCKED:
  1045.     case NGX_QUIC_FT_STREAMS_BLOCKED2:

  1047.         p = ngx_quic_parse_int(p, end, &f->u.streams_blocked.limit);
  1048.         if (p == NULL) {
  1049.             goto error;
  1050.         }

  1052.         if (f->u.streams_blocked.limit > 0x1000000000000000) {
  1053.             goto error;
  1054.         }

  1056.         f->u.streams_blocked.bidi =
  1057.                               (f->type == NGX_QUIC_FT_STREAMS_BLOCKED) ? 1 : 0;
  1058.         break;

  1060.     case NGX_QUIC_FT_MAX_STREAMS:
  1061.     case NGX_QUIC_FT_MAX_STREAMS2:

  1063.         p = ngx_quic_parse_int(p, end, &f->u.max_streams.limit);
  1064.         if (p == NULL) {
  1065.             goto error;
  1066.         }

  1068.         if (f->u.max_streams.limit > 0x1000000000000000) {
  1069.             goto error;
  1070.         }

  1072.         f->u.max_streams.bidi = (f->type == NGX_QUIC_FT_MAX_STREAMS) ? 1 : 0;

  1074.         break;

  1076.     case NGX_QUIC_FT_MAX_STREAM_DATA:

  1078.         p = ngx_quic_parse_int(p, end, &f->u.max_stream_data.id);
  1079.         if (p == NULL) {
  1080.             goto error;
  1081.         }

  1083.         p = ngx_quic_parse_int(p, end, &f->u.max_stream_data.limit);
  1084.         if (p == NULL) {
  1085.             goto error;
  1086.         }

  1088.         break;

  1090.     case NGX_QUIC_FT_DATA_BLOCKED:

  1092.         p = ngx_quic_parse_int(p, end, &f->u.data_blocked.limit);
  1093.         if (p == NULL) {
  1094.             goto error;
  1095.         }

  1097.         break;

  1099.     case NGX_QUIC_FT_STREAM_DATA_BLOCKED:

  1101.         p = ngx_quic_parse_int(p, end, &f->u.stream_data_blocked.id);
  1102.         if (p == NULL) {
  1103.             goto error;
  1104.         }

  1106.         p = ngx_quic_parse_int(p, end, &f->u.stream_data_blocked.limit);
  1107.         if (p == NULL) {
  1108.             goto error;
  1109.         }

  1111.         break;

  1113.     case NGX_QUIC_FT_PATH_CHALLENGE:

  1115.         p = ngx_quic_copy_bytes(p, end, 8, f->u.path_challenge.data);
  1116.         if (p == NULL) {
  1117.             goto error;
  1118.         }

  1120.         break;

  1122.     case NGX_QUIC_FT_PATH_RESPONSE:

  1124.         p = ngx_quic_copy_bytes(p, end, 8, f->u.path_response.data);
  1125.         if (p == NULL) {
  1126.             goto error;
  1127.         }

  1129.         break;

  1131.     default:
  1132.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  1133.                       "quic unknown frame type 0x%xi", f->type);
  1134.         return NGX_ERROR;
  1135.     }

  1137.     f->level = pkt->level;
  1138. #if (NGX_DEBUG)
  1139.     f->pnum = pkt->pn;
  1140. #endif

  1142.     return p - start;

  1144. error:

  1146.     pkt->error = NGX_QUIC_ERR_FRAME_ENCODING_ERROR;

  1148.     ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  1149.                   "quic failed to parse frame type:0x%xi", f->type);

  1151.     return NGX_ERROR;
  1152. }


  1155. static ngx_int_t
  1156. ‌ngx_quic_frame_allowed(ngx_quic_header_t *pkt, ngx_uint_t frame_type)
  1157. {
  1158.     uint8_t  ptype;

  1160.     /*
  1161.      * RFC 9000, 12.4. Frames and Frame Types: Table 3
  1162.      *
  1163.      * Frame permissions per packet: 4 bits: IH01
  1164.      */
  1165.     static uint8_t ngx_quic_frame_masks[] = {
  1166.          /* PADDING  */              0xF,
  1167.          /* PING */                  0xF,
  1168.          /* ACK */                   0xD,
  1169.          /* ACK_ECN */               0xD,
  1170.          /* RESET_STREAM */          0x3,
  1171.          /* STOP_SENDING */          0x3,
  1172.          /* CRYPTO */                0xD,
  1173.          /* NEW_TOKEN */             0x0, /* only sent by server */
  1174.          /* STREAM */                0x3,
  1175.          /* STREAM1 */               0x3,
  1176.          /* STREAM2 */               0x3,
  1177.          /* STREAM3 */               0x3,
  1178.          /* STREAM4 */               0x3,
  1179.          /* STREAM5 */               0x3,
  1180.          /* STREAM6 */               0x3,
  1181.          /* STREAM7 */               0x3,
  1182.          /* MAX_DATA */              0x3,
  1183.          /* MAX_STREAM_DATA */       0x3,
  1184.          /* MAX_STREAMS */           0x3,
  1185.          /* MAX_STREAMS2 */          0x3,
  1186.          /* DATA_BLOCKED */          0x3,
  1187.          /* STREAM_DATA_BLOCKED */   0x3,
  1188.          /* STREAMS_BLOCKED */       0x3,
  1189.          /* STREAMS_BLOCKED2 */      0x3,
  1190.          /* NEW_CONNECTION_ID */     0x3,
  1191.          /* RETIRE_CONNECTION_ID */  0x3,
  1192.          /* PATH_CHALLENGE */        0x3,
  1193.          /* PATH_RESPONSE */         0x1,
  1194.          /* CONNECTION_CLOSE */      0xF,
  1195.          /* CONNECTION_CLOSE2 */     0x3,
  1196.          /* HANDSHAKE_DONE */        0x0, /* only sent by server */
  1197.     };

  1199.     if (ngx_quic_long_pkt(pkt->flags)) {

  1201.         if (ngx_quic_pkt_in(pkt->flags)) {
  1202.             ptype = 8; /* initial */

  1204.         } else if (ngx_quic_pkt_hs(pkt->flags)) {
  1205.             ptype = 4; /* handshake */

  1207.         } else {
  1208.             ptype = 2; /* zero-rtt */
  1209.         }

  1211.     } else {
  1212.         ptype = 1; /* application data */
  1213.     }

  1215.     if (ptype & ngx_quic_frame_masks[frame_type]) {
  1216.         return NGX_OK;
  1217.     }

  1219.     ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  1220.                   "quic frame type 0x%xi is not "
  1221.                   "allowed in packet with flags 0x%xd",
  1222.                   frame_type, pkt->flags);

  1224.     return NGX_DECLINED;
  1225. }


  1228. ssize_t
  1229. ‌ngx_quic_parse_ack_range(ngx_log_t *log, u_char *start, u_char *end,
  1230.     uint64_t *gap, uint64_t *range)
  1231. {
  1232.     u_char  *p;

  1234.     p = start;

  1236.     p = ngx_quic_parse_int(p, end, gap);
  1237.     if (p == NULL) {
  1238.         ngx_log_error(NGX_LOG_INFO, log, 0,
  1239.                       "quic failed to parse ack frame gap");
  1240.         return NGX_ERROR;
  1241.     }

  1243.     p = ngx_quic_parse_int(p, end, range);
  1244.     if (p == NULL) {
  1245.         ngx_log_error(NGX_LOG_INFO, log, 0,
  1246.                       "quic failed to parse ack frame range");
  1247.         return NGX_ERROR;
  1248.     }

  1250.     return p - start;
  1251. }


  1254. size_t
  1255. ‌ngx_quic_create_ack_range(u_char *p, uint64_t gap, uint64_t range)
  1256. {
  1257.     size_t   len;
  1258.     u_char  *start;

  1260.     if (p == NULL) {
  1261.         len = ngx_quic_varint_len(gap);
  1262.         len += ngx_quic_varint_len(range);
  1263.         return len;
  1264.     }

  1266.     start = p;

  1268.     ngx_quic_build_int(&p, gap);
  1269.     ngx_quic_build_int(&p, range);

  1271.     return p - start;
  1272. }


  1275. ssize_t
  1276. ‌ngx_quic_create_frame(u_char *p, ngx_quic_frame_t *f)
  1277. {
  1278.     /*
  1279.      *  RFC 9002, 2.  Conventions and Definitions
  1280.      *
  1281.      *  Ack-eliciting frames:  All frames other than ACK, PADDING, and
  1282.      *  CONNECTION_CLOSE are considered ack-eliciting.
  1283.      */
  1284.     f->need_ack = 1;

  1286.     switch (f->type) {
  1287.     case NGX_QUIC_FT_PING:
  1288.         return ngx_quic_create_ping(p);

  1290.     case NGX_QUIC_FT_ACK:
  1291.         f->need_ack = 0;
  1292.         return ngx_quic_create_ack(p, &f->u.ack, f->data);

  1294.     case NGX_QUIC_FT_RESET_STREAM:
  1295.         return ngx_quic_create_reset_stream(p, &f->u.reset_stream);

  1297.     case NGX_QUIC_FT_STOP_SENDING:
  1298.         return ngx_quic_create_stop_sending(p, &f->u.stop_sending);

  1300.     case NGX_QUIC_FT_CRYPTO:
  1301.         return ngx_quic_create_crypto(p, &f->u.crypto, f->data);

  1303.     case NGX_QUIC_FT_HANDSHAKE_DONE:
  1304.         return ngx_quic_create_hs_done(p);

  1306.     case NGX_QUIC_FT_NEW_TOKEN:
  1307.         return ngx_quic_create_new_token(p, &f->u.token, f->data);

  1309.     case NGX_QUIC_FT_STREAM:
  1310.         return ngx_quic_create_stream(p, &f->u.stream, f->data);

  1312.     case NGX_QUIC_FT_CONNECTION_CLOSE:
  1313.     case NGX_QUIC_FT_CONNECTION_CLOSE_APP:
  1314.         f->need_ack = 0;
  1315.         return ngx_quic_create_close(p, f);

  1317.     case NGX_QUIC_FT_MAX_STREAMS:
  1318.         return ngx_quic_create_max_streams(p, &f->u.max_streams);

  1320.     case NGX_QUIC_FT_MAX_STREAM_DATA:
  1321.         return ngx_quic_create_max_stream_data(p, &f->u.max_stream_data);

  1323.     case NGX_QUIC_FT_MAX_DATA:
  1324.         return ngx_quic_create_max_data(p, &f->u.max_data);

  1326.     case NGX_QUIC_FT_PATH_CHALLENGE:
  1327.         return ngx_quic_create_path_challenge(p, &f->u.path_challenge);

  1329.     case NGX_QUIC_FT_PATH_RESPONSE:
  1330.         return ngx_quic_create_path_response(p, &f->u.path_response);

  1332.     case NGX_QUIC_FT_NEW_CONNECTION_ID:
  1333.         return ngx_quic_create_new_connection_id(p, &f->u.ncid);

  1335.     case NGX_QUIC_FT_RETIRE_CONNECTION_ID:
  1336.         return ngx_quic_create_retire_connection_id(p, &f->u.retire_cid);

  1338.     default:
  1339.         /* BUG: unsupported frame type generated */
  1340.         return NGX_ERROR;
  1341.     }
  1342. }


  1345. static size_t
  1346. ‌ngx_quic_create_ping(u_char *p)
  1347. {
  1348.     u_char  *start;

  1350.     if (p == NULL) {
  1351.         return ngx_quic_varint_len(NGX_QUIC_FT_PING);
  1352.     }

  1354.     start = p;

  1356.     ngx_quic_build_int(&p, NGX_QUIC_FT_PING);

  1358.     return p - start;
  1359. }


  1362. static size_t
  1363. ‌ngx_quic_create_ack(u_char *p, ngx_quic_ack_frame_t *ack, ngx_chain_t *ranges)
  1364. {
  1365.     size_t      len;
  1366.     u_char     *start;
  1367.     ngx_buf_t  *b;

  1369.     if (p == NULL) {
  1370.         len = ngx_quic_varint_len(NGX_QUIC_FT_ACK);
  1371.         len += ngx_quic_varint_len(ack->largest);
  1372.         len += ngx_quic_varint_len(ack->delay);
  1373.         len += ngx_quic_varint_len(ack->range_count);
  1374.         len += ngx_quic_varint_len(ack->first_range);
  1375.         len += ack->ranges_length;

  1377.         return len;
  1378.     }

  1380.     start = p;

  1382.     ngx_quic_build_int(&p, NGX_QUIC_FT_ACK);
  1383.     ngx_quic_build_int(&p, ack->largest);
  1384.     ngx_quic_build_int(&p, ack->delay);
  1385.     ngx_quic_build_int(&p, ack->range_count);
  1386.     ngx_quic_build_int(&p, ack->first_range);

  1388.     while (ranges) {
  1389.         b = ranges->buf;
  1390.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1391.         ranges = ranges->next;
  1392.     }

  1394.     return p - start;
  1395. }


  1398. static size_t
  1399. ‌ngx_quic_create_reset_stream(u_char *p, ngx_quic_reset_stream_frame_t *rs)
  1400. {
  1401.     size_t   len;
  1402.     u_char  *start;

  1404.     if (p == NULL) {
  1405.         len = ngx_quic_varint_len(NGX_QUIC_FT_RESET_STREAM);
  1406.         len += ngx_quic_varint_len(rs->id);
  1407.         len += ngx_quic_varint_len(rs->error_code);
  1408.         len += ngx_quic_varint_len(rs->final_size);
  1409.         return len;
  1410.     }

  1412.     start = p;

  1414.     ngx_quic_build_int(&p, NGX_QUIC_FT_RESET_STREAM);
  1415.     ngx_quic_build_int(&p, rs->id);
  1416.     ngx_quic_build_int(&p, rs->error_code);
  1417.     ngx_quic_build_int(&p, rs->final_size);

  1419.     return p - start;
  1420. }


  1423. static size_t
  1424. ‌ngx_quic_create_stop_sending(u_char *p, ngx_quic_stop_sending_frame_t *ss)
  1425. {
  1426.     size_t   len;
  1427.     u_char  *start;

  1429.     if (p == NULL) {
  1430.         len = ngx_quic_varint_len(NGX_QUIC_FT_STOP_SENDING);
  1431.         len += ngx_quic_varint_len(ss->id);
  1432.         len += ngx_quic_varint_len(ss->error_code);
  1433.         return len;
  1434.     }

  1436.     start = p;

  1438.     ngx_quic_build_int(&p, NGX_QUIC_FT_STOP_SENDING);
  1439.     ngx_quic_build_int(&p, ss->id);
  1440.     ngx_quic_build_int(&p, ss->error_code);

  1442.     return p - start;
  1443. }


  1446. static size_t
  1447. ‌ngx_quic_create_crypto(u_char *p, ngx_quic_crypto_frame_t *crypto,
  1448.     ngx_chain_t *data)
  1449. {
  1450.     size_t      len;
  1451.     u_char     *start;
  1452.     ngx_buf_t  *b;

  1454.     if (p == NULL) {
  1455.         len = ngx_quic_varint_len(NGX_QUIC_FT_CRYPTO);
  1456.         len += ngx_quic_varint_len(crypto->offset);
  1457.         len += ngx_quic_varint_len(crypto->length);
  1458.         len += crypto->length;

  1460.         return len;
  1461.     }

  1463.     start = p;

  1465.     ngx_quic_build_int(&p, NGX_QUIC_FT_CRYPTO);
  1466.     ngx_quic_build_int(&p, crypto->offset);
  1467.     ngx_quic_build_int(&p, crypto->length);

  1469.     while (data) {
  1470.         b = data->buf;
  1471.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1472.         data = data->next;
  1473.     }

  1475.     return p - start;
  1476. }


  1479. static size_t
  1480. ‌ngx_quic_create_hs_done(u_char *p)
  1481. {
  1482.     u_char  *start;

  1484.     if (p == NULL) {
  1485.         return ngx_quic_varint_len(NGX_QUIC_FT_HANDSHAKE_DONE);
  1486.     }

  1488.     start = p;

  1490.     ngx_quic_build_int(&p, NGX_QUIC_FT_HANDSHAKE_DONE);

  1492.     return p - start;
  1493. }


  1496. static size_t
  1497. ‌ngx_quic_create_new_token(u_char *p, ngx_quic_new_token_frame_t *token,
  1498.     ngx_chain_t *data)
  1499. {
  1500.     size_t      len;
  1501.     u_char     *start;
  1502.     ngx_buf_t  *b;

  1504.     if (p == NULL) {
  1505.         len = ngx_quic_varint_len(NGX_QUIC_FT_NEW_TOKEN);
  1506.         len += ngx_quic_varint_len(token->length);
  1507.         len += token->length;

  1509.         return len;
  1510.     }

  1512.     start = p;

  1514.     ngx_quic_build_int(&p, NGX_QUIC_FT_NEW_TOKEN);
  1515.     ngx_quic_build_int(&p, token->length);

  1517.     while (data) {
  1518.         b = data->buf;
  1519.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1520.         data = data->next;
  1521.     }

  1523.     return p - start;
  1524. }


  1527. static size_t
  1528. ‌ngx_quic_create_stream(u_char *p, ngx_quic_stream_frame_t *sf,
  1529.     ngx_chain_t *data)
  1530. {
  1531.     size_t      len;
  1532.     u_char     *start, type;
  1533.     ngx_buf_t  *b;

  1535.     type = NGX_QUIC_FT_STREAM;

  1537.     if (sf->off) {
  1538.         type |= NGX_QUIC_STREAM_FRAME_OFF;
  1539.     }

  1541.     if (sf->len) {
  1542.         type |= NGX_QUIC_STREAM_FRAME_LEN;
  1543.     }

  1545.     if (sf->fin) {
  1546.         type |= NGX_QUIC_STREAM_FRAME_FIN;
  1547.     }

  1549.     if (p == NULL) {
  1550.         len = ngx_quic_varint_len(type);
  1551.         len += ngx_quic_varint_len(sf->stream_id);

  1553.         if (sf->off) {
  1554.             len += ngx_quic_varint_len(sf->offset);
  1555.         }

  1557.         if (sf->len) {
  1558.             len += ngx_quic_varint_len(sf->length);
  1559.         }

  1561.         len += sf->length;

  1563.         return len;
  1564.     }

  1566.     start = p;

  1568.     ngx_quic_build_int(&p, type);
  1569.     ngx_quic_build_int(&p, sf->stream_id);

  1571.     if (sf->off) {
  1572.         ngx_quic_build_int(&p, sf->offset);
  1573.     }

  1575.     if (sf->len) {
  1576.         ngx_quic_build_int(&p, sf->length);
  1577.     }

  1579.     while (data) {
  1580.         b = data->buf;
  1581.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1582.         data = data->next;
  1583.     }

  1585.     return p - start;
  1586. }


  1589. static size_t
  1590. ‌ngx_quic_create_max_streams(u_char *p, ngx_quic_max_streams_frame_t *ms)
  1591. {
  1592.     size_t       len;
  1593.     u_char      *start;
  1594.     ngx_uint_t   type;

  1596.     type = ms->bidi ? NGX_QUIC_FT_MAX_STREAMS : NGX_QUIC_FT_MAX_STREAMS2;

  1598.     if (p == NULL) {
  1599.         len = ngx_quic_varint_len(type);
  1600.         len += ngx_quic_varint_len(ms->limit);
  1601.         return len;
  1602.     }

  1604.     start = p;

  1606.     ngx_quic_build_int(&p, type);
  1607.     ngx_quic_build_int(&p, ms->limit);

  1609.     return p - start;
  1610. }


  1613. static ngx_int_t
  1614. ‌ngx_quic_parse_transport_param(u_char *p, u_char *end, uint16_t id,
  1615.     ngx_quic_tp_t *dst)
  1616. {
  1617.     uint64_t   varint;
  1618.     ngx_str_t  str;

  1620.     varint = 0;
  1621.     ngx_str_null(&str);

  1623.     switch (id) {

  1625.     case NGX_QUIC_TP_DISABLE_ACTIVE_MIGRATION:
  1626.         /* zero-length option */
  1627.         if (end - p != 0) {
  1628.             return NGX_ERROR;
  1629.         }
  1630.         dst->disable_active_migration = 1;
  1631.         return NGX_OK;

  1633.     case NGX_QUIC_TP_MAX_IDLE_TIMEOUT:
  1634.     case NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE:
  1635.     case NGX_QUIC_TP_INITIAL_MAX_DATA:
  1636.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL:
  1637.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE:
  1638.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI:
  1639.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI:
  1640.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI:
  1641.     case NGX_QUIC_TP_ACK_DELAY_EXPONENT:
  1642.     case NGX_QUIC_TP_MAX_ACK_DELAY:
  1643.     case NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT:

  1645.         p = ngx_quic_parse_int(p, end, &varint);
  1646.         if (p == NULL) {
  1647.             return NGX_ERROR;
  1648.         }
  1649.         break;

  1651.     case NGX_QUIC_TP_INITIAL_SCID:

  1653.         str.len = end - p;
  1654.         str.data = p;
  1655.         break;

  1657.     default:
  1658.         return NGX_DECLINED;
  1659.     }

  1661.     switch (id) {

  1663.     case NGX_QUIC_TP_MAX_IDLE_TIMEOUT:
  1664.         dst->max_idle_timeout = varint;
  1665.         break;

  1667.     case NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE:
  1668.         dst->max_udp_payload_size = varint;
  1669.         break;

  1671.     case NGX_QUIC_TP_INITIAL_MAX_DATA:
  1672.         dst->initial_max_data = varint;
  1673.         break;

  1675.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL:
  1676.         dst->initial_max_stream_data_bidi_local = varint;
  1677.         break;

  1679.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE:
  1680.         dst->initial_max_stream_data_bidi_remote = varint;
  1681.         break;

  1683.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI:
  1684.         dst->initial_max_stream_data_uni = varint;
  1685.         break;

  1687.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI:
  1688.         dst->initial_max_streams_bidi = varint;
  1689.         break;

  1691.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI:
  1692.         dst->initial_max_streams_uni = varint;
  1693.         break;

  1695.     case NGX_QUIC_TP_ACK_DELAY_EXPONENT:
  1696.         dst->ack_delay_exponent = varint;
  1697.         break;

  1699.     case NGX_QUIC_TP_MAX_ACK_DELAY:
  1700.         dst->max_ack_delay = varint;
  1701.         break;

  1703.     case NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT:
  1704.         dst->active_connection_id_limit = varint;
  1705.         break;

  1707.     case NGX_QUIC_TP_INITIAL_SCID:
  1708.         dst->initial_scid = str;
  1709.         break;

  1711.     default:
  1712.         return NGX_ERROR;
  1713.     }

  1715.     return NGX_OK;
  1716. }


  1719. ngx_int_t
  1720. ‌ngx_quic_parse_transport_params(u_char *p, u_char *end, ngx_quic_tp_t *tp,
  1721.     ngx_log_t *log)
  1722. {
  1723.     uint64_t   id, len;
  1724.     ngx_int_t  rc;

  1726.     while (p < end) {
  1727.         p = ngx_quic_parse_int(p, end, &id);
  1728.         if (p == NULL) {
  1729.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1730.                           "quic failed to parse transport param id");
  1731.             return NGX_ERROR;
  1732.         }

  1734.         switch (id) {
  1735.         case NGX_QUIC_TP_ORIGINAL_DCID:
  1736.         case NGX_QUIC_TP_PREFERRED_ADDRESS:
  1737.         case NGX_QUIC_TP_RETRY_SCID:
  1738.         case NGX_QUIC_TP_SR_TOKEN:
  1739.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1740.                           "quic client sent forbidden transport param"
  1741.                           " id:0x%xL", id);
  1742.             return NGX_ERROR;
  1743.         }

  1745.         p = ngx_quic_parse_int(p, end, &len);
  1746.         if (p == NULL) {
  1747.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1748.                           "quic failed to parse"
  1749.                           " transport param id:0x%xL length", id);
  1750.             return NGX_ERROR;
  1751.         }

  1753.         if ((size_t) (end - p) < len) {
  1754.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1755.                           "quic failed to parse"
  1756.                           " transport param id:0x%xL, data length %uL too long",
  1757.                           id, len);
  1758.             return NGX_ERROR;
  1759.         }

  1761.         rc = ngx_quic_parse_transport_param(p, p + len, id, tp);

  1763.         if (rc == NGX_ERROR) {
  1764.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1765.                           "quic failed to parse"
  1766.                           " transport param id:0x%xL data", id);
  1767.             return NGX_ERROR;
  1768.         }

  1770.         if (rc == NGX_DECLINED) {
  1771.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1772.                           "quic %s transport param id:0x%xL, skipped",
  1773.                           (id % 31 == 27) ? "reserved" : "unknown", id);
  1774.         }

  1776.         p += len;
  1777.     }

  1779.     if (p != end) {
  1780.         ngx_log_error(NGX_LOG_INFO, log, 0,
  1781.                       "quic trailing garbage in"
  1782.                       " transport parameters: bytes:%ui",
  1783.                       end - p);
  1784.         return NGX_ERROR;
  1785.     }

  1787.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, log, 0,
  1788.                    "quic transport parameters parsed ok");

  1790.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1791.                    "quic tp disable active migration: %ui",
  1792.                    tp->disable_active_migration);

  1794.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "quic tp idle_timeout:%ui",
  1795.                    tp->max_idle_timeout);

  1797.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1798.                    "quic tp max_udp_payload_size:%ui",
  1799.                    tp->max_udp_payload_size);

  1801.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "quic tp max_data:%ui",
  1802.                    tp->initial_max_data);

  1804.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1805.                    "quic tp max_stream_data_bidi_local:%ui",
  1806.                    tp->initial_max_stream_data_bidi_local);

  1808.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1809.                    "quic tp max_stream_data_bidi_remote:%ui",
  1810.                    tp->initial_max_stream_data_bidi_remote);

  1812.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1813.                    "quic tp max_stream_data_uni:%ui",
  1814.                    tp->initial_max_stream_data_uni);

  1816.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1817.                    "quic tp initial_max_streams_bidi:%ui",
  1818.                    tp->initial_max_streams_bidi);

  1820.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1821.                    "quic tp initial_max_streams_uni:%ui",
  1822.                    tp->initial_max_streams_uni);

  1824.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1825.                    "quic tp ack_delay_exponent:%ui",
  1826.                    tp->ack_delay_exponent);

  1828.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "quic tp max_ack_delay:%ui",
  1829.                    tp->max_ack_delay);

  1831.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1832.                    "quic tp active_connection_id_limit:%ui",
  1833.                    tp->active_connection_id_limit);

  1835.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  1836.                    "quic tp initial source_connection_id len:%uz %xV",
  1837.                    tp->initial_scid.len, &tp->initial_scid);

  1839.     return NGX_OK;
  1840. }


  1843. static size_t
  1844. ‌ngx_quic_create_max_stream_data(u_char *p, ngx_quic_max_stream_data_frame_t *ms)
  1845. {
  1846.     size_t   len;
  1847.     u_char  *start;

  1849.     if (p == NULL) {
  1850.         len = ngx_quic_varint_len(NGX_QUIC_FT_MAX_STREAM_DATA);
  1851.         len += ngx_quic_varint_len(ms->id);
  1852.         len += ngx_quic_varint_len(ms->limit);
  1853.         return len;
  1854.     }

  1856.     start = p;

  1858.     ngx_quic_build_int(&p, NGX_QUIC_FT_MAX_STREAM_DATA);
  1859.     ngx_quic_build_int(&p, ms->id);
  1860.     ngx_quic_build_int(&p, ms->limit);

  1862.     return p - start;
  1863. }


  1866. static size_t
  1867. ‌ngx_quic_create_max_data(u_char *p, ngx_quic_max_data_frame_t *md)
  1868. {
  1869.     size_t   len;
  1870.     u_char  *start;

  1872.     if (p == NULL) {
  1873.         len = ngx_quic_varint_len(NGX_QUIC_FT_MAX_DATA);
  1874.         len += ngx_quic_varint_len(md->max_data);
  1875.         return len;
  1876.     }

  1878.     start = p;

  1880.     ngx_quic_build_int(&p, NGX_QUIC_FT_MAX_DATA);
  1881.     ngx_quic_build_int(&p, md->max_data);

  1883.     return p - start;
  1884. }


  1887. static size_t
  1888. ‌ngx_quic_create_path_challenge(u_char *p, ngx_quic_path_challenge_frame_t *pc)
  1889. {
  1890.     size_t   len;
  1891.     u_char  *start;

  1893.     if (p == NULL) {
  1894.         len = ngx_quic_varint_len(NGX_QUIC_FT_PATH_CHALLENGE);
  1895.         len += sizeof(pc->data);
  1896.         return len;
  1897.     }

  1899.     start = p;

  1901.     ngx_quic_build_int(&p, NGX_QUIC_FT_PATH_CHALLENGE);
  1902.     p = ngx_cpymem(p, &pc->data, sizeof(pc->data));

  1904.     return p - start;
  1905. }


  1908. static size_t
  1909. ‌ngx_quic_create_path_response(u_char *p, ngx_quic_path_challenge_frame_t *pc)
  1910. {
  1911.     size_t   len;
  1912.     u_char  *start;

  1914.     if (p == NULL) {
  1915.         len = ngx_quic_varint_len(NGX_QUIC_FT_PATH_RESPONSE);
  1916.         len += sizeof(pc->data);
  1917.         return len;
  1918.     }

  1920.     start = p;

  1922.     ngx_quic_build_int(&p, NGX_QUIC_FT_PATH_RESPONSE);
  1923.     p = ngx_cpymem(p, &pc->data, sizeof(pc->data));

  1925.     return p - start;
  1926. }


  1929. static size_t
  1930. ‌ngx_quic_create_new_connection_id(u_char *p, ngx_quic_new_conn_id_frame_t *ncid)
  1931. {
  1932.     size_t   len;
  1933.     u_char  *start;

  1935.     if (p == NULL) {
  1936.         len = ngx_quic_varint_len(NGX_QUIC_FT_NEW_CONNECTION_ID);
  1937.         len += ngx_quic_varint_len(ncid->seqnum);
  1938.         len += ngx_quic_varint_len(ncid->retire);
  1939.         len++;
  1940.         len += ncid->len;
  1941.         len += NGX_QUIC_SR_TOKEN_LEN;
  1942.         return len;
  1943.     }

  1945.     start = p;

  1947.     ngx_quic_build_int(&p, NGX_QUIC_FT_NEW_CONNECTION_ID);
  1948.     ngx_quic_build_int(&p, ncid->seqnum);
  1949.     ngx_quic_build_int(&p, ncid->retire);
  1950.     *p++ = ncid->len;
  1951.     p = ngx_cpymem(p, ncid->cid, ncid->len);
  1952.     p = ngx_cpymem(p, ncid->srt, NGX_QUIC_SR_TOKEN_LEN);

  1954.     return p - start;
  1955. }


  1958. static size_t
  1959. ‌ngx_quic_create_retire_connection_id(u_char *p,
  1960.     ngx_quic_retire_cid_frame_t *rcid)
  1961. {
  1962.     size_t   len;
  1963.     u_char  *start;

  1965.     if (p == NULL) {
  1966.         len = ngx_quic_varint_len(NGX_QUIC_FT_RETIRE_CONNECTION_ID);
  1967.         len += ngx_quic_varint_len(rcid->sequence_number);
  1968.         return len;
  1969.     }

  1971.     start = p;

  1973.     ngx_quic_build_int(&p, NGX_QUIC_FT_RETIRE_CONNECTION_ID);
  1974.     ngx_quic_build_int(&p, rcid->sequence_number);

  1976.     return p - start;
  1977. }


  1980. ngx_int_t
  1981. ‌ngx_quic_init_transport_params(ngx_quic_tp_t *tp, ngx_quic_conf_t *qcf)
  1982. {
  1983.     ngx_uint_t  nstreams;

  1985.     ngx_memzero(tp, sizeof(ngx_quic_tp_t));

  1987.     /*
  1988.      * set by ngx_memzero():
  1989.      *
  1990.      *     tp->disable_active_migration = 0;
  1991.      *     tp->original_dcid = { 0, NULL };
  1992.      *     tp->initial_scid = { 0, NULL };
  1993.      *     tp->retry_scid = { 0, NULL };
  1994.      *     tp->sr_token = { 0 }
  1995.      *     tp->sr_enabled = 0
  1996.      *     tp->preferred_address = NULL
  1997.      */

  1999.     tp->max_idle_timeout = qcf->idle_timeout;

  2001.     tp->max_udp_payload_size = NGX_QUIC_MAX_UDP_PAYLOAD_SIZE;

  2003.     nstreams = qcf->max_concurrent_streams_bidi
  2004.                + qcf->max_concurrent_streams_uni;

  2006.     tp->initial_max_data = nstreams * qcf->stream_buffer_size;
  2007.     tp->initial_max_stream_data_bidi_local = qcf->stream_buffer_size;
  2008.     tp->initial_max_stream_data_bidi_remote = qcf->stream_buffer_size;
  2009.     tp->initial_max_stream_data_uni = qcf->stream_buffer_size;

  2011.     tp->initial_max_streams_bidi = qcf->max_concurrent_streams_bidi;
  2012.     tp->initial_max_streams_uni = qcf->max_concurrent_streams_uni;

  2014.     tp->max_ack_delay = NGX_QUIC_DEFAULT_MAX_ACK_DELAY;
  2015.     tp->ack_delay_exponent = NGX_QUIC_DEFAULT_ACK_DELAY_EXPONENT;

  2017.     tp->active_connection_id_limit = qcf->active_connection_id_limit;
  2018.     tp->disable_active_migration = qcf->disable_active_migration;

  2020.     return NGX_OK;
  2021. }


  2024. ssize_t
  2025. ‌ngx_quic_create_transport_params(u_char *pos, u_char *end, ngx_quic_tp_t *tp,
  2026.     size_t *clen)
  2027. {
  2028.     u_char  *p;
  2029.     size_t   len;

  2031. ‌#define ngx_quic_tp_len(id, value)                                            \
  2032.     ngx_quic_varint_len(id)                                                   \
  2033.     + ngx_quic_varint_len(value)                                              \
  2034.     + ngx_quic_varint_len(ngx_quic_varint_len(value))

  2036. ‌#define ngx_quic_tp_vint(id, value)                                           \
  2037.     do {                                                                      \
  2038.         ngx_quic_build_int(&p, id);                                           \
  2039.         ngx_quic_build_int(&p, ngx_quic_varint_len(value));                   \
  2040.         ngx_quic_build_int(&p, value);                                        \
  2041.     } while (0)

  2043. ‌#define ngx_quic_tp_strlen(id, value)                                         \
  2044.     ngx_quic_varint_len(id)                                                   \
  2045.     + ngx_quic_varint_len(value.len)                                          \
  2046.     + value.len

  2048. ‌#define ngx_quic_tp_str(id, value)                                            \
  2049.     do {                                                                      \
  2050.         ngx_quic_build_int(&p, id);                                           \
  2051.         ngx_quic_build_int(&p, value.len);                                    \
  2052.         p = ngx_cpymem(p, value.data, value.len);                             \
  2053.     } while (0)

  2055.     len = ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_DATA, tp->initial_max_data);

  2057.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI,
  2058.                            tp->initial_max_streams_uni);

  2060.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI,
  2061.                            tp->initial_max_streams_bidi);

  2063.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
  2064.                            tp->initial_max_stream_data_bidi_local);

  2066.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
  2067.                            tp->initial_max_stream_data_bidi_remote);

  2069.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI,
  2070.                            tp->initial_max_stream_data_uni);

  2072.     len += ngx_quic_tp_len(NGX_QUIC_TP_MAX_IDLE_TIMEOUT,
  2073.                            tp->max_idle_timeout);

  2075.     len += ngx_quic_tp_len(NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE,
  2076.                            tp->max_udp_payload_size);

  2078.     if (tp->disable_active_migration) {
  2079.         len += ngx_quic_varint_len(NGX_QUIC_TP_DISABLE_ACTIVE_MIGRATION);
  2080.         len += ngx_quic_varint_len(0);
  2081.     }

  2083.     len += ngx_quic_tp_len(NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT,
  2084.                            tp->active_connection_id_limit);

  2086.     /* transport parameters listed above will be saved in 0-RTT context */
  2087.     if (clen) {
  2088.         *clen = len;
  2089.     }

  2091.     len += ngx_quic_tp_len(NGX_QUIC_TP_MAX_ACK_DELAY,
  2092.                            tp->max_ack_delay);

  2094.     len += ngx_quic_tp_len(NGX_QUIC_TP_ACK_DELAY_EXPONENT,
  2095.                            tp->ack_delay_exponent);

  2097.     len += ngx_quic_tp_strlen(NGX_QUIC_TP_ORIGINAL_DCID, tp->original_dcid);
  2098.     len += ngx_quic_tp_strlen(NGX_QUIC_TP_INITIAL_SCID, tp->initial_scid);

  2100.     if (tp->retry_scid.len) {
  2101.         len += ngx_quic_tp_strlen(NGX_QUIC_TP_RETRY_SCID, tp->retry_scid);
  2102.     }

  2104.     len += ngx_quic_varint_len(NGX_QUIC_TP_SR_TOKEN);
  2105.     len += ngx_quic_varint_len(NGX_QUIC_SR_TOKEN_LEN);
  2106.     len += NGX_QUIC_SR_TOKEN_LEN;

  2108.     if (pos == NULL) {
  2109.         return len;
  2110.     }

  2112.     p = pos;

  2114.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_DATA,
  2115.                      tp->initial_max_data);

  2117.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI,
  2118.                      tp->initial_max_streams_uni);

  2120.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI,
  2121.                      tp->initial_max_streams_bidi);

  2123.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
  2124.                      tp->initial_max_stream_data_bidi_local);

  2126.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
  2127.                      tp->initial_max_stream_data_bidi_remote);

  2129.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI,
  2130.                      tp->initial_max_stream_data_uni);

  2132.     ngx_quic_tp_vint(NGX_QUIC_TP_MAX_IDLE_TIMEOUT,
  2133.                      tp->max_idle_timeout);

  2135.     ngx_quic_tp_vint(NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE,
  2136.                      tp->max_udp_payload_size);

  2138.     if (tp->disable_active_migration) {
  2139.         ngx_quic_build_int(&p, NGX_QUIC_TP_DISABLE_ACTIVE_MIGRATION);
  2140.         ngx_quic_build_int(&p, 0);
  2141.     }

  2143.     ngx_quic_tp_vint(NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT,
  2144.                      tp->active_connection_id_limit);

  2146.     ngx_quic_tp_vint(NGX_QUIC_TP_MAX_ACK_DELAY,
  2147.                      tp->max_ack_delay);

  2149.     ngx_quic_tp_vint(NGX_QUIC_TP_ACK_DELAY_EXPONENT,
  2150.                      tp->ack_delay_exponent);

  2152.     ngx_quic_tp_str(NGX_QUIC_TP_ORIGINAL_DCID, tp->original_dcid);
  2153.     ngx_quic_tp_str(NGX_QUIC_TP_INITIAL_SCID, tp->initial_scid);

  2155.     if (tp->retry_scid.len) {
  2156.         ngx_quic_tp_str(NGX_QUIC_TP_RETRY_SCID, tp->retry_scid);
  2157.     }

  2159.     ngx_quic_build_int(&p, NGX_QUIC_TP_SR_TOKEN);
  2160.     ngx_quic_build_int(&p, NGX_QUIC_SR_TOKEN_LEN);
  2161.     p = ngx_cpymem(p, tp->sr_token, NGX_QUIC_SR_TOKEN_LEN);

  2163.     return p - pos;
  2164. }


  2167. static size_t
  2168. ‌ngx_quic_create_close(u_char *p, ngx_quic_frame_t *f)
  2169. {
  2170.     size_t                   len;
  2171.     u_char                  *start;
  2172.     ngx_quic_close_frame_t  *cl;

  2174.     cl = &f->u.close;

  2176.     if (p == NULL) {
  2177.         len = ngx_quic_varint_len(f->type);
  2178.         len += ngx_quic_varint_len(cl->error_code);

  2180.         if (f->type != NGX_QUIC_FT_CONNECTION_CLOSE_APP) {
  2181.             len += ngx_quic_varint_len(cl->frame_type);
  2182.         }

  2184.         len += ngx_quic_varint_len(cl->reason.len);
  2185.         len += cl->reason.len;

  2187.         return len;
  2188.     }

  2190.     start = p;

  2192.     ngx_quic_build_int(&p, f->type);
  2193.     ngx_quic_build_int(&p, cl->error_code);

  2195.     if (f->type != NGX_QUIC_FT_CONNECTION_CLOSE_APP) {
  2196.         ngx_quic_build_int(&p, cl->frame_type);
  2197.     }

  2199.     ngx_quic_build_int(&p, cl->reason.len);
  2200.     p = ngx_cpymem(p, cl->reason.data, cl->reason.len);

  2202.     return p - start;
  2203. }


  2206. void
  2207. ‌ngx_quic_dcid_encode_key(u_char *dcid, uint64_t key)
  2208. {
  2209.     (void) ngx_quic_write_uint64(dcid, key);
  2210. }

One Level Up Top Level