nginx: src/event/quic/ngx_event

comparison src/event/quic/ngx_event_quic.c @ 8687:1c6343bd7933 quic

QUIC: refactored packet processing. - split ngx_quic_process_packet() in two functions with the second one called ngx_quic_process_payload() in charge of decrypring and handling the payload - renamed ngx_quic_payload_handler() to ngx_quic_handle_frames() - moved error cleanup from ngx_quic_input() to ngx_quic_process_payload() - moved handling closed connection from ngx_quic_handle_frames() to ngx_quic_process_payload() - minor fixes

author	Roman Arutyunyan <arut@nginx.com>
date	Thu, 28 Jan 2021 12:35:18 +0300
parents	dffb66fb783b
children	a346905c359f

comparison

equal deleted inserted replaced

-:dffb66fb783b
+:1c6343bd7933
 static ngx_int_t ngx_quic_input(ngx_connection_t *c, ngx_buf_t *b,
 ngx_quic_conf_t *conf);
 static ngx_int_t ngx_quic_process_packet(ngx_connection_t *c,
 ngx_quic_conf_t *conf, ngx_quic_header_t *pkt);
+static ngx_int_t ngx_quic_process_payload(ngx_connection_t *c,
+ngx_quic_header_t *pkt);
 static ngx_int_t ngx_quic_send_early_cc(ngx_connection_t *c,
 ngx_quic_header_t *inpkt, ngx_uint_t err, const char *reason);
 static void ngx_quic_discard_ctx(ngx_connection_t *c,
 enum ssl_encryption_level_t level);
 static ngx_int_t ngx_quic_check_peer(ngx_quic_connection_t *qc,
 ngx_quic_header_t *pkt);
