One Level Up Top Level

src/event/quic/ngx_event_quic_output.c - nginx

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_MAX_UDP_SEGMENT_BUF  65487 /* 65K - IPv6 header */
  14. ‌#define NGX_QUIC_MAX_SEGMENTS            64 /* UDP_MAX_SEGMENTS */

  16. ‌#define NGX_QUIC_RETRY_TOKEN_LIFETIME     3 /* seconds */
  17. ‌#define NGX_QUIC_NEW_TOKEN_LIFETIME     600 /* seconds */
  18. ‌#define NGX_QUIC_RETRY_BUFFER_SIZE      256
  19.     /* 1 flags + 4 version + 3 x (1 + 20) s/o/dcid + itag + token(64) */

  21. /*
  22. * RFC 9000, 10.3.  Stateless Reset
  23. *
  24. * Endpoints MUST discard packets that are too small to be valid QUIC
  25. * packets.  With the set of AEAD functions defined in [QUIC-TLS],
  26. * short header packets that are smaller than 21 bytes are never valid.
  27. */
  28. ‌#define NGX_QUIC_MIN_PKT_LEN             41 /* 21 + 20 (server cid length) */

  30. ‌#define NGX_QUIC_MIN_SR_PACKET           43 /* 5 rand + 16 srt + 22 padding */
  31. ‌#define NGX_QUIC_MAX_SR_PACKET         1200

  33. ‌#define NGX_QUIC_CC_MIN_INTERVAL       1000 /* 1s */

  35. ‌#define NGX_QUIC_SOCKET_RETRY_DELAY      10 /* ms, for NGX_AGAIN on write */


  38. ‌#define ngx_quic_log_packet(log, pkt)                                         \
  39.     ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,                               \
  40.                    "quic packet tx %s bytes:%ui need_ack:%d"                  \
  41.                    " number:%L encoded nl:%d trunc:0x%xD",                    \
  42.                    ngx_quic_level_name((pkt)->level), (pkt)->payload.len,     \
  43.                    (pkt)->need_ack, (pkt)->number, (pkt)->num_len,            \
  44.                     (pkt)->trunc);


  47. static ngx_int_t ngx_quic_create_datagrams(ngx_connection_t *c);
  48. static void ngx_quic_commit_send(ngx_connection_t *c);
  49. static void ngx_quic_revert_send(ngx_connection_t *c,
  50.     uint64_t preserved_pnum[NGX_QUIC_SEND_CTX_LAST]);
  51. #if ((NGX_HAVE_UDP_SEGMENT) && (NGX_HAVE_MSGHDR_MSG_CONTROL))
  52. static ngx_uint_t ngx_quic_allow_segmentation(ngx_connection_t *c);
  53. static ngx_int_t ngx_quic_create_segments(ngx_connection_t *c);
  54. static ssize_t ngx_quic_send_segments(ngx_connection_t *c, u_char *buf,
  55.     size_t len, struct sockaddr *sockaddr, socklen_t socklen, size_t segment);
  56. #endif
  57. static ssize_t ngx_quic_output_packet(ngx_connection_t *c,
  58.     ngx_quic_send_ctx_t *ctx, u_char *data, size_t max, size_t min,
  59.     ngx_uint_t ack_only);
  60. static void ngx_quic_init_packet(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx,
  61.     ngx_quic_header_t *pkt, ngx_quic_path_t *path);
  62. static ngx_uint_t ngx_quic_get_padding_level(ngx_connection_t *c);
  63. static ssize_t ngx_quic_send(ngx_connection_t *c, u_char *buf, size_t len,
  64.     struct sockaddr *sockaddr, socklen_t socklen);
  65. static void ngx_quic_set_packet_number(ngx_quic_header_t *pkt,
  66.     ngx_quic_send_ctx_t *ctx);
  67. static ngx_int_t ngx_quic_stateless_reset_filter(ngx_connection_t *c);


  70. ngx_int_t
  71. ‌ngx_quic_output(ngx_connection_t *c)
  72. {
  73.     size_t                  in_flight;
  74.     ngx_int_t               rc;
  75.     ngx_quic_congestion_t  *cg;
  76.     ngx_quic_connection_t  *qc;

  78.     c->log->action = "sending frames";

  80.     qc = ngx_quic_get_connection(c);
  81.     cg = &qc->congestion;

  83.     in_flight = cg->in_flight;

  85. #if ((NGX_HAVE_UDP_SEGMENT) && (NGX_HAVE_MSGHDR_MSG_CONTROL))
  86.     if (ngx_quic_allow_segmentation(c)) {
  87.         rc = ngx_quic_create_segments(c);
  88.     } else
  89. #endif
  90.     {
  91.         rc = ngx_quic_create_datagrams(c);
  92.     }

  94.     if (rc != NGX_OK) {
  95.         return NGX_ERROR;
  96.     }

  98.     if (in_flight == cg->in_flight || qc->closing) {
  99.         /* no ack-eliciting data was sent or we are done */
  100.         return NGX_OK;
  101.     }

  103.     if (!qc->send_timer_set) {
  104.         qc->send_timer_set = 1;
  105.         ngx_add_timer(c->read, qc->tp.max_idle_timeout);
  106.     }

  108.     ngx_quic_set_lost_timer(c);

  110.     return NGX_OK;
  111. }


  114. static ngx_int_t
  115. ‌ngx_quic_create_datagrams(ngx_connection_t *c)
  116. {
  117.     size_t                  len, min;
  118.     ssize_t                 n;
  119.     u_char                 *p;
  120.     uint64_t                preserved_pnum[NGX_QUIC_SEND_CTX_LAST];
  121.     ngx_uint_t              i, pad;
  122.     ngx_quic_path_t        *path;
  123.     ngx_quic_send_ctx_t    *ctx;
  124.     ngx_quic_congestion_t  *cg;
  125.     ngx_quic_connection_t  *qc;
  126.     static u_char           dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

  128.     qc = ngx_quic_get_connection(c);
  129.     cg = &qc->congestion;
  130.     path = qc->path;

  132. #if (NGX_SUPPRESS_WARN)
  133.     ngx_memzero(preserved_pnum, sizeof(preserved_pnum));
  134. #endif

  136.     do {
  137.         p = dst;

  139.         len = ngx_quic_path_limit(c, path, path->mtu);

  141.         pad = ngx_quic_get_padding_level(c);

  143.         for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) {

  145.             ctx = &qc->send_ctx[i];

  147.             preserved_pnum[i] = ctx->pnum;

  149.             if (ngx_quic_generate_ack(c, ctx) != NGX_OK) {
  150.                 return NGX_ERROR;
  151.             }

  153.             min = (i == pad && p - dst < NGX_QUIC_MIN_INITIAL_SIZE)
  154.                   ? NGX_QUIC_MIN_INITIAL_SIZE - (p - dst) : 0;

  156.             if (min > len) {
  157.                 /* padding can't be applied - avoid sending the packet */
  158.                 ngx_quic_revert_send(c, preserved_pnum);
  159.                 return NGX_OK;
  160.             }

  162.             n = ngx_quic_output_packet(c, ctx, p, len, min,
  163.                                        cg->in_flight >= cg->window);
  164.             if (n == NGX_ERROR) {
  165.                 return NGX_ERROR;
  166.             }

  168.             p += n;
  169.             len -= n;
  170.         }

  172.         len = p - dst;
  173.         if (len == 0) {
  174.             break;
  175.         }

  177.         n = ngx_quic_send(c, dst, len, path->sockaddr, path->socklen);

  179.         if (n == NGX_ERROR) {
  180.             return NGX_ERROR;
  181.         }

  183.         if (n == NGX_AGAIN) {
  184.             ngx_quic_revert_send(c, preserved_pnum);
  185.             ngx_add_timer(&qc->push, NGX_QUIC_SOCKET_RETRY_DELAY);
  186.             break;
  187.         }

  189.         ngx_quic_commit_send(c);

  191.         path->sent += len;

  193.     } while (cg->in_flight < cg->window);

  195.     return NGX_OK;
  196. }


  199. static void
  200. ‌ngx_quic_commit_send(ngx_connection_t *c)
  201. {
  202.     ngx_uint_t              i, idle;
  203.     ngx_queue_t            *q;
  204.     ngx_quic_frame_t       *f;
  205.     ngx_quic_send_ctx_t    *ctx;
  206.     ngx_quic_congestion_t  *cg;
  207.     ngx_quic_connection_t  *qc;

  209.     qc = ngx_quic_get_connection(c);
  210.     cg = &qc->congestion;

  212.     idle = 1;

  214.     for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) {
  215.         ctx = &qc->send_ctx[i];

  217.         if (!ngx_queue_empty(&ctx->frames)) {
  218.             idle = 0;
  219.         }

  221.         while (!ngx_queue_empty(&ctx->sending)) {

  223.             q = ngx_queue_head(&ctx->sending);
  224.             f = ngx_queue_data(q, ngx_quic_frame_t, queue);

  226.             ngx_queue_remove(q);

  228.             if (f->pkt_need_ack && !qc->closing) {
  229.                 ngx_queue_insert_tail(&ctx->sent, q);

  231.                 cg->in_flight += f->plen;

  233.             } else {
  234.                 ngx_quic_free_frame(c, f);
  235.             }
  236.         }
  237.     }

  239.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  240.                    "quic congestion send if:%uz", cg->in_flight);

  242.     ngx_quic_congestion_idle(c, idle);
  243. }


  246. static void
  247. ‌ngx_quic_revert_send(ngx_connection_t *c, uint64_t pnum[NGX_QUIC_SEND_CTX_LAST])
  248. {
  249.     ngx_uint_t              i;
  250.     ngx_queue_t            *q;
  251.     ngx_quic_send_ctx_t    *ctx;
  252.     ngx_quic_connection_t  *qc;

  254.     qc = ngx_quic_get_connection(c);

  256.     for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) {
  257.         ctx = &qc->send_ctx[i];

  259.         if (ngx_queue_empty(&ctx->sending)) {
  260.             continue;
  261.         }

  263.         do {
  264.             q = ngx_queue_last(&ctx->sending);
  265.             ngx_queue_remove(q);
  266.             ngx_queue_insert_head(&ctx->frames, q);
  267.         } while (!ngx_queue_empty(&ctx->sending));

  269.         ctx->pnum = pnum[i];
  270.     }

  272.     ngx_quic_congestion_idle(c, 1);
  273. }


  276. #if ((NGX_HAVE_UDP_SEGMENT) && (NGX_HAVE_MSGHDR_MSG_CONTROL))

  278. static ngx_uint_t
  279. ‌ngx_quic_allow_segmentation(ngx_connection_t *c)
  280. {
  281.     size_t                  bytes, len;
  282.     ngx_queue_t            *q;
  283.     ngx_quic_frame_t       *f;
  284.     ngx_quic_send_ctx_t    *ctx;
  285.     ngx_quic_connection_t  *qc;

  287.     qc = ngx_quic_get_connection(c);

  289.     if (!qc->conf->gso_enabled) {
  290.         return 0;
  291.     }

  293.     if (!qc->path->validated) {
  294.         /* don't even try to be faster on non-validated paths */
  295.         return 0;
  296.     }

  298.     ctx = ngx_quic_get_send_ctx(qc, NGX_QUIC_ENCRYPTION_INITIAL);
  299.     if (!ngx_queue_empty(&ctx->frames)) {
  300.         return 0;
  301.     }

  303.     ctx = ngx_quic_get_send_ctx(qc, NGX_QUIC_ENCRYPTION_HANDSHAKE);
  304.     if (!ngx_queue_empty(&ctx->frames)) {
  305.         return 0;
  306.     }

  308.     ctx = ngx_quic_get_send_ctx(qc, NGX_QUIC_ENCRYPTION_APPLICATION);

  310.     bytes = 0;
  311.     len = ngx_min(qc->path->mtu, NGX_QUIC_MAX_UDP_SEGMENT_BUF);

  313.     for (q = ngx_queue_head(&ctx->frames);
  314.          q != ngx_queue_sentinel(&ctx->frames);
  315.          q = ngx_queue_next(q))
  316.     {
  317.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);

  319.         bytes += f->len;

  321.         if (qc->congestion.in_flight + bytes >= qc->congestion.window) {
  322.             return 0;
  323.         }

  325.         if (bytes > len * 3) {
  326.             /* require at least ~3 full packets to batch */
  327.             return 1;
  328.         }
  329.     }

  331.     return 0;
  332. }


  335. static ngx_int_t
  336. ‌ngx_quic_create_segments(ngx_connection_t *c)
  337. {
  338.     size_t                  len, segsize;
  339.     ssize_t                 n;
  340.     u_char                 *p, *end;
  341.     ngx_uint_t              nseg, level;
  342.     ngx_quic_path_t        *path;
  343.     ngx_quic_send_ctx_t    *ctx;
  344.     ngx_quic_congestion_t  *cg;
  345.     ngx_quic_connection_t  *qc;
  346.     static u_char           dst[NGX_QUIC_MAX_UDP_SEGMENT_BUF];
  347.     static uint64_t         preserved_pnum[NGX_QUIC_SEND_CTX_LAST];

  349.     qc = ngx_quic_get_connection(c);
  350.     cg = &qc->congestion;
  351.     path = qc->path;

  353.     ctx = ngx_quic_get_send_ctx(qc, NGX_QUIC_ENCRYPTION_APPLICATION);

  355.     if (ngx_quic_generate_ack(c, ctx) != NGX_OK) {
  356.         return NGX_ERROR;
  357.     }

  359.     segsize = ngx_min(path->mtu, NGX_QUIC_MAX_UDP_SEGMENT_BUF);
  360.     p = dst;
  361.     end = dst + sizeof(dst);

  363.     nseg = 0;

  365.     level = ctx - qc->send_ctx;
  366.     preserved_pnum[level] = ctx->pnum;

  368.     for ( ;; ) {

  370.         len = ngx_min(segsize, (size_t) (end - p));

  372.         if (len && cg->in_flight + (p - dst) < cg->window) {

  374.             n = ngx_quic_output_packet(c, ctx, p, len, len, 0);
  375.             if (n == NGX_ERROR) {
  376.                 return NGX_ERROR;
  377.             }

  379.             if (n) {
  380.                 p += n;
  381.                 nseg++;
  382.             }

  384.         } else {
  385.             n = 0;
  386.         }

  388.         if (p == dst) {
  389.             break;
  390.         }

  392.         if (n == 0 || nseg == NGX_QUIC_MAX_SEGMENTS) {
  393.             n = ngx_quic_send_segments(c, dst, p - dst, path->sockaddr,
  394.                                        path->socklen, segsize);
  395.             if (n == NGX_ERROR) {
  396.                 return NGX_ERROR;
  397.             }

  399.             if (n == NGX_AGAIN) {
  400.                 ngx_quic_revert_send(c, preserved_pnum);
  401.                 ngx_add_timer(&qc->push, NGX_QUIC_SOCKET_RETRY_DELAY);
  402.                 break;
  403.             }

  405.             ngx_quic_commit_send(c);

  407.             path->sent += n;

  409.             p = dst;
  410.             nseg = 0;
  411.             preserved_pnum[level] = ctx->pnum;
  412.         }
  413.     }

  415.     return NGX_OK;
  416. }


  419. static ssize_t
  420. ‌ngx_quic_send_segments(ngx_connection_t *c, u_char *buf, size_t len,
  421.     struct sockaddr *sockaddr, socklen_t socklen, size_t segment)
  422. {
  423.     size_t           clen;
  424.     ssize_t          n;
  425.     uint16_t        *valp;
  426.     struct iovec     iov;
  427.     struct msghdr    msg;
  428.     struct cmsghdr  *cmsg;

  430. #if (NGX_HAVE_ADDRINFO_CMSG)
  431.     char             msg_control[CMSG_SPACE(sizeof(uint16_t))
  432.                              + CMSG_SPACE(sizeof(ngx_addrinfo_t))];
  433. #else
  434.     char             msg_control[CMSG_SPACE(sizeof(uint16_t))];
  435. #endif

  437.     ngx_memzero(&msg, sizeof(struct msghdr));
  438.     ngx_memzero(msg_control, sizeof(msg_control));

  440.     iov.iov_len = len;
  441.     iov.iov_base = (void *) buf;

  443.     msg.msg_iov = &iov;
  444.     msg.msg_iovlen = 1;

  446.     msg.msg_name = sockaddr;
  447.     msg.msg_namelen = socklen;

  449.     msg.msg_control = msg_control;
  450.     msg.msg_controllen = sizeof(msg_control);

  452.     cmsg = CMSG_FIRSTHDR(&msg);

  454.     cmsg->cmsg_level = SOL_UDP;
  455.     cmsg->cmsg_type = UDP_SEGMENT;
  456.     cmsg->cmsg_len = CMSG_LEN(sizeof(uint16_t));

  458.     clen = CMSG_SPACE(sizeof(uint16_t));

  460.     valp = (void *) CMSG_DATA(cmsg);
  461.     *valp = segment;

  463. #if (NGX_HAVE_ADDRINFO_CMSG)
  464.     if (c->listening && c->listening->wildcard && c->local_sockaddr) {
  465.         cmsg = CMSG_NXTHDR(&msg, cmsg);
  466.         clen += ngx_set_srcaddr_cmsg(cmsg, c->local_sockaddr);
  467.     }
  468. #endif

  470.     msg.msg_controllen = clen;

  472.     n = ngx_sendmsg(c, &msg, 0);
  473.     if (n < 0) {
  474.         return n;
  475.     }

  477.     c->sent += n;

  479.     return n;
  480. }

  482. #endif



  486. static ngx_uint_t
  487. ‌ngx_quic_get_padding_level(ngx_connection_t *c)
  488. {
  489.     ngx_uint_t              i;
  490.     ngx_queue_t            *q;
  491.     ngx_quic_frame_t       *f;
  492.     ngx_quic_send_ctx_t    *ctx;
  493.     ngx_quic_connection_t  *qc;

  495.     /*
  496.      * RFC 9000, 14.1.  Initial Datagram Size
  497.      *
  498.      * Similarly, a server MUST expand the payload of all UDP datagrams
  499.      * carrying ack-eliciting Initial packets to at least the smallest
  500.      * allowed maximum datagram size of 1200 bytes.
  501.      */

  503.     qc = ngx_quic_get_connection(c);
  504.     ctx = ngx_quic_get_send_ctx(qc, NGX_QUIC_ENCRYPTION_INITIAL);

  506.     for (q = ngx_queue_head(&ctx->frames);
  507.          q != ngx_queue_sentinel(&ctx->frames);
  508.          q = ngx_queue_next(q))
  509.     {
  510.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);

  512.         if (f->need_ack) {
  513.             for (i = 0; i + 1 < NGX_QUIC_SEND_CTX_LAST; i++) {
  514.                 ctx = &qc->send_ctx[i + 1];

  516.                 if (ngx_queue_empty(&ctx->frames)) {
  517.                     break;
  518.                 }
  519.             }

  521.             return i;
  522.         }
  523.     }

  525.     return NGX_QUIC_SEND_CTX_LAST;
  526. }


  529. static ssize_t
  530. ‌ngx_quic_output_packet(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx,
  531.     u_char *data, size_t max, size_t min, ngx_uint_t ack_only)
  532. {
  533.     size_t                  len, pad, min_payload, max_payload;
  534.     u_char                 *p;
  535.     ssize_t                 flen;
  536.     ngx_str_t               res;
  537.     ngx_int_t               rc;
  538.     ngx_uint_t              nframes;
  539.     ngx_msec_t              now;
  540.     ngx_queue_t            *q;
  541.     ngx_quic_frame_t       *f;
  542.     ngx_quic_header_t       pkt;
  543.     ngx_quic_connection_t  *qc;
  544.     static u_char           src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

  546.     if (ngx_queue_empty(&ctx->frames)) {
  547.         return 0;
  548.     }

  550.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  551.                    "quic output %s packet max:%uz min:%uz",
  552.                    ngx_quic_level_name(ctx->level), max, min);

  554.     qc = ngx_quic_get_connection(c);

  556.     if (!ngx_quic_keys_available(qc->keys, ctx->level, 1)) {
  557.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "quic %s write keys discarded",
  558.                       ngx_quic_level_name(ctx->level));

  560.         while (!ngx_queue_empty(&ctx->frames)) {
  561.             q = ngx_queue_head(&ctx->frames);
  562.             ngx_queue_remove(q);

  564.             f = ngx_queue_data(q, ngx_quic_frame_t, queue);
  565.             ngx_quic_free_frame(c, f);
  566.         }

  568.         return 0;
  569.     }

  571.     ngx_quic_init_packet(c, ctx, &pkt, qc->path);

  573.     min_payload = ngx_quic_payload_size(&pkt, min);
  574.     max_payload = ngx_quic_payload_size(&pkt, max);

  576.     /* RFC 9001, 5.4.2.  Header Protection Sample */
  577.     pad = 4 - pkt.num_len;
  578.     min_payload = ngx_max(min_payload, pad);

  580.     if (min_payload > max_payload) {
  581.         return 0;
  582.     }

  584.     now = ngx_current_msec;
  585.     nframes = 0;
  586.     p = src;
  587.     len = 0;

  589.     for (q = ngx_queue_head(&ctx->frames);
  590.          q != ngx_queue_sentinel(&ctx->frames);
  591.          q = ngx_queue_next(q))
  592.     {
  593.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);

  595.         if (ack_only && f->type != NGX_QUIC_FT_ACK) {
  596.             break;
  597.         }

  599.         if (len >= max_payload) {
  600.             break;
  601.         }

  603.         if (len + f->len > max_payload) {
  604.             rc = ngx_quic_split_frame(c, f, max_payload - len);

  606.             if (rc == NGX_ERROR) {
  607.                 return NGX_ERROR;
  608.             }

  610.             if (rc == NGX_DECLINED) {
  611.                 break;
  612.             }
  613.         }

  615.         if (f->need_ack) {
  616.             pkt.need_ack = 1;
  617.         }

  619.         f->pnum = ctx->pnum;
  620.         f->send_time = now;
  621.         f->plen = 0;

  623.         ngx_quic_log_frame(c->log, f, 1);

  625.         flen = ngx_quic_create_frame(p, f);
  626.         if (flen == -1) {
  627.             return NGX_ERROR;
  628.         }

  630.         len += flen;
  631.         p += flen;

  633.         nframes++;
  634.     }

  636.     if (nframes == 0) {
  637.         return 0;
  638.     }

  640.     if (len < min_payload) {
  641.         ngx_memset(p, NGX_QUIC_FT_PADDING, min_payload - len);
  642.         len = min_payload;
  643.     }

  645.     pkt.payload.data = src;
  646.     pkt.payload.len = len;

  648.     res.data = data;

  650.     ngx_quic_log_packet(c->log, &pkt);

  652.     if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) {
  653.         return NGX_ERROR;
  654.     }

  656.     ctx->pnum++;

  658.     if (pkt.need_ack) {
  659.         q = ngx_queue_head(&ctx->frames);
  660.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);

  662.         f->plen = res.len;
  663.     }

  665.     while (nframes--) {
  666.         q = ngx_queue_head(&ctx->frames);
  667.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);

  669.         f->pkt_need_ack = pkt.need_ack;

  671.         ngx_queue_remove(q);
  672.         ngx_queue_insert_tail(&ctx->sending, q);
  673.     }

  675.     return res.len;
  676. }


  679. static void
  680. ‌ngx_quic_init_packet(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx,
  681.     ngx_quic_header_t *pkt, ngx_quic_path_t *path)
  682. {
  683.     ngx_quic_connection_t  *qc;

  685.     qc = ngx_quic_get_connection(c);

  687.     ngx_memzero(pkt, sizeof(ngx_quic_header_t));

  689.     pkt->flags = NGX_QUIC_PKT_FIXED_BIT;

  691.     if (ctx->level == NGX_QUIC_ENCRYPTION_INITIAL) {
  692.         pkt->flags |= NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_INITIAL;

  694.     } else if (ctx->level == NGX_QUIC_ENCRYPTION_HANDSHAKE) {
  695.         pkt->flags |= NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_HANDSHAKE;

  697.     } else {
  698.         if (qc->key_phase) {
  699.             pkt->flags |= NGX_QUIC_PKT_KPHASE;
  700.         }
  701.     }

  703.     pkt->dcid.data = path->cid->id;
  704.     pkt->dcid.len = path->cid->len;

  706.     pkt->scid = qc->tp.initial_scid;

  708.     pkt->version = qc->version;
  709.     pkt->log = c->log;
  710.     pkt->level = ctx->level;

  712.     pkt->keys = qc->keys;

  714.     ngx_quic_set_packet_number(pkt, ctx);
  715. }


  718. static ssize_t
  719. ‌ngx_quic_send(ngx_connection_t *c, u_char *buf, size_t len,
  720.     struct sockaddr *sockaddr, socklen_t socklen)
  721. {
  722.     ssize_t          n;
  723.     struct iovec     iov;
  724.     struct msghdr    msg;
  725. #if (NGX_HAVE_ADDRINFO_CMSG)
  726.     struct cmsghdr  *cmsg;
  727.     char             msg_control[CMSG_SPACE(sizeof(ngx_addrinfo_t))];
  728. #endif

  730.     ngx_memzero(&msg, sizeof(struct msghdr));

  732.     iov.iov_len = len;
  733.     iov.iov_base = (void *) buf;

  735.     msg.msg_iov = &iov;
  736.     msg.msg_iovlen = 1;

  738.     msg.msg_name = sockaddr;
  739.     msg.msg_namelen = socklen;

  741. #if (NGX_HAVE_ADDRINFO_CMSG)
  742.     if (c->listening && c->listening->wildcard && c->local_sockaddr) {

  744.         msg.msg_control = msg_control;
  745.         msg.msg_controllen = sizeof(msg_control);
  746.         ngx_memzero(msg_control, sizeof(msg_control));

  748.         cmsg = CMSG_FIRSTHDR(&msg);

  750.         msg.msg_controllen = ngx_set_srcaddr_cmsg(cmsg, c->local_sockaddr);
  751.     }
  752. #endif

  754.     n = ngx_sendmsg(c, &msg, 0);
  755.     if (n < 0) {
  756.         return n;
  757.     }

  759.     c->sent += n;

  761.     return n;
  762. }


  765. static void
  766. ‌ngx_quic_set_packet_number(ngx_quic_header_t *pkt, ngx_quic_send_ctx_t *ctx)
  767. {
  768.     uint64_t  delta;

  770.     delta = ctx->pnum - ctx->largest_ack;
  771.     pkt->number = ctx->pnum;

  773.     if (delta <= 0x7F) {
  774.         pkt->num_len = 1;
  775.         pkt->trunc = ctx->pnum & 0xff;

  777.     } else if (delta <= 0x7FFF) {
  778.         pkt->num_len = 2;
  779.         pkt->flags |= 0x1;
  780.         pkt->trunc = ctx->pnum & 0xffff;

  782.     } else if (delta <= 0x7FFFFF) {
  783.         pkt->num_len = 3;
  784.         pkt->flags |= 0x2;
  785.         pkt->trunc = ctx->pnum & 0xffffff;

  787.     } else {
  788.         pkt->num_len = 4;
  789.         pkt->flags |= 0x3;
  790.         pkt->trunc = ctx->pnum & 0xffffffff;
  791.     }
  792. }


  795. ngx_int_t
  796. ‌ngx_quic_negotiate_version(ngx_connection_t *c, ngx_quic_header_t *inpkt)
  797. {
  798.     size_t             len;
  799.     ngx_quic_header_t  pkt;
  800.     static u_char      buf[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

  802.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  803.                    "sending version negotiation packet");

  805.     pkt.log = c->log;
  806.     pkt.flags = NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_FIXED_BIT;
  807.     pkt.dcid = inpkt->scid;
  808.     pkt.scid = inpkt->dcid;

  810.     len = ngx_quic_create_version_negotiation(&pkt, buf);

  812. #ifdef NGX_QUIC_DEBUG_PACKETS
  813.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  814.                    "quic vnego packet to send len:%uz %*xs", len, len, buf);
  815. #endif

  817.     (void) ngx_quic_send(c, buf, len, c->sockaddr, c->socklen);

  819.     return NGX_DONE;
  820. }


  823. ngx_int_t
  824. ‌ngx_quic_send_stateless_reset(ngx_connection_t *c, ngx_quic_conf_t *conf,
  825.     ngx_quic_header_t *pkt)
  826. {
  827.     u_char     *token;
  828.     size_t      len, max;
  829.     uint16_t    rndbytes;
  830.     ngx_int_t   rc;
  831.     u_char      buf[NGX_QUIC_MAX_SR_PACKET];

  833.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  834.                    "quic handle stateless reset output");

  836.     if (pkt->len <= NGX_QUIC_MIN_PKT_LEN) {
  837.         return NGX_DECLINED;
  838.     }

  840.     rc = ngx_quic_stateless_reset_filter(c);
  841.     if (rc != NGX_OK) {
  842.         return rc;
  843.     }

  845.     if (pkt->len <= NGX_QUIC_MIN_SR_PACKET) {
  846.         len = pkt->len - 1;

  848.     } else {
  849.         max = ngx_min(NGX_QUIC_MAX_SR_PACKET, pkt->len);

  851.         if (RAND_bytes((u_char *) &rndbytes, sizeof(rndbytes)) != 1) {
  852.             return NGX_ERROR;
  853.         }

  855.         len = (rndbytes % (max - NGX_QUIC_MIN_SR_PACKET))
  856.               + NGX_QUIC_MIN_SR_PACKET;
  857.     }

  859.     if (RAND_bytes(buf, len - NGX_QUIC_SR_TOKEN_LEN) != 1) {
  860.         return NGX_ERROR;
  861.     }

  863.     buf[0] &= ~NGX_QUIC_PKT_LONG;
  864.     buf[0] |= NGX_QUIC_PKT_FIXED_BIT;

  866.     token = &buf[len - NGX_QUIC_SR_TOKEN_LEN];

  868.     if (ngx_quic_new_sr_token(c, &pkt->dcid, conf->sr_token_key, token)
  869.         != NGX_OK)
  870.     {
  871.         return NGX_ERROR;
  872.     }

  874.     (void) ngx_quic_send(c, buf, len, c->sockaddr, c->socklen);

  876.     return NGX_DECLINED;
  877. }


  880. static ngx_int_t
  881. ‌ngx_quic_stateless_reset_filter(ngx_connection_t *c)
  882. {
  883.     time_t      now;
  884.     u_char      salt;
  885.     ngx_uint_t  i, n, m, hit;
  886.     u_char      hash[20];

  888.     static time_t   t;
  889.     static u_char   rndbyte;
  890.     static uint8_t  bitmap[65536];

  892.     now = ngx_time();

  894.     if (t != now) {
  895.         t = now;

  897.         if (RAND_bytes(&rndbyte, 1) != 1) {
  898.             return NGX_ERROR;
  899.         }

  901.         ngx_memzero(bitmap, sizeof(bitmap));
  902.     }

  904.     hit = 0;

  906.     for (i = 0; i < 3; i++) {
  907.         salt = rndbyte + i;

  909.         ngx_quic_address_hash(c->sockaddr, c->socklen, 0, &salt, 1, hash);

  911.         n = hash[0] | hash[1] << 8;
  912.         m = 1 << hash[2] % 8;

  914.         if (!(bitmap[n] & m)) {
  915.             bitmap[n] |= m;

  917.         } else {
  918.             hit++;
  919.         }
  920.     }

  922.     if (hit == 3) {
  923.         return NGX_DECLINED;
  924.     }

  926.     return NGX_OK;
  927. }


  930. ngx_int_t
  931. ‌ngx_quic_send_cc(ngx_connection_t *c)
  932. {
  933.     ngx_quic_frame_t       *frame;
  934.     ngx_quic_connection_t  *qc;

  936.     qc = ngx_quic_get_connection(c);

  938.     if (qc->draining) {
  939.         return NGX_OK;
  940.     }

  942.     if (qc->closing
  943.         && ngx_current_msec - qc->last_cc < NGX_QUIC_CC_MIN_INTERVAL)
  944.     {
  945.         /* dot not send CC too often */
  946.         return NGX_OK;
  947.     }

  949.     frame = ngx_quic_alloc_frame(c);
  950.     if (frame == NULL) {
  951.         return NGX_ERROR;
  952.     }

  954.     frame->level = qc->error_level;
  955.     frame->type = qc->error_app ? NGX_QUIC_FT_CONNECTION_CLOSE_APP
  956.                                 : NGX_QUIC_FT_CONNECTION_CLOSE;
  957.     frame->u.close.error_code = qc->error;
  958.     frame->u.close.frame_type = qc->error_ftype;

  960.     if (qc->error_reason) {
  961.         frame->u.close.reason.len = ngx_strlen(qc->error_reason);
  962.         frame->u.close.reason.data = (u_char *) qc->error_reason;
  963.     }

  965.     frame->ignore_congestion = 1;

  967.     qc->last_cc = ngx_current_msec;

  969.     return ngx_quic_frame_sendto(c, frame, 0, qc->path);
  970. }


  973. ngx_int_t
  974. ‌ngx_quic_send_early_cc(ngx_connection_t *c, ngx_quic_header_t *inpkt,
  975.     ngx_uint_t err, const char *reason)
  976. {
  977.     ssize_t            len;
  978.     ngx_str_t          res;
  979.     ngx_quic_keys_t    keys;
  980.     ngx_quic_frame_t   frame;
  981.     ngx_quic_header_t  pkt;

  983.     static u_char       src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
  984.     static u_char       dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

  986.     ngx_memzero(&frame, sizeof(ngx_quic_frame_t));
  987.     ngx_memzero(&pkt, sizeof(ngx_quic_header_t));

  989.     frame.level = inpkt->level;
  990.     frame.type = NGX_QUIC_FT_CONNECTION_CLOSE;
  991.     frame.u.close.error_code = err;

  993.     frame.u.close.reason.data = (u_char *) reason;
  994.     frame.u.close.reason.len = ngx_strlen(reason);

  996.     ngx_quic_log_frame(c->log, &frame, 1);

  998.     len = ngx_quic_create_frame(NULL, &frame);
  999.     if (len > NGX_QUIC_MAX_UDP_PAYLOAD_SIZE) {
  1000.         return NGX_ERROR;
  1001.     }

  1003.     len = ngx_quic_create_frame(src, &frame);
  1004.     if (len == -1) {
  1005.         return NGX_ERROR;
  1006.     }

  1008.     ngx_memzero(&keys, sizeof(ngx_quic_keys_t));

  1010.     pkt.keys = &keys;

  1012.     if (ngx_quic_keys_set_initial_secret(pkt.keys, &inpkt->dcid, c->log)
  1013.         != NGX_OK)
  1014.     {
  1015.         return NGX_ERROR;
  1016.     }

  1018.     pkt.flags = NGX_QUIC_PKT_FIXED_BIT | NGX_QUIC_PKT_LONG
  1019.                 | NGX_QUIC_PKT_INITIAL;

  1021.     pkt.num_len = 1;
  1022.     /*
  1023.      * pkt.num = 0;
  1024.      * pkt.trunc = 0;
  1025.      */

  1027.     pkt.version = inpkt->version;
  1028.     pkt.log = c->log;
  1029.     pkt.level = inpkt->level;
  1030.     pkt.dcid = inpkt->scid;
  1031.     pkt.scid = inpkt->dcid;
  1032.     pkt.payload.data = src;
  1033.     pkt.payload.len = len;

  1035.     res.data = dst;

  1037.     ngx_quic_log_packet(c->log, &pkt);

  1039.     if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) {
  1040.         ngx_quic_keys_cleanup(pkt.keys);
  1041.         return NGX_ERROR;
  1042.     }

  1044.     if (ngx_quic_send(c, res.data, res.len, c->sockaddr, c->socklen) < 0) {
  1045.         ngx_quic_keys_cleanup(pkt.keys);
  1046.         return NGX_ERROR;
  1047.     }

  1049.     ngx_quic_keys_cleanup(pkt.keys);

  1051.     return NGX_DONE;
  1052. }


  1055. ngx_int_t
  1056. ‌ngx_quic_send_retry(ngx_connection_t *c, ngx_quic_conf_t *conf,
  1057.     ngx_quic_header_t *inpkt)
  1058. {
  1059.     time_t             expires;
  1060.     ssize_t            len;
  1061.     ngx_str_t          res, token;
  1062.     ngx_quic_header_t  pkt;

  1064.     u_char             buf[NGX_QUIC_RETRY_BUFFER_SIZE];
  1065.     u_char             dcid[NGX_QUIC_SERVER_CID_LEN];
  1066.     u_char             tbuf[NGX_QUIC_TOKEN_BUF_SIZE];

  1068.     expires = ngx_time() + NGX_QUIC_RETRY_TOKEN_LIFETIME;

  1070.     token.data = tbuf;
  1071.     token.len = NGX_QUIC_TOKEN_BUF_SIZE;

  1073.     if (ngx_quic_new_token(c->log, c->sockaddr, c->socklen, conf->av_token_key,
  1074.                            &token, &inpkt->dcid, expires, 1)
  1075.         != NGX_OK)
  1076.     {
  1077.         return NGX_ERROR;
  1078.     }

  1080.     ngx_memzero(&pkt, sizeof(ngx_quic_header_t));
  1081.     pkt.flags = NGX_QUIC_PKT_FIXED_BIT | NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_RETRY;
  1082.     pkt.version = inpkt->version;
  1083.     pkt.log = c->log;

  1085.     pkt.odcid = inpkt->dcid;
  1086.     pkt.dcid = inpkt->scid;

  1088.     /* TODO: generate routable dcid */
  1089.     if (RAND_bytes(dcid, NGX_QUIC_SERVER_CID_LEN) != 1) {
  1090.         return NGX_ERROR;
  1091.     }

  1093.     pkt.scid.len = NGX_QUIC_SERVER_CID_LEN;
  1094.     pkt.scid.data = dcid;

  1096.     pkt.token = token;

  1098.     res.data = buf;

  1100.     if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) {
  1101.         return NGX_ERROR;
  1102.     }

  1104. #ifdef NGX_QUIC_DEBUG_PACKETS
  1105.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1106.                    "quic packet to send len:%uz %xV", res.len, &res);
  1107. #endif

  1109.     len = ngx_quic_send(c, res.data, res.len, c->sockaddr, c->socklen);
  1110.     if (len < 0) {
  1111.         return NGX_ERROR;
  1112.     }

  1114.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1115.                    "quic retry packet sent to %xV", &pkt.dcid);

  1117.     /*
  1118.      * RFC 9000, 17.2.5.1.  Sending a Retry Packet
  1119.      *
  1120.      * A server MUST NOT send more than one Retry
  1121.      * packet in response to a single UDP datagram.
  1122.      * NGX_DONE will stop quic_input() from processing further
  1123.      */
  1124.     return NGX_DONE;
  1125. }


  1128. ngx_int_t
  1129. ‌ngx_quic_send_new_token(ngx_connection_t *c, ngx_quic_path_t *path)
  1130. {
  1131.     time_t                  expires;
  1132.     ngx_str_t               token;
  1133.     ngx_chain_t            *out;
  1134.     ngx_quic_frame_t       *frame;
  1135.     ngx_quic_connection_t  *qc;

  1137.     u_char                  tbuf[NGX_QUIC_TOKEN_BUF_SIZE];

  1139.     qc = ngx_quic_get_connection(c);

  1141.     expires = ngx_time() + NGX_QUIC_NEW_TOKEN_LIFETIME;

  1143.     token.data = tbuf;
  1144.     token.len = NGX_QUIC_TOKEN_BUF_SIZE;

  1146.     if (ngx_quic_new_token(c->log, path->sockaddr, path->socklen,
  1147.                            qc->conf->av_token_key, &token, NULL, expires, 0)
  1148.         != NGX_OK)
  1149.     {
  1150.         return NGX_ERROR;
  1151.     }

  1153.     out = ngx_quic_copy_buffer(c, token.data, token.len);
  1154.     if (out == NGX_CHAIN_ERROR) {
  1155.         return NGX_ERROR;
  1156.     }

  1158.     frame = ngx_quic_alloc_frame(c);
  1159.     if (frame == NULL) {
  1160.         return NGX_ERROR;
  1161.     }

  1163.     frame->level = NGX_QUIC_ENCRYPTION_APPLICATION;
  1164.     frame->type = NGX_QUIC_FT_NEW_TOKEN;
  1165.     frame->data = out;
  1166.     frame->u.token.length = token.len;

  1168.     ngx_quic_queue_frame(qc, frame);

  1170.     return NGX_OK;
  1171. }


  1174. ngx_int_t
  1175. ‌ngx_quic_send_ack(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx)
  1176. {
  1177.     size_t                  len, left;
  1178.     uint64_t                ack_delay;
  1179.     ngx_buf_t              *b;
  1180.     ngx_uint_t              i;
  1181.     ngx_chain_t            *cl, **ll;
  1182.     ngx_quic_frame_t       *frame;
  1183.     ngx_quic_connection_t  *qc;

  1185.     qc = ngx_quic_get_connection(c);

  1187.     ack_delay = ngx_current_msec - ctx->largest_received;
  1188.     ack_delay *= 1000;
  1189.     ack_delay >>= qc->tp.ack_delay_exponent;

  1191.     frame = ngx_quic_alloc_frame(c);
  1192.     if (frame == NULL) {
  1193.         return NGX_ERROR;
  1194.     }

  1196.     ll = &frame->data;
  1197.     b = NULL;

  1199.     for (i = 0; i < ctx->nranges; i++) {
  1200.         len = ngx_quic_create_ack_range(NULL, ctx->ranges[i].gap,
  1201.                                         ctx->ranges[i].range);

  1203.         left = b ? b->end - b->last : 0;

  1205.         if (left < len) {
  1206.             cl = ngx_quic_alloc_chain(c);
  1207.             if (cl == NULL) {
  1208.                 return NGX_ERROR;
  1209.             }

  1211.             *ll = cl;
  1212.             ll = &cl->next;

  1214.             b = cl->buf;
  1215.             left = b->end - b->last;

  1217.             if (left < len) {
  1218.                 return NGX_ERROR;
  1219.             }
  1220.         }

  1222.         b->last += ngx_quic_create_ack_range(b->last, ctx->ranges[i].gap,
  1223.                                              ctx->ranges[i].range);

  1225.         frame->u.ack.ranges_length += len;
  1226.     }

  1228.     *ll = NULL;

  1230.     frame->level = ctx->level;
  1231.     frame->type = NGX_QUIC_FT_ACK;
  1232.     frame->u.ack.largest = ctx->largest_range;
  1233.     frame->u.ack.delay = ack_delay;
  1234.     frame->u.ack.range_count = ctx->nranges;
  1235.     frame->u.ack.first_range = ctx->first_range;
  1236.     frame->len = ngx_quic_create_frame(NULL, frame);

  1238.     ngx_queue_insert_head(&ctx->frames, &frame->queue);

  1240.     return NGX_OK;
  1241. }


  1244. ngx_int_t
  1245. ‌ngx_quic_send_ack_range(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx,
  1246.     uint64_t smallest, uint64_t largest)
  1247. {
  1248.     ngx_quic_frame_t       *frame;
  1249.     ngx_quic_connection_t  *qc;

  1251.     qc = ngx_quic_get_connection(c);

  1253.     frame = ngx_quic_alloc_frame(c);
  1254.     if (frame == NULL) {
  1255.         return NGX_ERROR;
  1256.     }

  1258.     frame->level = ctx->level;
  1259.     frame->type = NGX_QUIC_FT_ACK;
  1260.     frame->u.ack.largest = largest;
  1261.     frame->u.ack.delay = 0;
  1262.     frame->u.ack.range_count = 0;
  1263.     frame->u.ack.first_range = largest - smallest;

  1265.     ngx_quic_queue_frame(qc, frame);

  1267.     return NGX_OK;
  1268. }


  1271. ngx_int_t
  1272. ‌ngx_quic_frame_sendto(ngx_connection_t *c, ngx_quic_frame_t *frame,
  1273.     size_t min, ngx_quic_path_t *path)
  1274. {
  1275.     size_t                  max, max_payload, min_payload, pad;
  1276.     ssize_t                 len, sent;
  1277.     ngx_str_t               res;
  1278.     ngx_msec_t              now;
  1279.     ngx_quic_header_t       pkt;
  1280.     ngx_quic_send_ctx_t    *ctx;
  1281.     ngx_quic_congestion_t  *cg;
  1282.     ngx_quic_connection_t  *qc;

  1284.     static u_char           src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
  1285.     static u_char           dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

  1287.     qc = ngx_quic_get_connection(c);
  1288.     cg = &qc->congestion;
  1289.     ctx = ngx_quic_get_send_ctx(qc, frame->level);

  1291.     now = ngx_current_msec;

  1293.     max = ngx_quic_path_limit(c, path, path->mtu);

  1295.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1296.                    "quic sendto %s packet max:%uz min:%uz",
  1297.                    ngx_quic_level_name(ctx->level), max, min);

  1299.     if (cg->in_flight >= cg->window && !frame->ignore_congestion) {
  1300.         ngx_quic_free_frame(c, frame);
  1301.         return NGX_AGAIN;
  1302.     }

  1304.     ngx_quic_init_packet(c, ctx, &pkt, path);

  1306.     min_payload = ngx_quic_payload_size(&pkt, min);
  1307.     max_payload = ngx_quic_payload_size(&pkt, max);

  1309.     /* RFC 9001, 5.4.2.  Header Protection Sample */
  1310.     pad = 4 - pkt.num_len;
  1311.     min_payload = ngx_max(min_payload, pad);

  1313.     if (min_payload > max_payload) {
  1314.         ngx_quic_free_frame(c, frame);
  1315.         return NGX_AGAIN;
  1316.     }

  1318. #if (NGX_DEBUG)
  1319.     frame->pnum = pkt.number;
  1320. #endif

  1322.     ngx_quic_log_frame(c->log, frame, 1);

  1324.     len = ngx_quic_create_frame(NULL, frame);
  1325.     if ((size_t) len > max_payload) {
  1326.         ngx_quic_free_frame(c, frame);
  1327.         return NGX_AGAIN;
  1328.     }

  1330.     len = ngx_quic_create_frame(src, frame);
  1331.     if (len == -1) {
  1332.         ngx_quic_free_frame(c, frame);
  1333.         return NGX_ERROR;
  1334.     }

  1336.     if (len < (ssize_t) min_payload) {
  1337.         ngx_memset(src + len, NGX_QUIC_FT_PADDING, min_payload - len);
  1338.         len = min_payload;
  1339.     }

  1341.     pkt.payload.data = src;
  1342.     pkt.payload.len = len;

  1344.     res.data = dst;

  1346.     ngx_quic_log_packet(c->log, &pkt);

  1348.     if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) {
  1349.         ngx_quic_free_frame(c, frame);
  1350.         return NGX_ERROR;
  1351.     }

  1353.     frame->pnum = ctx->pnum;
  1354.     frame->send_time = now;
  1355.     frame->plen = res.len;

  1357.     ctx->pnum++;

  1359.     sent = ngx_quic_send(c, res.data, res.len, path->sockaddr, path->socklen);
  1360.     if (sent < 0) {
  1361.         ngx_quic_free_frame(c, frame);
  1362.         return sent;
  1363.     }

  1365.     path->sent += sent;

  1367.     if (frame->need_ack && !qc->closing) {
  1368.         ngx_queue_insert_tail(&ctx->sent, &frame->queue);

  1370.         cg->in_flight += frame->plen;

  1372.     } else {
  1373.         ngx_quic_free_frame(c, frame);
  1374.         return NGX_OK;
  1375.     }

  1377.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1378.                    "quic congestion send if:%uz", cg->in_flight);

  1380.     if (!qc->send_timer_set) {
  1381.         qc->send_timer_set = 1;
  1382.         ngx_add_timer(c->read, qc->tp.max_idle_timeout);
  1383.     }

  1385.     ngx_quic_set_lost_timer(c);

  1387.     return NGX_OK;
  1388. }


  1391. size_t
  1392. ‌ngx_quic_path_limit(ngx_connection_t *c, ngx_quic_path_t *path, size_t size)
  1393. {
  1394.     off_t  max;

  1396.     if (!path->validated) {
  1397.         max = path->received * 3;
  1398.         max = (path->sent >= max) ? 0 : max - path->sent;

  1400.         if ((off_t) size > max) {
  1401.             return max;
  1402.         }
  1403.     }

  1405.     return size;
  1406. }

One Level Up Top Level