nginx: src/event/ngx_event_quic.c comparison

comparison src/event/ngx_event_quic.c @ 8657:2dfc5ef29973 quic

QUIC: introduced QUIC buffers. Buffers are used to hold frame data. They have a fixed size and are reused after being freed.

author	Roman Arutyunyan <arut@nginx.com>
date	Tue, 01 Dec 2020 19:11:01 +0000
parents	43f3574b3e6f
children	0af4ec6d1f92

comparison

equal deleted inserted replaced

-:43f3574b3e6f
+:2dfc5ef29973
 ngx_quic_conf_t                  *conf;
 ngx_event_t                       push;
 ngx_event_t                       pto;
 ngx_event_t                       close;
-ngx_queue_t                       free_frames;
 ngx_msec_t                        last_cc;
 ngx_msec_t                        latest_rtt;
 ngx_msec_t                        avg_rtt;
 ngx_msec_t                        min_rtt;
 ngx_msec_t                        rttvar;
 ngx_uint_t                        pto_count;
-#if (NGX_DEBUG)
+ngx_queue_t                       free_frames;
+ngx_chain_t                      *free_bufs;
+#ifdef NGX_QUIC_DEBUG_ALLOC
 ngx_uint_t                        nframes;
+ngx_uint_t                        nbufs;
 #endif
 ngx_quic_streams_t                streams;
 ngx_quic_congestion_t             congestion;
 size_t                            received;
 ngx_quic_send_ctx_t *ctx);
 static ngx_int_t ngx_quic_send_cc(ngx_connection_t *c);
 static ngx_int_t ngx_quic_send_new_token(ngx_connection_t *c);
 static ngx_int_t ngx_quic_handle_ack_frame(ngx_connection_t *c,
-ngx_quic_header_t *pkt, ngx_quic_ack_frame_t *f);
+ngx_quic_header_t *pkt, ngx_quic_frame_t *f);
 static ngx_int_t ngx_quic_handle_ack_frame_range(ngx_connection_t *c,
 ngx_quic_send_ctx_t *ctx, uint64_t min, uint64_t max,
 ngx_msec_t *send_time);
 static void ngx_quic_rtt_sample(ngx_connection_t *c, ngx_quic_ack_frame_t *ack,
 enum ssl_encryption_level_t level, ngx_msec_t send_time);
 static ngx_chain_t *ngx_quic_stream_send_chain(ngx_connection_t *c,
 ngx_chain_t *in, off_t limit);
 static size_t ngx_quic_max_stream_frame(ngx_quic_connection_t *qc);
 static size_t ngx_quic_max_stream_flow(ngx_connection_t *c);
 static void ngx_quic_stream_cleanup_handler(void *data);
-static ngx_quic_frame_t *ngx_quic_alloc_frame(ngx_connection_t *c, size_t size);
+static ngx_quic_frame_t *ngx_quic_alloc_frame(ngx_connection_t *c);
 static void ngx_quic_free_frame(ngx_connection_t *c, ngx_quic_frame_t *frame);
 static void ngx_quic_congestion_ack(ngx_connection_t *c,
 ngx_quic_frame_t *frame);
 static void ngx_quic_congestion_lost(ngx_connection_t *c,
 ngx_quic_frame_t *frame);