-static ngx_int_t ngx_quic_payload_handler(ngx_connection_t *c,
+static ngx_int_t ngx_quic_handle_frames(ngx_connection_t *c,
 ngx_quic_header_t *pkt);
 static ngx_int_t ngx_quic_ack_packet(ngx_connection_t *c,
 ngx_quic_header_t *pkt);
 static ngx_int_t ngx_quic_send_ack_range(ngx_connection_t *c,
 ngx_quic_send_ctx_t *ctx, uint64_t smallest, uint64_t largest);
 static ngx_int_t
 ngx_quic_input(ngx_connection_t *c, ngx_buf_t *b, ngx_quic_conf_t *conf)
 {
-u_char                 *p;
+u_char             *p;
-ngx_int_t               rc;
+ngx_int_t           rc;
-ngx_uint_t              good;
+ngx_uint_t          good;
-ngx_quic_header_t       pkt;
+ngx_quic_header_t   pkt;
-ngx_quic_connection_t  *qc;
 good = 0;
 p = b->pos;
 pkt.data = p;
 pkt.len = b->last - p;
 pkt.log = c->log;
 pkt.flags = p[0];
 pkt.raw->pos++;
-qc = ngx_quic_get_connection(c);
-if (qc) {
-qc->error = 0;
-qc->error_reason = 0;
-}
 rc = ngx_quic_process_packet(c, conf, &pkt);
 #if (NGX_DEBUG)
 if (pkt.parsed) {
 static ngx_int_t
 ngx_quic_process_packet(ngx_connection_t *c, ngx_quic_conf_t *conf,
 ngx_quic_header_t *pkt)
 {
 ngx_int_t               rc;
-ngx_quic_send_ctx_t    *ctx;
 ngx_quic_connection_t  *qc;
-static u_char           buf[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
 c->log->action = "parsing quic packet";
 rc = ngx_quic_parse_packet(pkt);
 }
 pkt->parsed = 1;
 c->log->action = "processing quic packet";
-qc = ngx_quic_get_connection(c);
 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic packet rx dcid len:%uz %xV",
 pkt->dcid.len, &pkt->dcid);
 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
 "quic token len:%uz %xV",
 pkt->token.len, &pkt->token);
 }
 #endif
+qc = ngx_quic_get_connection(c);
 if (qc) {
 if (rc == NGX_ABORT) {
 ngx_log_error(NGX_LOG_INFO, c->log, 0,
 }
 return NGX_DECLINED;
 }
+return ngx_quic_process_payload(c, pkt);
+}
+/* packet does not belong to a connection */
+if (rc == NGX_ABORT) {
+return ngx_quic_negotiate_version(c, pkt);
+}
+if (pkt->level == ssl_encryption_application) {
+return ngx_quic_send_stateless_reset(c, conf, pkt);
+}
+if (pkt->level != ssl_encryption_initial) {
+return NGX_ERROR;
+}
+c->log->action = "processing initial packet";
+if (pkt->dcid.len < NGX_QUIC_CID_LEN_MIN) {
+/* 7.2.  Negotiating Connection IDs */
+ngx_log_error(NGX_LOG_INFO, c->log, 0,
+"quic too short dcid in initial"
+" packet: len:%i", pkt->dcid.len);
+return NGX_ERROR;
+}
+/* process retry and initialize connection IDs */
+if (pkt->token.len) {
+rc = ngx_quic_validate_token(c, conf->token_key, pkt);
+if (rc == NGX_ERROR) {
+/* internal error */
+return NGX_ERROR;
+} else if (rc == NGX_ABORT) {
+/* token cannot be decrypted */
+return ngx_quic_send_early_cc(c, pkt,
+NGX_QUIC_ERR_INVALID_TOKEN,
+"cannot decrypt token");
+} else if (rc == NGX_DECLINED) {
+/* token is invalid */
+if (pkt->retried) {
+/* invalid Retry token */
+return ngx_quic_send_early_cc(c, pkt,
+NGX_QUIC_ERR_INVALID_TOKEN,
+"invalid token");
+} else if (conf->retry) {
+/* invalid NEW_TOKEN */
+return ngx_quic_send_retry(c, conf, pkt);
+}
+}
+/* NGX_OK */
+} else if (conf->retry) {
+return ngx_quic_send_retry(c, conf, pkt);
 } else {
+pkt->odcid = pkt->dcid;
-if (rc == NGX_ABORT) {
+}
-return ngx_quic_negotiate_version(c, pkt);
-}
+if (ngx_terminate || ngx_exiting) {
+if (conf->retry) {
-if (pkt->level == ssl_encryption_initial) {
+return ngx_quic_send_retry(c, conf, pkt);
-c->log->action = "processing initial packet";
+}
-if (pkt->dcid.len < NGX_QUIC_CID_LEN_MIN) {
+return NGX_ERROR;
-/* 7.2.  Negotiating Connection IDs */
+}
-ngx_log_error(NGX_LOG_INFO, c->log, 0,
-"quic too short dcid in initial"
+c->log->action = "creating quic connection";
-" packet: len:%i", pkt->dcid.len);
-return NGX_ERROR;
+qc = ngx_quic_new_connection(c, conf, pkt);
-}
+if (qc == NULL) {
+return NGX_ERROR;
-/* process retry and initialize connection IDs */
+}
-if (pkt->token.len) {
+return ngx_quic_process_payload(c, pkt);
+}
-rc = ngx_quic_validate_token(c, conf->token_key, pkt);
-if (rc == NGX_ERROR) {
+static ngx_int_t
-/* internal error */
+ngx_quic_process_payload(ngx_connection_t *c, ngx_quic_header_t *pkt)
-return NGX_ERROR;
+{
+ngx_int_t               rc;
-} else if (rc == NGX_ABORT) {
+ngx_quic_send_ctx_t    *ctx;
-/* token cannot be decrypted */
+ngx_quic_connection_t  *qc;
-return ngx_quic_send_early_cc(c, pkt,
+static u_char           buf[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
-NGX_QUIC_ERR_INVALID_TOKEN,
-"cannot decrypt token");
+qc = ngx_quic_get_connection(c);
-} else if (rc == NGX_DECLINED) {
-/* token is invalid */
+qc->error = 0;
+qc->error_reason = 0;
-if (pkt->retried) {
-/* invalid Retry token */
-return ngx_quic_send_early_cc(c, pkt,
-NGX_QUIC_ERR_INVALID_TOKEN,
-"invalid token");
-} else if (conf->retry) {
-/* invalid NEW_TOKEN */
-return ngx_quic_send_retry(c, conf, pkt);
-}
-}
-/* NGX_OK */
-} else if (conf->retry) {
-return ngx_quic_send_retry(c, conf, pkt);
-} else {
-pkt->odcid = pkt->dcid;
-}
-if (ngx_terminate || ngx_exiting) {
-if (conf->retry) {
-return ngx_quic_send_retry(c, conf, pkt);
-}
-return NGX_ERROR;
-}
-c->log->action = "creating quic connection";
-qc = ngx_quic_new_connection(c, conf, pkt);
-if (qc == NULL) {
-return NGX_ERROR;
-}
-} else if (pkt->level == ssl_encryption_application) {
-return ngx_quic_send_stateless_reset(c, conf, pkt);
-} else {
-return NGX_ERROR;
-}
-}
 c->log->action = "decrypting packet";
 if (!ngx_quic_keys_available(qc->keys, pkt->level)) {
 ngx_log_error(NGX_LOG_INFO, c->log, 0,
 if (qc->validated == 0) {
 qc->validated = 1;
 ngx_post_event(&qc->push, &ngx_posted_events);
 }
 }
-pkt->received = ngx_current_msec;
-c->log->action = "handling payload";
-if (pkt->level != ssl_encryption_application) {
-return ngx_quic_payload_handler(c, pkt);
-}
-if (!pkt->key_update) {
-return ngx_quic_payload_handler(c, pkt);
-}
-/* switch keys and generate next on Key Phase change */
-qc->key_phase ^= 1;
-ngx_quic_keys_switch(c, qc->keys);
-rc = ngx_quic_payload_handler(c, pkt);
-if (rc != NGX_OK) {
-return rc;
-}
-return ngx_quic_keys_update(c, qc->keys);
-}
-static ngx_int_t
-ngx_quic_send_early_cc(ngx_connection_t *c, ngx_quic_header_t *inpkt,
-ngx_uint_t err, const char *reason)
-{
-ssize_t            len;
-ngx_str_t          res;
-ngx_quic_frame_t   frame;
-ngx_quic_header_t  pkt;
-static u_char       src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
-static u_char       dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
-ngx_memzero(&frame, sizeof(ngx_quic_frame_t));
-ngx_memzero(&pkt, sizeof(ngx_quic_header_t));
-frame.level = inpkt->level;
-frame.type = NGX_QUIC_FT_CONNECTION_CLOSE;
-frame.u.close.error_code = err;
-frame.u.close.reason.data = (u_char *) reason;
-frame.u.close.reason.len = ngx_strlen(reason);
-len = ngx_quic_create_frame(NULL, &frame);
-if (len > NGX_QUIC_MAX_UDP_PAYLOAD_SIZE) {
-return NGX_ERROR;
-}
-ngx_quic_log_frame(c->log, &frame, 1);
-len = ngx_quic_create_frame(src, &frame);
-if (len == -1) {
-return NGX_ERROR;
-}
-pkt.keys = ngx_quic_keys_new(c->pool);
-if (pkt.keys == NULL) {
-return NGX_ERROR;
-}
-if (ngx_quic_keys_set_initial_secret(c->pool, pkt.keys, &inpkt->dcid)
-!= NGX_OK)
-{
-return NGX_ERROR;
-}
-pkt.flags = NGX_QUIC_PKT_FIXED_BIT | NGX_QUIC_PKT_LONG
-| NGX_QUIC_PKT_INITIAL;
-pkt.num_len = 1;
-/*
-* pkt.num = 0;
-* pkt.trunc = 0;
-*/
-pkt.version = inpkt->version;
-pkt.log = c->log;
-pkt.level = inpkt->level;
-pkt.dcid = inpkt->scid;
-pkt.scid = inpkt->dcid;
-pkt.payload.data = src;
-pkt.payload.len = len;
-res.data = dst;
-if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) {
-return NGX_ERROR;
-}
-if (ngx_quic_send(c, res.data, res.len) == NGX_ERROR) {
-return NGX_ERROR;
-}
-return NGX_OK;
-}
-static void
-ngx_quic_discard_ctx(ngx_connection_t *c, enum ssl_encryption_level_t level)
-{
-ngx_queue_t            *q;
-ngx_quic_frame_t       *f;
-ngx_quic_send_ctx_t    *ctx;
-ngx_quic_connection_t  *qc;
-qc = ngx_quic_get_connection(c);
-if (!ngx_quic_keys_available(qc->keys, level)) {
-return;
-}
-ngx_quic_keys_discard(qc->keys, level);
-qc->pto_count = 0;
-ctx = ngx_quic_get_send_ctx(qc, level);
-while (!ngx_queue_empty(&ctx->sent)) {
-q = ngx_queue_head(&ctx->sent);
-ngx_queue_remove(q);
-f = ngx_queue_data(q, ngx_quic_frame_t, queue);
-ngx_quic_congestion_ack(c, f);
-ngx_quic_free_frame(c, f);
-}
-while (!ngx_queue_empty(&ctx->frames)) {
-q = ngx_queue_head(&ctx->frames);
-ngx_queue_remove(q);
-f = ngx_queue_data(q, ngx_quic_frame_t, queue);
-ngx_quic_congestion_ack(c, f);
-ngx_quic_free_frame(c, f);
-}
-if (level == ssl_encryption_initial) {
-ngx_quic_clear_temp_server_ids(c);
-}
-ctx->send_ack = 0;
-}
-static ngx_int_t
-ngx_quic_check_peer(ngx_quic_connection_t *qc, ngx_quic_header_t *pkt)
-{
-ngx_queue_t           *q;
-ngx_quic_client_id_t  *cid;
-if (pkt->level == ssl_encryption_application) {
-return NGX_OK;
-}
-for (q = ngx_queue_head(&qc->client_ids);
-q != ngx_queue_sentinel(&qc->client_ids);
-q = ngx_queue_next(q))
-{
-cid = ngx_queue_data(q, ngx_quic_client_id_t, queue);
-if (pkt->scid.len == cid->len
-&& ngx_memcmp(pkt->scid.data, cid->id, cid->len) == 0)
-{
-return NGX_OK;
-}
-}
-ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic unexpected quic scid");
-return NGX_ERROR;
-}
-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);
 if (qc->closing) {
 /*
 * 10.1  Closing and Draining Connection States
 * ... delayed or reordered packets are properly discarded.
 qc->error_ftype = 0;
 qc->error_app = 0;
 return ngx_quic_send_cc(c);
 }
+pkt->received = ngx_current_msec;
+c->log->action = "handling payload";
+if (pkt->level != ssl_encryption_application) {
+return ngx_quic_handle_frames(c, pkt);
+}
+if (!pkt->key_update) {
+return ngx_quic_handle_frames(c, pkt);
+}
+/* switch keys and generate next on Key Phase change */
+qc->key_phase ^= 1;
+ngx_quic_keys_switch(c, qc->keys);
+rc = ngx_quic_handle_frames(c, pkt);
+if (rc != NGX_OK) {
+return rc;
+}
+return ngx_quic_keys_update(c, qc->keys);
+}
+static ngx_int_t
+ngx_quic_send_early_cc(ngx_connection_t *c, ngx_quic_header_t *inpkt,
+ngx_uint_t err, const char *reason)
+{
+ssize_t            len;
+ngx_str_t          res;
+ngx_quic_frame_t   frame;
+ngx_quic_header_t  pkt;
+static u_char       src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
+static u_char       dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];
+ngx_memzero(&frame, sizeof(ngx_quic_frame_t));
+ngx_memzero(&pkt, sizeof(ngx_quic_header_t));
+frame.level = inpkt->level;
+frame.type = NGX_QUIC_FT_CONNECTION_CLOSE;
+frame.u.close.error_code = err;
+frame.u.close.reason.data = (u_char *) reason;
+frame.u.close.reason.len = ngx_strlen(reason);
+len = ngx_quic_create_frame(NULL, &frame);
+if (len > NGX_QUIC_MAX_UDP_PAYLOAD_SIZE) {
+return NGX_ERROR;
+}
+ngx_quic_log_frame(c->log, &frame, 1);
+len = ngx_quic_create_frame(src, &frame);
+if (len == -1) {
+return NGX_ERROR;
+}
+pkt.keys = ngx_quic_keys_new(c->pool);
+if (pkt.keys == NULL) {
+return NGX_ERROR;
+}
+if (ngx_quic_keys_set_initial_secret(c->pool, pkt.keys, &inpkt->dcid)
+!= NGX_OK)
+{
+return NGX_ERROR;
+}
+pkt.flags = NGX_QUIC_PKT_FIXED_BIT | NGX_QUIC_PKT_LONG
+| NGX_QUIC_PKT_INITIAL;
+pkt.num_len = 1;
+/*
+* pkt.num = 0;
+* pkt.trunc = 0;
+*/
+pkt.version = inpkt->version;
+pkt.log = c->log;
+pkt.level = inpkt->level;
+pkt.dcid = inpkt->scid;
+pkt.scid = inpkt->dcid;
+pkt.payload.data = src;
+pkt.payload.len = len;
+res.data = dst;
+if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) {
+return NGX_ERROR;
+}
+if (ngx_quic_send(c, res.data, res.len) == NGX_ERROR) {
+return NGX_ERROR;
+}
+return NGX_OK;
+}
+static void
+ngx_quic_discard_ctx(ngx_connection_t *c, enum ssl_encryption_level_t level)
+{
+ngx_queue_t            *q;
+ngx_quic_frame_t       *f;
+ngx_quic_send_ctx_t    *ctx;
+ngx_quic_connection_t  *qc;
+qc = ngx_quic_get_connection(c);
+if (!ngx_quic_keys_available(qc->keys, level)) {
+return;
+}
+ngx_quic_keys_discard(qc->keys, level);
+qc->pto_count = 0;
+ctx = ngx_quic_get_send_ctx(qc, level);
+while (!ngx_queue_empty(&ctx->sent)) {
+q = ngx_queue_head(&ctx->sent);
+ngx_queue_remove(q);
+f = ngx_queue_data(q, ngx_quic_frame_t, queue);
+ngx_quic_congestion_ack(c, f);
+ngx_quic_free_frame(c, f);
+}
+while (!ngx_queue_empty(&ctx->frames)) {
+q = ngx_queue_head(&ctx->frames);
+ngx_queue_remove(q);
+f = ngx_queue_data(q, ngx_quic_frame_t, queue);
+ngx_quic_congestion_ack(c, f);
+ngx_quic_free_frame(c, f);
+}
+if (level == ssl_encryption_initial) {
+ngx_quic_clear_temp_server_ids(c);
+}
+ctx->send_ack = 0;
+}
+static ngx_int_t
+ngx_quic_check_peer(ngx_quic_connection_t *qc, ngx_quic_header_t *pkt)
+{
+ngx_queue_t           *q;
+ngx_quic_client_id_t  *cid;
+if (pkt->level == ssl_encryption_application) {
+return NGX_OK;
+}
+for (q = ngx_queue_head(&qc->client_ids);
+q != ngx_queue_sentinel(&qc->client_ids);
+q = ngx_queue_next(q))
+{
+cid = ngx_queue_data(q, ngx_quic_client_id_t, queue);
+if (pkt->scid.len == cid->len
+&& ngx_memcmp(pkt->scid.data, cid->id, cid->len) == 0)
+{
+return NGX_OK;
+}
+}
+ngx_log_error(NGX_LOG_INFO, pkt->log, 0, "quic unexpected quic scid");
+return NGX_ERROR;
+}
+static ngx_int_t
+ngx_quic_handle_frames(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);
 p = pkt->payload.data;
 end = p + pkt->payload.len;
 do_close = 0;

Mercurial > hg > nginx

comparison src/event/quic/ngx_event_quic.c @ 8687:1c6343bd7933 quic