Mercurial > hg > nginx
annotate src/event/quic/ngx_event_quic_output.c @ 9147:58afcd72446f
QUIC: path MTU discovery.
MTU selection starts by doubling the initial MTU until the first failure.
Then binary search is used to find the path MTU.
author | Roman Arutyunyan <arut@nginx.com> |
---|---|
date | Mon, 14 Aug 2023 09:21:27 +0400 |
parents | f3412ec3b6d1 |
children | 60c4e8d3151f |
rev | line source |
---|---|
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
2 /* |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
3 * Copyright (C) Nginx, Inc. |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
4 */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
5 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
6 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
7 #include <ngx_config.h> |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
8 #include <ngx_core.h> |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
9 #include <ngx_event.h> |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
10 #include <ngx_event_quic_connection.h> |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
11 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
12 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
13 #define NGX_QUIC_MAX_UDP_SEGMENT_BUF 65487 /* 65K - IPv6 header */ |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
14 #define NGX_QUIC_MAX_SEGMENTS 64 /* UDP_MAX_SEGMENTS */ |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
15 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
16 #define NGX_QUIC_RETRY_TOKEN_LIFETIME 3 /* seconds */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
17 #define NGX_QUIC_NEW_TOKEN_LIFETIME 600 /* seconds */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
18 #define NGX_QUIC_RETRY_BUFFER_SIZE 256 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
19 /* 1 flags + 4 version + 3 x (1 + 20) s/o/dcid + itag + token(64) */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
20 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
21 /* |
8797
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
22 * RFC 9000, 10.3. Stateless Reset |
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
23 * |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
24 * Endpoints MUST discard packets that are too small to be valid QUIC |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
25 * packets. With the set of AEAD functions defined in [QUIC-TLS], |
8797
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
26 * short header packets that are smaller than 21 bytes are never valid. |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
27 */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
28 #define NGX_QUIC_MIN_PKT_LEN 21 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
29 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
30 #define NGX_QUIC_MIN_SR_PACKET 43 /* 5 rand + 16 srt + 22 padding */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
31 #define NGX_QUIC_MAX_SR_PACKET 1200 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
32 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
33 #define NGX_QUIC_CC_MIN_INTERVAL 1000 /* 1s */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
34 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
35 #define NGX_QUIC_SOCKET_RETRY_DELAY 10 /* ms, for NGX_AGAIN on write */ |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
36 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
37 |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
38 static ngx_int_t ngx_quic_create_datagrams(ngx_connection_t *c); |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
39 static void ngx_quic_commit_send(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
40 static void ngx_quic_revert_send(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
41 uint64_t pnum); |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
42 #if ((NGX_HAVE_UDP_SEGMENT) && (NGX_HAVE_MSGHDR_MSG_CONTROL)) |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
43 static ngx_uint_t ngx_quic_allow_segmentation(ngx_connection_t *c); |
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
44 static ngx_int_t ngx_quic_create_segments(ngx_connection_t *c); |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
45 static ssize_t ngx_quic_send_segments(ngx_connection_t *c, u_char *buf, |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
46 size_t len, struct sockaddr *sockaddr, socklen_t socklen, size_t segment); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
47 #endif |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
48 static ssize_t ngx_quic_output_packet(ngx_connection_t *c, |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
49 ngx_quic_send_ctx_t *ctx, u_char *data, size_t max, size_t min); |
8892
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
50 static void ngx_quic_init_packet(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
51 ngx_quic_header_t *pkt, ngx_quic_path_t *path); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
52 static ngx_uint_t ngx_quic_get_padding_level(ngx_connection_t *c); |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
53 static ssize_t ngx_quic_send(ngx_connection_t *c, u_char *buf, size_t len, |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
54 struct sockaddr *sockaddr, socklen_t socklen); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
55 static void ngx_quic_set_packet_number(ngx_quic_header_t *pkt, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
56 ngx_quic_send_ctx_t *ctx); |
8941
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
57 static size_t ngx_quic_path_limit(ngx_connection_t *c, ngx_quic_path_t *path, |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
58 size_t size); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
59 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
60 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
61 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
62 ngx_quic_output(ngx_connection_t *c) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
63 { |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
64 size_t in_flight; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
65 ngx_int_t rc; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
66 ngx_quic_congestion_t *cg; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
67 ngx_quic_connection_t *qc; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
68 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
69 c->log->action = "sending frames"; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
70 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
71 qc = ngx_quic_get_connection(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
72 cg = &qc->congestion; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
73 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
74 in_flight = cg->in_flight; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
75 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
76 #if ((NGX_HAVE_UDP_SEGMENT) && (NGX_HAVE_MSGHDR_MSG_CONTROL)) |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
77 if (ngx_quic_allow_segmentation(c)) { |
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
78 rc = ngx_quic_create_segments(c); |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
79 } else |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
80 #endif |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
81 { |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
82 rc = ngx_quic_create_datagrams(c); |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
83 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
84 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
85 if (rc != NGX_OK) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
86 return NGX_ERROR; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
87 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
88 |
9001
868e1b76c956
QUIC: do not arm loss detection timer if nothing was sent.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9000
diff
changeset
|
89 if (in_flight == cg->in_flight || qc->closing) { |
868e1b76c956
QUIC: do not arm loss detection timer if nothing was sent.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9000
diff
changeset
|
90 /* no ack-eliciting data was sent or we are done */ |
868e1b76c956
QUIC: do not arm loss detection timer if nothing was sent.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9000
diff
changeset
|
91 return NGX_OK; |
868e1b76c956
QUIC: do not arm loss detection timer if nothing was sent.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9000
diff
changeset
|
92 } |
868e1b76c956
QUIC: do not arm loss detection timer if nothing was sent.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9000
diff
changeset
|
93 |
868e1b76c956
QUIC: do not arm loss detection timer if nothing was sent.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9000
diff
changeset
|
94 if (!qc->send_timer_set) { |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
95 qc->send_timer_set = 1; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
96 ngx_add_timer(c->read, qc->tp.max_idle_timeout); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
97 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
98 |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
99 ngx_quic_set_lost_timer(c); |
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
100 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
101 return NGX_OK; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
102 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
103 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
104 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
105 static ngx_int_t |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
106 ngx_quic_create_datagrams(ngx_connection_t *c) |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
107 { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
108 size_t len, min; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
109 ssize_t n; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
110 u_char *p; |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
111 uint64_t preserved_pnum[NGX_QUIC_SEND_CTX_LAST]; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
112 ngx_uint_t i, pad; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
113 ngx_quic_path_t *path; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
114 ngx_quic_send_ctx_t *ctx; |
8823
f3331deed357
QUIC: limit in-flight bytes by congestion window.
Roman Arutyunyan <arut@nginx.com>
parents:
8822
diff
changeset
|
115 ngx_quic_congestion_t *cg; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
116 ngx_quic_connection_t *qc; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
117 static u_char dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE]; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
118 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
119 qc = ngx_quic_get_connection(c); |
8823
f3331deed357
QUIC: limit in-flight bytes by congestion window.
Roman Arutyunyan <arut@nginx.com>
parents:
8822
diff
changeset
|
120 cg = &qc->congestion; |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
121 path = qc->path; |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
122 |
8823
f3331deed357
QUIC: limit in-flight bytes by congestion window.
Roman Arutyunyan <arut@nginx.com>
parents:
8822
diff
changeset
|
123 while (cg->in_flight < cg->window) { |
f3331deed357
QUIC: limit in-flight bytes by congestion window.
Roman Arutyunyan <arut@nginx.com>
parents:
8822
diff
changeset
|
124 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
125 p = dst; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
126 |
9147
58afcd72446f
QUIC: path MTU discovery.
Roman Arutyunyan <arut@nginx.com>
parents:
9146
diff
changeset
|
127 len = ngx_quic_path_limit(c, path, path->mtu); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
128 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
129 pad = ngx_quic_get_padding_level(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
130 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
131 for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
132 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
133 ctx = &qc->send_ctx[i]; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
134 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
135 preserved_pnum[i] = ctx->pnum; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
136 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
137 if (ngx_quic_generate_ack(c, ctx) != NGX_OK) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
138 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
139 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
140 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
141 min = (i == pad && p - dst < NGX_QUIC_MIN_INITIAL_SIZE) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
142 ? NGX_QUIC_MIN_INITIAL_SIZE - (p - dst) : 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
143 |
8891
c5155a0cb12f
QUIC: fixed processing of minimum packet size.
Vladimir Homutov <vl@nginx.com>
parents:
8823
diff
changeset
|
144 if (min > len) { |
9000
cd8018bc81a5
QUIC: fixed padding of initial packets in case of limited path.
Vladimir Homutov <vl@nginx.com>
parents:
8994
diff
changeset
|
145 /* padding can't be applied - avoid sending the packet */ |
cd8018bc81a5
QUIC: fixed padding of initial packets in case of limited path.
Vladimir Homutov <vl@nginx.com>
parents:
8994
diff
changeset
|
146 |
9006
5f78174d1ac1
QUIC: fixed output context restoring.
Vladimir Homutov <vl@nginx.com>
parents:
9001
diff
changeset
|
147 while (i-- > 0) { |
9000
cd8018bc81a5
QUIC: fixed padding of initial packets in case of limited path.
Vladimir Homutov <vl@nginx.com>
parents:
8994
diff
changeset
|
148 ctx = &qc->send_ctx[i]; |
cd8018bc81a5
QUIC: fixed padding of initial packets in case of limited path.
Vladimir Homutov <vl@nginx.com>
parents:
8994
diff
changeset
|
149 ngx_quic_revert_send(c, ctx, preserved_pnum[i]); |
cd8018bc81a5
QUIC: fixed padding of initial packets in case of limited path.
Vladimir Homutov <vl@nginx.com>
parents:
8994
diff
changeset
|
150 } |
cd8018bc81a5
QUIC: fixed padding of initial packets in case of limited path.
Vladimir Homutov <vl@nginx.com>
parents:
8994
diff
changeset
|
151 |
cd8018bc81a5
QUIC: fixed padding of initial packets in case of limited path.
Vladimir Homutov <vl@nginx.com>
parents:
8994
diff
changeset
|
152 return NGX_OK; |
8891
c5155a0cb12f
QUIC: fixed processing of minimum packet size.
Vladimir Homutov <vl@nginx.com>
parents:
8823
diff
changeset
|
153 } |
c5155a0cb12f
QUIC: fixed processing of minimum packet size.
Vladimir Homutov <vl@nginx.com>
parents:
8823
diff
changeset
|
154 |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
155 n = ngx_quic_output_packet(c, ctx, p, len, min); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
156 if (n == NGX_ERROR) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
157 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
158 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
159 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
160 p += n; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
161 len -= n; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
162 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
163 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
164 len = p - dst; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
165 if (len == 0) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
166 break; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
167 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
168 |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
169 n = ngx_quic_send(c, dst, len, path->sockaddr, path->socklen); |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
170 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
171 if (n == NGX_ERROR) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
172 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
173 } |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
174 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
175 if (n == NGX_AGAIN) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
176 for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
177 ngx_quic_revert_send(c, &qc->send_ctx[i], preserved_pnum[i]); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
178 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
179 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
180 ngx_add_timer(&qc->push, NGX_QUIC_SOCKET_RETRY_DELAY); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
181 break; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
182 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
183 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
184 for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
185 ngx_quic_commit_send(c, &qc->send_ctx[i]); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
186 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
187 |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
188 path->sent += len; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
189 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
190 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
191 return NGX_OK; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
192 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
193 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
194 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
195 static void |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
196 ngx_quic_commit_send(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx) |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
197 { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
198 ngx_queue_t *q; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
199 ngx_quic_frame_t *f; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
200 ngx_quic_congestion_t *cg; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
201 ngx_quic_connection_t *qc; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
202 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
203 qc = ngx_quic_get_connection(c); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
204 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
205 cg = &qc->congestion; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
206 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
207 while (!ngx_queue_empty(&ctx->sending)) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
208 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
209 q = ngx_queue_head(&ctx->sending); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
210 f = ngx_queue_data(q, ngx_quic_frame_t, queue); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
211 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
212 ngx_queue_remove(q); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
213 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
214 if (f->pkt_need_ack && !qc->closing) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
215 ngx_queue_insert_tail(&ctx->sent, q); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
216 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
217 cg->in_flight += f->plen; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
218 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
219 } else { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
220 ngx_quic_free_frame(c, f); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
221 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
222 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
223 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
224 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
225 "quic congestion send if:%uz", cg->in_flight); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
226 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
227 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
228 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
229 static void |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
230 ngx_quic_revert_send(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
231 uint64_t pnum) |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
232 { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
233 ngx_queue_t *q; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
234 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
235 while (!ngx_queue_empty(&ctx->sending)) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
236 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
237 q = ngx_queue_last(&ctx->sending); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
238 ngx_queue_remove(q); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
239 ngx_queue_insert_head(&ctx->frames, q); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
240 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
241 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
242 ctx->pnum = pnum; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
243 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
244 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
245 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
246 #if ((NGX_HAVE_UDP_SEGMENT) && (NGX_HAVE_MSGHDR_MSG_CONTROL)) |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
247 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
248 static ngx_uint_t |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
249 ngx_quic_allow_segmentation(ngx_connection_t *c) |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
250 { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
251 size_t bytes, len; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
252 ngx_queue_t *q; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
253 ngx_quic_frame_t *f; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
254 ngx_quic_send_ctx_t *ctx; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
255 ngx_quic_connection_t *qc; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
256 |
8815
8ab0d609af09
QUIC: the "quic_gso" directive.
Vladimir Homutov <vl@nginx.com>
parents:
8811
diff
changeset
|
257 qc = ngx_quic_get_connection(c); |
8ab0d609af09
QUIC: the "quic_gso" directive.
Vladimir Homutov <vl@nginx.com>
parents:
8811
diff
changeset
|
258 |
8ab0d609af09
QUIC: the "quic_gso" directive.
Vladimir Homutov <vl@nginx.com>
parents:
8811
diff
changeset
|
259 if (!qc->conf->gso_enabled) { |
8ab0d609af09
QUIC: the "quic_gso" directive.
Vladimir Homutov <vl@nginx.com>
parents:
8811
diff
changeset
|
260 return 0; |
8ab0d609af09
QUIC: the "quic_gso" directive.
Vladimir Homutov <vl@nginx.com>
parents:
8811
diff
changeset
|
261 } |
8ab0d609af09
QUIC: the "quic_gso" directive.
Vladimir Homutov <vl@nginx.com>
parents:
8811
diff
changeset
|
262 |
9144
bba136612fe4
QUIC: removed path->limited flag.
Roman Arutyunyan <arut@nginx.com>
parents:
9143
diff
changeset
|
263 if (!qc->path->validated) { |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
264 /* don't even try to be faster on non-validated paths */ |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
265 return 0; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
266 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
267 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
268 ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_initial); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
269 if (!ngx_queue_empty(&ctx->frames)) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
270 return 0; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
271 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
272 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
273 ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_handshake); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
274 if (!ngx_queue_empty(&ctx->frames)) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
275 return 0; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
276 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
277 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
278 ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
279 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
280 bytes = 0; |
9147
58afcd72446f
QUIC: path MTU discovery.
Roman Arutyunyan <arut@nginx.com>
parents:
9146
diff
changeset
|
281 len = ngx_min(qc->path->mtu, NGX_QUIC_MAX_UDP_SEGMENT_BUF); |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
282 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
283 for (q = ngx_queue_head(&ctx->frames); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
284 q != ngx_queue_sentinel(&ctx->frames); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
285 q = ngx_queue_next(q)) |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
286 { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
287 f = ngx_queue_data(q, ngx_quic_frame_t, queue); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
288 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
289 bytes += f->len; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
290 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
291 if (bytes > len * 3) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
292 /* require at least ~3 full packets to batch */ |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
293 return 1; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
294 } |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
295 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
296 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
297 return 0; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
298 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
299 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
300 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
301 static ngx_int_t |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
302 ngx_quic_create_segments(ngx_connection_t *c) |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
303 { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
304 size_t len, segsize; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
305 ssize_t n; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
306 u_char *p, *end; |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
307 uint64_t preserved_pnum; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
308 ngx_uint_t nseg; |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
309 ngx_quic_path_t *path; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
310 ngx_quic_send_ctx_t *ctx; |
8823
f3331deed357
QUIC: limit in-flight bytes by congestion window.
Roman Arutyunyan <arut@nginx.com>
parents:
8822
diff
changeset
|
311 ngx_quic_congestion_t *cg; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
312 ngx_quic_connection_t *qc; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
313 static u_char dst[NGX_QUIC_MAX_UDP_SEGMENT_BUF]; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
314 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
315 qc = ngx_quic_get_connection(c); |
8823
f3331deed357
QUIC: limit in-flight bytes by congestion window.
Roman Arutyunyan <arut@nginx.com>
parents:
8822
diff
changeset
|
316 cg = &qc->congestion; |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
317 path = qc->path; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
318 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
319 ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_application); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
320 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
321 if (ngx_quic_generate_ack(c, ctx) != NGX_OK) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
322 return NGX_ERROR; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
323 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
324 |
9147
58afcd72446f
QUIC: path MTU discovery.
Roman Arutyunyan <arut@nginx.com>
parents:
9146
diff
changeset
|
325 segsize = ngx_min(path->mtu, NGX_QUIC_MAX_UDP_SEGMENT_BUF); |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
326 p = dst; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
327 end = dst + sizeof(dst); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
328 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
329 nseg = 0; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
330 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
331 preserved_pnum = ctx->pnum; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
332 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
333 for ( ;; ) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
334 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
335 len = ngx_min(segsize, (size_t) (end - p)); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
336 |
9140
e9a003d40485
QUIC: fixed congesion control in GSO mode.
Roman Arutyunyan <arut@nginx.com>
parents:
9139
diff
changeset
|
337 if (len && cg->in_flight + (p - dst) < cg->window) { |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
338 |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
339 n = ngx_quic_output_packet(c, ctx, p, len, len); |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
340 if (n == NGX_ERROR) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
341 return NGX_ERROR; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
342 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
343 |
8899
25b87b392ce0
QUIC: fixed GSO packets count.
Vladimir Homutov <vl@nginx.com>
parents:
8894
diff
changeset
|
344 if (n) { |
25b87b392ce0
QUIC: fixed GSO packets count.
Vladimir Homutov <vl@nginx.com>
parents:
8894
diff
changeset
|
345 p += n; |
25b87b392ce0
QUIC: fixed GSO packets count.
Vladimir Homutov <vl@nginx.com>
parents:
8894
diff
changeset
|
346 nseg++; |
25b87b392ce0
QUIC: fixed GSO packets count.
Vladimir Homutov <vl@nginx.com>
parents:
8894
diff
changeset
|
347 } |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
348 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
349 } else { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
350 n = 0; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
351 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
352 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
353 if (p == dst) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
354 break; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
355 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
356 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
357 if (n == 0 || nseg == NGX_QUIC_MAX_SEGMENTS) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
358 n = ngx_quic_send_segments(c, dst, p - dst, path->sockaddr, |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
359 path->socklen, segsize); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
360 if (n == NGX_ERROR) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
361 return NGX_ERROR; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
362 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
363 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
364 if (n == NGX_AGAIN) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
365 ngx_quic_revert_send(c, ctx, preserved_pnum); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
366 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
367 ngx_add_timer(&qc->push, NGX_QUIC_SOCKET_RETRY_DELAY); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
368 break; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
369 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
370 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
371 ngx_quic_commit_send(c, ctx); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
372 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
373 path->sent += n; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
374 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
375 p = dst; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
376 nseg = 0; |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
377 preserved_pnum = ctx->pnum; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
378 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
379 } |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
380 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
381 return NGX_OK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
382 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
383 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
384 |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
385 static ssize_t |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
386 ngx_quic_send_segments(ngx_connection_t *c, u_char *buf, size_t len, |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
387 struct sockaddr *sockaddr, socklen_t socklen, size_t segment) |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
388 { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
389 size_t clen; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
390 ssize_t n; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
391 uint16_t *valp; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
392 struct iovec iov; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
393 struct msghdr msg; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
394 struct cmsghdr *cmsg; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
395 |
8976 | 396 #if (NGX_HAVE_ADDRINFO_CMSG) |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
397 char msg_control[CMSG_SPACE(sizeof(uint16_t)) |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
398 + CMSG_SPACE(sizeof(ngx_addrinfo_t))]; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
399 #else |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
400 char msg_control[CMSG_SPACE(sizeof(uint16_t))]; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
401 #endif |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
402 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
403 ngx_memzero(&msg, sizeof(struct msghdr)); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
404 ngx_memzero(msg_control, sizeof(msg_control)); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
405 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
406 iov.iov_len = len; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
407 iov.iov_base = buf; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
408 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
409 msg.msg_iov = &iov; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
410 msg.msg_iovlen = 1; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
411 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
412 msg.msg_name = sockaddr; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
413 msg.msg_namelen = socklen; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
414 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
415 msg.msg_control = msg_control; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
416 msg.msg_controllen = sizeof(msg_control); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
417 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
418 cmsg = CMSG_FIRSTHDR(&msg); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
419 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
420 cmsg->cmsg_level = SOL_UDP; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
421 cmsg->cmsg_type = UDP_SEGMENT; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
422 cmsg->cmsg_len = CMSG_LEN(sizeof(uint16_t)); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
423 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
424 clen = CMSG_SPACE(sizeof(uint16_t)); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
425 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
426 valp = (void *) CMSG_DATA(cmsg); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
427 *valp = segment; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
428 |
8976 | 429 #if (NGX_HAVE_ADDRINFO_CMSG) |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
430 if (c->listening && c->listening->wildcard && c->local_sockaddr) { |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
431 cmsg = CMSG_NXTHDR(&msg, cmsg); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
432 clen += ngx_set_srcaddr_cmsg(cmsg, c->local_sockaddr); |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
433 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
434 #endif |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
435 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
436 msg.msg_controllen = clen; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
437 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
438 n = ngx_sendmsg(c, &msg, 0); |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
439 if (n < 0) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
440 return n; |
8811
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
441 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
442 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
443 c->sent += n; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
444 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
445 return n; |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
446 } |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
447 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
448 #endif |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
449 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
450 |
bb5152ed045b
QUIC: added support for segmentation offloading.
Vladimir Homutov <vl@nginx.com>
parents:
8808
diff
changeset
|
451 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
452 static ngx_uint_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
453 ngx_quic_get_padding_level(ngx_connection_t *c) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
454 { |
9009
e5f16d886c97
QUIC: optimized datagram expansion with half-RTT tickets.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9006
diff
changeset
|
455 ngx_uint_t i; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
456 ngx_queue_t *q; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
457 ngx_quic_frame_t *f; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
458 ngx_quic_send_ctx_t *ctx; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
459 ngx_quic_connection_t *qc; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
460 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
461 /* |
8797
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
462 * RFC 9000, 14.1. Initial Datagram Size |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
463 * |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
464 * Similarly, a server MUST expand the payload of all UDP datagrams |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
465 * carrying ack-eliciting Initial packets to at least the smallest |
8797
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
466 * allowed maximum datagram size of 1200 bytes. |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
467 */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
468 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
469 qc = ngx_quic_get_connection(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
470 ctx = ngx_quic_get_send_ctx(qc, ssl_encryption_initial); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
471 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
472 for (q = ngx_queue_head(&ctx->frames); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
473 q != ngx_queue_sentinel(&ctx->frames); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
474 q = ngx_queue_next(q)) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
475 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
476 f = ngx_queue_data(q, ngx_quic_frame_t, queue); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
477 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
478 if (f->need_ack) { |
9009
e5f16d886c97
QUIC: optimized datagram expansion with half-RTT tickets.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9006
diff
changeset
|
479 for (i = 0; i + 1 < NGX_QUIC_SEND_CTX_LAST; i++) { |
e5f16d886c97
QUIC: optimized datagram expansion with half-RTT tickets.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9006
diff
changeset
|
480 ctx = &qc->send_ctx[i + 1]; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
481 |
9009
e5f16d886c97
QUIC: optimized datagram expansion with half-RTT tickets.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9006
diff
changeset
|
482 if (ngx_queue_empty(&ctx->frames)) { |
e5f16d886c97
QUIC: optimized datagram expansion with half-RTT tickets.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9006
diff
changeset
|
483 break; |
e5f16d886c97
QUIC: optimized datagram expansion with half-RTT tickets.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9006
diff
changeset
|
484 } |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
485 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
486 |
9009
e5f16d886c97
QUIC: optimized datagram expansion with half-RTT tickets.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9006
diff
changeset
|
487 return i; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
488 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
489 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
490 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
491 return NGX_QUIC_SEND_CTX_LAST; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
492 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
493 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
494 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
495 static ssize_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
496 ngx_quic_output_packet(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
497 u_char *data, size_t max, size_t min) |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
498 { |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
499 size_t len, pad, min_payload, max_payload; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
500 u_char *p; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
501 ssize_t flen; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
502 ngx_str_t res; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
503 ngx_int_t rc; |
9145
93aee926d27f
QUIC: removed explicit packet padding for certain frames.
Roman Arutyunyan <arut@nginx.com>
parents:
9144
diff
changeset
|
504 ngx_uint_t nframes; |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
505 ngx_msec_t now; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
506 ngx_queue_t *q; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
507 ngx_quic_frame_t *f; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
508 ngx_quic_header_t pkt; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
509 ngx_quic_connection_t *qc; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
510 static u_char src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE]; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
511 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
512 if (ngx_queue_empty(&ctx->frames)) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
513 return 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
514 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
515 |
8945
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
516 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0, |
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
517 "quic output %s packet max:%uz min:%uz", |
e72db9162180
QUIC: got rid of excessive "qsock" argument in ngx_quic_output.c.
Vladimir Homutov <vl@nginx.com>
parents:
8941
diff
changeset
|
518 ngx_quic_level_name(ctx->level), max, min); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
519 |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
520 qc = ngx_quic_get_connection(c); |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
521 |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
522 ngx_quic_init_packet(c, ctx, &pkt, qc->path); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
523 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
524 min_payload = ngx_quic_payload_size(&pkt, min); |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
525 max_payload = ngx_quic_payload_size(&pkt, max); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
526 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
527 /* RFC 9001, 5.4.2. Header Protection Sample */ |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
528 pad = 4 - pkt.num_len; |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
529 min_payload = ngx_max(min_payload, pad); |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
530 |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
531 if (min_payload > max_payload) { |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
532 return 0; |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
533 } |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
534 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
535 now = ngx_current_msec; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
536 nframes = 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
537 p = src; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
538 len = 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
539 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
540 for (q = ngx_queue_head(&ctx->frames); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
541 q != ngx_queue_sentinel(&ctx->frames); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
542 q = ngx_queue_next(q)) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
543 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
544 f = ngx_queue_data(q, ngx_quic_frame_t, queue); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
545 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
546 if (len >= max_payload) { |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
547 break; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
548 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
549 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
550 if (len + f->len > max_payload) { |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
551 rc = ngx_quic_split_frame(c, f, max_payload - len); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
552 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
553 if (rc == NGX_ERROR) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
554 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
555 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
556 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
557 if (rc == NGX_DECLINED) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
558 break; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
559 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
560 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
561 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
562 if (f->need_ack) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
563 pkt.need_ack = 1; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
564 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
565 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
566 ngx_quic_log_frame(c->log, f, 1); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
567 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
568 flen = ngx_quic_create_frame(p, f); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
569 if (flen == -1) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
570 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
571 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
572 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
573 len += flen; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
574 p += flen; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
575 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
576 f->pnum = ctx->pnum; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
577 f->first = now; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
578 f->last = now; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
579 f->plen = 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
580 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
581 nframes++; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
582 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
583 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
584 if (nframes == 0) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
585 return 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
586 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
587 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
588 if (len < min_payload) { |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
589 ngx_memset(p, NGX_QUIC_FT_PADDING, min_payload - len); |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
590 len = min_payload; |
9075
12b756caaf16
QUIC: fixed indentation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9072
diff
changeset
|
591 } |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
592 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
593 pkt.payload.data = src; |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
594 pkt.payload.len = len; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
595 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
596 res.data = data; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
597 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
598 ngx_log_debug6(NGX_LOG_DEBUG_EVENT, c->log, 0, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
599 "quic packet tx %s bytes:%ui" |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
600 " need_ack:%d number:%L encoded nl:%d trunc:0x%xD", |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
601 ngx_quic_level_name(ctx->level), pkt.payload.len, |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
602 pkt.need_ack, pkt.number, pkt.num_len, pkt.trunc); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
603 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
604 if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
605 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
606 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
607 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
608 ctx->pnum++; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
609 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
610 if (pkt.need_ack) { |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
611 q = ngx_queue_head(&ctx->frames); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
612 f = ngx_queue_data(q, ngx_quic_frame_t, queue); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
613 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
614 f->plen = res.len; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
615 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
616 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
617 while (nframes--) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
618 q = ngx_queue_head(&ctx->frames); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
619 f = ngx_queue_data(q, ngx_quic_frame_t, queue); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
620 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
621 f->pkt_need_ack = pkt.need_ack; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
622 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
623 ngx_queue_remove(q); |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
624 ngx_queue_insert_tail(&ctx->sending, q); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
625 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
626 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
627 return res.len; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
628 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
629 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
630 |
8892
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
631 static void |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
632 ngx_quic_init_packet(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
633 ngx_quic_header_t *pkt, ngx_quic_path_t *path) |
8892
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
634 { |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
635 ngx_quic_connection_t *qc; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
636 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
637 qc = ngx_quic_get_connection(c); |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
638 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
639 ngx_memzero(pkt, sizeof(ngx_quic_header_t)); |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
640 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
641 pkt->flags = NGX_QUIC_PKT_FIXED_BIT; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
642 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
643 if (ctx->level == ssl_encryption_initial) { |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
644 pkt->flags |= NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_INITIAL; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
645 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
646 } else if (ctx->level == ssl_encryption_handshake) { |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
647 pkt->flags |= NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_HANDSHAKE; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
648 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
649 } else { |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
650 if (qc->key_phase) { |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
651 pkt->flags |= NGX_QUIC_PKT_KPHASE; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
652 } |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
653 } |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
654 |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
655 pkt->dcid.data = path->cid->id; |
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
656 pkt->dcid.len = path->cid->len; |
8892
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
657 |
8985
da24a78720eb
QUIC: fixed handling of initial source connection id.
Vladimir Homutov <vl@nginx.com>
parents:
8980
diff
changeset
|
658 pkt->scid = qc->tp.initial_scid; |
8892
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
659 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
660 pkt->version = qc->version; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
661 pkt->log = c->log; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
662 pkt->level = ctx->level; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
663 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
664 pkt->keys = qc->keys; |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
665 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
666 ngx_quic_set_packet_number(pkt, ctx); |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
667 } |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
668 |
d8ac4d3c24ac
QUIC: added function to initialize packet.
Vladimir Homutov <vl@nginx.com>
parents:
8891
diff
changeset
|
669 |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
670 static ssize_t |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
671 ngx_quic_send(ngx_connection_t *c, u_char *buf, size_t len, |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
672 struct sockaddr *sockaddr, socklen_t socklen) |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
673 { |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
674 ssize_t n; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
675 struct iovec iov; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
676 struct msghdr msg; |
8976 | 677 #if (NGX_HAVE_ADDRINFO_CMSG) |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
678 struct cmsghdr *cmsg; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
679 char msg_control[CMSG_SPACE(sizeof(ngx_addrinfo_t))]; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
680 #endif |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
681 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
682 ngx_memzero(&msg, sizeof(struct msghdr)); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
683 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
684 iov.iov_len = len; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
685 iov.iov_base = buf; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
686 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
687 msg.msg_iov = &iov; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
688 msg.msg_iovlen = 1; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
689 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
690 msg.msg_name = sockaddr; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
691 msg.msg_namelen = socklen; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
692 |
8976 | 693 #if (NGX_HAVE_ADDRINFO_CMSG) |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
694 if (c->listening && c->listening->wildcard && c->local_sockaddr) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
695 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
696 msg.msg_control = msg_control; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
697 msg.msg_controllen = sizeof(msg_control); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
698 ngx_memzero(msg_control, sizeof(msg_control)); |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
699 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
700 cmsg = CMSG_FIRSTHDR(&msg); |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
701 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
702 msg.msg_controllen = ngx_set_srcaddr_cmsg(cmsg, c->local_sockaddr); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
703 } |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
704 #endif |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
705 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
706 n = ngx_sendmsg(c, &msg, 0); |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
707 if (n < 0) { |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
708 return n; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
709 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
710 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
711 c->sent += n; |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
712 |
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
713 return n; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
714 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
715 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
716 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
717 static void |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
718 ngx_quic_set_packet_number(ngx_quic_header_t *pkt, ngx_quic_send_ctx_t *ctx) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
719 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
720 uint64_t delta; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
721 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
722 delta = ctx->pnum - ctx->largest_ack; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
723 pkt->number = ctx->pnum; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
724 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
725 if (delta <= 0x7F) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
726 pkt->num_len = 1; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
727 pkt->trunc = ctx->pnum & 0xff; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
728 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
729 } else if (delta <= 0x7FFF) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
730 pkt->num_len = 2; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
731 pkt->flags |= 0x1; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
732 pkt->trunc = ctx->pnum & 0xffff; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
733 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
734 } else if (delta <= 0x7FFFFF) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
735 pkt->num_len = 3; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
736 pkt->flags |= 0x2; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
737 pkt->trunc = ctx->pnum & 0xffffff; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
738 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
739 } else { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
740 pkt->num_len = 4; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
741 pkt->flags |= 0x3; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
742 pkt->trunc = ctx->pnum & 0xffffffff; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
743 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
744 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
745 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
746 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
747 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
748 ngx_quic_negotiate_version(ngx_connection_t *c, ngx_quic_header_t *inpkt) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
749 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
750 size_t len; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
751 ngx_quic_header_t pkt; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
752 static u_char buf[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE]; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
753 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
754 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
755 "sending version negotiation packet"); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
756 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
757 pkt.log = c->log; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
758 pkt.flags = NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_FIXED_BIT; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
759 pkt.dcid = inpkt->scid; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
760 pkt.scid = inpkt->dcid; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
761 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
762 len = ngx_quic_create_version_negotiation(&pkt, buf); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
763 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
764 #ifdef NGX_QUIC_DEBUG_PACKETS |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
765 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
766 "quic vnego packet to send len:%uz %*xs", len, len, buf); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
767 #endif |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
768 |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
769 (void) ngx_quic_send(c, buf, len, c->sockaddr, c->socklen); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
770 |
8973
e5509ff0dfd2
QUIC: avoid logging error in case of version negotiation.
Vladimir Homutov <vl@nginx.com>
parents:
8971
diff
changeset
|
771 return NGX_DONE; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
772 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
773 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
774 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
775 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
776 ngx_quic_send_stateless_reset(ngx_connection_t *c, ngx_quic_conf_t *conf, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
777 ngx_quic_header_t *pkt) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
778 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
779 u_char *token; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
780 size_t len, max; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
781 uint16_t rndbytes; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
782 u_char buf[NGX_QUIC_MAX_SR_PACKET]; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
783 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
784 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
785 "quic handle stateless reset output"); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
786 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
787 if (pkt->len <= NGX_QUIC_MIN_PKT_LEN) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
788 return NGX_DECLINED; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
789 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
790 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
791 if (pkt->len <= NGX_QUIC_MIN_SR_PACKET) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
792 len = pkt->len - 1; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
793 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
794 } else { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
795 max = ngx_min(NGX_QUIC_MAX_SR_PACKET, pkt->len * 3); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
796 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
797 if (RAND_bytes((u_char *) &rndbytes, sizeof(rndbytes)) != 1) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
798 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
799 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
800 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
801 len = (rndbytes % (max - NGX_QUIC_MIN_SR_PACKET + 1)) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
802 + NGX_QUIC_MIN_SR_PACKET; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
803 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
804 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
805 if (RAND_bytes(buf, len - NGX_QUIC_SR_TOKEN_LEN) != 1) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
806 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
807 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
808 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
809 buf[0] &= ~NGX_QUIC_PKT_LONG; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
810 buf[0] |= NGX_QUIC_PKT_FIXED_BIT; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
811 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
812 token = &buf[len - NGX_QUIC_SR_TOKEN_LEN]; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
813 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
814 if (ngx_quic_new_sr_token(c, &pkt->dcid, conf->sr_token_key, token) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
815 != NGX_OK) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
816 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
817 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
818 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
819 |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
820 (void) ngx_quic_send(c, buf, len, c->sockaddr, c->socklen); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
821 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
822 return NGX_DECLINED; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
823 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
824 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
825 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
826 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
827 ngx_quic_send_cc(ngx_connection_t *c) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
828 { |
9092
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
829 ngx_quic_frame_t frame; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
830 ngx_quic_connection_t *qc; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
831 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
832 qc = ngx_quic_get_connection(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
833 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
834 if (qc->draining) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
835 return NGX_OK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
836 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
837 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
838 if (qc->closing |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
839 && ngx_current_msec - qc->last_cc < NGX_QUIC_CC_MIN_INTERVAL) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
840 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
841 /* dot not send CC too often */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
842 return NGX_OK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
843 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
844 |
9092
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
845 ngx_memzero(&frame, sizeof(ngx_quic_frame_t)); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
846 |
9092
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
847 frame.level = qc->error_level; |
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
848 frame.type = qc->error_app ? NGX_QUIC_FT_CONNECTION_CLOSE_APP |
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
849 : NGX_QUIC_FT_CONNECTION_CLOSE; |
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
850 frame.u.close.error_code = qc->error; |
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
851 frame.u.close.frame_type = qc->error_ftype; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
852 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
853 if (qc->error_reason) { |
9092
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
854 frame.u.close.reason.len = ngx_strlen(qc->error_reason); |
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
855 frame.u.close.reason.data = (u_char *) qc->error_reason; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
856 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
857 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
858 qc->last_cc = ngx_current_msec; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
859 |
9092
9553eea74f2a
QUIC: optimized immediate close.
Roman Arutyunyan <arut@nginx.com>
parents:
9075
diff
changeset
|
860 return ngx_quic_frame_sendto(c, &frame, 0, qc->path); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
861 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
862 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
863 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
864 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
865 ngx_quic_send_early_cc(ngx_connection_t *c, ngx_quic_header_t *inpkt, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
866 ngx_uint_t err, const char *reason) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
867 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
868 ssize_t len; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
869 ngx_str_t res; |
9025
e50f77a2d0b0
QUIC: removed ngx_quic_keys_new().
Vladimir Homutov <vl@nginx.com>
parents:
9024
diff
changeset
|
870 ngx_quic_keys_t keys; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
871 ngx_quic_frame_t frame; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
872 ngx_quic_header_t pkt; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
873 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
874 static u_char src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE]; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
875 static u_char dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE]; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
876 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
877 ngx_memzero(&frame, sizeof(ngx_quic_frame_t)); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
878 ngx_memzero(&pkt, sizeof(ngx_quic_header_t)); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
879 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
880 frame.level = inpkt->level; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
881 frame.type = NGX_QUIC_FT_CONNECTION_CLOSE; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
882 frame.u.close.error_code = err; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
883 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
884 frame.u.close.reason.data = (u_char *) reason; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
885 frame.u.close.reason.len = ngx_strlen(reason); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
886 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
887 len = ngx_quic_create_frame(NULL, &frame); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
888 if (len > NGX_QUIC_MAX_UDP_PAYLOAD_SIZE) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
889 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
890 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
891 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
892 ngx_quic_log_frame(c->log, &frame, 1); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
893 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
894 len = ngx_quic_create_frame(src, &frame); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
895 if (len == -1) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
896 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
897 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
898 |
9025
e50f77a2d0b0
QUIC: removed ngx_quic_keys_new().
Vladimir Homutov <vl@nginx.com>
parents:
9024
diff
changeset
|
899 ngx_memzero(&keys, sizeof(ngx_quic_keys_t)); |
e50f77a2d0b0
QUIC: removed ngx_quic_keys_new().
Vladimir Homutov <vl@nginx.com>
parents:
9024
diff
changeset
|
900 |
e50f77a2d0b0
QUIC: removed ngx_quic_keys_new().
Vladimir Homutov <vl@nginx.com>
parents:
9024
diff
changeset
|
901 pkt.keys = &keys; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
902 |
9024
f2925c80401c
QUIC: avoided pool usage in ngx_quic_protection.c.
Vladimir Homutov <vl@nginx.com>
parents:
9009
diff
changeset
|
903 if (ngx_quic_keys_set_initial_secret(pkt.keys, &inpkt->dcid, c->log) |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
904 != NGX_OK) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
905 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
906 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
907 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
908 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
909 pkt.flags = NGX_QUIC_PKT_FIXED_BIT | NGX_QUIC_PKT_LONG |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
910 | NGX_QUIC_PKT_INITIAL; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
911 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
912 pkt.num_len = 1; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
913 /* |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
914 * pkt.num = 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
915 * pkt.trunc = 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
916 */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
917 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
918 pkt.version = inpkt->version; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
919 pkt.log = c->log; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
920 pkt.level = inpkt->level; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
921 pkt.dcid = inpkt->scid; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
922 pkt.scid = inpkt->dcid; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
923 pkt.payload.data = src; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
924 pkt.payload.len = len; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
925 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
926 res.data = dst; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
927 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
928 if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
929 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
930 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
931 |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
932 if (ngx_quic_send(c, res.data, res.len, c->sockaddr, c->socklen) < 0) { |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
933 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
934 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
935 |
8994
e00295b76395
QUIC: revised ngx_quic_handle_datagram() error codes.
Vladimir Homutov <vl@nginx.com>
parents:
8985
diff
changeset
|
936 return NGX_DONE; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
937 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
938 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
939 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
940 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
941 ngx_quic_send_retry(ngx_connection_t *c, ngx_quic_conf_t *conf, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
942 ngx_quic_header_t *inpkt) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
943 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
944 time_t expires; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
945 ssize_t len; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
946 ngx_str_t res, token; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
947 ngx_quic_header_t pkt; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
948 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
949 u_char buf[NGX_QUIC_RETRY_BUFFER_SIZE]; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
950 u_char dcid[NGX_QUIC_SERVER_CID_LEN]; |
9026
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
951 u_char tbuf[NGX_QUIC_TOKEN_BUF_SIZE]; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
952 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
953 expires = ngx_time() + NGX_QUIC_RETRY_TOKEN_LIFETIME; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
954 |
9026
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
955 token.data = tbuf; |
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
956 token.len = NGX_QUIC_TOKEN_BUF_SIZE; |
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
957 |
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
958 if (ngx_quic_new_token(c->log, c->sockaddr, c->socklen, conf->av_token_key, |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
959 &token, &inpkt->dcid, expires, 1) |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
960 != NGX_OK) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
961 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
962 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
963 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
964 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
965 ngx_memzero(&pkt, sizeof(ngx_quic_header_t)); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
966 pkt.flags = NGX_QUIC_PKT_FIXED_BIT | NGX_QUIC_PKT_LONG | NGX_QUIC_PKT_RETRY; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
967 pkt.version = inpkt->version; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
968 pkt.log = c->log; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
969 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
970 pkt.odcid = inpkt->dcid; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
971 pkt.dcid = inpkt->scid; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
972 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
973 /* TODO: generate routable dcid */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
974 if (RAND_bytes(dcid, NGX_QUIC_SERVER_CID_LEN) != 1) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
975 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
976 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
977 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
978 pkt.scid.len = NGX_QUIC_SERVER_CID_LEN; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
979 pkt.scid.data = dcid; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
980 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
981 pkt.token = token; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
982 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
983 res.data = buf; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
984 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
985 if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
986 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
987 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
988 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
989 #ifdef NGX_QUIC_DEBUG_PACKETS |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
990 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
991 "quic packet to send len:%uz %xV", res.len, &res); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
992 #endif |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
993 |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
994 len = ngx_quic_send(c, res.data, res.len, c->sockaddr, c->socklen); |
8822
ad046179eb91
QUIC: handle EAGAIN properly on UDP sockets.
Vladimir Homutov <vl@nginx.com>
parents:
8815
diff
changeset
|
995 if (len < 0) { |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
996 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
997 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
998 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
999 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1000 "quic retry packet sent to %xV", &pkt.dcid); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1001 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1002 /* |
8797
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
1003 * RFC 9000, 17.2.5.1. Sending a Retry Packet |
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
1004 * |
4715f3e669f1
QUIC: updated specification references.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8763
diff
changeset
|
1005 * A server MUST NOT send more than one Retry |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1006 * packet in response to a single UDP datagram. |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1007 * NGX_DONE will stop quic_input() from processing further |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1008 */ |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1009 return NGX_DONE; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1010 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1011 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1012 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1013 ngx_int_t |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1014 ngx_quic_send_new_token(ngx_connection_t *c, ngx_quic_path_t *path) |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1015 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1016 time_t expires; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1017 ngx_str_t token; |
9072
def8e398d7c5
QUIC: fixed broken token in NEW_TOKEN (ticket #2446).
Roman Arutyunyan <arut@nginx.com>
parents:
9026
diff
changeset
|
1018 ngx_chain_t *out; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1019 ngx_quic_frame_t *frame; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1020 ngx_quic_connection_t *qc; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1021 |
9026
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
1022 u_char tbuf[NGX_QUIC_TOKEN_BUF_SIZE]; |
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
1023 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1024 qc = ngx_quic_get_connection(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1025 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1026 expires = ngx_time() + NGX_QUIC_NEW_TOKEN_LIFETIME; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1027 |
9026
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
1028 token.data = tbuf; |
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
1029 token.len = NGX_QUIC_TOKEN_BUF_SIZE; |
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
1030 |
3550b00d9dc8
QUIC: avoided pool usage in token calculation.
Vladimir Homutov <vl@nginx.com>
parents:
9025
diff
changeset
|
1031 if (ngx_quic_new_token(c->log, path->sockaddr, path->socklen, |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1032 qc->conf->av_token_key, &token, NULL, expires, 0) |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1033 != NGX_OK) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1034 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1035 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1036 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1037 |
9072
def8e398d7c5
QUIC: fixed broken token in NEW_TOKEN (ticket #2446).
Roman Arutyunyan <arut@nginx.com>
parents:
9026
diff
changeset
|
1038 out = ngx_quic_copy_buffer(c, token.data, token.len); |
def8e398d7c5
QUIC: fixed broken token in NEW_TOKEN (ticket #2446).
Roman Arutyunyan <arut@nginx.com>
parents:
9026
diff
changeset
|
1039 if (out == NGX_CHAIN_ERROR) { |
def8e398d7c5
QUIC: fixed broken token in NEW_TOKEN (ticket #2446).
Roman Arutyunyan <arut@nginx.com>
parents:
9026
diff
changeset
|
1040 return NGX_ERROR; |
def8e398d7c5
QUIC: fixed broken token in NEW_TOKEN (ticket #2446).
Roman Arutyunyan <arut@nginx.com>
parents:
9026
diff
changeset
|
1041 } |
def8e398d7c5
QUIC: fixed broken token in NEW_TOKEN (ticket #2446).
Roman Arutyunyan <arut@nginx.com>
parents:
9026
diff
changeset
|
1042 |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1043 frame = ngx_quic_alloc_frame(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1044 if (frame == NULL) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1045 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1046 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1047 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1048 frame->level = ssl_encryption_application; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1049 frame->type = NGX_QUIC_FT_NEW_TOKEN; |
9072
def8e398d7c5
QUIC: fixed broken token in NEW_TOKEN (ticket #2446).
Roman Arutyunyan <arut@nginx.com>
parents:
9026
diff
changeset
|
1050 frame->data = out; |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1051 frame->u.token.length = token.len; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1052 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1053 ngx_quic_queue_frame(qc, frame); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1054 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1055 return NGX_OK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1056 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1057 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1058 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1059 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1060 ngx_quic_send_ack(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1061 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1062 size_t len, left; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1063 uint64_t ack_delay; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1064 ngx_buf_t *b; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1065 ngx_uint_t i; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1066 ngx_chain_t *cl, **ll; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1067 ngx_quic_frame_t *frame; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1068 ngx_quic_connection_t *qc; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1069 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1070 qc = ngx_quic_get_connection(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1071 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1072 ack_delay = ngx_current_msec - ctx->largest_received; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1073 ack_delay *= 1000; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1074 ack_delay >>= qc->tp.ack_delay_exponent; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1075 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1076 frame = ngx_quic_alloc_frame(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1077 if (frame == NULL) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1078 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1079 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1080 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1081 ll = &frame->data; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1082 b = NULL; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1083 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1084 for (i = 0; i < ctx->nranges; i++) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1085 len = ngx_quic_create_ack_range(NULL, ctx->ranges[i].gap, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1086 ctx->ranges[i].range); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1087 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1088 left = b ? b->end - b->last : 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1089 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1090 if (left < len) { |
8948
19e063e955bf
QUIC: renamed buffer-related functions.
Roman Arutyunyan <arut@nginx.com>
parents:
8945
diff
changeset
|
1091 cl = ngx_quic_alloc_chain(c); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1092 if (cl == NULL) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1093 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1094 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1095 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1096 *ll = cl; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1097 ll = &cl->next; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1098 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1099 b = cl->buf; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1100 left = b->end - b->last; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1101 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1102 if (left < len) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1103 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1104 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1105 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1106 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1107 b->last += ngx_quic_create_ack_range(b->last, ctx->ranges[i].gap, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1108 ctx->ranges[i].range); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1109 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1110 frame->u.ack.ranges_length += len; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1111 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1112 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1113 *ll = NULL; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1114 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1115 frame->level = ctx->level; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1116 frame->type = NGX_QUIC_FT_ACK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1117 frame->u.ack.largest = ctx->largest_range; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1118 frame->u.ack.delay = ack_delay; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1119 frame->u.ack.range_count = ctx->nranges; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1120 frame->u.ack.first_range = ctx->first_range; |
9139
d7dec2970161
QUIC: always add ACK frame to the queue head.
Roman Arutyunyan <arut@nginx.com>
parents:
9093
diff
changeset
|
1121 frame->len = ngx_quic_create_frame(NULL, frame); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1122 |
9139
d7dec2970161
QUIC: always add ACK frame to the queue head.
Roman Arutyunyan <arut@nginx.com>
parents:
9093
diff
changeset
|
1123 ngx_queue_insert_head(&ctx->frames, &frame->queue); |
8751
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1124 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1125 return NGX_OK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1126 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1127 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1128 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1129 ngx_int_t |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1130 ngx_quic_send_ack_range(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1131 uint64_t smallest, uint64_t largest) |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1132 { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1133 ngx_quic_frame_t *frame; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1134 ngx_quic_connection_t *qc; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1135 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1136 qc = ngx_quic_get_connection(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1137 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1138 frame = ngx_quic_alloc_frame(c); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1139 if (frame == NULL) { |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1140 return NGX_ERROR; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1141 } |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1142 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1143 frame->level = ctx->level; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1144 frame->type = NGX_QUIC_FT_ACK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1145 frame->u.ack.largest = largest; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1146 frame->u.ack.delay = 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1147 frame->u.ack.range_count = 0; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1148 frame->u.ack.first_range = largest - smallest; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1149 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1150 ngx_quic_queue_frame(qc, frame); |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1151 |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1152 return NGX_OK; |
bc910a5ec737
QUIC: separate files for output and ack related processing.
Vladimir Homutov <vl@nginx.com>
parents:
diff
changeset
|
1153 } |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1154 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1155 |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1156 ngx_int_t |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1157 ngx_quic_frame_sendto(ngx_connection_t *c, ngx_quic_frame_t *frame, |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1158 size_t min, ngx_quic_path_t *path) |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1159 { |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1160 size_t min_payload, pad; |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1161 ssize_t len, sent; |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1162 ngx_str_t res; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1163 ngx_quic_header_t pkt; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1164 ngx_quic_send_ctx_t *ctx; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1165 ngx_quic_connection_t *qc; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1166 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1167 static u_char src[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE]; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1168 static u_char dst[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE]; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1169 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1170 qc = ngx_quic_get_connection(c); |
9093
9ae24a9ba763
QUIC: fixed encryption level in ngx_quic_frame_sendto().
Roman Arutyunyan <arut@nginx.com>
parents:
9092
diff
changeset
|
1171 ctx = ngx_quic_get_send_ctx(qc, frame->level); |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1172 |
8971
1e2f4e9c8195
QUIC: reworked migration handling.
Vladimir Homutov <vl@nginx.com>
parents:
8948
diff
changeset
|
1173 ngx_quic_init_packet(c, ctx, &pkt, path); |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1174 |
8941
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1175 min = ngx_quic_path_limit(c, path, min); |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1176 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1177 min_payload = min ? ngx_quic_payload_size(&pkt, min) : 0; |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1178 |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1179 pad = 4 - pkt.num_len; |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1180 min_payload = ngx_max(min_payload, pad); |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1181 |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1182 len = ngx_quic_create_frame(NULL, frame); |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1183 if (len > NGX_QUIC_MAX_UDP_PAYLOAD_SIZE) { |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1184 return NGX_ERROR; |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1185 } |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1186 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1187 ngx_quic_log_frame(c->log, frame, 1); |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1188 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1189 len = ngx_quic_create_frame(src, frame); |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1190 if (len == -1) { |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1191 return NGX_ERROR; |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1192 } |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1193 |
8894
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1194 if (len < (ssize_t) min_payload) { |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1195 ngx_memset(src + len, NGX_QUIC_FT_PADDING, min_payload - len); |
de7b9af30fc6
QUIC: refactored packet creation.
Vladimir Homutov <vl@nginx.com>
parents:
8892
diff
changeset
|
1196 len = min_payload; |
9075
12b756caaf16
QUIC: fixed indentation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
9072
diff
changeset
|
1197 } |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1198 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1199 pkt.payload.data = src; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1200 pkt.payload.len = len; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1201 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1202 res.data = dst; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1203 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1204 if (ngx_quic_encrypt(&pkt, &res) != NGX_OK) { |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1205 return NGX_ERROR; |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1206 } |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1207 |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1208 ctx->pnum++; |
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1209 |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1210 sent = ngx_quic_send(c, res.data, res.len, path->sockaddr, path->socklen); |
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1211 if (sent < 0) { |
9146
f3412ec3b6d1
QUIC: allowed ngx_quic_frame_sendto() to return NGX_AGAIN.
Roman Arutyunyan <arut@nginx.com>
parents:
9145
diff
changeset
|
1212 return sent; |
8932
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1213 } |
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1214 |
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1215 path->sent += sent; |
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1216 |
501f28679d56
QUIC: refactored ngx_quic_frame_sendto() function.
Vladimir Homutov <vl@nginx.com>
parents:
8916
diff
changeset
|
1217 return NGX_OK; |
8763
4117aa7fa38e
QUIC: connection migration.
Vladimir Homutov <vl@nginx.com>
parents:
8751
diff
changeset
|
1218 } |
8941
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1219 |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1220 |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1221 static size_t |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1222 ngx_quic_path_limit(ngx_connection_t *c, ngx_quic_path_t *path, size_t size) |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1223 { |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1224 off_t max; |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1225 |
9144
bba136612fe4
QUIC: removed path->limited flag.
Roman Arutyunyan <arut@nginx.com>
parents:
9143
diff
changeset
|
1226 if (!path->validated) { |
8941
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1227 max = path->received * 3; |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1228 max = (path->sent >= max) ? 0 : max - path->sent; |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1229 |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1230 if ((off_t) size > max) { |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1231 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1232 "quic path limit %uz - %O", size, max); |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1233 return max; |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1234 } |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1235 } |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1236 |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1237 return size; |
0433e69f5425
QUIC: added path limiting function ngx_quic_path_limit().
Roman Arutyunyan <arut@nginx.com>
parents:
8940
diff
changeset
|
1238 } |