One Level Up Top Level

src/event/quic/ngx_event_quic_transport.c - nginx-1.31.3 nginx/ @ 42f8df65b

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 = NGX_QUIC_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 (pkt->version == 0) {
  299.         /* version negotiation */
  300.         return NGX_ERROR;
  301.     }

  303.     if (!ngx_quic_supported_version(pkt->version)) {
  304.         return NGX_ABORT;
  305.     }

  307.     if (ngx_quic_parse_long_header_v1(pkt) != NGX_OK) {
  308.         return NGX_ERROR;
  309.     }

  311.     return NGX_OK;
  312. }


  315. static ngx_int_t
  316. ‌ngx_quic_parse_short_header(ngx_quic_header_t *pkt, size_t dcid_len)
  317. {
  318.     u_char  *p, *end;

  320.     p = pkt->raw->pos;
  321.     end = pkt->data + pkt->len;

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

  326.     if (!(pkt->flags & NGX_QUIC_PKT_FIXED_BIT)) {
  327.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic fixed bit is not set");
  328.         return NGX_ERROR;
  329.     }

  331.     pkt->dcid.len = dcid_len;

  333.     p = ngx_quic_read_bytes(p, end, dcid_len, &pkt->dcid.data);
  334.     if (p == NULL) {
  335.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  336.                       "quic packet is too small to read dcid");
  337.         return NGX_ERROR;
  338.     }

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

  342.     return NGX_OK;
  343. }


  346. static ngx_int_t
  347. ‌ngx_quic_parse_long_header(ngx_quic_header_t *pkt)
  348. {
  349.     u_char   *p, *end;
  350.     uint8_t   idlen;

  352.     p = pkt->raw->pos;
  353.     end = pkt->data + pkt->len;

  355.     p = ngx_quic_read_uint32(p, end, &pkt->version);
  356.     if (p == NULL) {
  357.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  358.                       "quic packet is too small to read version");
  359.         return NGX_ERROR;
  360.     }

  362.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pkt->log, 0,
  363.                    "quic packet rx long flags:%xd version:%xD",
  364.                    pkt->flags, pkt->version);

  366.     if (!(pkt->flags & NGX_QUIC_PKT_FIXED_BIT)) {
  367.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic fixed bit is not set");
  368.         return NGX_ERROR;
  369.     }

  371.     p = ngx_quic_read_uint8(p, end, &idlen);
  372.     if (p == NULL) {
  373.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  374.                       "quic packet is too small to read dcid len");
  375.         return NGX_ERROR;
  376.     }

  378.     if (idlen > NGX_QUIC_CID_LEN_MAX) {
  379.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  380.                       "quic packet dcid is too long");
  381.         return NGX_ERROR;
  382.     }

  384.     pkt->dcid.len = idlen;

  386.     p = ngx_quic_read_bytes(p, end, idlen, &pkt->dcid.data);
  387.     if (p == NULL) {
  388.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  389.                       "quic packet is too small to read dcid");
  390.         return NGX_ERROR;
  391.     }

  393.     p = ngx_quic_read_uint8(p, end, &idlen);
  394.     if (p == NULL) {
  395.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  396.                       "quic packet is too small to read scid len");
  397.         return NGX_ERROR;
  398.     }

  400.     if (idlen > NGX_QUIC_CID_LEN_MAX) {
  401.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  402.                       "quic packet scid is too long");
  403.         return NGX_ERROR;
  404.     }

  406.     pkt->scid.len = idlen;

  408.     p = ngx_quic_read_bytes(p, end, idlen, &pkt->scid.data);
  409.     if (p == NULL) {
  410.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  411.                       "quic packet is too small to read scid");
  412.         return NGX_ERROR;
  413.     }

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

  417.     return NGX_OK;
  418. }


  421. static ngx_int_t
  422. ‌ngx_quic_supported_version(uint32_t version)
  423. {
  424.     ngx_uint_t  i;

  426.     for (i = 0; i < NGX_QUIC_NVERSIONS; i++) {
  427.         if (ngx_quic_versions[i] == version) {
  428.             return 1;
  429.         }
  430.     }

  432.     return 0;
  433. }


  436. static ngx_int_t
  437. ‌ngx_quic_parse_long_header_v1(ngx_quic_header_t *pkt)
  438. {
  439.     u_char    *p, *end;
  440.     uint64_t   varint;

  442.     p = pkt->raw->pos;
  443.     end = pkt->raw->last;

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

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

  449.         if (pkt->len < NGX_QUIC_MIN_INITIAL_SIZE) {
  450.             ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  451.                           "quic UDP datagram is too small for initial packet");
  452.             return NGX_DECLINED;
  453.         }

  455.         p = ngx_quic_parse_int(p, end, &varint);
  456.         if (p == NULL) {
  457.             ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  458.                           "quic failed to parse token length");
  459.             return NGX_ERROR;
  460.         }

  462.         pkt->token.len = varint;

  464.         p = ngx_quic_read_bytes(p, end, pkt->token.len, &pkt->token.data);
  465.         if (p == NULL) {
  466.             ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  467.                           "quic packet too small to read token data");
  468.             return NGX_ERROR;
  469.         }

  471.         pkt->level = NGX_QUIC_ENCRYPTION_INITIAL;

  473.     } else if (ngx_quic_pkt_zrtt(pkt->flags)) {
  474.         pkt->level = NGX_QUIC_ENCRYPTION_EARLY_DATA;

  476.     } else if (ngx_quic_pkt_hs(pkt->flags)) {
  477.         pkt->level = NGX_QUIC_ENCRYPTION_HANDSHAKE;

  479.     } else {
  480.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  481.                       "quic bad packet type");
  482.         return NGX_DECLINED;
  483.     }

  485.     p = ngx_quic_parse_int(p, end, &varint);
  486.     if (p == NULL) {
  487.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic bad packet length");
  488.         return NGX_ERROR;
  489.     }

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

  495.     if (varint > (uint64_t) ((pkt->data + pkt->len) - p)) {
  496.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic truncated %s packet",
  497.                       ngx_quic_level_name(pkt->level));
  498.         return NGX_ERROR;
  499.     }

  501.     pkt->raw->pos = p;
  502.     pkt->len = p + varint - pkt->data;

  504.     return NGX_OK;
  505. }


  508. ngx_int_t
  509. ‌ngx_quic_get_packet_dcid(ngx_log_t *log, u_char *data, size_t n,
  510.     ngx_str_t *dcid)
  511. {
  512.     size_t  len, offset;

  514.     if (n == 0) {
  515.         goto failed;
  516.     }

  518.     if (ngx_quic_long_pkt(*data)) {
  519.         if (n < NGX_QUIC_LONG_DCID_LEN_OFFSET + 1) {
  520.             goto failed;
  521.         }

  523.         len = data[NGX_QUIC_LONG_DCID_LEN_OFFSET];
  524.         offset = NGX_QUIC_LONG_DCID_OFFSET;

  526.     } else {
  527.         len = NGX_QUIC_SERVER_CID_LEN;
  528.         offset = NGX_QUIC_SHORT_DCID_OFFSET;
  529.     }

  531.     if (n < len + offset) {
  532.         goto failed;
  533.     }

  535.     dcid->len = len;
  536.     dcid->data = &data[offset];

  538.     return NGX_OK;

  540. failed:

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

  544.     return NGX_ERROR;
  545. }


  548. size_t
  549. ‌ngx_quic_create_version_negotiation(ngx_quic_header_t *pkt, u_char *out)
  550. {
  551.     u_char      *p, *start;
  552.     ngx_uint_t   i;

  554.     p = start = out;

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

  558.     /*
  559.      * The Version field of a Version Negotiation packet
  560.      * MUST be set to 0x00000000
  561.      */
  562.     p = ngx_quic_write_uint32(p, 0);

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

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

  570.     for (i = 0; i < NGX_QUIC_NVERSIONS; i++) {
  571.         p = ngx_quic_write_uint32(p, ngx_quic_versions[i]);
  572.     }

  574.     return p - start;
  575. }


  578. /* returns the amount of payload quic packet of "pkt_len" size may fit or 0 */
  579. size_t
  580. ‌ngx_quic_payload_size(ngx_quic_header_t *pkt, size_t pkt_len)
  581. {
  582.     size_t  len;

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

  586.         len = 1 + pkt->dcid.len + pkt->num_len + NGX_QUIC_TAG_LEN;
  587.         if (len > pkt_len) {
  588.             return 0;
  589.         }

  591.         return pkt_len - len;
  592.     }

  594.     /* flags, version, dcid and scid with lengths and zero-length token */
  595.     len = 5 + 2 + pkt->dcid.len + pkt->scid.len
  596.           + (pkt->level == NGX_QUIC_ENCRYPTION_INITIAL ? 1 : 0);

  598.     if (len > pkt_len) {
  599.         return 0;
  600.     }

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

  606.     if (len > pkt_len) {
  607.         return 0;
  608.     }

  610.     return pkt_len - len;
  611. }


  614. size_t
  615. ‌ngx_quic_create_header(ngx_quic_header_t *pkt, u_char *out, u_char **pnp)
  616. {
  617.     return ngx_quic_short_pkt(pkt->flags)
  618.            ? ngx_quic_create_short_header(pkt, out, pnp)
  619.            : ngx_quic_create_long_header(pkt, out, pnp);
  620. }


  623. static size_t
  624. ‌ngx_quic_create_long_header(ngx_quic_header_t *pkt, u_char *out,
  625.     u_char **pnp)
  626. {
  627.     size_t   rem_len;
  628.     u_char  *p, *start;

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

  632.     if (out == NULL) {
  633.         return 5 + 2 + pkt->dcid.len + pkt->scid.len
  634.                + ngx_quic_varint_len(rem_len) + pkt->num_len
  635.                + (pkt->level == NGX_QUIC_ENCRYPTION_INITIAL ? 1 : 0);
  636.     }

  638.     p = start = out;

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

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

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

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

  650.     if (pkt->level == NGX_QUIC_ENCRYPTION_INITIAL) {
  651.         ngx_quic_build_int(&p, 0);
  652.     }

  654.     ngx_quic_build_int(&p, rem_len);

  656.     *pnp = p;

  658.     switch (pkt->num_len) {
  659.     case 1:
  660.         *p++ = pkt->trunc;
  661.         break;
  662.     case 2:
  663.         p = ngx_quic_write_uint16(p, pkt->trunc);
  664.         break;
  665.     case 3:
  666.         p = ngx_quic_write_uint24(p, pkt->trunc);
  667.         break;
  668.     case 4:
  669.         p = ngx_quic_write_uint32(p, pkt->trunc);
  670.         break;
  671.     }

  673.     return p - start;
  674. }


  677. static size_t
  678. ‌ngx_quic_create_short_header(ngx_quic_header_t *pkt, u_char *out,
  679.     u_char **pnp)
  680. {
  681.     u_char  *p, *start;

  683.     if (out == NULL) {
  684.         return 1 + pkt->dcid.len + pkt->num_len;
  685.     }

  687.     p = start = out;

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

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

  693.     *pnp = p;

  695.     switch (pkt->num_len) {
  696.     case 1:
  697.         *p++ = pkt->trunc;
  698.         break;
  699.     case 2:
  700.         p = ngx_quic_write_uint16(p, pkt->trunc);
  701.         break;
  702.     case 3:
  703.         p = ngx_quic_write_uint24(p, pkt->trunc);
  704.         break;
  705.     case 4:
  706.         p = ngx_quic_write_uint32(p, pkt->trunc);
  707.         break;
  708.     }

  710.     return p - start;
  711. }


  714. size_t
  715. ‌ngx_quic_create_retry_itag(ngx_quic_header_t *pkt, u_char *out,
  716.     u_char **start)
  717. {
  718.     u_char  *p;

  720.     p = out;

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

  725.     *start = p;

  727.     *p++ = 0xff;

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

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

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

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

  739.     return p - out;
  740. }


  743. ssize_t
  744. ‌ngx_quic_parse_frame(ngx_quic_header_t *pkt, u_char *start, u_char *end,
  745.     ngx_quic_frame_t *f)
  746. {
  747.     u_char      *p;
  748.     uint64_t     varint;
  749.     ngx_buf_t   *b;
  750.     ngx_uint_t   i;

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

  754.     p = start;

  756.     p = ngx_quic_parse_int(p, end, &varint);
  757.     if (p == NULL) {
  758.         pkt->error = NGX_QUIC_ERR_FRAME_ENCODING_ERROR;
  759.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  760.                       "quic failed to obtain quic frame type");
  761.         return NGX_ERROR;
  762.     }

  764.     if (varint > NGX_QUIC_FT_LAST) {
  765.         pkt->error = NGX_QUIC_ERR_FRAME_ENCODING_ERROR;
  766.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  767.                       "quic unknown frame type 0x%xL", varint);
  768.         return NGX_ERROR;
  769.     }

  771.     f->type = varint;

  773.     if (ngx_quic_frame_allowed(pkt, f->type) != NGX_OK) {
  774.         pkt->error = NGX_QUIC_ERR_PROTOCOL_VIOLATION;
  775.         return NGX_ERROR;
  776.     }

  778.     switch (f->type) {

  780.     case NGX_QUIC_FT_CRYPTO:

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

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

  792.         p = ngx_quic_read_bytes(p, end, f->u.crypto.length, &b->pos);
  793.         if (p == NULL) {
  794.             goto error;
  795.         }

  797.         b->last = p;

  799.         break;

  801.     case NGX_QUIC_FT_PADDING:

  803.         while (p < end && *p == NGX_QUIC_FT_PADDING) {
  804.             p++;
  805.         }

  807.         break;

  809.     case NGX_QUIC_FT_ACK:
  810.     case NGX_QUIC_FT_ACK_ECN:

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

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

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

  827.         p = ngx_quic_parse_int(p, end, &f->u.ack.first_range);
  828.         if (p == NULL) {
  829.             goto error;
  830.         }

  832.         b->pos = p;

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

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

  842.             p = ngx_quic_parse_int(p, end, &varint);
  843.             if (p == NULL) {
  844.                 goto error;
  845.             }
  846.         }

  848.         b->last = p;

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

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

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

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

  864.             p = ngx_quic_parse_int(p, end, &f->u.ack.ce);
  865.             if (p == NULL) {
  866.                 goto error;
  867.             }

  869.             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, pkt->log, 0,
  870.                            "quic ACK ECN counters ect0:%uL ect1:%uL ce:%uL",
  871.                            f->u.ack.ect0, f->u.ack.ect1, f->u.ack.ce);
  872.         }

  874.         break;

  876.     case NGX_QUIC_FT_PING:
  877.         break;

  879.     case NGX_QUIC_FT_NEW_CONNECTION_ID:

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

  886.         p = ngx_quic_parse_int(p, end, &f->u.ncid.retire);
  887.         if (p == NULL) {
  888.             goto error;
  889.         }

  891.         if (f->u.ncid.retire > f->u.ncid.seqnum) {
  892.             goto error;
  893.         }

  895.         p = ngx_quic_read_uint8(p, end, &f->u.ncid.len);
  896.         if (p == NULL) {
  897.             goto error;
  898.         }

  900.         if (f->u.ncid.len < 1 || f->u.ncid.len > NGX_QUIC_CID_LEN_MAX) {
  901.             goto error;
  902.         }

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

  909.         p = ngx_quic_copy_bytes(p, end, NGX_QUIC_SR_TOKEN_LEN, f->u.ncid.srt);
  910.         if (p == NULL) {
  911.             goto error;
  912.         }

  914.         break;

  916.     case NGX_QUIC_FT_RETIRE_CONNECTION_ID:

  918.         p = ngx_quic_parse_int(p, end, &f->u.retire_cid.sequence_number);
  919.         if (p == NULL) {
  920.             goto error;
  921.         }

  923.         break;

  925.     case NGX_QUIC_FT_CONNECTION_CLOSE:
  926.     case NGX_QUIC_FT_CONNECTION_CLOSE_APP:

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

  933.         if (f->type == NGX_QUIC_FT_CONNECTION_CLOSE) {
  934.             p = ngx_quic_parse_int(p, end, &f->u.close.frame_type);
  935.             if (p == NULL) {
  936.                 goto error;
  937.             }
  938.         }

  940.         p = ngx_quic_parse_int(p, end, &varint);
  941.         if (p == NULL) {
  942.             goto error;
  943.         }

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

  947.         p = ngx_quic_read_bytes(p, end, f->u.close.reason.len,
  948.                                 &f->u.close.reason.data);
  949.         if (p == NULL) {
  950.             goto error;
  951.         }

  953.         break;

  955.     case NGX_QUIC_FT_STREAM:
  956.     case NGX_QUIC_FT_STREAM1:
  957.     case NGX_QUIC_FT_STREAM2:
  958.     case NGX_QUIC_FT_STREAM3:
  959.     case NGX_QUIC_FT_STREAM4:
  960.     case NGX_QUIC_FT_STREAM5:
  961.     case NGX_QUIC_FT_STREAM6:
  962.     case NGX_QUIC_FT_STREAM7:

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

  966.         p = ngx_quic_parse_int(p, end, &f->u.stream.stream_id);
  967.         if (p == NULL) {
  968.             goto error;
  969.         }

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

  974.             p = ngx_quic_parse_int(p, end, &f->u.stream.offset);
  975.             if (p == NULL) {
  976.                 goto error;
  977.             }

  979.         } else {
  980.             f->u.stream.off = 0;
  981.             f->u.stream.offset = 0;
  982.         }

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

  987.             p = ngx_quic_parse_int(p, end, &f->u.stream.length);
  988.             if (p == NULL) {
  989.                 goto error;
  990.             }

  992.         } else {
  993.             f->u.stream.len = 0;
  994.             f->u.stream.length = end - p; /* up to packet end */
  995.         }

  997.         p = ngx_quic_read_bytes(p, end, f->u.stream.length, &b->pos);
  998.         if (p == NULL) {
  999.             goto error;
  1000.         }

  1002.         b->last = p;

  1004.         f->type = NGX_QUIC_FT_STREAM;
  1005.         break;

  1007.     case NGX_QUIC_FT_MAX_DATA:

  1009.         p = ngx_quic_parse_int(p, end, &f->u.max_data.max_data);
  1010.         if (p == NULL) {
  1011.             goto error;
  1012.         }

  1014.         break;

  1016.     case NGX_QUIC_FT_RESET_STREAM:

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

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

  1028.         p = ngx_quic_parse_int(p, end, &f->u.reset_stream.final_size);
  1029.         if (p == NULL) {
  1030.             goto error;
  1031.         }

  1033.         break;

  1035.     case NGX_QUIC_FT_STOP_SENDING:

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

  1042.         p = ngx_quic_parse_int(p, end, &f->u.stop_sending.error_code);
  1043.         if (p == NULL) {
  1044.             goto error;
  1045.         }

  1047.         break;

  1049.     case NGX_QUIC_FT_STREAMS_BLOCKED:
  1050.     case NGX_QUIC_FT_STREAMS_BLOCKED2:

  1052.         p = ngx_quic_parse_int(p, end, &f->u.streams_blocked.limit);
  1053.         if (p == NULL) {
  1054.             goto error;
  1055.         }

  1057.         if (f->u.streams_blocked.limit > 0x1000000000000000) {
  1058.             goto error;
  1059.         }

  1061.         f->u.streams_blocked.bidi =
  1062.                               (f->type == NGX_QUIC_FT_STREAMS_BLOCKED) ? 1 : 0;
  1063.         break;

  1065.     case NGX_QUIC_FT_MAX_STREAMS:
  1066.     case NGX_QUIC_FT_MAX_STREAMS2:

  1068.         p = ngx_quic_parse_int(p, end, &f->u.max_streams.limit);
  1069.         if (p == NULL) {
  1070.             goto error;
  1071.         }

  1073.         if (f->u.max_streams.limit > 0x1000000000000000) {
  1074.             goto error;
  1075.         }

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

  1079.         break;

  1081.     case NGX_QUIC_FT_MAX_STREAM_DATA:

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

  1088.         p = ngx_quic_parse_int(p, end, &f->u.max_stream_data.limit);
  1089.         if (p == NULL) {
  1090.             goto error;
  1091.         }

  1093.         break;

  1095.     case NGX_QUIC_FT_DATA_BLOCKED:

  1097.         p = ngx_quic_parse_int(p, end, &f->u.data_blocked.limit);
  1098.         if (p == NULL) {
  1099.             goto error;
  1100.         }

  1102.         break;

  1104.     case NGX_QUIC_FT_STREAM_DATA_BLOCKED:

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

  1111.         p = ngx_quic_parse_int(p, end, &f->u.stream_data_blocked.limit);
  1112.         if (p == NULL) {
  1113.             goto error;
  1114.         }

  1116.         break;

  1118.     case NGX_QUIC_FT_PATH_CHALLENGE:

  1120.         p = ngx_quic_copy_bytes(p, end, 8, f->u.path_challenge.data);
  1121.         if (p == NULL) {
  1122.             goto error;
  1123.         }

  1125.         break;

  1127.     case NGX_QUIC_FT_PATH_RESPONSE:

  1129.         p = ngx_quic_copy_bytes(p, end, 8, f->u.path_response.data);
  1130.         if (p == NULL) {
  1131.             goto error;
  1132.         }

  1134.         break;

  1136.     default:
  1137.         ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  1138.                       "quic unknown frame type 0x%xi", f->type);
  1139.         return NGX_ERROR;
  1140.     }

  1142.     f->level = pkt->level;
  1143. #if (NGX_DEBUG)
  1144.     f->pnum = pkt->pn;
  1145. #endif

  1147.     return p - start;

  1149. error:

  1151.     pkt->error = NGX_QUIC_ERR_FRAME_ENCODING_ERROR;

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

  1156.     return NGX_ERROR;
  1157. }


  1160. static ngx_int_t
  1161. ‌ngx_quic_frame_allowed(ngx_quic_header_t *pkt, ngx_uint_t frame_type)
  1162. {
  1163.     uint8_t  ptype;

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

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

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

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

  1212.         } else {
  1213.             ptype = 2; /* zero-rtt */
  1214.         }

  1216.     } else {
  1217.         ptype = 1; /* application data */
  1218.     }

  1220.     if (ptype & ngx_quic_frame_masks[frame_type]) {
  1221.         return NGX_OK;
  1222.     }

  1224.     ngx_log_error(NGX_LOG_INFO, pkt->log, 0,
  1225.                   "quic frame type 0x%xi is not "
  1226.                   "allowed in packet with flags 0x%xd",
  1227.                   frame_type, pkt->flags);

  1229.     return NGX_DECLINED;
  1230. }


  1233. ssize_t
  1234. ‌ngx_quic_parse_ack_range(ngx_log_t *log, u_char *start, u_char *end,
  1235.     uint64_t *gap, uint64_t *range)
  1236. {
  1237.     u_char  *p;

  1239.     p = start;

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

  1248.     p = ngx_quic_parse_int(p, end, range);
  1249.     if (p == NULL) {
  1250.         ngx_log_error(NGX_LOG_INFO, log, 0,
  1251.                       "quic failed to parse ack frame range");
  1252.         return NGX_ERROR;
  1253.     }

  1255.     return p - start;
  1256. }


  1259. size_t
  1260. ‌ngx_quic_create_ack_range(u_char *p, uint64_t gap, uint64_t range)
  1261. {
  1262.     size_t   len;
  1263.     u_char  *start;

  1265.     if (p == NULL) {
  1266.         len = ngx_quic_varint_len(gap);
  1267.         len += ngx_quic_varint_len(range);
  1268.         return len;
  1269.     }

  1271.     start = p;

  1273.     ngx_quic_build_int(&p, gap);
  1274.     ngx_quic_build_int(&p, range);

  1276.     return p - start;
  1277. }


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

  1291.     switch (f->type) {
  1292.     case NGX_QUIC_FT_PING:
  1293.         return ngx_quic_create_ping(p);

  1295.     case NGX_QUIC_FT_ACK:
  1296.         f->need_ack = 0;
  1297.         return ngx_quic_create_ack(p, &f->u.ack, f->data);

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

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

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

  1308.     case NGX_QUIC_FT_HANDSHAKE_DONE:
  1309.         return ngx_quic_create_hs_done(p);

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

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

  1317.     case NGX_QUIC_FT_CONNECTION_CLOSE:
  1318.     case NGX_QUIC_FT_CONNECTION_CLOSE_APP:
  1319.         f->need_ack = 0;
  1320.         return ngx_quic_create_close(p, f);

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

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

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

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

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

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

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

  1343.     default:
  1344.         /* BUG: unsupported frame type generated */
  1345.         return NGX_ERROR;
  1346.     }
  1347. }


  1350. static size_t
  1351. ‌ngx_quic_create_ping(u_char *p)
  1352. {
  1353.     u_char  *start;

  1355.     if (p == NULL) {
  1356.         return ngx_quic_varint_len(NGX_QUIC_FT_PING);
  1357.     }

  1359.     start = p;

  1361.     ngx_quic_build_int(&p, NGX_QUIC_FT_PING);

  1363.     return p - start;
  1364. }


  1367. static size_t
  1368. ‌ngx_quic_create_ack(u_char *p, ngx_quic_ack_frame_t *ack, ngx_chain_t *ranges)
  1369. {
  1370.     size_t      len;
  1371.     u_char     *start;
  1372.     ngx_buf_t  *b;

  1374.     if (p == NULL) {
  1375.         len = ngx_quic_varint_len(NGX_QUIC_FT_ACK);
  1376.         len += ngx_quic_varint_len(ack->largest);
  1377.         len += ngx_quic_varint_len(ack->delay);
  1378.         len += ngx_quic_varint_len(ack->range_count);
  1379.         len += ngx_quic_varint_len(ack->first_range);
  1380.         len += ack->ranges_length;

  1382.         return len;
  1383.     }

  1385.     start = p;

  1387.     ngx_quic_build_int(&p, NGX_QUIC_FT_ACK);
  1388.     ngx_quic_build_int(&p, ack->largest);
  1389.     ngx_quic_build_int(&p, ack->delay);
  1390.     ngx_quic_build_int(&p, ack->range_count);
  1391.     ngx_quic_build_int(&p, ack->first_range);

  1393.     while (ranges) {
  1394.         b = ranges->buf;
  1395.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1396.         ranges = ranges->next;
  1397.     }

  1399.     return p - start;
  1400. }


  1403. static size_t
  1404. ‌ngx_quic_create_reset_stream(u_char *p, ngx_quic_reset_stream_frame_t *rs)
  1405. {
  1406.     size_t   len;
  1407.     u_char  *start;

  1409.     if (p == NULL) {
  1410.         len = ngx_quic_varint_len(NGX_QUIC_FT_RESET_STREAM);
  1411.         len += ngx_quic_varint_len(rs->id);
  1412.         len += ngx_quic_varint_len(rs->error_code);
  1413.         len += ngx_quic_varint_len(rs->final_size);
  1414.         return len;
  1415.     }

  1417.     start = p;

  1419.     ngx_quic_build_int(&p, NGX_QUIC_FT_RESET_STREAM);
  1420.     ngx_quic_build_int(&p, rs->id);
  1421.     ngx_quic_build_int(&p, rs->error_code);
  1422.     ngx_quic_build_int(&p, rs->final_size);

  1424.     return p - start;
  1425. }


  1428. static size_t
  1429. ‌ngx_quic_create_stop_sending(u_char *p, ngx_quic_stop_sending_frame_t *ss)
  1430. {
  1431.     size_t   len;
  1432.     u_char  *start;

  1434.     if (p == NULL) {
  1435.         len = ngx_quic_varint_len(NGX_QUIC_FT_STOP_SENDING);
  1436.         len += ngx_quic_varint_len(ss->id);
  1437.         len += ngx_quic_varint_len(ss->error_code);
  1438.         return len;
  1439.     }

  1441.     start = p;

  1443.     ngx_quic_build_int(&p, NGX_QUIC_FT_STOP_SENDING);
  1444.     ngx_quic_build_int(&p, ss->id);
  1445.     ngx_quic_build_int(&p, ss->error_code);

  1447.     return p - start;
  1448. }


  1451. static size_t
  1452. ‌ngx_quic_create_crypto(u_char *p, ngx_quic_crypto_frame_t *crypto,
  1453.     ngx_chain_t *data)
  1454. {
  1455.     size_t      len;
  1456.     u_char     *start;
  1457.     ngx_buf_t  *b;

  1459.     if (p == NULL) {
  1460.         len = ngx_quic_varint_len(NGX_QUIC_FT_CRYPTO);
  1461.         len += ngx_quic_varint_len(crypto->offset);
  1462.         len += ngx_quic_varint_len(crypto->length);
  1463.         len += crypto->length;

  1465.         return len;
  1466.     }

  1468.     start = p;

  1470.     ngx_quic_build_int(&p, NGX_QUIC_FT_CRYPTO);
  1471.     ngx_quic_build_int(&p, crypto->offset);
  1472.     ngx_quic_build_int(&p, crypto->length);

  1474.     while (data) {
  1475.         b = data->buf;
  1476.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1477.         data = data->next;
  1478.     }

  1480.     return p - start;
  1481. }


  1484. static size_t
  1485. ‌ngx_quic_create_hs_done(u_char *p)
  1486. {
  1487.     u_char  *start;

  1489.     if (p == NULL) {
  1490.         return ngx_quic_varint_len(NGX_QUIC_FT_HANDSHAKE_DONE);
  1491.     }

  1493.     start = p;

  1495.     ngx_quic_build_int(&p, NGX_QUIC_FT_HANDSHAKE_DONE);

  1497.     return p - start;
  1498. }


  1501. static size_t
  1502. ‌ngx_quic_create_new_token(u_char *p, ngx_quic_new_token_frame_t *token,
  1503.     ngx_chain_t *data)
  1504. {
  1505.     size_t      len;
  1506.     u_char     *start;
  1507.     ngx_buf_t  *b;

  1509.     if (p == NULL) {
  1510.         len = ngx_quic_varint_len(NGX_QUIC_FT_NEW_TOKEN);
  1511.         len += ngx_quic_varint_len(token->length);
  1512.         len += token->length;

  1514.         return len;
  1515.     }

  1517.     start = p;

  1519.     ngx_quic_build_int(&p, NGX_QUIC_FT_NEW_TOKEN);
  1520.     ngx_quic_build_int(&p, token->length);

  1522.     while (data) {
  1523.         b = data->buf;
  1524.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1525.         data = data->next;
  1526.     }

  1528.     return p - start;
  1529. }


  1532. static size_t
  1533. ‌ngx_quic_create_stream(u_char *p, ngx_quic_stream_frame_t *sf,
  1534.     ngx_chain_t *data)
  1535. {
  1536.     size_t      len;
  1537.     u_char     *start, type;
  1538.     ngx_buf_t  *b;

  1540.     type = NGX_QUIC_FT_STREAM;

  1542.     if (sf->off) {
  1543.         type |= NGX_QUIC_STREAM_FRAME_OFF;
  1544.     }

  1546.     if (sf->len) {
  1547.         type |= NGX_QUIC_STREAM_FRAME_LEN;
  1548.     }

  1550.     if (sf->fin) {
  1551.         type |= NGX_QUIC_STREAM_FRAME_FIN;
  1552.     }

  1554.     if (p == NULL) {
  1555.         len = ngx_quic_varint_len(type);
  1556.         len += ngx_quic_varint_len(sf->stream_id);

  1558.         if (sf->off) {
  1559.             len += ngx_quic_varint_len(sf->offset);
  1560.         }

  1562.         if (sf->len) {
  1563.             len += ngx_quic_varint_len(sf->length);
  1564.         }

  1566.         len += sf->length;

  1568.         return len;
  1569.     }

  1571.     start = p;

  1573.     ngx_quic_build_int(&p, type);
  1574.     ngx_quic_build_int(&p, sf->stream_id);

  1576.     if (sf->off) {
  1577.         ngx_quic_build_int(&p, sf->offset);
  1578.     }

  1580.     if (sf->len) {
  1581.         ngx_quic_build_int(&p, sf->length);
  1582.     }

  1584.     while (data) {
  1585.         b = data->buf;
  1586.         p = ngx_cpymem(p, b->pos, b->last - b->pos);
  1587.         data = data->next;
  1588.     }

  1590.     return p - start;
  1591. }


  1594. static size_t
  1595. ‌ngx_quic_create_max_streams(u_char *p, ngx_quic_max_streams_frame_t *ms)
  1596. {
  1597.     size_t       len;
  1598.     u_char      *start;
  1599.     ngx_uint_t   type;

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

  1603.     if (p == NULL) {
  1604.         len = ngx_quic_varint_len(type);
  1605.         len += ngx_quic_varint_len(ms->limit);
  1606.         return len;
  1607.     }

  1609.     start = p;

  1611.     ngx_quic_build_int(&p, type);
  1612.     ngx_quic_build_int(&p, ms->limit);

  1614.     return p - start;
  1615. }


  1618. static ngx_int_t
  1619. ‌ngx_quic_parse_transport_param(u_char *p, u_char *end, uint16_t id,
  1620.     ngx_quic_tp_t *dst)
  1621. {
  1622.     uint64_t   varint;
  1623.     ngx_str_t  str;

  1625.     varint = 0;
  1626.     ngx_str_null(&str);

  1628.     switch (id) {

  1630.     case NGX_QUIC_TP_DISABLE_ACTIVE_MIGRATION:
  1631.         /* zero-length option */
  1632.         if (end - p != 0) {
  1633.             return NGX_ERROR;
  1634.         }
  1635.         dst->disable_active_migration = 1;
  1636.         return NGX_OK;

  1638.     case NGX_QUIC_TP_MAX_IDLE_TIMEOUT:
  1639.     case NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE:
  1640.     case NGX_QUIC_TP_INITIAL_MAX_DATA:
  1641.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL:
  1642.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE:
  1643.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI:
  1644.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI:
  1645.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI:
  1646.     case NGX_QUIC_TP_ACK_DELAY_EXPONENT:
  1647.     case NGX_QUIC_TP_MAX_ACK_DELAY:
  1648.     case NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT:

  1650.         p = ngx_quic_parse_int(p, end, &varint);
  1651.         if (p == NULL) {
  1652.             return NGX_ERROR;
  1653.         }
  1654.         break;

  1656.     case NGX_QUIC_TP_INITIAL_SCID:

  1658.         str.len = end - p;
  1659.         str.data = p;
  1660.         break;

  1662.     default:
  1663.         return NGX_DECLINED;
  1664.     }

  1666.     switch (id) {

  1668.     case NGX_QUIC_TP_MAX_IDLE_TIMEOUT:
  1669.         dst->max_idle_timeout = varint;
  1670.         break;

  1672.     case NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE:
  1673.         dst->max_udp_payload_size = varint;
  1674.         break;

  1676.     case NGX_QUIC_TP_INITIAL_MAX_DATA:
  1677.         dst->initial_max_data = varint;
  1678.         break;

  1680.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL:
  1681.         dst->initial_max_stream_data_bidi_local = varint;
  1682.         break;

  1684.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE:
  1685.         dst->initial_max_stream_data_bidi_remote = varint;
  1686.         break;

  1688.     case NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI:
  1689.         dst->initial_max_stream_data_uni = varint;
  1690.         break;

  1692.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI:
  1693.         dst->initial_max_streams_bidi = varint;
  1694.         break;

  1696.     case NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI:
  1697.         dst->initial_max_streams_uni = varint;
  1698.         break;

  1700.     case NGX_QUIC_TP_ACK_DELAY_EXPONENT:
  1701.         dst->ack_delay_exponent = varint;
  1702.         break;

  1704.     case NGX_QUIC_TP_MAX_ACK_DELAY:
  1705.         dst->max_ack_delay = varint;
  1706.         break;

  1708.     case NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT:
  1709.         dst->active_connection_id_limit = varint;
  1710.         break;

  1712.     case NGX_QUIC_TP_INITIAL_SCID:
  1713.         dst->initial_scid = str;
  1714.         break;

  1716.     default:
  1717.         return NGX_ERROR;
  1718.     }

  1720.     return NGX_OK;
  1721. }


  1724. ngx_int_t
  1725. ‌ngx_quic_parse_transport_params(u_char *p, u_char *end, ngx_quic_tp_t *tp,
  1726.     ngx_log_t *log)
  1727. {
  1728.     uint64_t   id, len;
  1729.     ngx_int_t  rc;

  1731.     while (p < end) {
  1732.         p = ngx_quic_parse_int(p, end, &id);
  1733.         if (p == NULL) {
  1734.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1735.                           "quic failed to parse transport param id");
  1736.             return NGX_ERROR;
  1737.         }

  1739.         switch (id) {
  1740.         case NGX_QUIC_TP_ORIGINAL_DCID:
  1741.         case NGX_QUIC_TP_PREFERRED_ADDRESS:
  1742.         case NGX_QUIC_TP_RETRY_SCID:
  1743.         case NGX_QUIC_TP_SR_TOKEN:
  1744.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1745.                           "quic client sent forbidden transport param"
  1746.                           " id:0x%xL", id);
  1747.             return NGX_ERROR;
  1748.         }

  1750.         p = ngx_quic_parse_int(p, end, &len);
  1751.         if (p == NULL) {
  1752.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1753.                           "quic failed to parse"
  1754.                           " transport param id:0x%xL length", id);
  1755.             return NGX_ERROR;
  1756.         }

  1758.         if ((size_t) (end - p) < len) {
  1759.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1760.                           "quic failed to parse"
  1761.                           " transport param id:0x%xL, data length %uL too long",
  1762.                           id, len);
  1763.             return NGX_ERROR;
  1764.         }

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

  1768.         if (rc == NGX_ERROR) {
  1769.             ngx_log_error(NGX_LOG_INFO, log, 0,
  1770.                           "quic failed to parse"
  1771.                           " transport param id:0x%xL data", id);
  1772.             return NGX_ERROR;
  1773.         }

  1775.         if (rc == NGX_DECLINED) {
  1776.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  1777.                           "quic %s transport param id:0x%xL, skipped",
  1778.                           (id % 31 == 27) ? "reserved" : "unknown", id);
  1779.         }

  1781.         p += len;
  1782.     }

  1784.     if (p != end) {
  1785.         ngx_log_error(NGX_LOG_INFO, log, 0,
  1786.                       "quic trailing garbage in"
  1787.                       " transport parameters: bytes:%ui",
  1788.                       end - p);
  1789.         return NGX_ERROR;
  1790.     }

  1792.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, log, 0,
  1793.                    "quic transport parameters parsed ok");

  1795.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1796.                    "quic tp disable active migration: %ui",
  1797.                    tp->disable_active_migration);

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

  1802.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1803.                    "quic tp max_udp_payload_size:%ui",
  1804.                    tp->max_udp_payload_size);

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

  1809.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1810.                    "quic tp max_stream_data_bidi_local:%ui",
  1811.                    tp->initial_max_stream_data_bidi_local);

  1813.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1814.                    "quic tp max_stream_data_bidi_remote:%ui",
  1815.                    tp->initial_max_stream_data_bidi_remote);

  1817.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1818.                    "quic tp max_stream_data_uni:%ui",
  1819.                    tp->initial_max_stream_data_uni);

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

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

  1829.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1830.                    "quic tp ack_delay_exponent:%ui",
  1831.                    tp->ack_delay_exponent);

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

  1836.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
  1837.                    "quic tp active_connection_id_limit:%ui",
  1838.                    tp->active_connection_id_limit);

  1840.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
  1841.                    "quic tp initial source_connection_id len:%uz %xV",
  1842.                    tp->initial_scid.len, &tp->initial_scid);

  1844.     return NGX_OK;
  1845. }


  1848. static size_t
  1849. ‌ngx_quic_create_max_stream_data(u_char *p, ngx_quic_max_stream_data_frame_t *ms)
  1850. {
  1851.     size_t   len;
  1852.     u_char  *start;

  1854.     if (p == NULL) {
  1855.         len = ngx_quic_varint_len(NGX_QUIC_FT_MAX_STREAM_DATA);
  1856.         len += ngx_quic_varint_len(ms->id);
  1857.         len += ngx_quic_varint_len(ms->limit);
  1858.         return len;
  1859.     }

  1861.     start = p;

  1863.     ngx_quic_build_int(&p, NGX_QUIC_FT_MAX_STREAM_DATA);
  1864.     ngx_quic_build_int(&p, ms->id);
  1865.     ngx_quic_build_int(&p, ms->limit);

  1867.     return p - start;
  1868. }


  1871. static size_t
  1872. ‌ngx_quic_create_max_data(u_char *p, ngx_quic_max_data_frame_t *md)
  1873. {
  1874.     size_t   len;
  1875.     u_char  *start;

  1877.     if (p == NULL) {
  1878.         len = ngx_quic_varint_len(NGX_QUIC_FT_MAX_DATA);
  1879.         len += ngx_quic_varint_len(md->max_data);
  1880.         return len;
  1881.     }

  1883.     start = p;

  1885.     ngx_quic_build_int(&p, NGX_QUIC_FT_MAX_DATA);
  1886.     ngx_quic_build_int(&p, md->max_data);

  1888.     return p - start;
  1889. }


  1892. static size_t
  1893. ‌ngx_quic_create_path_challenge(u_char *p, ngx_quic_path_challenge_frame_t *pc)
  1894. {
  1895.     size_t   len;
  1896.     u_char  *start;

  1898.     if (p == NULL) {
  1899.         len = ngx_quic_varint_len(NGX_QUIC_FT_PATH_CHALLENGE);
  1900.         len += sizeof(pc->data);
  1901.         return len;
  1902.     }

  1904.     start = p;

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

  1909.     return p - start;
  1910. }


  1913. static size_t
  1914. ‌ngx_quic_create_path_response(u_char *p, ngx_quic_path_challenge_frame_t *pc)
  1915. {
  1916.     size_t   len;
  1917.     u_char  *start;

  1919.     if (p == NULL) {
  1920.         len = ngx_quic_varint_len(NGX_QUIC_FT_PATH_RESPONSE);
  1921.         len += sizeof(pc->data);
  1922.         return len;
  1923.     }

  1925.     start = p;

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

  1930.     return p - start;
  1931. }


  1934. static size_t
  1935. ‌ngx_quic_create_new_connection_id(u_char *p, ngx_quic_new_conn_id_frame_t *ncid)
  1936. {
  1937.     size_t   len;
  1938.     u_char  *start;

  1940.     if (p == NULL) {
  1941.         len = ngx_quic_varint_len(NGX_QUIC_FT_NEW_CONNECTION_ID);
  1942.         len += ngx_quic_varint_len(ncid->seqnum);
  1943.         len += ngx_quic_varint_len(ncid->retire);
  1944.         len++;
  1945.         len += ncid->len;
  1946.         len += NGX_QUIC_SR_TOKEN_LEN;
  1947.         return len;
  1948.     }

  1950.     start = p;

  1952.     ngx_quic_build_int(&p, NGX_QUIC_FT_NEW_CONNECTION_ID);
  1953.     ngx_quic_build_int(&p, ncid->seqnum);
  1954.     ngx_quic_build_int(&p, ncid->retire);
  1955.     *p++ = ncid->len;
  1956.     p = ngx_cpymem(p, ncid->cid, ncid->len);
  1957.     p = ngx_cpymem(p, ncid->srt, NGX_QUIC_SR_TOKEN_LEN);

  1959.     return p - start;
  1960. }


  1963. static size_t
  1964. ‌ngx_quic_create_retire_connection_id(u_char *p,
  1965.     ngx_quic_retire_cid_frame_t *rcid)
  1966. {
  1967.     size_t   len;
  1968.     u_char  *start;

  1970.     if (p == NULL) {
  1971.         len = ngx_quic_varint_len(NGX_QUIC_FT_RETIRE_CONNECTION_ID);
  1972.         len += ngx_quic_varint_len(rcid->sequence_number);
  1973.         return len;
  1974.     }

  1976.     start = p;

  1978.     ngx_quic_build_int(&p, NGX_QUIC_FT_RETIRE_CONNECTION_ID);
  1979.     ngx_quic_build_int(&p, rcid->sequence_number);

  1981.     return p - start;
  1982. }


  1985. ngx_int_t
  1986. ‌ngx_quic_init_transport_params(ngx_quic_tp_t *tp, ngx_quic_conf_t *qcf)
  1987. {
  1988.     ngx_uint_t  nstreams;

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

  1992.     /*
  1993.      * set by ngx_memzero():
  1994.      *
  1995.      *     tp->disable_active_migration = 0;
  1996.      *     tp->original_dcid = { 0, NULL };
  1997.      *     tp->initial_scid = { 0, NULL };
  1998.      *     tp->retry_scid = { 0, NULL };
  1999.      *     tp->sr_token = { 0 }
  2000.      *     tp->sr_enabled = 0
  2001.      *     tp->preferred_address = NULL
  2002.      */

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

  2006.     tp->max_udp_payload_size = NGX_QUIC_MAX_UDP_PAYLOAD_SIZE;

  2008.     nstreams = qcf->max_concurrent_streams_bidi
  2009.                + qcf->max_concurrent_streams_uni;

  2011.     tp->initial_max_data = nstreams * qcf->stream_buffer_size;
  2012.     tp->initial_max_stream_data_bidi_local = qcf->stream_buffer_size;
  2013.     tp->initial_max_stream_data_bidi_remote = qcf->stream_buffer_size;
  2014.     tp->initial_max_stream_data_uni = qcf->stream_buffer_size;

  2016.     tp->initial_max_streams_bidi = qcf->max_concurrent_streams_bidi;
  2017.     tp->initial_max_streams_uni = qcf->max_concurrent_streams_uni;

  2019.     tp->max_ack_delay = NGX_QUIC_DEFAULT_MAX_ACK_DELAY;
  2020.     tp->ack_delay_exponent = NGX_QUIC_DEFAULT_ACK_DELAY_EXPONENT;

  2022.     tp->active_connection_id_limit = qcf->active_connection_id_limit;
  2023.     tp->disable_active_migration = qcf->disable_active_migration;

  2025.     return NGX_OK;
  2026. }


  2029. ssize_t
  2030. ‌ngx_quic_create_transport_params(u_char *pos, u_char *end, ngx_quic_tp_t *tp,
  2031.     size_t *clen)
  2032. {
  2033.     u_char  *p;
  2034.     size_t   len;

  2036. ‌#define ngx_quic_tp_len(id, value)                                            \
  2037.     ngx_quic_varint_len(id)                                                   \
  2038.     + ngx_quic_varint_len(value)                                              \
  2039.     + ngx_quic_varint_len(ngx_quic_varint_len(value))

  2041. ‌#define ngx_quic_tp_vint(id, value)                                           \
  2042.     do {                                                                      \
  2043.         ngx_quic_build_int(&p, id);                                           \
  2044.         ngx_quic_build_int(&p, ngx_quic_varint_len(value));                   \
  2045.         ngx_quic_build_int(&p, value);                                        \
  2046.     } while (0)

  2048. ‌#define ngx_quic_tp_strlen(id, value)                                         \
  2049.     ngx_quic_varint_len(id)                                                   \
  2050.     + ngx_quic_varint_len(value.len)                                          \
  2051.     + value.len

  2053. ‌#define ngx_quic_tp_str(id, value)                                            \
  2054.     do {                                                                      \
  2055.         ngx_quic_build_int(&p, id);                                           \
  2056.         ngx_quic_build_int(&p, value.len);                                    \
  2057.         p = ngx_cpymem(p, value.data, value.len);                             \
  2058.     } while (0)

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

  2062.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI,
  2063.                            tp->initial_max_streams_uni);

  2065.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI,
  2066.                            tp->initial_max_streams_bidi);

  2068.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
  2069.                            tp->initial_max_stream_data_bidi_local);

  2071.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
  2072.                            tp->initial_max_stream_data_bidi_remote);

  2074.     len += ngx_quic_tp_len(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI,
  2075.                            tp->initial_max_stream_data_uni);

  2077.     len += ngx_quic_tp_len(NGX_QUIC_TP_MAX_IDLE_TIMEOUT,
  2078.                            tp->max_idle_timeout);

  2080.     len += ngx_quic_tp_len(NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE,
  2081.                            tp->max_udp_payload_size);

  2083.     if (tp->disable_active_migration) {
  2084.         len += ngx_quic_varint_len(NGX_QUIC_TP_DISABLE_ACTIVE_MIGRATION);
  2085.         len += ngx_quic_varint_len(0);
  2086.     }

  2088.     len += ngx_quic_tp_len(NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT,
  2089.                            tp->active_connection_id_limit);

  2091.     /* transport parameters listed above will be saved in 0-RTT context */
  2092.     if (clen) {
  2093.         *clen = len;
  2094.     }

  2096.     len += ngx_quic_tp_len(NGX_QUIC_TP_MAX_ACK_DELAY,
  2097.                            tp->max_ack_delay);

  2099.     len += ngx_quic_tp_len(NGX_QUIC_TP_ACK_DELAY_EXPONENT,
  2100.                            tp->ack_delay_exponent);

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

  2105.     if (tp->retry_scid.len) {
  2106.         len += ngx_quic_tp_strlen(NGX_QUIC_TP_RETRY_SCID, tp->retry_scid);
  2107.     }

  2109.     len += ngx_quic_varint_len(NGX_QUIC_TP_SR_TOKEN);
  2110.     len += ngx_quic_varint_len(NGX_QUIC_SR_TOKEN_LEN);
  2111.     len += NGX_QUIC_SR_TOKEN_LEN;

  2113.     if (pos == NULL) {
  2114.         return len;
  2115.     }

  2117.     p = pos;

  2119.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_DATA,
  2120.                      tp->initial_max_data);

  2122.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAMS_UNI,
  2123.                      tp->initial_max_streams_uni);

  2125.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAMS_BIDI,
  2126.                      tp->initial_max_streams_bidi);

  2128.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
  2129.                      tp->initial_max_stream_data_bidi_local);

  2131.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
  2132.                      tp->initial_max_stream_data_bidi_remote);

  2134.     ngx_quic_tp_vint(NGX_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI,
  2135.                      tp->initial_max_stream_data_uni);

  2137.     ngx_quic_tp_vint(NGX_QUIC_TP_MAX_IDLE_TIMEOUT,
  2138.                      tp->max_idle_timeout);

  2140.     ngx_quic_tp_vint(NGX_QUIC_TP_MAX_UDP_PAYLOAD_SIZE,
  2141.                      tp->max_udp_payload_size);

  2143.     if (tp->disable_active_migration) {
  2144.         ngx_quic_build_int(&p, NGX_QUIC_TP_DISABLE_ACTIVE_MIGRATION);
  2145.         ngx_quic_build_int(&p, 0);
  2146.     }

  2148.     ngx_quic_tp_vint(NGX_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT,
  2149.                      tp->active_connection_id_limit);

  2151.     ngx_quic_tp_vint(NGX_QUIC_TP_MAX_ACK_DELAY,
  2152.                      tp->max_ack_delay);

  2154.     ngx_quic_tp_vint(NGX_QUIC_TP_ACK_DELAY_EXPONENT,
  2155.                      tp->ack_delay_exponent);

  2157.     ngx_quic_tp_str(NGX_QUIC_TP_ORIGINAL_DCID, tp->original_dcid);
  2158.     ngx_quic_tp_str(NGX_QUIC_TP_INITIAL_SCID, tp->initial_scid);

  2160.     if (tp->retry_scid.len) {
  2161.         ngx_quic_tp_str(NGX_QUIC_TP_RETRY_SCID, tp->retry_scid);
  2162.     }

  2164.     ngx_quic_build_int(&p, NGX_QUIC_TP_SR_TOKEN);
  2165.     ngx_quic_build_int(&p, NGX_QUIC_SR_TOKEN_LEN);
  2166.     p = ngx_cpymem(p, tp->sr_token, NGX_QUIC_SR_TOKEN_LEN);

  2168.     return p - pos;
  2169. }


  2172. static size_t
  2173. ‌ngx_quic_create_close(u_char *p, ngx_quic_frame_t *f)
  2174. {
  2175.     size_t                   len;
  2176.     u_char                  *start;
  2177.     ngx_quic_close_frame_t  *cl;

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

  2181.     if (p == NULL) {
  2182.         len = ngx_quic_varint_len(f->type);
  2183.         len += ngx_quic_varint_len(cl->error_code);

  2185.         if (f->type != NGX_QUIC_FT_CONNECTION_CLOSE_APP) {
  2186.             len += ngx_quic_varint_len(cl->frame_type);
  2187.         }

  2189.         len += ngx_quic_varint_len(cl->reason.len);
  2190.         len += cl->reason.len;

  2192.         return len;
  2193.     }

  2195.     start = p;

  2197.     ngx_quic_build_int(&p, f->type);
  2198.     ngx_quic_build_int(&p, cl->error_code);

  2200.     if (f->type != NGX_QUIC_FT_CONNECTION_CLOSE_APP) {
  2201.         ngx_quic_build_int(&p, cl->frame_type);
  2202.     }

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

  2207.     return p - start;
  2208. }


  2211. void
  2212. ‌ngx_quic_dcid_encode_key(u_char *dcid, uint64_t key)
  2213. {
  2214.     (void) ngx_quic_write_uint64(dcid, key);
  2215. }

One Level Up Top Level