One Level Up Top Level

src/http/v3/ngx_http_v3_uni.c - nginx source code

Data types defined

Functions defined

Source code


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


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  13. ‌typedef struct {
  14.     ngx_http_v3_parse_uni_t         parse;
  15.     ngx_int_t                       index;
  16. ‌} ngx_http_v3_uni_stream_t;


  19. static void ngx_http_v3_close_uni_stream(ngx_connection_t *c);
  20. static void ngx_http_v3_uni_read_handler(ngx_event_t *rev);
  21. static void ngx_http_v3_uni_dummy_read_handler(ngx_event_t *wev);
  22. static void ngx_http_v3_uni_dummy_write_handler(ngx_event_t *wev);


  25. void
  26. ‌ngx_http_v3_init_uni_stream(ngx_connection_t *c)
  27. {
  28.     uint64_t                   n;
  29.     ngx_http_v3_session_t     *h3c;
  30.     ngx_http_v3_uni_stream_t  *us;

  32.     h3c = ngx_http_v3_get_session(c);
  33.     if (h3c->hq) {
  34.         ngx_http_v3_finalize_connection(c,
  35.                                         NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR,
  36.                                         "uni stream in hq mode");
  37.         c->data = NULL;
  38.         ngx_http_v3_close_uni_stream(c);
  39.         return;
  40.     }

  42.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 init uni stream");

  44.     n = c->quic->id >> 2;

  46.     if (n >= NGX_HTTP_V3_MAX_UNI_STREAMS) {
  47.         ngx_http_v3_finalize_connection(c,
  48.                                       NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR,
  49.                                       "reached maximum number of uni streams");
  50.         c->data = NULL;
  51.         ngx_http_v3_close_uni_stream(c);
  52.         return;
  53.     }

  55.     ngx_quic_cancelable_stream(c);

  57.     us = ngx_pcalloc(c->pool, sizeof(ngx_http_v3_uni_stream_t));
  58.     if (us == NULL) {
  59.         ngx_http_v3_finalize_connection(c,
  60.                                         NGX_HTTP_V3_ERR_INTERNAL_ERROR,
  61.                                         "memory allocation error");
  62.         c->data = NULL;
  63.         ngx_http_v3_close_uni_stream(c);
  64.         return;
  65.     }

  67.     us->index = -1;

  69.     c->data = us;

  71.     c->read->handler = ngx_http_v3_uni_read_handler;
  72.     c->write->handler = ngx_http_v3_uni_dummy_write_handler;

  74.     ngx_http_v3_uni_read_handler(c->read);
  75. }


  78. static void
  79. ‌ngx_http_v3_close_uni_stream(ngx_connection_t *c)
  80. {
  81.     ngx_pool_t                *pool;
  82.     ngx_http_v3_session_t     *h3c;
  83.     ngx_http_v3_uni_stream_t  *us;

  85.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 close stream");

  87.     us = c->data;

  89.     if (us && us->index >= 0) {
  90.         h3c = ngx_http_v3_get_session(c);
  91.         h3c->known_streams[us->index] = NULL;
  92.     }

  94.     c->destroyed = 1;

  96.     pool = c->pool;

  98.     ngx_close_connection(c);

  100.     ngx_destroy_pool(pool);
  101. }


  104. ngx_int_t
  105. ‌ngx_http_v3_register_uni_stream(ngx_connection_t *c, uint64_t type)
  106. {
  107.     ngx_int_t                  index;
  108.     ngx_http_v3_session_t     *h3c;
  109.     ngx_http_v3_uni_stream_t  *us;

  111.     h3c = ngx_http_v3_get_session(c);

  113.     switch (type) {

  115.     case NGX_HTTP_V3_STREAM_ENCODER:

  117.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  118.                        "http3 encoder stream");
  119.         index = NGX_HTTP_V3_STREAM_CLIENT_ENCODER;
  120.         break;

  122.     case NGX_HTTP_V3_STREAM_DECODER:

  124.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  125.                        "http3 decoder stream");
  126.         index = NGX_HTTP_V3_STREAM_CLIENT_DECODER;
  127.         break;

  129.     case NGX_HTTP_V3_STREAM_CONTROL:

  131.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  132.                        "http3 control stream");
  133.         index = NGX_HTTP_V3_STREAM_CLIENT_CONTROL;

  135.         break;

  137.     default:

  139.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  140.                        "http3 stream 0x%02xL", type);

  142.         if (h3c->known_streams[NGX_HTTP_V3_STREAM_CLIENT_ENCODER] == NULL
  143.             || h3c->known_streams[NGX_HTTP_V3_STREAM_CLIENT_DECODER] == NULL
  144.             || h3c->known_streams[NGX_HTTP_V3_STREAM_CLIENT_CONTROL] == NULL)
  145.         {
  146.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "missing mandatory stream");
  147.             return NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR;
  148.         }

  150.         index = -1;
  151.     }

  153.     if (index >= 0) {
  154.         if (h3c->known_streams[index]) {
  155.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "stream exists");
  156.             return NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR;
  157.         }

  159.         h3c->known_streams[index] = c;

  161.         us = c->data;
  162.         us->index = index;
  163.     }

  165.     return NGX_OK;
  166. }


  169. static void
  170. ‌ngx_http_v3_uni_read_handler(ngx_event_t *rev)
  171. {
  172.     u_char                     buf[128];
  173.     ssize_t                    n;
  174.     ngx_buf_t                  b;
  175.     ngx_int_t                  rc;
  176.     ngx_connection_t          *c;
  177.     ngx_http_v3_session_t     *h3c;
  178.     ngx_http_v3_uni_stream_t  *us;

  180.     c = rev->data;
  181.     us = c->data;

  183.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 read handler");

  185.     if (c->close) {
  186.         ngx_http_v3_close_uni_stream(c);
  187.         return;
  188.     }

  190.     ngx_memzero(&b, sizeof(ngx_buf_t));

  192.     while (rev->ready) {

  194.         n = c->recv(c, buf, sizeof(buf));

  196.         if (n == NGX_ERROR) {
  197.             rc = NGX_HTTP_V3_ERR_INTERNAL_ERROR;
  198.             goto failed;
  199.         }

  201.         if (n == 0) {
  202.             if (us->index >= 0) {
  203.                 rc = NGX_HTTP_V3_ERR_CLOSED_CRITICAL_STREAM;
  204.                 goto failed;
  205.             }

  207.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 read eof");
  208.             ngx_http_v3_close_uni_stream(c);
  209.             return;
  210.         }

  212.         if (n == NGX_AGAIN) {
  213.             break;
  214.         }

  216.         b.pos = buf;
  217.         b.last = buf + n;

  219.         h3c = ngx_http_v3_get_session(c);
  220.         h3c->total_bytes += n;

  222.         if (ngx_http_v3_check_flood(c) != NGX_OK) {
  223.             ngx_http_v3_close_uni_stream(c);
  224.             return;
  225.         }

  227.         rc = ngx_http_v3_parse_uni(c, &us->parse, &b);

  229.         if (rc == NGX_DONE) {
  230.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  231.                            "http3 read done");
  232.             ngx_http_v3_close_uni_stream(c);
  233.             return;
  234.         }

  236.         if (rc > 0) {
  237.             goto failed;
  238.         }

  240.         if (rc != NGX_AGAIN) {
  241.             rc = NGX_HTTP_V3_ERR_GENERAL_PROTOCOL_ERROR;
  242.             goto failed;
  243.         }
  244.     }

  246.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  247.         rc = NGX_HTTP_V3_ERR_INTERNAL_ERROR;
  248.         goto failed;
  249.     }

  251.     return;

  253. failed:

  255.     ngx_http_v3_finalize_connection(c, rc, "stream error");
  256.     ngx_http_v3_close_uni_stream(c);
  257. }


  260. static void
  261. ‌ngx_http_v3_uni_dummy_read_handler(ngx_event_t *rev)
  262. {
  263.     u_char             ch;
  264.     ngx_connection_t  *c;

  266.     c = rev->data;

  268.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 dummy read handler");

  270.     if (c->close) {
  271.         ngx_http_v3_close_uni_stream(c);
  272.         return;
  273.     }

  275.     if (rev->ready) {
  276.         if (c->recv(c, &ch, 1) != 0) {
  277.             ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_NO_ERROR, NULL);
  278.             ngx_http_v3_close_uni_stream(c);
  279.             return;
  280.         }
  281.     }

  283.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  284.         ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_INTERNAL_ERROR,
  285.                                         NULL);
  286.         ngx_http_v3_close_uni_stream(c);
  287.     }
  288. }


  291. static void
  292. ‌ngx_http_v3_uni_dummy_write_handler(ngx_event_t *wev)
  293. {
  294.     ngx_connection_t  *c;

  296.     c = wev->data;

  298.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 dummy write handler");

  300.     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  301.         ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_INTERNAL_ERROR,
  302.                                         NULL);
  303.         ngx_http_v3_close_uni_stream(c);
  304.     }
  305. }


  308. ngx_connection_t *
  309. ‌ngx_http_v3_get_uni_stream(ngx_connection_t *c, ngx_uint_t type)
  310. {
  311.     u_char                     buf[NGX_HTTP_V3_VARLEN_INT_LEN];
  312.     size_t                     n;
  313.     ngx_int_t                  index;
  314.     ngx_connection_t          *sc;
  315.     ngx_http_v3_session_t     *h3c;
  316.     ngx_http_v3_uni_stream_t  *us;

  318.     switch (type) {
  319.     case NGX_HTTP_V3_STREAM_ENCODER:
  320.         index = NGX_HTTP_V3_STREAM_SERVER_ENCODER;
  321.         break;
  322.     case NGX_HTTP_V3_STREAM_DECODER:
  323.         index = NGX_HTTP_V3_STREAM_SERVER_DECODER;
  324.         break;
  325.     case NGX_HTTP_V3_STREAM_CONTROL:
  326.         index = NGX_HTTP_V3_STREAM_SERVER_CONTROL;
  327.         break;
  328.     default:
  329.         index = -1;
  330.     }

  332.     h3c = ngx_http_v3_get_session(c);

  334.     if (index >= 0) {
  335.         if (h3c->known_streams[index]) {
  336.             return h3c->known_streams[index];
  337.         }
  338.     }

  340.     sc = ngx_quic_open_stream(c, 0);
  341.     if (sc == NULL) {
  342.         goto failed;
  343.     }

  345.     ngx_quic_cancelable_stream(sc);

  347.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  348.                    "http3 create uni stream, type:%ui", type);

  350.     us = ngx_pcalloc(sc->pool, sizeof(ngx_http_v3_uni_stream_t));
  351.     if (us == NULL) {
  352.         goto failed;
  353.     }

  355.     us->index = index;

  357.     sc->data = us;

  359.     sc->read->handler = ngx_http_v3_uni_dummy_read_handler;
  360.     sc->write->handler = ngx_http_v3_uni_dummy_write_handler;

  362.     if (index >= 0) {
  363.         h3c->known_streams[index] = sc;
  364.     }

  366.     n = (u_char *) ngx_http_v3_encode_varlen_int(buf, type) - buf;

  368.     h3c = ngx_http_v3_get_session(c);
  369.     h3c->total_bytes += n;

  371.     if (sc->send(sc, buf, n) != (ssize_t) n) {
  372.         goto failed;
  373.     }

  375.     ngx_post_event(sc->read, &ngx_posted_events);

  377.     return sc;

  379. failed:

  381.     ngx_log_error(NGX_LOG_ERR, c->log, 0, "failed to create server stream");

  383.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR,
  384.                                     "failed to create server stream");
  385.     if (sc) {
  386.         ngx_http_v3_close_uni_stream(sc);
  387.     }

  389.     return NULL;
  390. }


  393. ngx_int_t
  394. ‌ngx_http_v3_send_settings(ngx_connection_t *c)
  395. {
  396.     u_char                  *p, buf[NGX_HTTP_V3_VARLEN_INT_LEN * 6];
  397.     size_t                   n;
  398.     ngx_connection_t        *cc;
  399.     ngx_http_v3_session_t   *h3c;
  400.     ngx_http_v3_srv_conf_t  *h3scf;

  402.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 send settings");

  404.     cc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_CONTROL);
  405.     if (cc == NULL) {
  406.         return NGX_ERROR;
  407.     }

  409.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  411.     n = ngx_http_v3_encode_varlen_int(NULL,
  412.                                       NGX_HTTP_V3_PARAM_MAX_TABLE_CAPACITY);
  413.     n += ngx_http_v3_encode_varlen_int(NULL, h3scf->max_table_capacity);
  414.     n += ngx_http_v3_encode_varlen_int(NULL, NGX_HTTP_V3_PARAM_BLOCKED_STREAMS);
  415.     n += ngx_http_v3_encode_varlen_int(NULL, h3scf->max_blocked_streams);

  417.     p = (u_char *) ngx_http_v3_encode_varlen_int(buf,
  418.                                                  NGX_HTTP_V3_FRAME_SETTINGS);
  419.     p = (u_char *) ngx_http_v3_encode_varlen_int(p, n);
  420.     p = (u_char *) ngx_http_v3_encode_varlen_int(p,
  421.                                          NGX_HTTP_V3_PARAM_MAX_TABLE_CAPACITY);
  422.     p = (u_char *) ngx_http_v3_encode_varlen_int(p, h3scf->max_table_capacity);
  423.     p = (u_char *) ngx_http_v3_encode_varlen_int(p,
  424.                                             NGX_HTTP_V3_PARAM_BLOCKED_STREAMS);
  425.     p = (u_char *) ngx_http_v3_encode_varlen_int(p, h3scf->max_blocked_streams);
  426.     n = p - buf;

  428.     h3c = ngx_http_v3_get_session(c);
  429.     h3c->total_bytes += n;

  431.     if (cc->send(cc, buf, n) != (ssize_t) n) {
  432.         goto failed;
  433.     }

  435.     return NGX_OK;

  437. failed:

  439.     ngx_log_error(NGX_LOG_ERR, c->log, 0, "failed to send settings");

  441.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  442.                                     "failed to send settings");
  443.     ngx_http_v3_close_uni_stream(cc);

  445.     return NGX_ERROR;
  446. }


  449. ngx_int_t
  450. ‌ngx_http_v3_send_goaway(ngx_connection_t *c, uint64_t id)
  451. {
  452.     u_char                 *p, buf[NGX_HTTP_V3_VARLEN_INT_LEN * 3];
  453.     size_t                  n;
  454.     ngx_connection_t       *cc;
  455.     ngx_http_v3_session_t  *h3c;

  457.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 send goaway %uL", id);

  459.     cc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_CONTROL);
  460.     if (cc == NULL) {
  461.         return NGX_ERROR;
  462.     }

  464.     n = ngx_http_v3_encode_varlen_int(NULL, id);
  465.     p = (u_char *) ngx_http_v3_encode_varlen_int(buf, NGX_HTTP_V3_FRAME_GOAWAY);
  466.     p = (u_char *) ngx_http_v3_encode_varlen_int(p, n);
  467.     p = (u_char *) ngx_http_v3_encode_varlen_int(p, id);
  468.     n = p - buf;

  470.     h3c = ngx_http_v3_get_session(c);
  471.     h3c->total_bytes += n;

  473.     if (cc->send(cc, buf, n) != (ssize_t) n) {
  474.         goto failed;
  475.     }

  477.     return NGX_OK;

  479. failed:

  481.     ngx_log_error(NGX_LOG_ERR, c->log, 0, "failed to send goaway");

  483.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  484.                                     "failed to send goaway");
  485.     ngx_http_v3_close_uni_stream(cc);

  487.     return NGX_ERROR;
  488. }


  491. ngx_int_t
  492. ‌ngx_http_v3_send_ack_section(ngx_connection_t *c, ngx_uint_t stream_id)
  493. {
  494.     u_char                  buf[NGX_HTTP_V3_PREFIX_INT_LEN];
  495.     size_t                  n;
  496.     ngx_connection_t       *dc;
  497.     ngx_http_v3_session_t  *h3c;

  499.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  500.                    "http3 send section acknowledgement %ui", stream_id);

  502.     dc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_DECODER);
  503.     if (dc == NULL) {
  504.         return NGX_ERROR;
  505.     }

  507.     buf[0] = 0x80;
  508.     n = (u_char *) ngx_http_v3_encode_prefix_int(buf, stream_id, 7) - buf;

  510.     h3c = ngx_http_v3_get_session(c);
  511.     h3c->total_bytes += n;

  513.     if (dc->send(dc, buf, n) != (ssize_t) n) {
  514.         goto failed;
  515.     }

  517.     return NGX_OK;

  519. failed:

  521.     ngx_log_error(NGX_LOG_ERR, c->log, 0,
  522.                   "failed to send section acknowledgement");

  524.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  525.                                     "failed to send section acknowledgement");
  526.     ngx_http_v3_close_uni_stream(dc);

  528.     return NGX_ERROR;
  529. }


  532. ngx_int_t
  533. ‌ngx_http_v3_send_cancel_stream(ngx_connection_t *c, ngx_uint_t stream_id)
  534. {
  535.     u_char                  buf[NGX_HTTP_V3_PREFIX_INT_LEN];
  536.     size_t                  n;
  537.     ngx_connection_t       *dc;
  538.     ngx_http_v3_session_t  *h3c;

  540.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  541.                    "http3 send stream cancellation %ui", stream_id);

  543.     dc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_DECODER);
  544.     if (dc == NULL) {
  545.         return NGX_ERROR;
  546.     }

  548.     buf[0] = 0x40;
  549.     n = (u_char *) ngx_http_v3_encode_prefix_int(buf, stream_id, 6) - buf;

  551.     h3c = ngx_http_v3_get_session(c);
  552.     h3c->total_bytes += n;

  554.     if (dc->send(dc, buf, n) != (ssize_t) n) {
  555.         goto failed;
  556.     }

  558.     return NGX_OK;

  560. failed:

  562.     ngx_log_error(NGX_LOG_ERR, c->log, 0, "failed to send stream cancellation");

  564.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  565.                                     "failed to send stream cancellation");
  566.     ngx_http_v3_close_uni_stream(dc);

  568.     return NGX_ERROR;
  569. }


  572. ngx_int_t
  573. ‌ngx_http_v3_send_inc_insert_count(ngx_connection_t *c, ngx_uint_t inc)
  574. {
  575.     u_char                  buf[NGX_HTTP_V3_PREFIX_INT_LEN];
  576.     size_t                  n;
  577.     ngx_connection_t       *dc;
  578.     ngx_http_v3_session_t  *h3c;

  580.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  581.                    "http3 send insert count increment %ui", inc);

  583.     dc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_DECODER);
  584.     if (dc == NULL) {
  585.         return NGX_ERROR;
  586.     }

  588.     buf[0] = 0;
  589.     n = (u_char *) ngx_http_v3_encode_prefix_int(buf, inc, 6) - buf;

  591.     h3c = ngx_http_v3_get_session(c);
  592.     h3c->total_bytes += n;

  594.     if (dc->send(dc, buf, n) != (ssize_t) n) {
  595.         goto failed;
  596.     }

  598.     return NGX_OK;

  600. failed:

  602.     ngx_log_error(NGX_LOG_ERR, c->log, 0,
  603.                   "failed to send insert count increment");

  605.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  606.                                     "failed to send insert count increment");
  607.     ngx_http_v3_close_uni_stream(dc);

  609.     return NGX_ERROR;
  610. }


  613. ngx_int_t
  614. ‌ngx_http_v3_cancel_stream(ngx_connection_t *c, ngx_uint_t stream_id)
  615. {
  616.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  617.                    "http3 cancel stream %ui", stream_id);

  619.     /* we do not use dynamic tables */

  621.     return NGX_OK;
  622. }

One Level Up Top Level