One Level Up Top Level

src/event/quic/ngx_event_quic.c - nginx-1.31.7 nginx/ @ 939334eff

Global variables defined

Functions 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_sha1.h>
  11. #include <ngx_event_quic_connection.h>


  14. static ngx_quic_connection_t *ngx_quic_new_connection(ngx_connection_t *c,
  15.     ngx_quic_conf_t *conf, ngx_quic_header_t *pkt);
  16. static ngx_int_t ngx_quic_handle_stateless_reset(ngx_connection_t *c,
  17.     ngx_quic_header_t *pkt);
  18. static void ngx_quic_input_handler(ngx_event_t *rev);
  19. static void ngx_quic_close_handler(ngx_event_t *ev);

  21. static ngx_int_t ngx_quic_handle_datagram(ngx_connection_t *c, ngx_buf_t *b,
  22.     ngx_quic_conf_t *conf);
  23. static ngx_int_t ngx_quic_handle_packet(ngx_connection_t *c,
  24.     ngx_quic_conf_t *conf, ngx_quic_header_t *pkt);
  25. static ngx_int_t ngx_quic_handle_payload(ngx_connection_t *c,
  26.     ngx_quic_header_t *pkt);
  27. static ngx_int_t ngx_quic_check_csid(ngx_quic_connection_t *qc,
  28.     ngx_quic_header_t *pkt);
  29. static ngx_int_t ngx_quic_handle_frames(ngx_connection_t *c,
  30.     ngx_quic_header_t *pkt);

  32. static void ngx_quic_push_handler(ngx_event_t *ev);


  35. ‌static ngx_core_module_t  ngx_quic_module_ctx = {
  36.     ngx_string("quic"),
  37.     NULL,
  38.     NULL
  39. };


  42. ‌ngx_module_t  ngx_quic_module = {
  43.     NGX_MODULE_V1,
  44.     &ngx_quic_module_ctx,                  /* module context */
  45.     NULL,                                  /* module directives */
  46.     NGX_CORE_MODULE,                       /* module type */
  47.     NULL,                                  /* init master */
  48.     NULL,                                  /* init module */
  49.     NULL,                                  /* init process */
  50.     NULL,                                  /* init thread */
  51.     NULL,                                  /* exit thread */
  52.     NULL,                                  /* exit process */
  53.     NULL,                                  /* exit master */
  54.     NGX_MODULE_V1_PADDING
  55. };


  58. #if (NGX_DEBUG)

  60. void
  61. ‌ngx_quic_connstate_dbg(ngx_connection_t *c)
  62. {
  63.     u_char                 *p, *last;
  64.     ngx_quic_connection_t  *qc;
  65.     u_char                  buf[NGX_MAX_ERROR_STR];

  67.     p = buf;
  68.     last = p + sizeof(buf);

  70.     qc = ngx_quic_get_connection(c);

  72.     p = ngx_slprintf(p, last, "state:");

  74.     if (qc) {

  76.         if (qc->error) {
  77.             p = ngx_slprintf(p, last, "%s", qc->error_app ? " app" : "");
  78.             p = ngx_slprintf(p, last, " error:%ui", qc->error);

  80.             if (qc->error_reason) {
  81.                 p = ngx_slprintf(p, last, " \"%s\"", qc->error_reason);
  82.             }
  83.         }

  85.         p = ngx_slprintf(p, last, "%s", qc->shutdown ? " shutdown" : "");
  86.         p = ngx_slprintf(p, last, "%s", qc->closing ? " closing" : "");
  87.         p = ngx_slprintf(p, last, "%s", qc->draining ? " draining" : "");
  88.         p = ngx_slprintf(p, last, "%s", qc->key_phase ? " kp" : "");

  90.     } else {
  91.         p = ngx_slprintf(p, last, " early");
  92.     }

  94.     if (c->read->timer_set) {
  95.         p = ngx_slprintf(p, last,
  96.                          qc && qc->send_timer_set ? " send:%M" : " read:%M",
  97.                          c->read->timer.key - ngx_current_msec);
  98.     }

  100.     if (qc) {

  102.         if (qc->push.timer_set) {
  103.             p = ngx_slprintf(p, last, " push:%M",
  104.                              qc->push.timer.key - ngx_current_msec);
  105.         }

  107.         if (qc->pto.timer_set) {
  108.             p = ngx_slprintf(p, last, " pto:%M",
  109.                              qc->pto.timer.key - ngx_current_msec);
  110.         }

  112.         if (qc->close.timer_set) {
  113.             p = ngx_slprintf(p, last, " close:%M",
  114.                              qc->close.timer.key - ngx_current_msec);
  115.         }
  116.     }

  118.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  119.                    "quic %*s", p - buf, buf);
  120. }

  122. #endif


  125. ngx_int_t
  126. ‌ngx_quic_apply_transport_params(ngx_connection_t *c, ngx_quic_tp_t *ctp)
  127. {
  128.     ngx_str_t               scid;
  129.     ngx_quic_connection_t  *qc;

  131.     qc = ngx_quic_get_connection(c);

  133.     scid.data = qc->path->cid->id;
  134.     scid.len = qc->path->cid->len;

  136.     if (scid.len != ctp->initial_scid.len
  137.         || ngx_memcmp(scid.data, ctp->initial_scid.data, scid.len) != 0)
  138.     {
  139.         qc->error = NGX_QUIC_ERR_TRANSPORT_PARAMETER_ERROR;
  140.         qc->error_reason = "invalid initial_source_connection_id";

  142.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  143.                       "quic client initial_source_connection_id mismatch");
  144.         return NGX_ERROR;
  145.     }

  147.     if (ctp->max_udp_payload_size < NGX_QUIC_MIN_INITIAL_SIZE
  148.         || ctp->max_udp_payload_size > NGX_QUIC_MAX_UDP_PAYLOAD_SIZE)
  149.     {
  150.         qc->error = NGX_QUIC_ERR_TRANSPORT_PARAMETER_ERROR;
  151.         qc->error_reason = "invalid maximum packet size";

  153.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  154.                       "quic maximum packet size is invalid");
  155.         return NGX_ERROR;
  156.     }

  158.     if (ctp->active_connection_id_limit < 2) {
  159.         qc->error = NGX_QUIC_ERR_TRANSPORT_PARAMETER_ERROR;
  160.         qc->error_reason = "invalid active_connection_id_limit";

  162.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  163.                       "quic active_connection_id_limit is invalid");
  164.         return NGX_ERROR;
  165.     }

  167.     if (ctp->ack_delay_exponent > 20) {
  168.         qc->error = NGX_QUIC_ERR_TRANSPORT_PARAMETER_ERROR;
  169.         qc->error_reason = "invalid ack_delay_exponent";

  171.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  172.                       "quic ack_delay_exponent is invalid");
  173.         return NGX_ERROR;
  174.     }

  176.     if (ctp->max_ack_delay >= 16384) {
  177.         qc->error = NGX_QUIC_ERR_TRANSPORT_PARAMETER_ERROR;
  178.         qc->error_reason = "invalid max_ack_delay";

  180.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  181.                       "quic max_ack_delay is invalid");
  182.         return NGX_ERROR;
  183.     }

  185.     if (ctp->max_idle_timeout > 0
  186.         && ctp->max_idle_timeout < qc->tp.max_idle_timeout)
  187.     {
  188.         qc->tp.max_idle_timeout = ctp->max_idle_timeout;
  189.     }

  191.     qc->streams.server_max_streams_bidi = ctp->initial_max_streams_bidi;
  192.     qc->streams.server_max_streams_uni = ctp->initial_max_streams_uni;

  194.     ngx_memcpy(&qc->ctp, ctp, sizeof(ngx_quic_tp_t));

  196.     return NGX_OK;
  197. }


  200. void
  201. ‌ngx_quic_run(ngx_connection_t *c, ngx_quic_conf_t *conf)
  202. {
  203.     ngx_int_t               rc;
  204.     ngx_quic_connection_t  *qc;

  206.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic run");

  208.     rc = ngx_quic_handle_datagram(c, c->buffer, conf);
  209.     if (rc != NGX_OK) {
  210.         ngx_quic_close_connection(c, rc);
  211.         return;
  212.     }

  214.     /* quic connection is now created */
  215.     qc = ngx_quic_get_connection(c);

  217.     ngx_add_timer(c->read, qc->tp.max_idle_timeout);

  219.     if (!qc->streams.initialized) {
  220.         ngx_add_timer(&qc->close, qc->conf->handshake_timeout);
  221.     }

  223.     ngx_quic_connstate_dbg(c);

  225.     c->read->handler = ngx_quic_input_handler;

  227.     return;
  228. }


  231. static ngx_quic_connection_t *
  232. ‌ngx_quic_new_connection(ngx_connection_t *c, ngx_quic_conf_t *conf,
  233.     ngx_quic_header_t *pkt)
  234. {
  235.     ngx_uint_t              i;
  236.     ngx_quic_tp_t          *ctp;
  237.     ngx_quic_connection_t  *qc;

  239.     qc = ngx_pcalloc(c->pool, sizeof(ngx_quic_connection_t));
  240.     if (qc == NULL) {
  241.         return NULL;
  242.     }

  244.     qc->keys = ngx_pcalloc(c->pool, sizeof(ngx_quic_keys_t));
  245.     if (qc->keys == NULL) {
  246.         return NULL;
  247.     }

  249.     qc->version = pkt->version;

  251.     ngx_rbtree_init(&qc->streams.tree, &qc->streams.sentinel,
  252.                     ngx_quic_rbtree_insert_stream);

  254.     for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) {
  255.         ngx_queue_init(&qc->send_ctx[i].frames);
  256.         ngx_queue_init(&qc->send_ctx[i].sending);
  257.         ngx_queue_init(&qc->send_ctx[i].sent);
  258.         qc->send_ctx[i].largest_pn = NGX_QUIC_UNSET_PN;
  259.         qc->send_ctx[i].largest_ack = NGX_QUIC_UNSET_PN;
  260.         qc->send_ctx[i].largest_range = NGX_QUIC_UNSET_PN;
  261.         qc->send_ctx[i].pending_ack = NGX_QUIC_UNSET_PN;
  262.     }

  264.     qc->send_ctx[0].level = NGX_QUIC_ENCRYPTION_INITIAL;
  265.     qc->send_ctx[1].level = NGX_QUIC_ENCRYPTION_HANDSHAKE;
  266.     qc->send_ctx[2].level = NGX_QUIC_ENCRYPTION_APPLICATION;

  268.     ngx_queue_init(&qc->free_frames);

  270.     ngx_quic_init_rtt(qc);

  272.     qc->pto.log = c->log;
  273.     qc->pto.data = c;
  274.     qc->pto.handler = ngx_quic_pto_handler;

  276.     qc->push.log = c->log;
  277.     qc->push.data = c;
  278.     qc->push.handler = ngx_quic_push_handler;

  280.     qc->close.log = c->log;
  281.     qc->close.data = c;
  282.     qc->close.handler = ngx_quic_close_handler;

  284.     qc->path_validation.log = c->log;
  285.     qc->path_validation.data = c;
  286.     qc->path_validation.handler = ngx_quic_path_handler;

  288.     qc->key_update.log = c->log;
  289.     qc->key_update.data = c;
  290.     qc->key_update.handler = ngx_quic_keys_update;

  292.     qc->conf = conf;

  294.     if (ngx_quic_init_transport_params(&qc->tp, conf) != NGX_OK) {
  295.         return NULL;
  296.     }

  298.     ctp = &qc->ctp;

  300.     /* defaults to be used before actual client parameters are received */
  301.     ctp->max_udp_payload_size = NGX_QUIC_MAX_UDP_PAYLOAD_SIZE;
  302.     ctp->ack_delay_exponent = NGX_QUIC_DEFAULT_ACK_DELAY_EXPONENT;
  303.     ctp->max_ack_delay = NGX_QUIC_DEFAULT_MAX_ACK_DELAY;
  304.     ctp->active_connection_id_limit = 2;

  306.     ngx_queue_init(&qc->streams.uninitialized);
  307.     ngx_queue_init(&qc->streams.free);

  309.     qc->streams.recv_max_data = qc->tp.initial_max_data;
  310.     qc->streams.recv_window = qc->streams.recv_max_data;

  312.     qc->streams.client_max_streams_uni = qc->tp.initial_max_streams_uni;
  313.     qc->streams.client_max_streams_bidi = qc->tp.initial_max_streams_bidi;

  315.     qc->congestion.window = ngx_min(10 * NGX_QUIC_MIN_INITIAL_SIZE,
  316.                                     ngx_max(2 * NGX_QUIC_MIN_INITIAL_SIZE,
  317.                                             14720));
  318.     qc->congestion.ssthresh = (size_t) -1;
  319.     qc->congestion.mtu = NGX_QUIC_MIN_INITIAL_SIZE;
  320.     qc->congestion.recovery_start = ngx_current_msec - 1;

  322.     qc->max_frames = (conf->max_concurrent_streams_uni
  323.                       + conf->max_concurrent_streams_bidi)
  324.                      * conf->stream_buffer_size / 2000;
  325.     qc->max_frames = ngx_max(qc->max_frames, 10000);

  327.     if (pkt->validated && pkt->retried) {
  328.         qc->tp.retry_scid.len = pkt->dcid.len;
  329.         qc->tp.retry_scid.data = ngx_pstrdup(c->pool, &pkt->dcid);
  330.         if (qc->tp.retry_scid.data == NULL) {
  331.             return NULL;
  332.         }
  333.     }

  335.     if (ngx_quic_keys_set_initial_secret(qc->keys, &pkt->dcid, c->log)
  336.         != NGX_OK)
  337.     {
  338.         return NULL;
  339.     }

  341.     qc->validated = pkt->validated;

  343.     if (ngx_quic_open_sockets(c, qc, pkt) != NGX_OK) {
  344.         ngx_quic_keys_cleanup(qc->keys);
  345.         return NULL;
  346.     }

  348.     c->idle = 1;
  349.     ngx_reusable_connection(c, 1);

  351.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  352.                    "quic connection created");

  354.     return qc;
  355. }


  358. static ngx_int_t
  359. ‌ngx_quic_handle_stateless_reset(ngx_connection_t *c, ngx_quic_header_t *pkt)
  360. {
  361.     u_char                 *tail, ch;
  362.     ngx_uint_t              i;
  363.     ngx_queue_t            *q;
  364.     ngx_quic_client_id_t   *cid;
  365.     ngx_quic_connection_t  *qc;

  367.     qc = ngx_quic_get_connection(c);

  369.     /* A stateless reset uses an entire UDP datagram */
  370.     if (!pkt->first) {
  371.         return NGX_DECLINED;
  372.     }

  374.     tail = pkt->raw->last - NGX_QUIC_SR_TOKEN_LEN;

  376.     for (q = ngx_queue_head(&qc->client_ids);
  377.          q != ngx_queue_sentinel(&qc->client_ids);
  378.          q = ngx_queue_next(q))
  379.     {
  380.         cid = ngx_queue_data(q, ngx_quic_client_id_t, queue);

  382.         if (cid->seqnum == 0 || !cid->used) {
  383.             /*
  384.              * No stateless reset token in initial connection id.
  385.              * Don't accept a token from an unused connection id.
  386.              */
  387.             continue;
  388.         }

  390.         /* constant time comparison */

  392.         for (ch = 0, i = 0; i < NGX_QUIC_SR_TOKEN_LEN; i++) {
  393.             ch |= tail[i] ^ cid->sr_token[i];
  394.         }

  396.         if (ch == 0) {
  397.             return NGX_OK;
  398.         }
  399.     }

  401.     return NGX_DECLINED;
  402. }


  405. static void
  406. ‌ngx_quic_input_handler(ngx_event_t *rev)
  407. {
  408.     ngx_int_t               rc;
  409.     ngx_buf_t              *b;
  410.     ngx_connection_t       *c;
  411.     ngx_quic_connection_t  *qc;

  413.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, rev->log, 0, "quic input handler");

  415.     c = rev->data;
  416.     qc = ngx_quic_get_connection(c);

  418.     c->log->action = "handling quic input";

  420.     if (rev->timedout) {
  421.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
  422.                       "quic client timed out");
  423.         ngx_quic_close_connection(c, NGX_DONE);
  424.         return;
  425.     }

  427.     if (c->close) {
  428.         c->close = 0;

  430.         if (!ngx_exiting || !qc->streams.initialized) {
  431.             qc->error = NGX_QUIC_ERR_NO_ERROR;
  432.             qc->error_reason = "graceful shutdown";
  433.             ngx_quic_close_connection(c, NGX_ERROR);
  434.             return;
  435.         }

  437.         if (!qc->closing && qc->conf->shutdown) {
  438.             qc->conf->shutdown(c);
  439.         }

  441.         return;
  442.     }

  444.     b = c->udp->buffer;
  445.     if (b == NULL) {
  446.         return;
  447.     }

  449.     rc = ngx_quic_handle_datagram(c, b, NULL);

  451.     if (rc == NGX_ERROR) {
  452.         ngx_quic_close_connection(c, NGX_ERROR);
  453.         return;
  454.     }

  456.     if (rc == NGX_DONE) {
  457.         return;
  458.     }

  460.     /* rc == NGX_OK */

  462.     qc->send_timer_set = 0;
  463.     ngx_add_timer(rev, qc->tp.max_idle_timeout);

  465.     ngx_quic_connstate_dbg(c);
  466. }


  469. void
  470. ‌ngx_quic_close_connection(ngx_connection_t *c, ngx_int_t rc)
  471. {
  472.     ngx_uint_t              i;
  473.     ngx_pool_t             *pool;
  474.     ngx_quic_send_ctx_t    *ctx;
  475.     ngx_quic_connection_t  *qc;

  477.     qc = ngx_quic_get_connection(c);

  479.     if (qc == NULL) {
  480.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  481.                        "quic packet rejected rc:%i, cleanup connection", rc);
  482.         goto quic_done;
  483.     }

  485.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  486.                    "quic close %s rc:%i",
  487.                    qc->closing ? "resumed": "initiated", rc);

  489.     if (!qc->closing) {

  491.         /* drop packets from retransmit queues, no ack is expected */
  492.         for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) {
  493.             ngx_quic_free_frames(c, &qc->send_ctx[i].frames);
  494.             ngx_quic_free_frames(c, &qc->send_ctx[i].sent);
  495.         }

  497.         if (qc->close.timer_set) {
  498.             ngx_del_timer(&qc->close);
  499.         }

  501.         if (rc == NGX_DONE) {

  503.             /*
  504.              * RFC 9000, 10.1.  Idle Timeout
  505.              *
  506.              *  If a max_idle_timeout is specified by either endpoint in its
  507.              *  transport parameters (Section 18.2), the connection is silently
  508.              *  closed and its state is discarded when it remains idle
  509.              */

  511.             /* this case also handles some errors from ngx_quic_run() */

  513.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  514.                            "quic close silent drain:%d timedout:%d",
  515.                            qc->draining, c->read->timedout);
  516.         } else {

  518.             /*
  519.              * RFC 9000, 10.2.  Immediate Close
  520.              *
  521.              *  An endpoint sends a CONNECTION_CLOSE frame (Section 19.19)
  522.              *  to terminate the connection immediately.
  523.              */

  525.             if (qc->error == 0 && rc == NGX_ERROR) {
  526.                 qc->error = NGX_QUIC_ERR_INTERNAL_ERROR;
  527.                 qc->error_app = 0;
  528.             }

  530.             ngx_log_debug5(NGX_LOG_DEBUG_EVENT, c->log, 0,
  531.                            "quic close immediate term:%d drain:%d "
  532.                            "%serror:%ui \"%s\"",
  533.                            rc == NGX_ERROR ? 1 : 0, qc->draining,
  534.                            qc->error_app ? "app " : "", qc->error,
  535.                            qc->error_reason ? qc->error_reason : "");

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

  540.                 if (!ngx_quic_keys_available(qc->keys, ctx->level, 1)) {
  541.                     continue;
  542.                 }

  544.                 qc->error_level = ctx->level;
  545.                 (void) ngx_quic_send_cc(c);

  547.                 if (rc == NGX_OK) {
  548.                     ngx_add_timer(&qc->close, 3 * ngx_quic_pto(c, ctx));
  549.                 }
  550.             }
  551.         }

  553.         qc->closing = 1;
  554.     }

  556.     if (rc == NGX_ERROR && qc->close.timer_set) {
  557.         /* do not wait for timer in case of fatal error */
  558.         ngx_del_timer(&qc->close);
  559.     }

  561.     if (ngx_quic_close_streams(c, qc) == NGX_AGAIN) {
  562.         return;
  563.     }

  565.     if (qc->push.timer_set) {
  566.         ngx_del_timer(&qc->push);
  567.     }

  569.     if (qc->pto.timer_set) {
  570.         ngx_del_timer(&qc->pto);
  571.     }

  573.     if (qc->path_validation.timer_set) {
  574.         ngx_del_timer(&qc->path_validation);
  575.     }

  577.     if (qc->push.posted) {
  578.         ngx_delete_posted_event(&qc->push);
  579.     }

  581.     if (qc->key_update.posted) {
  582.         ngx_delete_posted_event(&qc->key_update);
  583.     }

  585.     if (qc->close.timer_set) {
  586.         return;
  587.     }

  589.     if (qc->close.posted) {
  590.         ngx_delete_posted_event(&qc->close);
  591.     }

  593.     ngx_quic_close_sockets(c);

  595.     ngx_quic_keys_cleanup(qc->keys);

  597.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic close completed");

  599.     /* may be tested from SSL callback during SSL shutdown */
  600.     c->udp = NULL;

  602. quic_done:

  604.     if (c->ssl) {
  605.         (void) ngx_ssl_shutdown(c);
  606.     }

  608.     if (c->read->timer_set) {
  609.         ngx_del_timer(c->read);
  610.     }

  612. #if (NGX_STAT_STUB)
  613.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  614. #endif

  616.     c->destroyed = 1;

  618.     pool = c->pool;

  620.     ngx_close_connection(c);

  622.     ngx_destroy_pool(pool);
  623. }


  626. void
  627. ‌ngx_quic_finalize_connection(ngx_connection_t *c, ngx_uint_t err,
  628.     const char *reason)
  629. {
  630.     ngx_quic_connection_t  *qc;

  632.     qc = ngx_quic_get_connection(c);

  634.     if (qc->closing) {
  635.         return;
  636.     }

  638.     qc->error = err;
  639.     qc->error_reason = reason;
  640.     qc->error_app = 1;
  641.     qc->error_ftype = 0;

  643.     ngx_post_event(&qc->close, &ngx_posted_events);
  644. }


  647. void
  648. ‌ngx_quic_shutdown_connection(ngx_connection_t *c, ngx_uint_t err,
  649.     const char *reason)
  650. {
  651.     ngx_quic_connection_t  *qc;

  653.     qc = ngx_quic_get_connection(c);
  654.     qc->shutdown = 1;
  655.     qc->shutdown_code = err;
  656.     qc->shutdown_reason = reason;

  658.     ngx_quic_shutdown_quic(c);
  659. }


  662. static void
  663. ‌ngx_quic_close_handler(ngx_event_t *ev)
  664. {
  665.     ngx_connection_t  *c;

  667.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "quic close handler");

  669.     c = ev->data;

  671.     ngx_quic_close_connection(c, NGX_OK);
  672. }


  675. static ngx_int_t
  676. ‌ngx_quic_handle_datagram(ngx_connection_t *c, ngx_buf_t *b,
  677.     ngx_quic_conf_t *conf)
  678. {
  679.     size_t                  size;
  680.     u_char                 *p, *start;
  681.     ngx_int_t               rc;
  682.     ngx_uint_t              good;
  683.     ngx_quic_path_t        *path;
  684.     ngx_quic_header_t       pkt;
  685.     ngx_quic_connection_t  *qc;

  687.     good = 0;
  688.     path = NULL;

  690.     size = b->last - b->pos;

  692.     p = start = b->pos;

  694.     while (p < b->last) {

  696.         ngx_memzero(&pkt, sizeof(ngx_quic_header_t));
  697.         pkt.raw = b;
  698.         pkt.data = p;
  699.         pkt.len = b->last - p;
  700.         pkt.log = c->log;
  701.         pkt.first = (p == start) ? 1 : 0;
  702.         pkt.path = path;
  703.         pkt.flags = p[0];
  704.         pkt.raw->pos++;

  706.         rc = ngx_quic_handle_packet(c, conf, &pkt);

  708. #if (NGX_DEBUG)
  709.         if (pkt.parsed) {
  710.             ngx_log_debug5(NGX_LOG_DEBUG_EVENT, c->log, 0,
  711.                            "quic packet done rc:%i level:%s"
  712.                            " decr:%d pn:%L perr:%ui",
  713.                            rc, ngx_quic_level_name(pkt.level),
  714.                            pkt.decrypted, pkt.pn, pkt.error);
  715.         } else {
  716.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  717.                            "quic packet done rc:%i parse failed", rc);
  718.         }
  719. #endif

  721.         if (rc == NGX_ERROR || rc == NGX_DONE) {
  722.             return rc;
  723.         }

  725.         if (rc == NGX_OK) {
  726.             good = 1;
  727.         }

  729.         path = pkt.path; /* preserve packet path from 1st packet */

  731.         /* NGX_OK || NGX_DECLINED */

  733.         /*
  734.          * we get NGX_DECLINED when there are no keys [yet] available
  735.          * to decrypt packet.
  736.          * Instead of queueing it, we ignore it and rely on the sender's
  737.          * retransmission:
  738.          *
  739.          * RFC 9000, 12.2.  Coalescing Packets
  740.          *
  741.          * For example, if decryption fails (because the keys are
  742.          * not available or for any other reason), the receiver MAY either
  743.          * discard or buffer the packet for later processing and MUST
  744.          * attempt to process the remaining packets.
  745.          *
  746.          * We also skip packets that don't match connection state
  747.          * or cannot be parsed properly.
  748.          */

  750.         /* b->pos is at header end, adjust by actual packet length */
  751.         b->pos = pkt.data + pkt.len;

  753.         p = b->pos;
  754.     }

  756.     if (!good) {
  757.         return NGX_DONE;
  758.     }

  760.     qc = ngx_quic_get_connection(c);

  762.     if (qc) {
  763.         qc->received += size;

  765.         if ((uint64_t) (c->sent + qc->received) / 8 >
  766.             (qc->streams.sent + qc->streams.recv_last) + 1048576)
  767.         {
  768.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "quic flood detected");

  770.             qc->error = NGX_QUIC_ERR_NO_ERROR;
  771.             qc->error_reason = "QUIC flood detected";
  772.             return NGX_ERROR;
  773.         }
  774.     }

  776.     return NGX_OK;
  777. }


  780. static ngx_int_t
  781. ‌ngx_quic_handle_packet(ngx_connection_t *c, ngx_quic_conf_t *conf,
  782.     ngx_quic_header_t *pkt)
  783. {
  784.     ngx_int_t               rc;
  785.     ngx_quic_socket_t      *qsock;
  786.     ngx_quic_connection_t  *qc;

  788.     c->log->action = "parsing quic packet";

  790.     rc = ngx_quic_parse_packet(pkt);

  792.     if (rc == NGX_ERROR) {
  793.         return NGX_DECLINED;
  794.     }

  796.     pkt->parsed = 1;

  798.     c->log->action = "handling quic packet";

  800.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  801.                    "quic packet rx dcid len:%uz %xV",
  802.                    pkt->dcid.len, &pkt->dcid);

  804. #if (NGX_DEBUG)
  805.     if (pkt->level != NGX_QUIC_ENCRYPTION_APPLICATION) {
  806.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  807.                        "quic packet rx scid len:%uz %xV",
  808.                        pkt->scid.len, &pkt->scid);
  809.     }

  811.     if (pkt->level == NGX_QUIC_ENCRYPTION_INITIAL) {
  812.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  813.                        "quic address validation token len:%uz %xV",
  814.                        pkt->token.len, &pkt->token);
  815.     }
  816. #endif

  818.     qc = ngx_quic_get_connection(c);

  820.     if (qc) {

  822.         if (rc == NGX_ABORT) {
  823.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  824.                           "quic unsupported version: 0x%xD", pkt->version);
  825.             return NGX_DECLINED;
  826.         }

  828.         if (pkt->level != NGX_QUIC_ENCRYPTION_APPLICATION) {

  830.             if (pkt->version != qc->version) {
  831.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  832.                               "quic version mismatch: 0x%xD", pkt->version);
  833.                 return NGX_DECLINED;
  834.             }

  836.             if (pkt->first) {
  837.                 qsock = ngx_quic_get_socket(c);

  839.                 if (ngx_cmp_sockaddr(&qsock->sockaddr.sockaddr, qsock->socklen,
  840.                                      qc->path->sockaddr, qc->path->socklen, 1)
  841.                     != NGX_OK)
  842.                 {
  843.                     /* packet comes from unknown path, possibly migration */
  844.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  845.                                    "quic too early migration attempt");
  846.                     return NGX_DONE;
  847.                 }
  848.             }

  850.             if (ngx_quic_check_csid(qc, pkt) != NGX_OK) {
  851.                 return NGX_DECLINED;
  852.             }

  854.         }

  856.         rc = ngx_quic_handle_payload(c, pkt);

  858.         if (rc == NGX_DECLINED
  859.             && pkt->level == NGX_QUIC_ENCRYPTION_APPLICATION)
  860.         {
  861.             if (ngx_quic_handle_stateless_reset(c, pkt) == NGX_OK) {
  862.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  863.                               "quic stateless reset packet detected");

  865.                 qc->draining = 1;
  866.                 ngx_post_event(&qc->close, &ngx_posted_events);

  868.                 return NGX_OK;
  869.             }
  870.         }

  872.         return rc;
  873.     }

  875.     /* packet does not belong to a connection */

  877.     if (rc == NGX_ABORT) {
  878.         return ngx_quic_negotiate_version(c, pkt);
  879.     }

  881.     if (pkt->level == NGX_QUIC_ENCRYPTION_APPLICATION) {
  882.         return ngx_quic_send_stateless_reset(c, conf, pkt);
  883.     }

  885.     if (pkt->level != NGX_QUIC_ENCRYPTION_INITIAL) {
  886.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  887.                        "quic expected initial, got handshake");
  888.         return NGX_ERROR;
  889.     }

  891.     c->log->action = "handling initial packet";

  893.     if (pkt->dcid.len < NGX_QUIC_CID_LEN_MIN) {
  894.         /* RFC 9000, 7.2.  Negotiating Connection IDs */
  895.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  896.                       "quic too short dcid in initial"
  897.                       " packet: len:%i", pkt->dcid.len);
  898.         return NGX_ERROR;
  899.     }

  901.     /* process retry and initialize connection IDs */

  903.     if (pkt->token.len) {

  905.         rc = ngx_quic_validate_token(c, conf->av_token_key, pkt);

  907.         if (rc == NGX_ERROR) {
  908.             /* internal error */
  909.             return NGX_ERROR;

  911.         } else if (rc == NGX_ABORT) {
  912.             /* token cannot be decrypted */
  913.             return ngx_quic_send_early_cc(c, pkt,
  914.                                           NGX_QUIC_ERR_INVALID_TOKEN,
  915.                                           "cannot decrypt token");
  916.         } else if (rc == NGX_DECLINED) {
  917.             /* token is invalid */

  919.             if (pkt->retried) {
  920.                 /* invalid address validation token */
  921.                 return ngx_quic_send_early_cc(c, pkt,
  922.                                           NGX_QUIC_ERR_INVALID_TOKEN,
  923.                                           "invalid address validation token");
  924.             } else if (conf->retry) {
  925.                 /* invalid NEW_TOKEN */
  926.                 return ngx_quic_send_retry(c, conf, pkt);
  927.             }
  928.         }

  930.         /* NGX_OK */

  932.     } else if (conf->retry) {
  933.         return ngx_quic_send_retry(c, conf, pkt);

  935.     } else {
  936.         pkt->odcid = pkt->dcid;
  937.     }

  939.     if (ngx_terminate || ngx_exiting) {
  940.         if (conf->retry) {
  941.             return ngx_quic_send_retry(c, conf, pkt);
  942.         }

  944.         return NGX_ERROR;
  945.     }

  947.     c->log->action = "creating quic connection";

  949.     qc = ngx_quic_new_connection(c, conf, pkt);
  950.     if (qc == NULL) {
  951.         return NGX_ERROR;
  952.     }

  954.     return ngx_quic_handle_payload(c, pkt);
  955. }


  958. static ngx_int_t
  959. ‌ngx_quic_handle_payload(ngx_connection_t *c, ngx_quic_header_t *pkt)
  960. {
  961.     ngx_int_t               rc;
  962.     ngx_quic_send_ctx_t    *ctx;
  963.     ngx_quic_connection_t  *qc;
  964.     static u_char           buf[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

  966.     qc = ngx_quic_get_connection(c);

  968.     qc->error = 0;
  969.     qc->error_reason = NULL;

  971.     c->log->action = "decrypting packet";

  973.     if (!ngx_quic_keys_available(qc->keys, pkt->level, 0)) {
  974.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  975.                       "quic no %s keys, ignoring packet",
  976.                       ngx_quic_level_name(pkt->level));
  977.         return NGX_DECLINED;
  978.     }

  980. #if (NGX_QUIC_QUICTLS_API)
  981.     /* QuicTLS provides app read keys before completing handshake */

  983.     if (pkt->level == NGX_QUIC_ENCRYPTION_APPLICATION && !c->ssl->handshaked) {
  984.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  985.                       "quic no %s keys ready, ignoring packet",
  986.                       ngx_quic_level_name(pkt->level));
  987.         return NGX_DECLINED;
  988.     }
  989. #endif

  991.     pkt->keys = qc->keys;
  992.     pkt->key_phase = qc->key_phase;
  993.     pkt->plaintext = buf;

  995.     ctx = ngx_quic_get_send_ctx(qc, pkt->level);

  997.     rc = ngx_quic_decrypt(pkt, &ctx->largest_pn);
  998.     if (rc != NGX_OK) {
  999.         qc->error = pkt->error;
  1000.         qc->error_reason = "failed to decrypt packet";
  1001.         return rc;
  1002.     }

  1004.     pkt->decrypted = 1;

  1006.     c->log->action = "handling decrypted packet";

  1008.     if (pkt->path == NULL) {
  1009.         rc = ngx_quic_set_path(c, pkt);
  1010.         if (rc != NGX_OK) {
  1011.             return rc;
  1012.         }
  1013.     }

  1015.     if (c->ssl == NULL) {
  1016.         if (ngx_quic_init_connection(c) != NGX_OK) {
  1017.             return NGX_ERROR;
  1018.         }
  1019.     }

  1021.     if (pkt->level == NGX_QUIC_ENCRYPTION_HANDSHAKE) {
  1022.         /*
  1023.          * RFC 9001, 4.9.1.  Discarding Initial Keys
  1024.          *
  1025.          * The successful use of Handshake packets indicates
  1026.          * that no more Initial packets need to be exchanged
  1027.          */
  1028.         ngx_quic_discard_ctx(c, NGX_QUIC_ENCRYPTION_INITIAL);

  1030.         if (!qc->path->validated) {
  1031.             qc->path->validated = 1;
  1032.             ngx_quic_path_dbg(c, "in handshake", qc->path);
  1033.             ngx_post_event(&qc->push, &ngx_posted_events);
  1034.         }
  1035.     }

  1037.     if (pkt->level == NGX_QUIC_ENCRYPTION_APPLICATION) {
  1038.         /*
  1039.          * RFC 9001, 4.9.3.  Discarding 0-RTT Keys
  1040.          *
  1041.          * After receiving a 1-RTT packet, servers MUST discard
  1042.          * 0-RTT keys within a short time
  1043.          */
  1044.         ngx_quic_keys_discard(qc->keys, NGX_QUIC_ENCRYPTION_EARLY_DATA);
  1045.     }

  1047.     if (qc->closing) {
  1048.         /*
  1049.          * RFC 9000, 10.2.  Immediate Close
  1050.          *
  1051.          * ... delayed or reordered packets are properly discarded.
  1052.          *
  1053.          *  In the closing state, an endpoint retains only enough information
  1054.          *  to generate a packet containing a CONNECTION_CLOSE frame and to
  1055.          *  identify packets as belonging to the connection.
  1056.          */

  1058.         qc->error_level = pkt->level;
  1059.         qc->error = NGX_QUIC_ERR_NO_ERROR;
  1060.         qc->error_reason = "connection is closing, packet discarded";
  1061.         qc->error_ftype = 0;
  1062.         qc->error_app = 0;

  1064.         return ngx_quic_send_cc(c);
  1065.     }

  1067.     pkt->received = ngx_current_msec;

  1069.     c->log->action = "handling payload";

  1071.     if (pkt->level != NGX_QUIC_ENCRYPTION_APPLICATION) {
  1072.         return ngx_quic_handle_frames(c, pkt);
  1073.     }

  1075.     if (!pkt->key_update) {
  1076.         return ngx_quic_handle_frames(c, pkt);
  1077.     }

  1079.     /* switch keys and generate next on Key Phase change */

  1081.     qc->key_phase ^= 1;
  1082.     ngx_quic_keys_switch(c, qc->keys);

  1084.     rc = ngx_quic_handle_frames(c, pkt);
  1085.     if (rc != NGX_OK) {
  1086.         return rc;
  1087.     }

  1089.     ngx_post_event(&qc->key_update, &ngx_posted_events);

  1091.     return NGX_OK;
  1092. }


  1095. void
  1096. ‌ngx_quic_discard_ctx(ngx_connection_t *c, ngx_uint_t level)
  1097. {
  1098.     ngx_queue_t            *q;
  1099.     ngx_quic_frame_t       *f;
  1100.     ngx_quic_socket_t      *qsock;
  1101.     ngx_quic_send_ctx_t    *ctx;
  1102.     ngx_quic_connection_t  *qc;

  1104.     qc = ngx_quic_get_connection(c);

  1106.     if (!ngx_quic_keys_available(qc->keys, level, 0)
  1107.         && !ngx_quic_keys_available(qc->keys, level, 1))
  1108.     {
  1109.         return;
  1110.     }

  1112.     ngx_quic_keys_discard(qc->keys, level);

  1114.     qc->pto_count = 0;

  1116.     ctx = ngx_quic_get_send_ctx(qc, level);

  1118.     ngx_quic_free_buffer(c, &ctx->crypto);

  1120.     while (!ngx_queue_empty(&ctx->sent)) {
  1121.         q = ngx_queue_head(&ctx->sent);
  1122.         ngx_queue_remove(q);

  1124.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);
  1125.         ngx_quic_congestion_ack(c, f);
  1126.         ngx_quic_free_frame(c, f);
  1127.     }

  1129.     while (!ngx_queue_empty(&ctx->frames)) {
  1130.         q = ngx_queue_head(&ctx->frames);
  1131.         ngx_queue_remove(q);

  1133.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);
  1134.         ngx_quic_free_frame(c, f);
  1135.     }

  1137.     if (level == NGX_QUIC_ENCRYPTION_INITIAL) {
  1138.         /* close temporary listener with initial dcid */
  1139.         qsock = ngx_quic_find_socket(c, NGX_QUIC_UNSET_PN);
  1140.         if (qsock) {
  1141.             ngx_quic_close_socket(c, qsock);
  1142.         }
  1143.     }

  1145.     ctx->send_ack = 0;

  1147.     ngx_quic_set_lost_timer(c);
  1148. }


  1151. static ngx_int_t
  1152. ‌ngx_quic_check_csid(ngx_quic_connection_t *qc, ngx_quic_header_t *pkt)
  1153. {
  1154.     ngx_queue_t           *q;
  1155.     ngx_quic_client_id_t  *cid;

  1157.     for (q = ngx_queue_head(&qc->client_ids);
  1158.          q != ngx_queue_sentinel(&qc->client_ids);
  1159.          q = ngx_queue_next(q))
  1160.     {
  1161.         cid = ngx_queue_data(q, ngx_quic_client_id_t, queue);

  1163.         if (pkt->scid.len == cid->len
  1164.             && ngx_memcmp(pkt->scid.data, cid->id, cid->len) == 0)
  1165.         {
  1166.             return NGX_OK;
  1167.         }
  1168.     }

  1170.     ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic unexpected quic scid");
  1171.     return NGX_ERROR;
  1172. }


  1175. static ngx_int_t
  1176. ‌ngx_quic_handle_frames(ngx_connection_t *c, ngx_quic_header_t *pkt)
  1177. {
  1178.     u_char                 *end, *p;
  1179.     ssize_t                 len;
  1180.     ngx_buf_t               buf;
  1181.     ngx_uint_t              do_close, nonprobing;
  1182.     ngx_chain_t             chain;
  1183.     ngx_quic_frame_t        frame;
  1184.     ngx_quic_connection_t  *qc;

  1186.     qc = ngx_quic_get_connection(c);

  1188.     p = pkt->payload.data;
  1189.     end = p + pkt->payload.len;

  1191.     do_close = 0;
  1192.     nonprobing = 0;

  1194.     while (p < end) {

  1196.         c->log->action = "parsing frames";

  1198.         ngx_memzero(&frame, sizeof(ngx_quic_frame_t));
  1199.         ngx_memzero(&buf, sizeof(ngx_buf_t));
  1200.         buf.temporary = 1;

  1202.         chain.buf = &buf;
  1203.         chain.next = NULL;
  1204.         frame.data = &chain;

  1206.         len = ngx_quic_parse_frame(pkt, p, end, &frame);

  1208.         if (len < 0) {
  1209.             qc->error = pkt->error;
  1210.             return NGX_ERROR;
  1211.         }

  1213.         ngx_quic_log_frame(c->log, &frame, 0);

  1215.         c->log->action = "handling frames";

  1217.         p += len;

  1219.         switch (frame.type) {
  1220.         /* probing frames */
  1221.         case NGX_QUIC_FT_PADDING:
  1222.         case NGX_QUIC_FT_PATH_CHALLENGE:
  1223.         case NGX_QUIC_FT_PATH_RESPONSE:
  1224.         case NGX_QUIC_FT_NEW_CONNECTION_ID:
  1225.             break;

  1227.         /* non-probing frames */
  1228.         default:
  1229.             nonprobing = 1;
  1230.             break;
  1231.         }

  1233.         switch (frame.type) {

  1235.         case NGX_QUIC_FT_ACK:
  1236.             if (ngx_quic_handle_ack_frame(c, pkt, &frame) != NGX_OK) {
  1237.                 return NGX_ERROR;
  1238.             }

  1240.             continue;

  1242.         case NGX_QUIC_FT_PADDING:
  1243.             /* no action required */
  1244.             continue;

  1246.         case NGX_QUIC_FT_CONNECTION_CLOSE:
  1247.         case NGX_QUIC_FT_CONNECTION_CLOSE_APP:
  1248.             do_close = 1;
  1249.             continue;
  1250.         }

  1252.         /* got there with ack-eliciting packet */
  1253.         pkt->need_ack = 1;

  1255.         switch (frame.type) {

  1257.         case NGX_QUIC_FT_CRYPTO:

  1259.             if (ngx_quic_handle_crypto_frame(c, pkt, &frame) != NGX_OK) {
  1260.                 return NGX_ERROR;
  1261.             }

  1263.             break;

  1265.         case NGX_QUIC_FT_PING:
  1266.             break;

  1268.         case NGX_QUIC_FT_STREAM:

  1270.             if (ngx_quic_handle_stream_frame(c, pkt, &frame) != NGX_OK) {
  1271.                 return NGX_ERROR;
  1272.             }

  1274.             break;

  1276.         case NGX_QUIC_FT_MAX_DATA:

  1278.             if (ngx_quic_handle_max_data_frame(c, &frame.u.max_data) != NGX_OK)
  1279.             {
  1280.                 return NGX_ERROR;
  1281.             }

  1283.             break;

  1285.         case NGX_QUIC_FT_STREAMS_BLOCKED:
  1286.         case NGX_QUIC_FT_STREAMS_BLOCKED2:

  1288.             if (ngx_quic_handle_streams_blocked_frame(c, pkt,
  1289.                                                       &frame.u.streams_blocked)
  1290.                 != NGX_OK)
  1291.             {
  1292.                 return NGX_ERROR;
  1293.             }

  1295.             break;

  1297.         case NGX_QUIC_FT_DATA_BLOCKED:

  1299.             if (ngx_quic_handle_data_blocked_frame(c, pkt,
  1300.                                                    &frame.u.data_blocked)
  1301.                 != NGX_OK)
  1302.             {
  1303.                 return NGX_ERROR;
  1304.             }

  1306.             break;

  1308.         case NGX_QUIC_FT_STREAM_DATA_BLOCKED:

  1310.             if (ngx_quic_handle_stream_data_blocked_frame(c, pkt,
  1311.                                                   &frame.u.stream_data_blocked)
  1312.                 != NGX_OK)
  1313.             {
  1314.                 return NGX_ERROR;
  1315.             }

  1317.             break;

  1319.         case NGX_QUIC_FT_MAX_STREAM_DATA:

  1321.             if (ngx_quic_handle_max_stream_data_frame(c, pkt,
  1322.                                                       &frame.u.max_stream_data)
  1323.                 != NGX_OK)
  1324.             {
  1325.                 return NGX_ERROR;
  1326.             }

  1328.             break;

  1330.         case NGX_QUIC_FT_RESET_STREAM:

  1332.             if (ngx_quic_handle_reset_stream_frame(c, pkt,
  1333.                                                    &frame.u.reset_stream)
  1334.                 != NGX_OK)
  1335.             {
  1336.                 return NGX_ERROR;
  1337.             }

  1339.             break;

  1341.         case NGX_QUIC_FT_STOP_SENDING:

  1343.             if (ngx_quic_handle_stop_sending_frame(c, pkt,
  1344.                                                    &frame.u.stop_sending)
  1345.                 != NGX_OK)
  1346.             {
  1347.                 return NGX_ERROR;
  1348.             }

  1350.             break;

  1352.         case NGX_QUIC_FT_MAX_STREAMS:
  1353.         case NGX_QUIC_FT_MAX_STREAMS2:

  1355.             if (ngx_quic_handle_max_streams_frame(c, pkt, &frame.u.max_streams)
  1356.                 != NGX_OK)
  1357.             {
  1358.                 return NGX_ERROR;
  1359.             }

  1361.             break;

  1363.         case NGX_QUIC_FT_PATH_CHALLENGE:

  1365.             if (ngx_quic_handle_path_challenge_frame(c, pkt,
  1366.                                                      &frame.u.path_challenge)
  1367.                 != NGX_OK)
  1368.             {
  1369.                 return NGX_ERROR;
  1370.             }

  1372.             break;

  1374.         case NGX_QUIC_FT_PATH_RESPONSE:

  1376.             if (ngx_quic_handle_path_response_frame(c, &frame.u.path_response)
  1377.                 != NGX_OK)
  1378.             {
  1379.                 return NGX_ERROR;
  1380.             }

  1382.             break;

  1384.         case NGX_QUIC_FT_NEW_CONNECTION_ID:

  1386.             if (ngx_quic_handle_new_connection_id_frame(c, &frame.u.ncid)
  1387.                 != NGX_OK)
  1388.             {
  1389.                 return NGX_ERROR;
  1390.             }

  1392.             break;

  1394.         case NGX_QUIC_FT_RETIRE_CONNECTION_ID:

  1396.             if (ngx_quic_handle_retire_connection_id_frame(c,
  1397.                                                            &frame.u.retire_cid)
  1398.                 != NGX_OK)
  1399.             {
  1400.                 return NGX_ERROR;
  1401.             }

  1403.             break;

  1405.         default:
  1406.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1407.                            "quic missing frame handler");
  1408.             return NGX_ERROR;
  1409.         }
  1410.     }

  1412.     if (p != end) {
  1413.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1414.                       "quic trailing garbage in payload:%ui bytes", end - p);

  1416.         qc->error = NGX_QUIC_ERR_FRAME_ENCODING_ERROR;
  1417.         return NGX_ERROR;
  1418.     }

  1420.     if (do_close) {
  1421.         qc->draining = 1;
  1422.         ngx_post_event(&qc->close, &ngx_posted_events);
  1423.     }

  1425.     if (pkt->path != qc->path && nonprobing) {

  1427.         /*
  1428.          * RFC 9000, 9.2.  Initiating Connection Migration
  1429.          *
  1430.          * An endpoint can migrate a connection to a new local
  1431.          * address by sending packets containing non-probing frames
  1432.          * from that address.
  1433.          */
  1434.         if (ngx_quic_handle_migration(c, pkt) != NGX_OK) {
  1435.             return NGX_ERROR;
  1436.         }
  1437.     }

  1439.     if (ngx_quic_ack_packet(c, pkt) != NGX_OK) {
  1440.         return NGX_ERROR;
  1441.     }

  1443.     return NGX_OK;
  1444. }


  1447. static void
  1448. ‌ngx_quic_push_handler(ngx_event_t *ev)
  1449. {
  1450.     ngx_connection_t  *c;

  1452.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "quic push handler");

  1454.     c = ev->data;

  1456.     if (ngx_quic_output(c) != NGX_OK) {
  1457.         ngx_quic_close_connection(c, NGX_ERROR);
  1458.         return;
  1459.     }

  1461.     ngx_quic_connstate_dbg(c);
  1462. }


  1465. void
  1466. ‌ngx_quic_shutdown_quic(ngx_connection_t *c)
  1467. {
  1468.     ngx_quic_connection_t  *qc;

  1470.     if (c->reusable) {
  1471.         qc = ngx_quic_get_connection(c);
  1472.         ngx_quic_finalize_connection(c, qc->shutdown_code, qc->shutdown_reason);
  1473.     }
  1474. }


  1477. void
  1478. ‌ngx_quic_address_hash(struct sockaddr *sockaddr, socklen_t socklen,
  1479.     ngx_uint_t no_port, u_char *salt, size_t saltlen, u_char buf[20])
  1480. {
  1481.     size_t                len;
  1482.     u_char               *data;
  1483.     ngx_sha1_t            sha1;
  1484.     struct sockaddr_in   *sin;
  1485. #if (NGX_HAVE_INET6)
  1486.     struct sockaddr_in6  *sin6;
  1487. #endif

  1489.     len = (size_t) socklen;
  1490.     data = (u_char *) sockaddr;

  1492.     if (no_port) {
  1493.         switch (sockaddr->sa_family) {

  1495. #if (NGX_HAVE_INET6)
  1496.         case AF_INET6:
  1497.             sin6 = (struct sockaddr_in6 *) sockaddr;

  1499.             len = sizeof(struct in6_addr);
  1500.             data = sin6->sin6_addr.s6_addr;

  1502.             break;
  1503. #endif

  1505.         case AF_INET:
  1506.             sin = (struct sockaddr_in *) sockaddr;

  1508.             len = sizeof(in_addr_t);
  1509.             data = (u_char *) &sin->sin_addr;

  1511.             break;
  1512.         }
  1513.     }

  1515.     ngx_sha1_init(&sha1);
  1516.     ngx_sha1_update(&sha1, data, len);

  1518.     if (salt) {
  1519.         ngx_sha1_update(&sha1, salt, saltlen);
  1520.     }

  1522.     ngx_sha1_final(buf, &sha1);
  1523. }

One Level Up Top Level