+static ngx_chain_t *ngx_quic_alloc_buf(ngx_connection_t *c);
+static void ngx_quic_free_bufs(ngx_connection_t *c, ngx_chain_t *in);
+static ngx_chain_t *ngx_quic_copy_buf(ngx_connection_t *c, u_char *data,
+size_t len);
+static ngx_chain_t *ngx_quic_copy_chain(ngx_connection_t *c, ngx_chain_t *in,
+size_t limit);
 static SSL_QUIC_METHOD quic_method = {
 #if BORINGSSL_API_VERSION >= 10
 ngx_quic_set_read_secret,
 case NGX_QUIC_FT_ACK_ECN:
 p = ngx_slprintf(p, last, "ACK n:%ui delay:%uL ",
 f->u.ack.range_count, f->u.ack.delay);
-pos = f->u.ack.ranges_start;
+if (f->data) {
-end = f->u.ack.ranges_end;
+pos = f->data->buf->pos;
+end = f->data->buf->end;
+} else {
+pos = NULL;
+end = NULL;
+}
 largest = f->u.ack.largest;
 smallest = f->u.ack.largest - f->u.ack.first_range;
 if (largest == smallest) {
 if (f->u.stream.fin) {
 p = ngx_slprintf(p, last, " fin:1");
 }
 #ifdef NGX_QUIC_DEBUG_FRAMES
-p = ngx_slprintf(p, last, " data len:%uL %*xs", f->u.stream.length,
+{
-(size_t) f->u.stream.length, f->u.stream.data);
+ngx_chain_t  *cl;
+p = ngx_slprintf(p, last, " data:");
+for (cl = f->data; cl; cl = cl->next) {
+p = ngx_slprintf(p, last, "%*xs",
+cl->buf->last - cl->buf->pos, cl->buf->pos);
+}
+}
 #endif
 break;
 case NGX_QUIC_FT_MAX_DATA:
 while (p < end) {
 fsize = ngx_min(limit, (size_t) (end - p));
-frame = ngx_quic_alloc_frame(c, fsize);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return 0;
 }
-ngx_memcpy(frame->data, p, fsize);
+frame->data = ngx_quic_copy_buf(c, p, fsize);
+if (frame->data == NGX_CHAIN_ERROR) {
+return 0;
+}
 frame->level = level;
 frame->type = NGX_QUIC_FT_CRYPTO;
 frame->u.crypto.offset = fs->sent;
 frame->u.crypto.length = fsize;
-frame->u.crypto.data = frame->data;
 fs->sent += fsize;
 p += fsize;
 ngx_quic_queue_frame(qc, frame);
 ngx_del_timer(&qc->pto);
 }
 if (qc->push.posted) {
 ngx_delete_posted_event(&qc->push);
-}
-for (i = 0; i < NGX_QUIC_ENCRYPTION_LAST; i++) {
-ngx_quic_free_frames(c, &qc->crypto[i].frames);
-}
-for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) {
-ngx_quic_free_frames(c, &qc->send_ctx[i].frames);
-ngx_quic_free_frames(c, &qc->send_ctx[i].sent);
 }
 while (!ngx_queue_empty(&qc->server_ids)) {
 q = ngx_queue_head(&qc->server_ids);
 sid = ngx_queue_data(q, ngx_quic_server_id_t, queue);
 static ngx_int_t
 ngx_quic_payload_handler(ngx_connection_t *c, ngx_quic_header_t *pkt)
 {
 u_char                 *end, *p;
 ssize_t                 len;
+ngx_buf_t               buf;
 ngx_uint_t              do_close;
+ngx_chain_t             chain;
 ngx_quic_frame_t        frame;
 ngx_quic_connection_t  *qc;
 qc = ngx_quic_get_connection(c);
 while (p < end) {
 c->log->action = "parsing frames";
+ngx_memzero(&buf, sizeof(ngx_buf_t));
+chain.buf = &buf;
+chain.next = NULL;
+frame.data = &chain;
 len = ngx_quic_parse_frame(pkt, p, end, &frame);
 if (len < 0) {
 qc->error = pkt->error;
 return NGX_ERROR;
 p += len;
 switch (frame.type) {
 case NGX_QUIC_FT_ACK:
-if (ngx_quic_handle_ack_frame(c, pkt, &frame.u.ack) != NGX_OK) {
+if (ngx_quic_handle_ack_frame(c, pkt, &frame) != NGX_OK) {
 return NGX_ERROR;
 }
 continue;
 ngx_quic_send_ack_range(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx,
 uint64_t smallest, uint64_t largest)
 {
 ngx_quic_frame_t  *frame;
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = ctx->level;
 static ngx_int_t
 ngx_quic_send_ack(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx)
 {
-u_char                 *p;
+size_t                  len, left;
-size_t                  ranges_len;
 uint64_t                ack_delay;
+ngx_buf_t              *b;
 ngx_uint_t              i;
+ngx_chain_t            *cl, **ll;
 ngx_quic_frame_t       *frame;
 ngx_quic_connection_t  *qc;
 qc = ngx_quic_get_connection(c);
 } else {
 ack_delay = 0;
 }
-ranges_len = 0;
+frame = ngx_quic_alloc_frame(c);
-for (i = 0; i < ctx->nranges; i++) {
-ranges_len += ngx_quic_create_ack_range(NULL, ctx->ranges[i].gap,
-ctx->ranges[i].range);
-}
-frame = ngx_quic_alloc_frame(c, ranges_len);
 if (frame == NULL) {
 return NGX_ERROR;
 }
-p = frame->data;
+ll = &frame->data;
+b = NULL;
 for (i = 0; i < ctx->nranges; i++) {
-p += ngx_quic_create_ack_range(p, ctx->ranges[i].gap,
+len = ngx_quic_create_ack_range(NULL, ctx->ranges[i].gap,
 ctx->ranges[i].range);
-}
+left = b ? b->end - b->last : 0;
+if (left < len) {
+cl = ngx_quic_alloc_buf(c);
+if (cl == NULL) {
+return NGX_ERROR;
+}
+*ll = cl;
+ll = &cl->next;
+b = cl->buf;
+left = b->end - b->last;
+if (left < len) {
+return NGX_ERROR;
+}
+}
+b->last += ngx_quic_create_ack_range(b->last, ctx->ranges[i].gap,
+ctx->ranges[i].range);
+frame->u.ack.ranges_length += len;
+}
+*ll = NULL;
 frame->level = ctx->level;
 frame->type = NGX_QUIC_FT_ACK;
 frame->u.ack.largest = ctx->largest_range;
 frame->u.ack.delay = ack_delay;
 frame->u.ack.range_count = ctx->nranges;
 frame->u.ack.first_range = ctx->first_range;
-frame->u.ack.ranges_start = frame->data;
-frame->u.ack.ranges_end = frame->data + ranges_len;
 ngx_quic_queue_frame(qc, frame);
 return NGX_OK;
 }
 {
 /* dot not send CC too often */
 return NGX_OK;
 }
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = qc->error_level;
 if (ngx_quic_new_token(c, &token) != NGX_OK) {
 return NGX_ERROR;
 }
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = ssl_encryption_application;
 }
 static ngx_int_t
 ngx_quic_handle_ack_frame(ngx_connection_t *c, ngx_quic_header_t *pkt,
-ngx_quic_ack_frame_t *ack)
+ngx_quic_frame_t *f)
 {
 ssize_t                 n;
 u_char                 *pos, *end;
 uint64_t                min, max, gap, range;
 ngx_msec_t              send_time;
 ngx_uint_t              i;
 ngx_quic_send_ctx_t    *ctx;
+ngx_quic_ack_frame_t   *ack;
 ngx_quic_connection_t  *qc;
 qc = ngx_quic_get_connection(c);
 ctx = ngx_quic_get_send_ctx(qc, pkt->level);
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic ngx_quic_handle_ack_frame level:%d", pkt->level);
+ack = &f->u.ack;
 /*
 *  If any computed packet number is negative, an endpoint MUST
 *  generate a connection error of type FRAME_ENCODING_ERROR.
 *  (19.3.1)
 if (send_time != NGX_TIMER_INFINITE) {
 ngx_quic_rtt_sample(c, ack, pkt->level, send_time);
 }
 }
-pos = ack->ranges_start;
+if (f->data) {
-end = ack->ranges_end;
+pos = f->data->buf->pos;
+end = f->data->buf->last;
+} else {
+pos = NULL;
+end = NULL;
+}
 for (i = 0; i < ack->range_count; i++) {
 n = ngx_quic_parse_ack_range(pkt->log, pos, end, &gap, &range);
 if (n == NGX_ERROR) {
 static ngx_int_t
 ngx_quic_adjust_frame_offset(ngx_connection_t *c, ngx_quic_frame_t *frame,
 uint64_t offset_in)
 {
-size_t                     tail;
+size_t                     tail, n;
+ngx_buf_t                 *b;
+ngx_chain_t               *cl;
 ngx_quic_ordered_frame_t  *f;
 f = &frame->u.ord;
 tail = offset_in - f->offset;
 "quic adjusted ordered frame data start to expected offset");
 /* intersecting range: adjust data size */
 f->offset += tail;
-f->data += tail;
 f->length -= tail;
+for (cl = frame->data; cl; cl = cl->next) {
+b = cl->buf;
+n = ngx_buf_size(b);
+if (n >= tail) {
+b->pos += tail;
+break;
+}
+cl->buf->pos = cl->buf->last;
+tail -= n;
+}
 return NGX_OK;
 }
 static ngx_int_t
 ngx_quic_buffer_frame(ngx_connection_t *c, ngx_quic_frames_stream_t *fs,
 ngx_quic_frame_t *frame)
 {
-u_char                    *data;
 ngx_queue_t               *q;
 ngx_quic_frame_t          *dst, *item;
 ngx_quic_ordered_frame_t  *f, *df;
 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
 f = &frame->u.ord;
 /* frame start offset is in the future, buffer it */
-dst = ngx_quic_alloc_frame(c, f->length);
+dst = ngx_quic_alloc_frame(c);
 if (dst == NULL) {
 return NGX_ERROR;
 }
-data = dst->data;
 ngx_memcpy(dst, frame, sizeof(ngx_quic_frame_t));
-dst->data = data;
+dst->data = ngx_quic_copy_chain(c, frame->data, 0);
-ngx_memcpy(dst->data, f->data, f->length);
+if (dst->data == NGX_CHAIN_ERROR) {
+return NGX_ERROR;
+}
 df = &dst->u.ord;
-df->data = dst->data;
 fs->total += f->length;
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic ordered frame with unexpected offset:"
 static ngx_int_t
 ngx_quic_crypto_input(ngx_connection_t *c, ngx_quic_frame_t *frame, void *data)
 {
-int                       n, sslerr;
+int                     n, sslerr;
-ngx_ssl_conn_t           *ssl_conn;
+ngx_buf_t              *b;
-ngx_quic_connection_t    *qc;
+ngx_chain_t            *cl;
-ngx_quic_crypto_frame_t  *f;
+ngx_ssl_conn_t         *ssl_conn;
+ngx_quic_connection_t  *qc;
 qc = ngx_quic_get_connection(c);
-f = &frame->u.crypto;
 ssl_conn = c->ssl->connection;
 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic SSL_quic_read_level:%d SSL_quic_write_level:%d",
 (int) SSL_quic_read_level(ssl_conn),
 (int) SSL_quic_write_level(ssl_conn));
-if (!SSL_provide_quic_data(ssl_conn, SSL_quic_read_level(ssl_conn),
+for (cl = frame->data; cl; cl = cl->next) {
-f->data, f->length))
+b = cl->buf;
-{
-ngx_ssl_error(NGX_LOG_INFO, c->log, 0,
+if (!SSL_provide_quic_data(ssl_conn, SSL_quic_read_level(ssl_conn),
-"SSL_provide_quic_data() failed");
+b->pos, b->last - b->pos))
-return NGX_ERROR;
+{
+ngx_ssl_error(NGX_LOG_INFO, c->log, 0,
+"SSL_provide_quic_data() failed");
+return NGX_ERROR;
+}
 }
 n = SSL_do_handshake(ssl_conn);
 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic handshake completed successfully");
 c->ssl->handshaked = 1;
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 /* 12.4 Frames and frame types, figure 8 */
 ngx_quic_stream_input(ngx_connection_t *c, ngx_quic_frame_t *frame, void *data)
 {
 uint64_t                  id;
 ngx_buf_t                *b;
 ngx_event_t              *rev;
+ngx_chain_t              *cl;
 ngx_quic_stream_t        *sn;
 ngx_quic_connection_t    *qc;
 ngx_quic_stream_frame_t  *f;
 qc = ngx_quic_get_connection(c);
 if ((size_t) (b->end - b->last) < f->length) {
 b->last = ngx_movemem(b->start, b->pos, b->last - b->pos);
 b->pos = b->start;
 }
-b->last = ngx_cpymem(b->last, f->data, f->length);
+for (cl = frame->data; cl; cl = cl->next) {
+b->last = ngx_cpymem(b->last, cl->buf->pos,
+cl->buf->last - cl->buf->pos);
+}
 rev = sn->c->read;
 rev->ready = 1;
 if (f->fin) {
 } else {
 b = sn->b;
 n = sn->fs.received + (b->pos - b->start) + (b->end - b->last);
 }
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = pkt->level;
 ngx_quic_frame_t       *frame;
 ngx_quic_connection_t  *qc;
 qc = ngx_quic_get_connection(c);
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = pkt->level;
 ngx_quic_frame_t       *frame;
 ngx_quic_connection_t  *qc;
 qc = ngx_quic_get_connection(c);
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = level;
 sid = ngx_quic_insert_server_id(c, &dcid);
 if (sid == NULL) {
 return NGX_ERROR;
 }
-frame = ngx_quic_alloc_frame(c, 0);
+frame = ngx_quic_alloc_frame(c);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = ssl_encryption_application;
 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic stream id:0x%xL recv len:%z of size:%uz",
 qs->id, len, size);
 if (!rev->pending_eof) {
-frame = ngx_quic_alloc_frame(pc, 0);
+frame = ngx_quic_alloc_frame(pc);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 frame->level = ssl_encryption_application;
 ngx_quic_queue_frame(qc, frame);
 }
 if ((qc->streams.recv_max_data / 2) < qc->streams.received) {
-frame = ngx_quic_alloc_frame(pc, 0);
+frame = ngx_quic_alloc_frame(pc);
 if (frame == NULL) {
 return NGX_ERROR;
 }
 static ngx_chain_t *
 ngx_quic_stream_send_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
 {
-u_char                 *p;
+size_t                  n, max, max_frame, max_flow, max_limit;
-size_t                  n, max, max_frame, max_flow, max_limit, len;
 #if (NGX_DEBUG)
 size_t                  sent;
-#endif
-ngx_buf_t              *b;
-#if (NGX_DEBUG)
 ngx_uint_t              nframes;
 #endif
 ngx_event_t            *wev;
 ngx_chain_t            *cl;
 ngx_connection_t       *pc;
 if (n == 0) {
 wev->ready = (max_flow ? 1 : 0);
 break;
 }
-frame = ngx_quic_alloc_frame(pc, n);
+frame = ngx_quic_alloc_frame(pc);
 if (frame == NULL) {
 return NGX_CHAIN_ERROR;
 }
 frame->level = ssl_encryption_application;
 frame->u.stream.type = frame->type;
 frame->u.stream.stream_id = qs->id;
 frame->u.stream.offset = c->sent;
 frame->u.stream.length = n;
-frame->u.stream.data = frame->data;
 c->sent += n;
 qc->streams.sent += n;
 max_flow -= n;
 #if (NGX_DEBUG)
 sent += n;
 nframes++;
 #endif
-for (p = frame->data; n > 0; cl = cl->next) {
+frame->data = ngx_quic_copy_chain(pc, cl, n);
-b = cl->buf;
+if (frame->data == NGX_CHAIN_ERROR) {
+return NGX_CHAIN_ERROR;
-if (!ngx_buf_in_memory(b)) {
-continue;
-}
-len = ngx_min(n, (size_t) (b->last - b->pos));
-p = ngx_cpymem(p, b->pos, len);
-b->pos += len;
-n -= len;
 }
 ngx_quic_queue_frame(qc, frame);
 }
 if ((qs->id & NGX_QUIC_STREAM_SERVER_INITIATED) == 0
 || (qs->id & NGX_QUIC_STREAM_UNIDIRECTIONAL) == 0)
 {
 if (!c->read->pending_eof && !c->read->error) {
-frame = ngx_quic_alloc_frame(pc, 0);
+frame = ngx_quic_alloc_frame(pc);
 if (frame == NULL) {
 return;
 }
 frame->level = ssl_encryption_application;
 ngx_quic_queue_frame(qc, frame);
 }
 }
 if ((qs->id & NGX_QUIC_STREAM_SERVER_INITIATED) == 0) {
-frame = ngx_quic_alloc_frame(pc, 0);
+frame = ngx_quic_alloc_frame(pc);
 if (frame == NULL) {
 return;
 }
 frame->level = ssl_encryption_application;
 }
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic stream id:0x%xL send fin", qs->id);
-frame = ngx_quic_alloc_frame(pc, 0);
+frame = ngx_quic_alloc_frame(pc);
 if (frame == NULL) {
 return;
 }
 frame->level = ssl_encryption_application;
 frame->u.stream.type = frame->type;
 frame->u.stream.stream_id = qs->id;
 frame->u.stream.offset = c->sent;
 frame->u.stream.length = 0;
-frame->u.stream.data = NULL;
 ngx_quic_queue_frame(qc, frame);
 (void) ngx_quic_output(pc);
 }
 static ngx_quic_frame_t *
-ngx_quic_alloc_frame(ngx_connection_t *c, size_t size)
+ngx_quic_alloc_frame(ngx_connection_t *c)
 {
-u_char                 *p;
 ngx_queue_t            *q;
 ngx_quic_frame_t       *frame;
 ngx_quic_connection_t  *qc;
-if (size) {
-p = ngx_alloc(size, c->log);
-if (p == NULL) {
-return NULL;
-}
-} else {
-p = NULL;
-}
 qc = ngx_quic_get_connection(c);
 if (!ngx_queue_empty(&qc->free_frames)) {
 q = ngx_queue_head(&qc->free_frames);
 frame = ngx_queue_data(q, ngx_quic_frame_t, queue);
 ngx_queue_remove(&frame->queue);
-#ifdef NGX_QUIC_DEBUG_FRAMES_ALLOC
+#ifdef NGX_QUIC_DEBUG_ALLOC
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic reuse frame n:%ui", qc->nframes);
 #endif
 } else {
 frame = ngx_pcalloc(c->pool, sizeof(ngx_quic_frame_t));
 if (frame == NULL) {
-ngx_free(p);
 return NULL;
 }
-#if (NGX_DEBUG)
+#ifdef NGX_QUIC_DEBUG_ALLOC
 ++qc->nframes;
-#endif
-#ifdef NGX_QUIC_DEBUG_FRAMES_ALLOC
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic alloc frame n:%ui", qc->nframes);
 #endif
 }
 ngx_memzero(frame, sizeof(ngx_quic_frame_t));
-frame->data = p;
 return frame;
 }
 ngx_quic_connection_t  *qc;
 qc = ngx_quic_get_connection(c);
 if (frame->data) {
-ngx_free(frame->data);
+ngx_quic_free_bufs(c, frame->data);
-frame->data = NULL;
 }
 ngx_queue_insert_head(&qc->free_frames, &frame->queue);
-#ifdef NGX_QUIC_DEBUG_FRAMES_ALLOC
+#ifdef NGX_QUIC_DEBUG_ALLOC
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic free frame n:%ui", qc->nframes);
 #endif
 }
 version = qc->version;
 return (version & 0xff000000) == 0xff000000 ? version & 0xff : version;
 }
+static ngx_chain_t *
+ngx_quic_alloc_buf(ngx_connection_t *c)
+{
+ngx_buf_t              *b;
+ngx_chain_t            *cl;
+ngx_quic_connection_t  *qc;
+qc = ngx_quic_get_connection(c);
+if (qc->free_bufs) {
+cl = qc->free_bufs;
+qc->free_bufs = cl->next;
+b = cl->buf;
+b->pos = b->start;
+b->last = b->start;
+#ifdef NGX_QUIC_DEBUG_ALLOC
+ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
+"quic reuse buffer n:%ui", qc->nbufs);
+#endif
+return cl;
+}
+cl = ngx_alloc_chain_link(c->pool);
+if (cl == NULL) {
+return NULL;
+}
+b = ngx_create_temp_buf(c->pool, NGX_QUIC_BUFFER_SIZE);
+if (b == NULL) {
+return NULL;
+}
+b->tag = (ngx_buf_tag_t) &ngx_quic_alloc_buf;
+cl->buf = b;
+#ifdef NGX_QUIC_DEBUG_ALLOC
+++qc->nbufs;
+ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
+"quic alloc buffer n:%ui", qc->nbufs);
+#endif
+return cl;
+}
+static void
+ngx_quic_free_bufs(ngx_connection_t *c, ngx_chain_t *in)
+{
+ngx_chain_t            *cl;
+ngx_quic_connection_t  *qc;
+qc = ngx_quic_get_connection(c);
+while (in) {
+#ifdef NGX_QUIC_DEBUG_ALLOC
+ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
+"quic free buffer n:%ui", qc->nbufs);
+#endif
+cl = in;
+in = in->next;
+cl->next = qc->free_bufs;
+qc->free_bufs = cl;
+}
+}
+static ngx_chain_t *
+ngx_quic_copy_buf(ngx_connection_t *c, u_char *data, size_t len)
+{
+size_t        n;
+ngx_buf_t    *b;
+ngx_chain_t  *cl, *out, **ll;
+out = NULL;
+ll = &out;
+while (len) {
+cl = ngx_quic_alloc_buf(c);
+if (cl == NULL) {
+return NGX_CHAIN_ERROR;
+}
+b = cl->buf;
+n = ngx_min((size_t) (b->end - b->last), len);
+b->last = ngx_cpymem(b->last, data, n);
+data += n;
+len -= n;
+*ll = cl;
+ll = &cl->next;
+}
+*ll = NULL;
+return out;
+}
+static ngx_chain_t *
+ngx_quic_copy_chain(ngx_connection_t *c, ngx_chain_t *in, size_t limit)
+{
+size_t        n;
+ngx_buf_t    *b;
+ngx_chain_t  *cl, *out, **ll;
+out = NULL;
+ll = &out;
+while (in) {
+if (!ngx_buf_in_memory(in->buf) || ngx_buf_size(in->buf) == 0) {
+in = in->next;
+continue;
+}
+cl = ngx_quic_alloc_buf(c);
+if (cl == NULL) {
+return NGX_CHAIN_ERROR;
+}
+*ll = cl;
+ll = &cl->next;
+b = cl->buf;
+while (in && b->last != b->end) {
+n = ngx_min(in->buf->last - in->buf->pos, b->end - b->last);
+if (limit > 0 && n > limit) {
+n = limit;
+}
+b->last = ngx_cpymem(b->last, in->buf->pos, n);
+in->buf->pos += n;
+if (in->buf->pos == in->buf->last) {
+in = in->next;
+}
+if (limit > 0) {
+if (limit == n) {
+goto done;
+}
+limit -= n;
+}
+}
+}
+done:
+*ll = NULL;
+return out;
+}

Mercurial > hg > nginx

comparison src/event/ngx_event_quic.c @ 8657:2dfc5ef29973 quic