One Level Up Top Level

src/event/quic/ngx_event_quic_frames.c - nginx source code

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_BUFFER_SIZE  4096

  15. ‌#define ngx_quic_buf_refs(b)         (b)->shadow->num
  16. ‌#define ngx_quic_buf_inc_refs(b)     ngx_quic_buf_refs(b)++
  17. ‌#define ngx_quic_buf_dec_refs(b)     ngx_quic_buf_refs(b)--
  18. ‌#define ngx_quic_buf_set_refs(b, v)  ngx_quic_buf_refs(b) = v


  21. static ngx_buf_t *ngx_quic_alloc_buf(ngx_connection_t *c);
  22. static void ngx_quic_free_buf(ngx_connection_t *c, ngx_buf_t *b);
  23. static ngx_buf_t *ngx_quic_clone_buf(ngx_connection_t *c, ngx_buf_t *b);
  24. static ngx_int_t ngx_quic_split_chain(ngx_connection_t *c, ngx_chain_t *cl,
  25.     off_t offset);


  28. static ngx_buf_t *
  29. ‌ngx_quic_alloc_buf(ngx_connection_t *c)
  30. {
  31.     u_char                 *p;
  32.     ngx_buf_t              *b;
  33.     ngx_quic_connection_t  *qc;

  35.     qc = ngx_quic_get_connection(c);

  37.     b = qc->free_bufs;

  39.     if (b) {
  40.         qc->free_bufs = b->shadow;
  41.         p = b->start;

  43.     } else {
  44.         b = qc->free_shadow_bufs;

  46.         if (b) {
  47.             qc->free_shadow_bufs = b->shadow;

  49. #ifdef NGX_QUIC_DEBUG_ALLOC
  50.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  51.                            "quic use shadow buffer n:%ui %ui",
  52.                            ++qc->nbufs, --qc->nshadowbufs);
  53. #endif

  55.         } else {
  56.             b = ngx_palloc(c->pool, sizeof(ngx_buf_t));
  57.             if (b == NULL) {
  58.                 return NULL;
  59.             }

  61. #ifdef NGX_QUIC_DEBUG_ALLOC
  62.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  63.                            "quic new buffer n:%ui", ++qc->nbufs);
  64. #endif
  65.         }

  67.         p = ngx_pnalloc(c->pool, NGX_QUIC_BUFFER_SIZE);
  68.         if (p == NULL) {
  69.             return NULL;
  70.         }
  71.     }

  73. #ifdef NGX_QUIC_DEBUG_ALLOC
  74.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic alloc buffer %p", b);
  75. #endif

  77.     ngx_memzero(b, sizeof(ngx_buf_t));

  79.     b->tag = (ngx_buf_tag_t) &ngx_quic_alloc_buf;
  80.     b->temporary = 1;
  81.     b->shadow = b;

  83.     b->start = p;
  84.     b->pos = p;
  85.     b->last = p;
  86.     b->end = p + NGX_QUIC_BUFFER_SIZE;

  88.     ngx_quic_buf_set_refs(b, 1);

  90.     return b;
  91. }


  94. static void
  95. ‌ngx_quic_free_buf(ngx_connection_t *c, ngx_buf_t *b)
  96. {
  97.     ngx_buf_t              *shadow;
  98.     ngx_quic_connection_t  *qc;

  100.     qc = ngx_quic_get_connection(c);

  102.     ngx_quic_buf_dec_refs(b);

  104. #ifdef NGX_QUIC_DEBUG_ALLOC
  105.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  106.                    "quic free buffer %p r:%ui",
  107.                    b, (ngx_uint_t) ngx_quic_buf_refs(b));
  108. #endif

  110.     shadow = b->shadow;

  112.     if (ngx_quic_buf_refs(b) == 0) {
  113.         shadow->shadow = qc->free_bufs;
  114.         qc->free_bufs = shadow;
  115.     }

  117.     if (b != shadow) {
  118.         b->shadow = qc->free_shadow_bufs;
  119.         qc->free_shadow_bufs = b;
  120.     }

  122. }


  125. static ngx_buf_t *
  126. ‌ngx_quic_clone_buf(ngx_connection_t *c, ngx_buf_t *b)
  127. {
  128.     ngx_buf_t              *nb;
  129.     ngx_quic_connection_t  *qc;

  131.     qc = ngx_quic_get_connection(c);

  133.     nb = qc->free_shadow_bufs;

  135.     if (nb) {
  136.         qc->free_shadow_bufs = nb->shadow;

  138.     } else {
  139.         nb = ngx_palloc(c->pool, sizeof(ngx_buf_t));
  140.         if (nb == NULL) {
  141.             return NULL;
  142.         }

  144. #ifdef NGX_QUIC_DEBUG_ALLOC
  145.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  146.                        "quic new shadow buffer n:%ui", ++qc->nshadowbufs);
  147. #endif
  148.     }

  150.     *nb = *b;

  152.     ngx_quic_buf_inc_refs(b);

  154. #ifdef NGX_QUIC_DEBUG_ALLOC
  155.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  156.                    "quic clone buffer %p %p r:%ui",
  157.                    b, nb, (ngx_uint_t) ngx_quic_buf_refs(b));
  158. #endif

  160.     return nb;
  161. }


  164. static ngx_int_t
  165. ‌ngx_quic_split_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t offset)
  166. {
  167.     ngx_buf_t    *b, *tb;
  168.     ngx_chain_t  *tail;

  170.     b = cl->buf;

  172.     tail = ngx_alloc_chain_link(c->pool);
  173.     if (tail == NULL) {
  174.         return NGX_ERROR;
  175.     }

  177.     tb = ngx_quic_clone_buf(c, b);
  178.     if (tb == NULL) {
  179.         return NGX_ERROR;
  180.     }

  182.     tail->buf = tb;

  184.     tb->pos += offset;

  186.     b->last = tb->pos;
  187.     b->last_buf = 0;

  189.     tail->next = cl->next;
  190.     cl->next = tail;

  192.     return NGX_OK;
  193. }


  196. ngx_quic_frame_t *
  197. ‌ngx_quic_alloc_frame(ngx_connection_t *c)
  198. {
  199.     ngx_queue_t            *q;
  200.     ngx_quic_frame_t       *frame;
  201.     ngx_quic_connection_t  *qc;

  203.     qc = ngx_quic_get_connection(c);

  205.     if (!ngx_queue_empty(&qc->free_frames)) {

  207.         q = ngx_queue_head(&qc->free_frames);
  208.         frame = ngx_queue_data(q, ngx_quic_frame_t, queue);

  210.         ngx_queue_remove(&frame->queue);

  212. #ifdef NGX_QUIC_DEBUG_ALLOC
  213.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  214.                        "quic reuse frame n:%ui", qc->nframes);
  215. #endif

  217.     } else if (qc->nframes < 10000) {
  218.         frame = ngx_palloc(c->pool, sizeof(ngx_quic_frame_t));
  219.         if (frame == NULL) {
  220.             return NULL;
  221.         }

  223.         ++qc->nframes;

  225. #ifdef NGX_QUIC_DEBUG_ALLOC
  226.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  227.                        "quic alloc frame n:%ui", qc->nframes);
  228. #endif

  230.     } else {
  231.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "quic flood detected");
  232.         return NULL;
  233.     }

  235.     ngx_memzero(frame, sizeof(ngx_quic_frame_t));

  237.     return frame;
  238. }


  241. void
  242. ‌ngx_quic_free_frame(ngx_connection_t *c, ngx_quic_frame_t *frame)
  243. {
  244.     ngx_quic_connection_t  *qc;

  246.     qc = ngx_quic_get_connection(c);

  248.     if (frame->data) {
  249.         ngx_quic_free_chain(c, frame->data);
  250.     }

  252.     ngx_queue_insert_head(&qc->free_frames, &frame->queue);

  254. #ifdef NGX_QUIC_DEBUG_ALLOC
  255.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  256.                    "quic free frame n:%ui", qc->nframes);
  257. #endif
  258. }


  261. void
  262. ‌ngx_quic_free_chain(ngx_connection_t *c, ngx_chain_t *in)
  263. {
  264.     ngx_chain_t  *cl;

  266.     while (in) {
  267.         cl = in;
  268.         in = in->next;

  270.         ngx_quic_free_buf(c, cl->buf);
  271.         ngx_free_chain(c->pool, cl);
  272.     }
  273. }


  276. void
  277. ‌ngx_quic_free_frames(ngx_connection_t *c, ngx_queue_t *frames)
  278. {
  279.     ngx_queue_t       *q;
  280.     ngx_quic_frame_t  *f;

  282.     do {
  283.         q = ngx_queue_head(frames);

  285.         if (q == ngx_queue_sentinel(frames)) {
  286.             break;
  287.         }

  289.         ngx_queue_remove(q);

  291.         f = ngx_queue_data(q, ngx_quic_frame_t, queue);

  293.         ngx_quic_free_frame(c, f);
  294.     } while (1);
  295. }


  298. void
  299. ‌ngx_quic_queue_frame(ngx_quic_connection_t *qc, ngx_quic_frame_t *frame)
  300. {
  301.     ngx_quic_send_ctx_t  *ctx;

  303.     ctx = ngx_quic_get_send_ctx(qc, frame->level);

  305.     ngx_queue_insert_tail(&ctx->frames, &frame->queue);

  307.     frame->len = ngx_quic_create_frame(NULL, frame);
  308.     /* always succeeds */

  310.     if (qc->closing) {
  311.         return;
  312.     }

  314.     ngx_post_event(&qc->push, &ngx_posted_events);
  315. }


  318. ngx_int_t
  319. ‌ngx_quic_split_frame(ngx_connection_t *c, ngx_quic_frame_t *f, size_t len)
  320. {
  321.     size_t                     shrink;
  322.     ngx_chain_t               *out;
  323.     ngx_quic_frame_t          *nf;
  324.     ngx_quic_buffer_t          qb;
  325.     ngx_quic_ordered_frame_t  *of, *onf;

  327.     switch (f->type) {
  328.     case NGX_QUIC_FT_CRYPTO:
  329.     case NGX_QUIC_FT_STREAM:
  330.         break;

  332.     default:
  333.         return NGX_DECLINED;
  334.     }

  336.     if ((size_t) f->len <= len) {
  337.         return NGX_OK;
  338.     }

  340.     shrink = f->len - len;

  342.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  343.                    "quic split frame now:%uz need:%uz shrink:%uz",
  344.                    f->len, len, shrink);

  346.     of = &f->u.ord;

  348.     if (of->length <= shrink) {
  349.         return NGX_DECLINED;
  350.     }

  352.     of->length -= shrink;
  353.     f->len = ngx_quic_create_frame(NULL, f);

  355.     if ((size_t) f->len > len) {
  356.         ngx_log_error(NGX_LOG_ERR, c->log, 0, "could not split QUIC frame");
  357.         return NGX_ERROR;
  358.     }

  360.     ngx_memzero(&qb, sizeof(ngx_quic_buffer_t));
  361.     qb.chain = f->data;

  363.     out = ngx_quic_read_buffer(c, &qb, of->length);
  364.     if (out == NGX_CHAIN_ERROR) {
  365.         return NGX_ERROR;
  366.     }

  368.     f->data = out;

  370.     nf = ngx_quic_alloc_frame(c);
  371.     if (nf == NULL) {
  372.         return NGX_ERROR;
  373.     }

  375.     *nf = *f;
  376.     onf = &nf->u.ord;
  377.     onf->offset += of->length;
  378.     onf->length = shrink;
  379.     nf->len = ngx_quic_create_frame(NULL, nf);
  380.     nf->data = qb.chain;

  382.     if (f->type == NGX_QUIC_FT_STREAM) {
  383.         f->u.stream.fin = 0;
  384.     }

  386.     ngx_queue_insert_after(&f->queue, &nf->queue);

  388.     return NGX_OK;
  389. }


  392. ngx_chain_t *
  393. ‌ngx_quic_copy_buffer(ngx_connection_t *c, u_char *data, size_t len)
  394. {
  395.     ngx_buf_t          buf;
  396.     ngx_chain_t        cl, *out;
  397.     ngx_quic_buffer_t  qb;

  399.     ngx_memzero(&buf, sizeof(ngx_buf_t));

  401.     buf.pos = data;
  402.     buf.last = buf.pos + len;
  403.     buf.temporary = 1;

  405.     cl.buf = &buf;
  406.     cl.next = NULL;

  408.     ngx_memzero(&qb, sizeof(ngx_quic_buffer_t));

  410.     if (ngx_quic_write_buffer(c, &qb, &cl, len, 0) == NGX_CHAIN_ERROR) {
  411.         return NGX_CHAIN_ERROR;
  412.     }

  414.     out = ngx_quic_read_buffer(c, &qb, len);
  415.     if (out == NGX_CHAIN_ERROR) {
  416.         return NGX_CHAIN_ERROR;
  417.     }

  419.     ngx_quic_free_buffer(c, &qb);

  421.     return out;
  422. }


  425. ngx_chain_t *
  426. ‌ngx_quic_read_buffer(ngx_connection_t *c, ngx_quic_buffer_t *qb, uint64_t limit)
  427. {
  428.     uint64_t      n;
  429.     ngx_buf_t    *b;
  430.     ngx_chain_t  *out, **ll;

  432.     out = qb->chain;

  434.     for (ll = &out; *ll; ll = &(*ll)->next) {
  435.         b = (*ll)->buf;

  437.         if (b->sync) {
  438.             /* hole */
  439.             break;
  440.         }

  442.         if (limit == 0) {
  443.             break;
  444.         }

  446.         n = b->last - b->pos;

  448.         if (n > limit) {
  449.             if (ngx_quic_split_chain(c, *ll, limit) != NGX_OK) {
  450.                 return NGX_CHAIN_ERROR;
  451.             }

  453.             n = limit;
  454.         }

  456.         limit -= n;
  457.         qb->offset += n;
  458.     }

  460.     if (qb->offset >= qb->last_offset) {
  461.         qb->last_chain = NULL;
  462.     }

  464.     qb->chain = *ll;
  465.     *ll = NULL;

  467.     return out;
  468. }


  471. void
  472. ‌ngx_quic_skip_buffer(ngx_connection_t *c, ngx_quic_buffer_t *qb,
  473.     uint64_t offset)
  474. {
  475.     size_t        n;
  476.     ngx_buf_t    *b;
  477.     ngx_chain_t  *cl;

  479.     while (qb->chain) {
  480.         if (qb->offset >= offset) {
  481.             break;
  482.         }

  484.         cl = qb->chain;
  485.         b = cl->buf;
  486.         n = b->last - b->pos;

  488.         if (qb->offset + n > offset) {
  489.             n = offset - qb->offset;
  490.             b->pos += n;
  491.             qb->offset += n;
  492.             break;
  493.         }

  495.         qb->offset += n;
  496.         qb->chain = cl->next;

  498.         cl->next = NULL;
  499.         ngx_quic_free_chain(c, cl);
  500.     }

  502.     if (qb->chain == NULL) {
  503.         qb->offset = offset;
  504.     }

  506.     if (qb->offset >= qb->last_offset) {
  507.         qb->last_chain = NULL;
  508.     }
  509. }


  512. ngx_chain_t *
  513. ‌ngx_quic_alloc_chain(ngx_connection_t *c)
  514. {
  515.     ngx_chain_t  *cl;

  517.     cl = ngx_alloc_chain_link(c->pool);
  518.     if (cl == NULL) {
  519.         return NULL;
  520.     }

  522.     cl->buf = ngx_quic_alloc_buf(c);
  523.     if (cl->buf == NULL) {
  524.         return NULL;
  525.     }

  527.     return cl;
  528. }


  531. ngx_chain_t *
  532. ‌ngx_quic_write_buffer(ngx_connection_t *c, ngx_quic_buffer_t *qb,
  533.     ngx_chain_t *in, uint64_t limit, uint64_t offset)
  534. {
  535.     u_char       *p;
  536.     uint64_t      n, base;
  537.     ngx_buf_t    *b;
  538.     ngx_chain_t  *cl, **chain;

  540.     if (qb->last_chain && offset >= qb->last_offset) {
  541.         base = qb->last_offset;
  542.         chain = &qb->last_chain;

  544.     } else {
  545.         base = qb->offset;
  546.         chain = &qb->chain;
  547.     }

  549.     while (in && limit) {

  551.         if (offset < base) {
  552.             n = ngx_min((uint64_t) (in->buf->last - in->buf->pos),
  553.                         ngx_min(base - offset, limit));

  555.             in->buf->pos += n;
  556.             offset += n;
  557.             limit -= n;

  559.             if (in->buf->pos == in->buf->last) {
  560.                 in = in->next;
  561.             }

  563.             continue;
  564.         }

  566.         cl = *chain;

  568.         if (cl == NULL) {
  569.             cl = ngx_quic_alloc_chain(c);
  570.             if (cl == NULL) {
  571.                 return NGX_CHAIN_ERROR;
  572.             }

  574.             cl->buf->last = cl->buf->end;
  575.             cl->buf->sync = 1; /* hole */
  576.             cl->next = NULL;
  577.             *chain = cl;
  578.         }

  580.         b = cl->buf;
  581.         n = b->last - b->pos;

  583.         if (base + n <= offset) {
  584.             base += n;
  585.             chain = &cl->next;
  586.             continue;
  587.         }

  589.         if (b->sync && offset > base) {
  590.             if (ngx_quic_split_chain(c, cl, offset - base) != NGX_OK) {
  591.                 return NGX_CHAIN_ERROR;
  592.             }

  594.             continue;
  595.         }

  597.         p = b->pos + (offset - base);

  599.         while (in) {

  601.             if (!ngx_buf_in_memory(in->buf) || in->buf->pos == in->buf->last) {
  602.                 in = in->next;
  603.                 continue;
  604.             }

  606.             if (p == b->last || limit == 0) {
  607.                 break;
  608.             }

  610.             n = ngx_min(b->last - p, in->buf->last - in->buf->pos);
  611.             n = ngx_min(n, limit);

  613.             if (b->sync) {
  614.                 ngx_memcpy(p, in->buf->pos, n);
  615.                 qb->size += n;
  616.             }

  618.             p += n;
  619.             in->buf->pos += n;
  620.             offset += n;
  621.             limit -= n;
  622.         }

  624.         if (b->sync && p == b->last) {
  625.             b->sync = 0;
  626.             continue;
  627.         }

  629.         if (b->sync && p != b->pos) {
  630.             if (ngx_quic_split_chain(c, cl, p - b->pos) != NGX_OK) {
  631.                 return NGX_CHAIN_ERROR;
  632.             }

  634.             b->sync = 0;
  635.         }
  636.     }

  638.     qb->last_offset = base;
  639.     qb->last_chain = *chain;

  641.     return in;
  642. }


  645. void
  646. ‌ngx_quic_free_buffer(ngx_connection_t *c, ngx_quic_buffer_t *qb)
  647. {
  648.     ngx_quic_free_chain(c, qb->chain);

  650.     qb->chain = NULL;
  651.     qb->last_chain = NULL;
  652. }


  655. #if (NGX_DEBUG)

  657. void
  658. ‌ngx_quic_log_frame(ngx_log_t *log, ngx_quic_frame_t *f, ngx_uint_t tx)
  659. {
  660.     u_char      *p, *last, *pos, *end;
  661.     ssize_t      n;
  662.     uint64_t     gap, range, largest, smallest;
  663.     ngx_uint_t   i;
  664.     u_char       buf[NGX_MAX_ERROR_STR];

  666.     p = buf;
  667.     last = buf + sizeof(buf);

  669.     switch (f->type) {

  671.     case NGX_QUIC_FT_CRYPTO:
  672.         p = ngx_slprintf(p, last, "CRYPTO len:%uL off:%uL",
  673.                          f->u.crypto.length, f->u.crypto.offset);

  675. #ifdef NGX_QUIC_DEBUG_FRAMES
  676.         {
  677.             ngx_chain_t  *cl;

  679.             p = ngx_slprintf(p, last, " data:");

  681.             for (cl = f->data; cl; cl = cl->next) {
  682.                 p = ngx_slprintf(p, last, "%*xs",
  683.                                  cl->buf->last - cl->buf->pos, cl->buf->pos);
  684.             }
  685.         }
  686. #endif

  688.         break;

  690.     case NGX_QUIC_FT_PADDING:
  691.         p = ngx_slprintf(p, last, "PADDING");
  692.         break;

  694.     case NGX_QUIC_FT_ACK:
  695.     case NGX_QUIC_FT_ACK_ECN:

  697.         p = ngx_slprintf(p, last, "ACK n:%ui delay:%uL ",
  698.                          f->u.ack.range_count, f->u.ack.delay);

  700.         if (f->data) {
  701.             pos = f->data->buf->pos;
  702.             end = f->data->buf->last;

  704.         } else {
  705.             pos = NULL;
  706.             end = NULL;
  707.         }

  709.         largest = f->u.ack.largest;
  710.         smallest = f->u.ack.largest - f->u.ack.first_range;

  712.         if (largest == smallest) {
  713.             p = ngx_slprintf(p, last, "%uL", largest);

  715.         } else {
  716.             p = ngx_slprintf(p, last, "%uL-%uL", largest, smallest);
  717.         }

  719.         for (i = 0; i < f->u.ack.range_count; i++) {
  720.             n = ngx_quic_parse_ack_range(log, pos, end, &gap, &range);
  721.             if (n == NGX_ERROR) {
  722.                 break;
  723.             }

  725.             pos += n;

  727.             largest = smallest - gap - 2;
  728.             smallest = largest - range;

  730.             if (largest == smallest) {
  731.                 p = ngx_slprintf(p, last, " %uL", largest);

  733.             } else {
  734.                 p = ngx_slprintf(p, last, " %uL-%uL", largest, smallest);
  735.             }
  736.         }

  738.         if (f->type == NGX_QUIC_FT_ACK_ECN) {
  739.             p = ngx_slprintf(p, last, " ECN counters ect0:%uL ect1:%uL ce:%uL",
  740.                              f->u.ack.ect0, f->u.ack.ect1, f->u.ack.ce);
  741.         }
  742.         break;

  744.     case NGX_QUIC_FT_PING:
  745.         p = ngx_slprintf(p, last, "PING");
  746.         break;

  748.     case NGX_QUIC_FT_NEW_CONNECTION_ID:
  749.         p = ngx_slprintf(p, last,
  750.                          "NEW_CONNECTION_ID seq:%uL retire:%uL len:%ud",
  751.                          f->u.ncid.seqnum, f->u.ncid.retire, f->u.ncid.len);
  752.         break;

  754.     case NGX_QUIC_FT_RETIRE_CONNECTION_ID:
  755.         p = ngx_slprintf(p, last, "RETIRE_CONNECTION_ID seqnum:%uL",
  756.                          f->u.retire_cid.sequence_number);
  757.         break;

  759.     case NGX_QUIC_FT_CONNECTION_CLOSE:
  760.     case NGX_QUIC_FT_CONNECTION_CLOSE_APP:
  761.         p = ngx_slprintf(p, last, "CONNECTION_CLOSE%s err:%ui",
  762.                          f->type == NGX_QUIC_FT_CONNECTION_CLOSE ? "" : "_APP",
  763.                          f->u.close.error_code);

  765.         if (f->u.close.reason.len) {
  766.             p = ngx_slprintf(p, last, " %V", &f->u.close.reason);
  767.         }

  769.         if (f->type == NGX_QUIC_FT_CONNECTION_CLOSE) {
  770.             p = ngx_slprintf(p, last, " ft:%ui", f->u.close.frame_type);
  771.         }

  773.         break;

  775.     case NGX_QUIC_FT_STREAM:
  776.         p = ngx_slprintf(p, last, "STREAM id:0x%xL", f->u.stream.stream_id);

  778.         if (f->u.stream.off) {
  779.             p = ngx_slprintf(p, last, " off:%uL", f->u.stream.offset);
  780.         }

  782.         if (f->u.stream.len) {
  783.             p = ngx_slprintf(p, last, " len:%uL", f->u.stream.length);
  784.         }

  786.         if (f->u.stream.fin) {
  787.             p = ngx_slprintf(p, last, " fin:1");
  788.         }

  790. #ifdef NGX_QUIC_DEBUG_FRAMES
  791.         {
  792.             ngx_chain_t  *cl;

  794.             p = ngx_slprintf(p, last, " data:");

  796.             for (cl = f->data; cl; cl = cl->next) {
  797.                 p = ngx_slprintf(p, last, "%*xs",
  798.                                  cl->buf->last - cl->buf->pos, cl->buf->pos);
  799.             }
  800.         }
  801. #endif

  803.         break;

  805.     case NGX_QUIC_FT_MAX_DATA:
  806.         p = ngx_slprintf(p, last, "MAX_DATA max_data:%uL on recv",
  807.                          f->u.max_data.max_data);
  808.         break;

  810.     case NGX_QUIC_FT_RESET_STREAM:
  811.         p = ngx_slprintf(p, last, "RESET_STREAM"
  812.                         " id:0x%xL error_code:0x%xL final_size:0x%xL",
  813.                         f->u.reset_stream.id, f->u.reset_stream.error_code,
  814.                         f->u.reset_stream.final_size);
  815.         break;

  817.     case NGX_QUIC_FT_STOP_SENDING:
  818.         p = ngx_slprintf(p, last, "STOP_SENDING id:0x%xL err:0x%xL",
  819.                          f->u.stop_sending.id, f->u.stop_sending.error_code);
  820.         break;

  822.     case NGX_QUIC_FT_STREAMS_BLOCKED:
  823.     case NGX_QUIC_FT_STREAMS_BLOCKED2:
  824.         p = ngx_slprintf(p, last, "STREAMS_BLOCKED limit:%uL bidi:%ui",
  825.                          f->u.streams_blocked.limit, f->u.streams_blocked.bidi);
  826.         break;

  828.     case NGX_QUIC_FT_MAX_STREAMS:
  829.     case NGX_QUIC_FT_MAX_STREAMS2:
  830.         p = ngx_slprintf(p, last, "MAX_STREAMS limit:%uL bidi:%ui",
  831.                          f->u.max_streams.limit, f->u.max_streams.bidi);
  832.         break;

  834.     case NGX_QUIC_FT_MAX_STREAM_DATA:
  835.         p = ngx_slprintf(p, last, "MAX_STREAM_DATA id:0x%xL limit:%uL",
  836.                          f->u.max_stream_data.id, f->u.max_stream_data.limit);
  837.         break;


  840.     case NGX_QUIC_FT_DATA_BLOCKED:
  841.         p = ngx_slprintf(p, last, "DATA_BLOCKED limit:%uL",
  842.                          f->u.data_blocked.limit);
  843.         break;

  845.     case NGX_QUIC_FT_STREAM_DATA_BLOCKED:
  846.         p = ngx_slprintf(p, last, "STREAM_DATA_BLOCKED id:0x%xL limit:%uL",
  847.                          f->u.stream_data_blocked.id,
  848.                          f->u.stream_data_blocked.limit);
  849.         break;

  851.     case NGX_QUIC_FT_PATH_CHALLENGE:
  852.         p = ngx_slprintf(p, last, "PATH_CHALLENGE data:0x%*xs",
  853.                          sizeof(f->u.path_challenge.data),
  854.                          f->u.path_challenge.data);
  855.         break;

  857.     case NGX_QUIC_FT_PATH_RESPONSE:
  858.         p = ngx_slprintf(p, last, "PATH_RESPONSE data:0x%*xs",
  859.                          sizeof(f->u.path_challenge.data),
  860.                          f->u.path_challenge.data);
  861.         break;

  863.     case NGX_QUIC_FT_NEW_TOKEN:
  864.         p = ngx_slprintf(p, last, "NEW_TOKEN");

  866. #ifdef NGX_QUIC_DEBUG_FRAMES
  867.         {
  868.             ngx_chain_t  *cl;

  870.             p = ngx_slprintf(p, last, " token:");

  872.             for (cl = f->data; cl; cl = cl->next) {
  873.                 p = ngx_slprintf(p, last, "%*xs",
  874.                                  cl->buf->last - cl->buf->pos, cl->buf->pos);
  875.             }
  876.         }
  877. #endif

  879.         break;

  881.     case NGX_QUIC_FT_HANDSHAKE_DONE:
  882.         p = ngx_slprintf(p, last, "HANDSHAKE DONE");
  883.         break;

  885.     default:
  886.         p = ngx_slprintf(p, last, "unknown type 0x%xi", f->type);
  887.         break;
  888.     }

  890.     ngx_log_debug5(NGX_LOG_DEBUG_EVENT, log, 0, "quic frame %s %s:%uL %*s",
  891.                    tx ? "tx" : "rx", ngx_quic_level_name(f->level), f->pnum,
  892.                    p - buf, buf);
  893. }

  895. #endif

One Level Up Top Level