One Level Up Top Level

src/http/v3/ngx_http_v3_uni.c - nginx-1.31.3 nginx/ @ 42f8df65b

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_uint_t                 streams;
  109.     ngx_http_v3_session_t     *h3c;
  110.     ngx_http_v3_uni_stream_t  *us;

  112.     h3c = ngx_http_v3_get_session(c);

  114.     switch (type) {

  116.     case NGX_HTTP_V3_STREAM_ENCODER:

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

  123.     case NGX_HTTP_V3_STREAM_DECODER:

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

  130.     case NGX_HTTP_V3_STREAM_CONTROL:

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

  136.         break;

  138.     default:

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

  143.         streams = (1 << NGX_HTTP_V3_STREAM_CLIENT_ENCODER)
  144.                   | (1 << NGX_HTTP_V3_STREAM_CLIENT_DECODER)
  145.                   | (1 << NGX_HTTP_V3_STREAM_CLIENT_CONTROL);

  147.         if ((h3c->created_streams & streams) != streams) {
  148.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "missing mandatory stream");
  149.             return NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR;
  150.         }

  152.         index = -1;
  153.     }

  155.     if (index >= 0) {
  156.         if (h3c->created_streams & (1 << index)) {
  157.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "stream already created");
  158.             return NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR;
  159.         }

  161.         h3c->known_streams[index] = c;
  162.         h3c->created_streams |= 1 << index;

  164.         us = c->data;
  165.         us->index = index;
  166.     }

  168.     return NGX_OK;
  169. }


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

  183.     c = rev->data;
  184.     us = c->data;

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

  188.     if (c->close) {
  189.         ngx_http_v3_close_uni_stream(c);
  190.         return;
  191.     }

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

  195.     while (rev->ready) {

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

  199.         if (n == NGX_ERROR) {
  200.             rc = NGX_HTTP_V3_ERR_INTERNAL_ERROR;
  201.             goto failed;
  202.         }

  204.         if (n == 0) {
  205.             if (us->index >= 0) {
  206.                 rc = NGX_HTTP_V3_ERR_CLOSED_CRITICAL_STREAM;
  207.                 goto failed;
  208.             }

  210.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 read eof");
  211.             ngx_http_v3_close_uni_stream(c);
  212.             return;
  213.         }

  215.         if (n == NGX_AGAIN) {
  216.             break;
  217.         }

  219.         b.pos = buf;
  220.         b.last = buf + n;

  222.         h3c = ngx_http_v3_get_session(c);
  223.         h3c->total_bytes += n;

  225.         if (ngx_http_v3_check_flood(c) != NGX_OK) {
  226.             ngx_http_v3_close_uni_stream(c);
  227.             return;
  228.         }

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

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

  239.         if (rc > 0) {
  240.             goto failed;
  241.         }

  243.         if (rc != NGX_AGAIN) {
  244.             rc = NGX_HTTP_V3_ERR_GENERAL_PROTOCOL_ERROR;
  245.             goto failed;
  246.         }
  247.     }

  249.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  250.         rc = NGX_HTTP_V3_ERR_INTERNAL_ERROR;
  251.         goto failed;
  252.     }

  254.     return;

  256. failed:

  258.     ngx_http_v3_finalize_connection(c, rc, "stream error");
  259.     ngx_http_v3_close_uni_stream(c);
  260. }


  263. static void
  264. ‌ngx_http_v3_uni_dummy_read_handler(ngx_event_t *rev)
  265. {
  266.     u_char             ch;
  267.     ngx_connection_t  *c;

  269.     c = rev->data;

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

  273.     if (c->close) {
  274.         ngx_http_v3_close_uni_stream(c);
  275.         return;
  276.     }

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

  286.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  287.         ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_INTERNAL_ERROR,
  288.                                         NULL);
  289.         ngx_http_v3_close_uni_stream(c);
  290.     }
  291. }


  294. static void
  295. ‌ngx_http_v3_uni_dummy_write_handler(ngx_event_t *wev)
  296. {
  297.     ngx_connection_t  *c;

  299.     c = wev->data;

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

  303.     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  304.         ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_INTERNAL_ERROR,
  305.                                         NULL);
  306.         ngx_http_v3_close_uni_stream(c);
  307.     }
  308. }


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

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

  335.     h3c = ngx_http_v3_get_session(c);

  337.     if (index >= 0) {
  338.         if (h3c->known_streams[index]) {
  339.             return h3c->known_streams[index];
  340.         }
  341.     }

  343.     sc = ngx_quic_open_stream(c, 0);
  344.     if (sc == NULL) {
  345.         goto failed;
  346.     }

  348.     ngx_quic_cancelable_stream(sc);

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

  353.     us = ngx_pcalloc(sc->pool, sizeof(ngx_http_v3_uni_stream_t));
  354.     if (us == NULL) {
  355.         goto failed;
  356.     }

  358.     us->index = index;

  360.     sc->data = us;

  362.     sc->read->handler = ngx_http_v3_uni_dummy_read_handler;
  363.     sc->write->handler = ngx_http_v3_uni_dummy_write_handler;

  365.     if (index >= 0) {
  366.         h3c->known_streams[index] = sc;
  367.     }

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

  371.     h3c = ngx_http_v3_get_session(c);
  372.     h3c->total_bytes += n;

  374.     if (sc->send(sc, buf, n) != (ssize_t) n) {
  375.         goto failed;
  376.     }

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

  380.     return sc;

  382. failed:

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

  386.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_STREAM_CREATION_ERROR,
  387.                                     "failed to create server stream");
  388.     if (sc) {
  389.         ngx_http_v3_close_uni_stream(sc);
  390.     }

  392.     return NULL;
  393. }


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

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

  407.     cc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_CONTROL);
  408.     if (cc == NULL) {
  409.         return NGX_ERROR;
  410.     }

  412.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  414.     n = ngx_http_v3_encode_varlen_int(NULL,
  415.                                       NGX_HTTP_V3_PARAM_MAX_TABLE_CAPACITY);
  416.     n += ngx_http_v3_encode_varlen_int(NULL, h3scf->max_table_capacity);
  417.     n += ngx_http_v3_encode_varlen_int(NULL, NGX_HTTP_V3_PARAM_BLOCKED_STREAMS);
  418.     n += ngx_http_v3_encode_varlen_int(NULL, h3scf->max_blocked_streams);

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

  431.     h3c = ngx_http_v3_get_session(c);
  432.     h3c->total_bytes += n;

  434.     if (cc->send(cc, buf, n) != (ssize_t) n) {
  435.         goto failed;
  436.     }

  438.     return NGX_OK;

  440. failed:

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

  444.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  445.                                     "failed to send settings");
  446.     ngx_http_v3_close_uni_stream(cc);

  448.     return NGX_ERROR;
  449. }


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

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

  462.     cc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_CONTROL);
  463.     if (cc == NULL) {
  464.         return NGX_ERROR;
  465.     }

  467.     n = ngx_http_v3_encode_varlen_int(NULL, id);
  468.     p = (u_char *) ngx_http_v3_encode_varlen_int(buf, NGX_HTTP_V3_FRAME_GOAWAY);
  469.     p = (u_char *) ngx_http_v3_encode_varlen_int(p, n);
  470.     p = (u_char *) ngx_http_v3_encode_varlen_int(p, id);
  471.     n = p - buf;

  473.     h3c = ngx_http_v3_get_session(c);
  474.     h3c->total_bytes += n;

  476.     if (cc->send(cc, buf, n) != (ssize_t) n) {
  477.         goto failed;
  478.     }

  480.     return NGX_OK;

  482. failed:

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

  486.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  487.                                     "failed to send goaway");
  488.     ngx_http_v3_close_uni_stream(cc);

  490.     return NGX_ERROR;
  491. }


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

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

  505.     dc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_DECODER);
  506.     if (dc == NULL) {
  507.         return NGX_ERROR;
  508.     }

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

  513.     h3c = ngx_http_v3_get_session(c);
  514.     h3c->total_bytes += n;

  516.     if (dc->send(dc, buf, n) != (ssize_t) n) {
  517.         goto failed;
  518.     }

  520.     return NGX_OK;

  522. failed:

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

  527.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  528.                                     "failed to send section acknowledgement");
  529.     ngx_http_v3_close_uni_stream(dc);

  531.     return NGX_ERROR;
  532. }


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

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

  546.     dc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_DECODER);
  547.     if (dc == NULL) {
  548.         return NGX_ERROR;
  549.     }

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

  554.     h3c = ngx_http_v3_get_session(c);
  555.     h3c->total_bytes += n;

  557.     if (dc->send(dc, buf, n) != (ssize_t) n) {
  558.         goto failed;
  559.     }

  561.     return NGX_OK;

  563. failed:

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

  567.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  568.                                     "failed to send stream cancellation");
  569.     ngx_http_v3_close_uni_stream(dc);

  571.     return NGX_ERROR;
  572. }


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

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

  586.     dc = ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_DECODER);
  587.     if (dc == NULL) {
  588.         return NGX_ERROR;
  589.     }

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

  594.     h3c = ngx_http_v3_get_session(c);
  595.     h3c->total_bytes += n;

  597.     if (dc->send(dc, buf, n) != (ssize_t) n) {
  598.         goto failed;
  599.     }

  601.     return NGX_OK;

  603. failed:

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

  608.     ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  609.                                     "failed to send insert count increment");
  610.     ngx_http_v3_close_uni_stream(dc);

  612.     return NGX_ERROR;
  613. }


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

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

  624.     return NGX_OK;
  625. }

One Level Up Top Level