Nginx/nginx
1
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2024-11-21 16:28:40 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

QUIC: path MTU discovery.

Browse Source 
MTU selection starts by doubling the initial MTU until the first failure.
Then binary search is used to find the path MTU.
This commit is contained in:
Roman Arutyunyan 2023-08-14 09:21:27 +04:00
parent 58fc5e2830
commit eeb8a9f56f
12 changed files with 360 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/core/ngx_connection.c
View File

@ -1583,6 +1583,10 @@ ngx_connection_error(ngx_connection_t *c, ngx_err_t err, char *text)
}
#endif
if (err == NGX_EMSGSIZE && c->log_error == NGX_ERROR_IGNORE_EMSGSIZE) {
return 0;
}
if (err == 0
|| err == NGX_ECONNRESET
#if (NGX_WIN32)
@ -1600,6 +1604,7 @@ ngx_connection_error(ngx_connection_t *c, ngx_err_t err, char *text)
{
switch (c->log_error) {
case NGX_ERROR_IGNORE_EMSGSIZE:
case NGX_ERROR_IGNORE_EINVAL:
case NGX_ERROR_IGNORE_ECONNRESET:
case NGX_ERROR_INFO:

3
src/core/ngx_connection.h
View File

@ -97,7 +97,8 @@ typedef enum {
NGX_ERROR_ERR,
NGX_ERROR_INFO,
NGX_ERROR_IGNORE_ECONNRESET,
NGX_ERROR_IGNORE_EINVAL
NGX_ERROR_IGNORE_EINVAL,
NGX_ERROR_IGNORE_EMSGSIZE
} ngx_connection_log_error_e;

9
src/event/quic/ngx_event_quic.c
View File

@ -149,11 +149,6 @@ ngx_quic_apply_transport_params(ngx_connection_t *c, ngx_quic_tp_t *ctp)
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"quic maximum packet size is invalid");
return NGX_ERROR;
} else if (ctp->max_udp_payload_size > ngx_quic_max_udp_payload(c)) {
ctp->max_udp_payload_size = ngx_quic_max_udp_payload(c);
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic client maximum packet size truncated");
}
if (ctp->active_connection_id_limit < 2) {
@ -286,7 +281,7 @@ ngx_quic_new_connection(ngx_connection_t *c, ngx_quic_conf_t *conf,
qc->path_validation.log = c->log;
qc->path_validation.data = c;
qc->path_validation.handler = ngx_quic_path_validation_handler;
qc->path_validation.handler = ngx_quic_path_handler;
qc->conf = conf;
@ -297,7 +292,7 @@ ngx_quic_new_connection(ngx_connection_t *c, ngx_quic_conf_t *conf,
ctp = &qc->ctp;
/* defaults to be used before actual client parameters are received */
ctp->max_udp_payload_size = ngx_quic_max_udp_payload(c);
ctp->max_udp_payload_size = NGX_QUIC_MAX_UDP_PAYLOAD_SIZE;
ctp->ack_delay_exponent = NGX_QUIC_DEFAULT_ACK_DELAY_EXPONENT;
ctp->max_ack_delay = NGX_QUIC_DEFAULT_MAX_ACK_DELAY;
ctp->active_connection_id_limit = 2;

6
src/event/quic/ngx_event_quic_ack.c
View File

@ -229,6 +229,12 @@ ngx_quic_handle_ack_frame_range(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx,
qc = ngx_quic_get_connection(c);
if (ctx->level == ssl_encryption_application) {
if (ngx_quic_handle_path_mtu(c, qc->path, min, max) != NGX_OK) {
return NGX_ERROR;
}
}
st->max_pn = NGX_TIMER_INFINITE;
found = 0;

16
src/event/quic/ngx_event_quic_connection.h
View File

@ -66,6 +66,14 @@ typedef struct ngx_quic_keys_s ngx_quic_keys_t;
#define ngx_quic_get_socket(c) ((ngx_quic_socket_t *)((c)->udp))
typedef enum {
NGX_QUIC_PATH_IDLE = 0,
NGX_QUIC_PATH_VALIDATING,
NGX_QUIC_PATH_WAITING,
NGX_QUIC_PATH_MTUD
} ngx_quic_path_state_e;
struct ngx_quic_client_id_s {
ngx_queue_t queue;
uint64_t seqnum;
@ -89,18 +97,22 @@ struct ngx_quic_path_s {
ngx_sockaddr_t sa;
socklen_t socklen;
ngx_quic_client_id_t *cid;
ngx_quic_path_state_e state;
ngx_msec_t expires;
ngx_uint_t tries;
ngx_uint_t tag;
size_t mtu;
size_t mtud;
size_t max_mtu;
off_t sent;
off_t received;
u_char challenge1[8];
u_char challenge2[8];
uint64_t seqnum;
uint64_t mtu_pnum[NGX_QUIC_PATH_RETRIES];
ngx_str_t addr_text;
u_char text[NGX_SOCKADDR_STRLEN];
unsigned validated:1;
unsigned validating:1;
ngx_uint_t validated; /* unsigned validated:1; */
};

387
src/event/quic/ngx_event_quic_migration.c
View File

@ -10,6 +10,10 @@
#include <ngx_event_quic_connection.h>
#define NGX_QUIC_PATH_MTU_DELAY 100
#define NGX_QUIC_PATH_MTU_PRECISION 16
static void ngx_quic_set_connection_path(ngx_connection_t *c,
ngx_quic_path_t *path);
static ngx_int_t ngx_quic_validate_path(ngx_connection_t *c,
@ -17,7 +21,15 @@ static ngx_int_t ngx_quic_validate_path(ngx_connection_t *c,
static ngx_int_t ngx_quic_send_path_challenge(ngx_connection_t *c,
ngx_quic_path_t *path);
static void ngx_quic_set_path_timer(ngx_connection_t *c);
static ngx_int_t ngx_quic_expire_path_validation(ngx_connection_t *c,
ngx_quic_path_t *path);
static ngx_int_t ngx_quic_expire_path_mtu_delay(ngx_connection_t *c,
ngx_quic_path_t *path);
static ngx_int_t ngx_quic_expire_path_mtu_discovery(ngx_connection_t *c,
ngx_quic_path_t *path);
static ngx_quic_path_t *ngx_quic_get_path(ngx_connection_t *c, ngx_uint_t tag);
static ngx_int_t ngx_quic_send_path_mtu_probe(ngx_connection_t *c,
ngx_quic_path_t *path);
ngx_int_t
@ -97,7 +109,7 @@ ngx_quic_handle_path_response_frame(ngx_connection_t *c,
{
path = ngx_queue_data(q, ngx_quic_path_t, queue);
if (!path->validating) {
if (path->state != NGX_QUIC_PATH_VALIDATING) {
continue;
}
@ -136,6 +148,9 @@ valid:
{
/* address did not change */
rst = 0;
path->mtu = prev->mtu;
path->max_mtu = prev->max_mtu;
}
}
@ -167,9 +182,8 @@ valid:
ngx_quic_path_dbg(c, "is validated", path);
path->validated = 1;
path->validating = 0;
ngx_quic_set_path_timer(c);
ngx_quic_discover_path_mtu(c, path);
return NGX_OK;
}
@ -217,6 +231,8 @@ ngx_quic_new_path(ngx_connection_t *c,
path->addr_text.len = ngx_sock_ntop(sockaddr, socklen, path->text,
NGX_SOCKADDR_STRLEN, 1);
path->mtu = NGX_QUIC_MIN_INITIAL_SIZE;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic path seq:%uL created addr:%V",
path->seqnum, &path->addr_text);
@ -464,7 +480,7 @@ ngx_quic_handle_migration(ngx_connection_t *c, ngx_quic_header_t *pkt)
ngx_quic_set_connection_path(c, next);
if (!next->validated && !next->validating) {
if (!next->validated && next->state != NGX_QUIC_PATH_VALIDATING) {
if (ngx_quic_validate_path(c, next) != NGX_OK) {
return NGX_ERROR;
}
@ -492,7 +508,6 @@ ngx_quic_validate_path(ngx_connection_t *c, ngx_quic_path_t *path)
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic initiated validation of path seq:%uL", path->seqnum);
path->validating = 1;
path->tries = 0;
if (RAND_bytes(path->challenge1, 8) != 1) {
@ -511,6 +526,7 @@ ngx_quic_validate_path(ngx_connection_t *c, ngx_quic_path_t *path)
pto = ngx_max(ngx_quic_pto(c, ctx), 1000);
path->expires = ngx_current_msec + pto;
path->state = NGX_QUIC_PATH_VALIDATING;
ngx_quic_set_path_timer(c);
@ -558,6 +574,42 @@ ngx_quic_send_path_challenge(ngx_connection_t *c, ngx_quic_path_t *path)
}
void
ngx_quic_discover_path_mtu(ngx_connection_t *c, ngx_quic_path_t *path)
{
ngx_quic_connection_t *qc;
qc = ngx_quic_get_connection(c);
if (path->max_mtu) {
if (path->max_mtu - path->mtu <= NGX_QUIC_PATH_MTU_PRECISION) {
path->state = NGX_QUIC_PATH_IDLE;
ngx_quic_set_path_timer(c);
return;
}
path->mtud = (path->mtu + path->max_mtu) / 2;
} else {
path->mtud = path->mtu * 2;
if (path->mtud >= qc->ctp.max_udp_payload_size) {
path->mtud = qc->ctp.max_udp_payload_size;
path->max_mtu = qc->ctp.max_udp_payload_size;
}
}
path->state = NGX_QUIC_PATH_WAITING;
path->expires = ngx_current_msec + NGX_QUIC_PATH_MTU_DELAY;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic path seq:%uL schedule mtu:%uz",
path->seqnum, path->mtud);
ngx_quic_set_path_timer(c);
}
static void
ngx_quic_set_path_timer(ngx_connection_t *c)
{
@ -578,7 +630,7 @@ ngx_quic_set_path_timer(ngx_connection_t *c)
{
path = ngx_queue_data(q, ngx_quic_path_t, queue);
if (!path->validating) {
if (path->state == NGX_QUIC_PATH_IDLE) {
continue;
}
@ -600,22 +652,18 @@ ngx_quic_set_path_timer(ngx_connection_t *c)
void
ngx_quic_path_validation_handler(ngx_event_t *ev)
ngx_quic_path_handler(ngx_event_t *ev)
{
ngx_msec_t now;
ngx_queue_t *q;
ngx_msec_int_t left, next, pto;
ngx_quic_path_t *path, *bkp;
ngx_msec_int_t left;
ngx_quic_path_t *path;
ngx_connection_t *c;
ngx_quic_send_ctx_t *ctx;
ngx_quic_connection_t *qc;
c = ev->data;
qc = ngx_quic_get_connection(c);
ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application);
next = -1;
now = ngx_current_msec;
q = ngx_queue_head(&qc->paths);
@ -625,83 +673,280 @@ ngx_quic_path_validation_handler(ngx_event_t *ev)
path = ngx_queue_data(q, ngx_quic_path_t, queue);
q = ngx_queue_next(q);
if (!path->validating) {
if (path->state == NGX_QUIC_PATH_IDLE) {
continue;
}
left = path->expires - now;
if (left > 0) {
if (next == -1 || left < next) {
next = left;
}
continue;
}
if (++path->tries < NGX_QUIC_PATH_RETRIES) {
pto = ngx_max(ngx_quic_pto(c, ctx), 1000) << path->tries;
path->expires = ngx_current_msec + pto;
if (next == -1 || pto < next) {
next = pto;
switch (path->state) {
case NGX_QUIC_PATH_VALIDATING:
if (ngx_quic_expire_path_validation(c, path) != NGX_OK) {
goto failed;
}
/* retransmit */
(void) ngx_quic_send_path_challenge(c, path);
break;
continue;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
"quic path seq:%uL validation failed", path->seqnum);
/* found expired path */
path->validated = 0;
path->validating = 0;
/* RFC 9000, 9.3.2. On-Path Address Spoofing
*
* To protect the connection from failing due to such a spurious
* migration, an endpoint MUST revert to using the last validated
* peer address when validation of a new peer address fails.
*/
if (qc->path == path) {
/* active path validation failed */
bkp = ngx_quic_get_path(c, NGX_QUIC_PATH_BACKUP);
if (bkp == NULL) {
qc->error = NGX_QUIC_ERR_NO_VIABLE_PATH;
qc->error_reason = "no viable path";
ngx_quic_close_connection(c, NGX_ERROR);
return;
case NGX_QUIC_PATH_WAITING:
if (ngx_quic_expire_path_mtu_delay(c, path) != NGX_OK) {
goto failed;
}
qc->path = bkp;
qc->path->tag = NGX_QUIC_PATH_ACTIVE;
break;
ngx_quic_set_connection_path(c, qc->path);
case NGX_QUIC_PATH_MTUD:
if (ngx_quic_expire_path_mtu_discovery(c, path) != NGX_OK) {
goto failed;
}
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"quic path seq:%uL addr:%V is restored from backup",
qc->path->seqnum, &qc->path->addr_text);
break;
ngx_quic_path_dbg(c, "is active", qc->path);
}
if (ngx_quic_free_path(c, path) != NGX_OK) {
ngx_quic_close_connection(c, NGX_ERROR);
return;
default:
break;
}
}
if (next != -1) {
ngx_add_timer(&qc->path_validation, next);
ngx_quic_set_path_timer(c);
return;
failed:
ngx_quic_close_connection(c, NGX_ERROR);
}
static ngx_int_t
ngx_quic_expire_path_validation(ngx_connection_t *c, ngx_quic_path_t *path)
{
ngx_msec_int_t pto;
ngx_quic_path_t *bkp;
ngx_quic_send_ctx_t *ctx;
ngx_quic_connection_t *qc;
qc = ngx_quic_get_connection(c);
ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application);
if (++path->tries < NGX_QUIC_PATH_RETRIES) {
pto = ngx_max(ngx_quic_pto(c, ctx), 1000) << path->tries;
path->expires = ngx_current_msec + pto;
(void) ngx_quic_send_path_challenge(c, path);
return NGX_OK;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic path seq:%uL validation failed", path->seqnum);
/* found expired path */
path->validated = 0;
/* RFC 9000, 9.3.2. On-Path Address Spoofing
*
* To protect the connection from failing due to such a spurious
* migration, an endpoint MUST revert to using the last validated
* peer address when validation of a new peer address fails.
*/
if (qc->path == path) {
/* active path validation failed */
bkp = ngx_quic_get_path(c, NGX_QUIC_PATH_BACKUP);
if (bkp == NULL) {
qc->error = NGX_QUIC_ERR_NO_VIABLE_PATH;
qc->error_reason = "no viable path";
return NGX_ERROR;
}
qc->path = bkp;
qc->path->tag = NGX_QUIC_PATH_ACTIVE;
ngx_quic_set_connection_path(c, qc->path);
ngx_log_error(NGX_LOG_INFO, c->log, 0,
"quic path seq:%uL addr:%V is restored from backup",
qc->path->seqnum, &qc->path->addr_text);
ngx_quic_path_dbg(c, "is active", qc->path);
}
return ngx_quic_free_path(c, path);
}
static ngx_int_t
ngx_quic_expire_path_mtu_delay(ngx_connection_t *c, ngx_quic_path_t *path)
{
ngx_int_t rc;
ngx_uint_t i;
ngx_msec_t pto;
ngx_quic_send_ctx_t *ctx;
ngx_quic_connection_t *qc;
qc = ngx_quic_get_connection(c);
ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application);
path->tries = 0;
for ( ;; ) {
for (i = 0; i < NGX_QUIC_PATH_RETRIES; i++) {
path->mtu_pnum[i] = NGX_QUIC_UNSET_PN;
}
rc = ngx_quic_send_path_mtu_probe(c, path);
if (rc == NGX_ERROR) {
return NGX_ERROR;
}
if (rc == NGX_OK) {
pto = ngx_quic_pto(c, ctx);
path->expires = ngx_current_msec + pto;
path->state = NGX_QUIC_PATH_MTUD;
return NGX_OK;
}
/* rc == NGX_DECLINED */
path->max_mtu = path->mtud;
if (path->max_mtu - path->mtu <= NGX_QUIC_PATH_MTU_PRECISION) {
path->state = NGX_QUIC_PATH_IDLE;
return NGX_OK;
}
path->mtud = (path->mtu + path->max_mtu) / 2;
}
}
static ngx_int_t
ngx_quic_expire_path_mtu_discovery(ngx_connection_t *c, ngx_quic_path_t *path)
{
ngx_int_t rc;
ngx_msec_int_t pto;
ngx_quic_send_ctx_t *ctx;
ngx_quic_connection_t *qc;
qc = ngx_quic_get_connection(c);
ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application);
if (++path->tries < NGX_QUIC_PATH_RETRIES) {
rc = ngx_quic_send_path_mtu_probe(c, path);
if (rc == NGX_ERROR) {
return NGX_ERROR;
}
if (rc == NGX_OK) {
pto = ngx_quic_pto(c, ctx) << path->tries;
path->expires = ngx_current_msec + pto;
return NGX_OK;
}
/* rc == NGX_DECLINED */
}
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic path seq:%uL expired mtu:%uz",
path->seqnum, path->mtud);
path->max_mtu = path->mtud;
ngx_quic_discover_path_mtu(c, path);
return NGX_OK;
}
static ngx_int_t
ngx_quic_send_path_mtu_probe(ngx_connection_t *c, ngx_quic_path_t *path)
{
ngx_int_t rc;
ngx_uint_t log_error;
ngx_quic_frame_t frame;
ngx_quic_send_ctx_t *ctx;
ngx_quic_connection_t *qc;
ngx_memzero(&frame, sizeof(ngx_quic_frame_t));
frame.level = ssl_encryption_application;
frame.type = NGX_QUIC_FT_PING;
qc = ngx_quic_get_connection(c);
ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application);
path->mtu_pnum[path->tries] = ctx->pnum;
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic path seq:%uL send probe "
"mtu:%uz pnum:%uL tries:%ui",
path->seqnum, path->mtud, ctx->pnum, path->tries);
log_error = c->log_error;
c->log_error = NGX_ERROR_IGNORE_EMSGSIZE;
rc = ngx_quic_frame_sendto(c, &frame, path->mtud, path);
c->log_error = log_error;
if (rc == NGX_ERROR) {
if (c->write->error) {
c->write->error = 0;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic path seq:%uL rejected mtu:%uz",
path->seqnum, path->mtud);
return NGX_DECLINED;
}
return NGX_ERROR;
}
return NGX_OK;
}
ngx_int_t
ngx_quic_handle_path_mtu(ngx_connection_t *c, ngx_quic_path_t *path,
uint64_t min, uint64_t max)
{
uint64_t pnum;
ngx_uint_t i;
if (path->state != NGX_QUIC_PATH_MTUD) {
return NGX_OK;
}
for (i = 0; i < NGX_QUIC_PATH_RETRIES; i++) {
pnum = path->mtu_pnum[i];
if (pnum == NGX_QUIC_UNSET_PN) {
break;
}
if (pnum < min || pnum > max) {
continue;
}
path->mtu = path->mtud;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"quic path seq:%uL ack mtu:%uz",
path->seqnum, path->mtu);
ngx_quic_discover_path_mtu(c, path);
break;
}
return NGX_OK;
}

12
src/event/quic/ngx_event_quic_migration.h
View File

@ -18,10 +18,10 @@
#define NGX_QUIC_PATH_BACKUP 2
#define ngx_quic_path_dbg(c, msg, path) \
ngx_log_debug6(NGX_LOG_DEBUG_EVENT, c->log, 0, \
"quic path seq:%uL %s sent:%O recvd:%O state:%s%s", \
ngx_log_debug7(NGX_LOG_DEBUG_EVENT, c->log, 0, \
"quic path seq:%uL %s tx:%O rx:%O valid:%ui st:%d mtu:%uz",\
path->seqnum, msg, path->sent, path->received, \
path->validated ? "V": "N", path->validating ? "R": "");
path->validated, path->state, path->mtu);
ngx_int_t ngx_quic_handle_path_challenge_frame(ngx_connection_t *c,
ngx_quic_header_t *pkt, ngx_quic_path_challenge_frame_t *f);
@ -36,6 +36,10 @@ ngx_int_t ngx_quic_set_path(ngx_connection_t *c, ngx_quic_header_t *pkt);
ngx_int_t ngx_quic_handle_migration(ngx_connection_t *c,
ngx_quic_header_t *pkt);
void ngx_quic_path_validation_handler(ngx_event_t *ev);
void ngx_quic_path_handler(ngx_event_t *ev);
void ngx_quic_discover_path_mtu(ngx_connection_t *c, ngx_quic_path_t *path);
ngx_int_t ngx_quic_handle_path_mtu(ngx_connection_t *c,
ngx_quic_path_t *path, uint64_t min, uint64_t max);
#endif /* _NGX_EVENT_QUIC_MIGRATION_H_INCLUDED_ */

30
src/event/quic/ngx_event_quic_output.c
View File

@ -10,9 +10,6 @@
#include <ngx_event_quic_connection.h>
#define NGX_QUIC_MAX_UDP_PAYLOAD_OUT 1252
#define NGX_QUIC_MAX_UDP_PAYLOAD_OUT6 1232
#define NGX_QUIC_MAX_UDP_SEGMENT_BUF 65487 /* 65K - IPv6 header */
#define NGX_QUIC_MAX_SEGMENTS 64 /* UDP_MAX_SEGMENTS */
@ -61,21 +58,6 @@ static size_t ngx_quic_path_limit(ngx_connection_t *c, ngx_quic_path_t *path,
size_t size);
size_t
ngx_quic_max_udp_payload(ngx_connection_t *c)
{
/* TODO: path MTU discovery */
#if (NGX_HAVE_INET6)
if (c->sockaddr->sa_family == AF_INET6) {
return NGX_QUIC_MAX_UDP_PAYLOAD_OUT6;
}
#endif
return NGX_QUIC_MAX_UDP_PAYLOAD_OUT;
}
ngx_int_t
ngx_quic_output(ngx_connection_t *c)
{
@ -142,10 +124,7 @@ ngx_quic_create_datagrams(ngx_connection_t *c)
p = dst;
len = ngx_min(qc->ctp.max_udp_payload_size,
NGX_QUIC_MAX_UDP_PAYLOAD_SIZE);
len = ngx_quic_path_limit(c, path, len);
len = ngx_quic_path_limit(c, path, path->mtu);
pad = ngx_quic_get_padding_level(c);
@ -299,9 +278,7 @@ ngx_quic_allow_segmentation(ngx_connection_t *c)
ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application);
bytes = 0;
len = ngx_min(qc->ctp.max_udp_payload_size,
NGX_QUIC_MAX_UDP_SEGMENT_BUF);
len = ngx_min(qc->path->mtu, NGX_QUIC_MAX_UDP_SEGMENT_BUF);
for (q = ngx_queue_head(&ctx->frames);
q != ngx_queue_sentinel(&ctx->frames);
@ -345,8 +322,7 @@ ngx_quic_create_segments(ngx_connection_t *c)
return NGX_ERROR;
}
segsize = ngx_min(qc->ctp.max_udp_payload_size,
NGX_QUIC_MAX_UDP_SEGMENT_BUF);
segsize = ngx_min(path->mtu, NGX_QUIC_MAX_UDP_SEGMENT_BUF);
p = dst;
end = dst + sizeof(dst);

2
src/event/quic/ngx_event_quic_output.h
View File

@ -12,8 +12,6 @@
#include <ngx_core.h>
size_t ngx_quic_max_udp_payload(ngx_connection_t *c);
ngx_int_t ngx_quic_output(ngx_connection_t *c);
ngx_int_t ngx_quic_negotiate_version(ngx_connection_t *c,

2
src/event/quic/ngx_event_quic_ssl.c
View File

@ -494,6 +494,8 @@ ngx_quic_crypto_input(ngx_connection_t *c, ngx_chain_t *data)
*/
ngx_quic_discard_ctx(c, ssl_encryption_handshake);
ngx_quic_discover_path_mtu(c, qc->path);
/* start accepting clients on negotiated number of server ids */
if (ngx_quic_create_sockets(c) != NGX_OK) {
return NGX_ERROR;

1
src/os/unix/ngx_errno.h
View File

@ -54,6 +54,7 @@ typedef int ngx_err_t;
#define NGX_ENOMOREFILES 0
#define NGX_ELOOP ELOOP
#define NGX_EBADF EBADF
#define NGX_EMSGSIZE EMSGSIZE
#if (NGX_HAVE_OPENAT)
#define NGX_EMLINK EMLINK

1
src/os/win32/ngx_errno.h
View File

@ -57,6 +57,7 @@ typedef DWORD ngx_err_t;
#define NGX_EILSEQ ERROR_NO_UNICODE_TRANSLATION
#define NGX_ELOOP 0
#define NGX_EBADF WSAEBADF
#define NGX_EMSGSIZE WSAEMSGSIZE
#define NGX_EALREADY WSAEALREADY
#define NGX_EINVAL WSAEINVAL