Mercurial > hg > nginx
annotate src/event/ngx_event_quic.c @ 8246:0d9bc77ae30d quic
Reset QUIC timeout on every datagram.
| author | Roman Arutyunyan <arut@nginx.com> |
|---|---|
| date | Thu, 19 Mar 2020 21:46:28 +0300 |
| parents | a14afe21e692 |
| children | e9891e8ee975 |
| rev | line source |
|---|---|
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
1 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
2 /* |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
3 * Copyright (C) Nginx, Inc. |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
4 */ |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
5 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
6 |
| 8171 | 7 #include <ngx_config.h> |
| 8 #include <ngx_core.h> | |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
9 #include <ngx_event.h> |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
10 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
11 |
| 8225 | 12 typedef struct { |
| 13 ngx_rbtree_node_t node; | |
| 14 ngx_buf_t *b; | |
| 15 ngx_connection_t *c; | |
| 16 ngx_quic_stream_t s; | |
| 17 } ngx_quic_stream_node_t; | |
| 18 | |
| 19 | |
| 20 typedef struct { | |
| 21 ngx_rbtree_t tree; | |
| 22 ngx_rbtree_node_t sentinel; | |
| 23 ngx_msec_t timeout; | |
| 24 ngx_connection_handler_pt handler; | |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
25 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
26 ngx_uint_t id_counter; |
| 8225 | 27 } ngx_quic_streams_t; |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
28 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
29 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
30 struct ngx_quic_connection_s { |
| 8225 | 31 ngx_str_t scid; |
| 32 ngx_str_t dcid; | |
| 33 ngx_str_t token; | |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
34 |
| 8225 | 35 /* current packet numbers for each namespace */ |
| 36 ngx_uint_t initial_pn; | |
| 37 ngx_uint_t handshake_pn; | |
| 38 ngx_uint_t appdata_pn; | |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
39 |
| 8225 | 40 ngx_quic_secrets_t secrets; |
| 41 ngx_ssl_t *ssl; | |
| 42 ngx_quic_frame_t *frames; | |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
43 |
| 8225 | 44 ngx_quic_streams_t streams; |
|
8237
ff540f13d95d
MAX_DATA frame parser/handler.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8236
diff
changeset
|
45 ngx_uint_t max_data; |
| 8225 | 46 }; |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
47 |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
48 |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
49 #if BORINGSSL_API_VERSION >= 10 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
50 static int ngx_quic_set_read_secret(ngx_ssl_conn_t *ssl_conn, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
51 enum ssl_encryption_level_t level, const SSL_CIPHER *cipher, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
52 const uint8_t *secret, size_t secret_len); |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
53 static int ngx_quic_set_write_secret(ngx_ssl_conn_t *ssl_conn, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
54 enum ssl_encryption_level_t level, const SSL_CIPHER *cipher, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
55 const uint8_t *secret, size_t secret_len); |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
56 #else |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
57 static int ngx_quic_set_encryption_secrets(ngx_ssl_conn_t *ssl_conn, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
58 enum ssl_encryption_level_t level, const uint8_t *read_secret, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
59 const uint8_t *write_secret, size_t secret_len); |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
60 #endif |
| 8225 | 61 |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
62 static int ngx_quic_add_handshake_data(ngx_ssl_conn_t *ssl_conn, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
63 enum ssl_encryption_level_t level, const uint8_t *data, size_t len); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
64 static int ngx_quic_flush_flight(ngx_ssl_conn_t *ssl_conn); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
65 static int ngx_quic_send_alert(ngx_ssl_conn_t *ssl_conn, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
66 enum ssl_encryption_level_t level, uint8_t alert); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
67 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
68 |
| 8225 | 69 static ngx_int_t ngx_quic_new_connection(ngx_connection_t *c, ngx_ssl_t *ssl, |
| 70 ngx_quic_header_t *pkt); | |
| 71 static ngx_int_t ngx_quic_init_connection(ngx_connection_t *c); | |
| 72 static void ngx_quic_handshake_handler(ngx_event_t *rev); | |
| 73 static void ngx_quic_close_connection(ngx_connection_t *c); | |
| 74 | |
| 75 static ngx_int_t ngx_quic_input(ngx_connection_t *c, ngx_buf_t *b); | |
| 76 static ngx_int_t ngx_quic_initial_input(ngx_connection_t *c, | |
| 77 ngx_quic_header_t *pkt); | |
| 78 static ngx_int_t ngx_quic_handshake_input(ngx_connection_t *c, | |
| 79 ngx_quic_header_t *pkt); | |
| 80 static ngx_int_t ngx_quic_app_input(ngx_connection_t *c, | |
| 81 ngx_quic_header_t *pkt); | |
| 82 static ngx_int_t ngx_quic_payload_handler(ngx_connection_t *c, | |
| 83 ngx_quic_header_t *pkt); | |
| 84 | |
| 85 static ngx_int_t ngx_quic_handle_ack_frame(ngx_connection_t *c, | |
| 86 ngx_quic_header_t *pkt, ngx_quic_ack_frame_t *f); | |
| 87 static ngx_int_t ngx_quic_handle_crypto_frame(ngx_connection_t *c, | |
| 88 ngx_quic_header_t *pkt, ngx_quic_crypto_frame_t *frame); | |
| 89 static ngx_int_t ngx_quic_handle_stream_frame(ngx_connection_t *c, | |
| 90 ngx_quic_header_t *pkt, ngx_quic_stream_frame_t *frame); | |
|
8245
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
91 static ngx_int_t ngx_quic_handle_streams_blocked_frame(ngx_connection_t *c, |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
92 ngx_quic_header_t *pkt, ngx_quic_streams_blocked_frame_t *f); |
| 8225 | 93 |
| 94 static void ngx_quic_queue_frame(ngx_quic_connection_t *qc, | |
| 95 ngx_quic_frame_t *frame); | |
| 96 | |
| 97 static ngx_int_t ngx_quic_output(ngx_connection_t *c); | |
| 98 ngx_int_t ngx_quic_frames_send(ngx_connection_t *c, ngx_quic_frame_t *start, | |
| 99 ngx_quic_frame_t *end, size_t total); | |
| 100 static ngx_int_t ngx_quic_send_packet(ngx_connection_t *c, | |
| 101 ngx_quic_connection_t *qc, enum ssl_encryption_level_t level, | |
| 102 ngx_str_t *payload); | |
| 103 | |
| 104 | |
| 105 static void ngx_quic_rbtree_insert_stream(ngx_rbtree_node_t *temp, | |
| 106 ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel); | |
| 107 static ngx_quic_stream_node_t *ngx_quic_find_stream(ngx_rbtree_t *rbtree, | |
| 108 ngx_uint_t key); | |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
109 static ngx_quic_stream_node_t *ngx_quic_create_stream(ngx_connection_t *c, |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
110 ngx_uint_t id); |
|
8211
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
111 static ssize_t ngx_quic_stream_recv(ngx_connection_t *c, u_char *buf, |
|
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
112 size_t size); |
|
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
113 static ssize_t ngx_quic_stream_send(ngx_connection_t *c, u_char *buf, |
|
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
114 size_t size); |
|
8239
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
115 static void ngx_quic_stream_cleanup_handler(void *data); |
|
8211
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
116 static ngx_chain_t *ngx_quic_stream_send_chain(ngx_connection_t *c, |
|
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
117 ngx_chain_t *in, off_t limit); |
|
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
118 |
| 8225 | 119 |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
120 static SSL_QUIC_METHOD quic_method = { |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
121 #if BORINGSSL_API_VERSION >= 10 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
122 ngx_quic_set_read_secret, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
123 ngx_quic_set_write_secret, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
124 #else |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
125 ngx_quic_set_encryption_secrets, |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
126 #endif |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
127 ngx_quic_add_handshake_data, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
128 ngx_quic_flush_flight, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
129 ngx_quic_send_alert, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
130 }; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
131 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
132 |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
133 #if BORINGSSL_API_VERSION >= 10 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
134 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
135 static int |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
136 ngx_quic_set_read_secret(ngx_ssl_conn_t *ssl_conn, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
137 enum ssl_encryption_level_t level, const SSL_CIPHER *cipher, |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
138 const uint8_t *rsecret, size_t secret_len) |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
139 { |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
140 ngx_connection_t *c; |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
141 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
142 c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn); |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
143 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
144 ngx_quic_hexdump(c->log, "level:%d read secret", |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
145 rsecret, secret_len, level); |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
146 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
147 return ngx_quic_set_encryption_secret(c->pool, ssl_conn, level, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
148 rsecret, secret_len, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
149 &c->quic->secrets.client); |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
150 } |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
151 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
152 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
153 static int |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
154 ngx_quic_set_write_secret(ngx_ssl_conn_t *ssl_conn, |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
155 enum ssl_encryption_level_t level, const SSL_CIPHER *cipher, |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
156 const uint8_t *wsecret, size_t secret_len) |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
157 { |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
158 ngx_connection_t *c; |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
159 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
160 c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn); |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
161 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
162 ngx_quic_hexdump(c->log, "level:%d write secret", |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
163 wsecret, secret_len, level); |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
164 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
165 return ngx_quic_set_encryption_secret(c->pool, ssl_conn, level, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
166 wsecret, secret_len, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
167 &c->quic->secrets.server); |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
168 } |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
169 |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
170 #else |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
171 |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
172 static int |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
173 ngx_quic_set_encryption_secrets(ngx_ssl_conn_t *ssl_conn, |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
174 enum ssl_encryption_level_t level, const uint8_t *rsecret, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
175 const uint8_t *wsecret, size_t secret_len) |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
176 { |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
177 ngx_int_t rc; |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
178 ngx_connection_t *c; |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
179 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
180 c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
181 |
|
8222
bec4cd55361e
Fixed a typo with OpenSSL.
Vladimir Homutov <vl@nginx.com>
parents:
8221
diff
changeset
|
182 ngx_quic_hexdump(c->log, "level:%d read", rsecret, secret_len, level); |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
183 ngx_quic_hexdump(c->log, "level:%d write", wsecret, secret_len, level); |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
184 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
185 rc = ngx_quic_set_encryption_secret(c->pool, ssl_conn, level, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
186 rsecret, secret_len, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
187 &c->quic->secrets.client); |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
188 if (rc != 1) { |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
189 return rc; |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
190 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
191 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
192 return ngx_quic_set_encryption_secret(c->pool, ssl_conn, level, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
193 wsecret, secret_len, |
|
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
194 &c->quic->secrets.server); |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
195 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
196 |
|
8204
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
197 #endif |
|
9e0c30e1f7fb
Compatibility with BoringSSL revised QUIC encryption secret APIs.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8203
diff
changeset
|
198 |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
199 |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
200 static int |
|
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
201 ngx_quic_add_handshake_data(ngx_ssl_conn_t *ssl_conn, |
|
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
202 enum ssl_encryption_level_t level, const uint8_t *data, size_t len) |
|
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
203 { |
| 8225 | 204 u_char *p; |
| 205 ngx_quic_frame_t *frame; | |
| 206 ngx_connection_t *c; | |
| 207 ngx_quic_connection_t *qc; | |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
208 |
|
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
209 c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn); |
|
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
210 qc = c->quic; |
|
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
211 |
|
8186
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
212 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
213 "ngx_quic_add_handshake_data"); |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
214 |
|
8186
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
215 frame = ngx_pcalloc(c->pool, sizeof(ngx_quic_frame_t)); |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
216 if (frame == NULL) { |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
217 return 0; |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
218 } |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
219 |
|
8186
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
220 p = ngx_pnalloc(c->pool, len); |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
221 if (p == NULL) { |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
222 return 0; |
|
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
223 } |
|
8186
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
224 |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
225 ngx_memcpy(p, data, len); |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
226 |
|
8186
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
227 frame->level = level; |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
228 frame->type = NGX_QUIC_FT_CRYPTO; |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
229 frame->u.crypto.len = len; |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
230 frame->u.crypto.data = p; |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
231 |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
232 ngx_sprintf(frame->info, "crypto, generated by SSL len=%ui level=%d", len, level); |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
233 |
|
0a2683df5f11
Implemented improved version of quic_output().
Vladimir Homutov <vl@nginx.com>
parents:
8185
diff
changeset
|
234 ngx_quic_queue_frame(qc, frame); |
|
8184
ec1f84996990
Split frame and packet generation into separate steps.
Vladimir Homutov <vl@nginx.com>
parents:
8183
diff
changeset
|
235 |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
236 return 1; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
237 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
238 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
239 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
240 static int |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
241 ngx_quic_flush_flight(ngx_ssl_conn_t *ssl_conn) |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
242 { |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
243 ngx_connection_t *c; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
244 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
245 c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
246 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
247 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "ngx_quic_flush_flight()"); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
248 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
249 return 1; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
250 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
251 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
252 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
253 static int |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
254 ngx_quic_send_alert(ngx_ssl_conn_t *ssl_conn, enum ssl_encryption_level_t level, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
255 uint8_t alert) |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
256 { |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
257 ngx_connection_t *c; |
|
8235
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
258 ngx_quic_frame_t *frame; |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
259 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
260 c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
261 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
262 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
263 "ngx_quic_send_alert(), lvl=%d, alert=%d", |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
264 (int) level, (int) alert); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
265 |
|
8235
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
266 frame = ngx_pcalloc(c->pool, sizeof(ngx_quic_frame_t)); |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
267 if (frame == NULL) { |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
268 return 0; |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
269 } |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
270 |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
271 frame->level = level; |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
272 frame->type = NGX_QUIC_FT_CONNECTION_CLOSE; |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
273 frame->u.close.error_code = 0x100 + alert; |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
274 |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
275 ngx_quic_queue_frame(c->quic, frame); |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
276 |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
277 if (ngx_quic_output(c) != NGX_OK) { |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
278 return 0; |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
279 } |
|
552d6868091b
Implemented send_alert callback, CONNECTION_CLOSE writer.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8234
diff
changeset
|
280 |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
281 return 1; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
282 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
283 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
284 |
| 8225 | 285 void |
| 286 ngx_quic_run(ngx_connection_t *c, ngx_ssl_t *ssl, ngx_msec_t timeout, | |
| 287 ngx_connection_handler_pt handler) | |
| 288 { | |
| 289 ngx_buf_t *b; | |
| 290 ngx_quic_header_t pkt; | |
| 291 | |
| 292 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic handshake"); | |
| 293 | |
| 294 c->log->action = "QUIC handshaking"; | |
| 295 | |
| 296 ngx_memzero(&pkt, sizeof(ngx_quic_header_t)); | |
| 297 | |
| 298 b = c->buffer; | |
| 299 | |
| 300 pkt.log = c->log; | |
| 301 pkt.raw = b; | |
| 302 pkt.data = b->start; | |
| 303 pkt.len = b->last - b->start; | |
| 304 | |
| 305 if (ngx_quic_new_connection(c, ssl, &pkt) != NGX_OK) { | |
| 306 ngx_quic_close_connection(c); | |
| 307 return; | |
| 308 } | |
| 309 | |
| 310 // we don't need stream handler for initial packet processing | |
| 311 c->quic->streams.handler = handler; | |
| 312 c->quic->streams.timeout = timeout; | |
| 313 | |
| 314 ngx_add_timer(c->read, timeout); | |
| 315 | |
| 316 c->read->handler = ngx_quic_handshake_handler; | |
| 317 | |
| 318 return; | |
| 319 } | |
| 320 | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
321 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
322 static ngx_int_t |
| 8225 | 323 ngx_quic_new_connection(ngx_connection_t *c, ngx_ssl_t *ssl, |
| 324 ngx_quic_header_t *pkt) | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
325 { |
| 8225 | 326 ngx_quic_connection_t *qc; |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
327 |
| 8225 | 328 if (ngx_buf_size(pkt->raw) < 1200) { |
| 329 ngx_log_error(NGX_LOG_INFO, c->log, 0, "too small UDP datagram"); | |
| 330 return NGX_ERROR; | |
| 331 } | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
332 |
| 8225 | 333 if (ngx_quic_parse_long_header(pkt) != NGX_OK) { |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
334 return NGX_ERROR; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
335 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
336 |
| 8225 | 337 if ((pkt->flags & 0xf0) != NGX_QUIC_PKT_INITIAL) { |
| 338 ngx_log_error(NGX_LOG_INFO, c->log, 0, | |
| 339 "invalid initial packet: 0x%xi", pkt->flags); | |
| 340 return NGX_ERROR; | |
| 341 } | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
342 |
| 8225 | 343 if (ngx_quic_parse_initial_header(pkt) != NGX_OK) { |
| 344 return NGX_ERROR; | |
| 345 } | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
346 |
| 8225 | 347 qc = ngx_pcalloc(c->pool, sizeof(ngx_quic_connection_t)); |
| 348 if (qc == NULL) { | |
| 349 return NGX_ERROR; | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
350 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
351 |
| 8225 | 352 ngx_rbtree_init(&qc->streams.tree, &qc->streams.sentinel, |
| 353 ngx_quic_rbtree_insert_stream); | |
| 354 | |
| 355 c->quic = qc; | |
| 356 qc->ssl = ssl; | |
| 357 | |
| 358 qc->dcid.len = pkt->dcid.len; | |
| 359 qc->dcid.data = ngx_pnalloc(c->pool, pkt->dcid.len); | |
| 360 if (qc->dcid.data == NULL) { | |
| 361 return NGX_ERROR; | |
| 362 } | |
| 363 ngx_memcpy(qc->dcid.data, pkt->dcid.data, qc->dcid.len); | |
| 364 | |
| 365 qc->scid.len = pkt->scid.len; | |
| 366 qc->scid.data = ngx_pnalloc(c->pool, qc->scid.len); | |
| 367 if (qc->scid.data == NULL) { | |
| 368 return NGX_ERROR; | |
| 369 } | |
| 370 ngx_memcpy(qc->scid.data, pkt->scid.data, qc->scid.len); | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
371 |
| 8225 | 372 qc->token.len = pkt->token.len; |
| 373 qc->token.data = ngx_pnalloc(c->pool, qc->token.len); | |
| 374 if (qc->token.data == NULL) { | |
| 375 return NGX_ERROR; | |
| 376 } | |
| 377 ngx_memcpy(qc->token.data, pkt->token.data, qc->token.len); | |
| 378 | |
| 379 | |
| 380 if (ngx_quic_set_initial_secret(c->pool, &qc->secrets, &qc->dcid) | |
| 381 != NGX_OK) | |
| 382 { | |
| 383 return NGX_ERROR; | |
| 384 } | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
385 |
| 8225 | 386 pkt->secret = &qc->secrets.client.in; |
| 387 pkt->level = ssl_encryption_initial; | |
| 388 | |
| 389 if (ngx_quic_decrypt(c->pool, NULL, pkt) != NGX_OK) { | |
| 390 return NGX_ERROR; | |
| 391 } | |
| 392 | |
| 393 if (ngx_quic_init_connection(c) != NGX_OK) { | |
| 394 return NGX_ERROR; | |
| 395 } | |
| 396 | |
| 397 return ngx_quic_payload_handler(c, pkt); | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
398 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
399 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
400 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
401 static ngx_int_t |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
402 ngx_quic_init_connection(ngx_connection_t *c) |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
403 { |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
404 int n, sslerr; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
405 ngx_ssl_conn_t *ssl_conn; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
406 ngx_quic_connection_t *qc; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
407 |
|
8205
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
408 static const uint8_t params[] = |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
409 "\x00\x29" /* parameters length: 41 bytes */ |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
410 "\x00\x0e\x00\x01\x05" /* active connection id limit: 5 */ |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
411 "\x00\x04\x00\x04\x80\x98\x96\x80" /* initial max data = 10000000 */ |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
412 "\x00\x09\x00\x01\x03" /* initial max streams uni: 3 */ |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
413 "\x00\x08\x00\x01\x10" /* initial max streams bidi: 16 */ |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
414 "\x00\x05\x00\x02\x40\xff" /* initial max stream bidi local: 255 */ |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
415 "\x00\x06\x00\x02\x40\xff" /* initial max stream bidi remote: 255 */ |
|
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
416 "\x00\x07\x00\x02\x40\xff"; /* initial max stream data uni: 255 */ |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
417 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
418 qc = c->quic; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
419 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
420 if (ngx_ssl_create_connection(qc->ssl, c, NGX_SSL_BUFFER) != NGX_OK) { |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
421 return NGX_ERROR; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
422 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
423 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
424 ssl_conn = c->ssl->connection; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
425 |
|
8232
253cf267f95a
Moved setting QUIC methods to runtime.
Roman Arutyunyan <arut@nginx.com>
parents:
8231
diff
changeset
|
426 if (SSL_set_quic_method(ssl_conn, &quic_method) == 0) { |
|
253cf267f95a
Moved setting QUIC methods to runtime.
Roman Arutyunyan <arut@nginx.com>
parents:
8231
diff
changeset
|
427 ngx_log_error(NGX_LOG_INFO, c->log, 0, |
|
253cf267f95a
Moved setting QUIC methods to runtime.
Roman Arutyunyan <arut@nginx.com>
parents:
8231
diff
changeset
|
428 "SSL_set_quic_method() failed"); |
|
253cf267f95a
Moved setting QUIC methods to runtime.
Roman Arutyunyan <arut@nginx.com>
parents:
8231
diff
changeset
|
429 return NGX_ERROR; |
|
253cf267f95a
Moved setting QUIC methods to runtime.
Roman Arutyunyan <arut@nginx.com>
parents:
8231
diff
changeset
|
430 } |
|
253cf267f95a
Moved setting QUIC methods to runtime.
Roman Arutyunyan <arut@nginx.com>
parents:
8231
diff
changeset
|
431 |
|
8205
a5423632d67b
Added more transport parameters.
Vladimir Homutov <vl@nginx.com>
parents:
8204
diff
changeset
|
432 if (SSL_set_quic_transport_params(ssl_conn, params, sizeof(params) - 1) == 0) { |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
433 ngx_log_error(NGX_LOG_INFO, c->log, 0, |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
434 "SSL_set_quic_transport_params() failed"); |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
435 return NGX_ERROR; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
436 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
437 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
438 n = SSL_do_handshake(ssl_conn); |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
439 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
440 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_do_handshake: %d", n); |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
441 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
442 if (n == -1) { |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
443 sslerr = SSL_get_error(ssl_conn, n); |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
444 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
445 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
446 sslerr); |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
447 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
448 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
449 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
450 "SSL_quic_read_level: %d, SSL_quic_write_level: %d", |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
451 (int) SSL_quic_read_level(ssl_conn), |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
452 (int) SSL_quic_write_level(ssl_conn)); |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
453 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
454 return NGX_OK; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
455 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
456 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
457 |
| 8225 | 458 static void |
| 459 ngx_quic_handshake_handler(ngx_event_t *rev) | |
|
8211
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
460 { |
| 8225 | 461 ssize_t n; |
| 462 ngx_buf_t b; | |
| 463 ngx_connection_t *c; | |
|
8211
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
464 |
| 8225 | 465 u_char buf[512]; |
|
8211
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
466 |
| 8225 | 467 b.start = buf; |
| 468 b.end = buf + 512; | |
| 469 b.pos = b.last = b.start; | |
|
8211
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
470 |
| 8225 | 471 c = rev->data; |
|
8211
6bc18966b8c1
Stream "connection" read/write methods.
Vladimir Homutov <vl@nginx.com>
parents:
8209
diff
changeset
|
472 |
| 8225 | 473 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, rev->log, 0, "quic handshake handler"); |
|
8212
e3c0b19a3a8a
Implemented ngx_quic_stream_send_chain() method.
Roman Arutyunyan <arut@nginx.com>
parents:
8211
diff
changeset
|
474 |
| 8225 | 475 if (rev->timedout) { |
| 476 ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out"); | |
| 477 ngx_quic_close_connection(c); | |
| 478 return; | |
|
8212
e3c0b19a3a8a
Implemented ngx_quic_stream_send_chain() method.
Roman Arutyunyan <arut@nginx.com>
parents:
8211
diff
changeset
|
479 } |
|
e3c0b19a3a8a
Implemented ngx_quic_stream_send_chain() method.
Roman Arutyunyan <arut@nginx.com>
parents:
8211
diff
changeset
|
480 |
|
8246
0d9bc77ae30d
Reset QUIC timeout on every datagram.
Roman Arutyunyan <arut@nginx.com>
parents:
8245
diff
changeset
|
481 ngx_add_timer(rev, c->quic->streams.timeout); |
|
0d9bc77ae30d
Reset QUIC timeout on every datagram.
Roman Arutyunyan <arut@nginx.com>
parents:
8245
diff
changeset
|
482 |
| 8225 | 483 if (c->close) { |
| 484 ngx_quic_close_connection(c); | |
| 485 return; | |
| 486 } | |
|
8220
7ada2feeac18
Added processing of CONNECTION CLOSE frames.
Vladimir Homutov <vl@nginx.com>
parents:
8218
diff
changeset
|
487 |
| 8225 | 488 n = c->recv(c, b.start, b.end - b.start); |
| 8215 | 489 |
| 8225 | 490 if (n == NGX_AGAIN) { |
| 491 return; | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
492 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
493 |
| 8225 | 494 if (n == NGX_ERROR) { |
| 495 c->read->eof = 1; | |
| 496 ngx_quic_close_connection(c); | |
| 497 return; | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
498 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
499 |
| 8225 | 500 b.last += n; |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
501 |
| 8225 | 502 if (ngx_quic_input(c, &b) != NGX_OK) { |
| 503 ngx_quic_close_connection(c); | |
| 504 return; | |
| 505 } | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
506 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
507 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
508 |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
509 static void |
| 8225 | 510 ngx_quic_close_connection(ngx_connection_t *c) |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
511 { |
| 8225 | 512 ngx_pool_t *pool; |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
513 |
| 8225 | 514 /* XXX wait for all streams to close */ |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
515 |
| 8225 | 516 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, |
| 517 "close quic connection: %d", c->fd); | |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
518 |
| 8225 | 519 if (c->ssl) { |
| 520 (void) ngx_ssl_shutdown(c); | |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
521 } |
|
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
522 |
| 8225 | 523 #if (NGX_STAT_STUB) |
| 524 (void) ngx_atomic_fetch_add(ngx_stat_active, -1); | |
| 525 #endif | |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
526 |
| 8225 | 527 c->destroyed = 1; |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
528 |
| 8225 | 529 pool = c->pool; |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
530 |
| 8225 | 531 ngx_close_connection(c); |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
532 |
| 8225 | 533 ngx_destroy_pool(pool); |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
534 } |
|
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
535 |
|
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
536 |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
537 static ngx_int_t |
| 8225 | 538 ngx_quic_input(ngx_connection_t *c, ngx_buf_t *b) |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
539 { |
| 8225 | 540 u_char *p; |
| 541 ngx_int_t rc; | |
| 542 ngx_quic_header_t pkt; | |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
543 |
| 8225 | 544 if (c->quic == NULL) { |
| 545 // XXX: possible? | |
| 546 ngx_log_error(NGX_LOG_INFO, c->log, 0, "BUG: no QUIC in connection"); | |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
547 return NGX_ERROR; |
|
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
548 } |
|
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
549 |
| 8225 | 550 p = b->start; |
|
8208
4ae9ac69ab93
HTTP/QUIC interface reworked.
Vladimir Homutov <vl@nginx.com>
parents:
8207
diff
changeset
|
551 |
| 8225 | 552 do { |
| 553 ngx_memzero(&pkt, sizeof(ngx_quic_header_t)); | |
| 554 pkt.raw = b; | |
| 555 pkt.data = p; | |
| 556 pkt.len = b->last - p; | |
| 557 pkt.log = c->log; | |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
558 |
| 8225 | 559 if (p[0] == 0) { |
| 560 /* XXX: no idea WTF is this, just ignore */ | |
| 561 ngx_log_error(NGX_LOG_ALERT, c->log, 0, "FIREFOX: ZEROES"); | |
| 562 break; | |
| 563 } | |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
564 |
| 8225 | 565 // TODO: check current state |
| 566 if (p[0] & NGX_QUIC_PKT_LONG) { | |
| 567 | |
| 568 if ((p[0] & 0xf0) == NGX_QUIC_PKT_INITIAL) { | |
| 569 rc = ngx_quic_initial_input(c, &pkt); | |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
570 |
| 8225 | 571 } else if ((p[0] & 0xf0) == NGX_QUIC_PKT_HANDSHAKE) { |
| 572 rc = ngx_quic_handshake_input(c, &pkt); | |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
573 |
| 8225 | 574 } else { |
| 575 ngx_log_error(NGX_LOG_INFO, c->log, 0, | |
| 576 "BUG: unknown quic state"); | |
| 577 return NGX_ERROR; | |
| 578 } | |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
579 |
| 8225 | 580 } else { |
| 581 rc = ngx_quic_app_input(c, &pkt); | |
| 582 } | |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
583 |
| 8225 | 584 if (rc == NGX_ERROR) { |
| 585 return NGX_ERROR; | |
| 586 } | |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
587 |
| 8225 | 588 /* b->pos is at header end, adjust by actual packet length */ |
| 589 p = b->pos + pkt.len; | |
| 590 b->pos = p; /* reset b->pos to the next packet start */ | |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
591 |
| 8225 | 592 } while (p < b->last); |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
593 |
| 8225 | 594 return NGX_OK; |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
595 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
596 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
597 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
598 static ngx_int_t |
| 8223 | 599 ngx_quic_initial_input(ngx_connection_t *c, ngx_quic_header_t *pkt) |
| 600 { | |
| 601 ngx_ssl_conn_t *ssl_conn; | |
| 602 ngx_quic_connection_t *qc; | |
| 603 | |
| 604 qc = c->quic; | |
| 605 ssl_conn = c->ssl->connection; | |
| 606 | |
|
8224
ae35ccba7aa6
Extracted transport part of the code into separate file.
Vladimir Homutov <vl@nginx.com>
parents:
8223
diff
changeset
|
607 if (ngx_quic_parse_long_header(pkt) != NGX_OK) { |
| 8223 | 608 return NGX_ERROR; |
| 609 } | |
| 610 | |
|
8224
ae35ccba7aa6
Extracted transport part of the code into separate file.
Vladimir Homutov <vl@nginx.com>
parents:
8223
diff
changeset
|
611 if (ngx_quic_parse_initial_header(pkt) != NGX_OK) { |
| 8223 | 612 return NGX_ERROR; |
| 613 } | |
| 614 | |
| 615 pkt->secret = &qc->secrets.client.in; | |
| 616 pkt->level = ssl_encryption_initial; | |
| 617 | |
| 618 if (ngx_quic_decrypt(c->pool, ssl_conn, pkt) != NGX_OK) { | |
| 619 return NGX_ERROR; | |
| 620 } | |
| 621 | |
| 622 return ngx_quic_payload_handler(c, pkt); | |
| 623 } | |
| 624 | |
| 625 | |
| 626 static ngx_int_t | |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
627 ngx_quic_handshake_input(ngx_connection_t *c, ngx_quic_header_t *pkt) |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
628 { |
|
8188
bf555b94e387
Using cached ssl_conn in ngx_quic_handshake_input(), NFC.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8187
diff
changeset
|
629 ngx_ssl_conn_t *ssl_conn; |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
630 ngx_quic_connection_t *qc; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
631 |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
632 qc = c->quic; |
|
8188
bf555b94e387
Using cached ssl_conn in ngx_quic_handshake_input(), NFC.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8187
diff
changeset
|
633 ssl_conn = c->ssl->connection; |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
634 |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
635 /* extract cleartext data into pkt */ |
|
8224
ae35ccba7aa6
Extracted transport part of the code into separate file.
Vladimir Homutov <vl@nginx.com>
parents:
8223
diff
changeset
|
636 if (ngx_quic_parse_long_header(pkt) != NGX_OK) { |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
637 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
638 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
639 |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
640 if (pkt->dcid.len != qc->dcid.len) { |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
641 ngx_log_error(NGX_LOG_INFO, c->log, 0, "unexpected quic dcidl"); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
642 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
643 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
644 |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
645 if (ngx_memcmp(pkt->dcid.data, qc->dcid.data, qc->dcid.len) != 0) { |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
646 ngx_log_error(NGX_LOG_INFO, c->log, 0, "unexpected quic dcid"); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
647 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
648 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
649 |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
650 if (pkt->scid.len != qc->scid.len) { |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
651 ngx_log_error(NGX_LOG_INFO, c->log, 0, "unexpected quic scidl"); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
652 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
653 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
654 |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
655 if (ngx_memcmp(pkt->scid.data, qc->scid.data, qc->scid.len) != 0) { |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
656 ngx_log_error(NGX_LOG_INFO, c->log, 0, "unexpected quic scid"); |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
657 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
658 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
659 |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
660 if ((pkt->flags & 0xf0) != NGX_QUIC_PKT_HANDSHAKE) { |
|
8193
4355efde26d8
Added functions to decrypt long packets.
Vladimir Homutov <vl@nginx.com>
parents:
8192
diff
changeset
|
661 ngx_log_error(NGX_LOG_INFO, c->log, 0, |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
662 "invalid packet type: 0x%xi", pkt->flags); |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
663 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
664 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
665 |
|
8224
ae35ccba7aa6
Extracted transport part of the code into separate file.
Vladimir Homutov <vl@nginx.com>
parents:
8223
diff
changeset
|
666 if (ngx_quic_parse_handshake_header(pkt) != NGX_OK) { |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
667 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
668 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
669 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
670 pkt->secret = &qc->secrets.client.hs; |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
671 pkt->level = ssl_encryption_handshake; |
|
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
672 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
673 if (ngx_quic_decrypt(c->pool, c->ssl->connection, pkt) != NGX_OK) { |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
674 return NGX_ERROR; |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
675 } |
|
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
676 |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
677 return ngx_quic_payload_handler(c, pkt); |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
678 } |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
679 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
680 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
681 static ngx_int_t |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
682 ngx_quic_app_input(ngx_connection_t *c, ngx_quic_header_t *pkt) |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
683 { |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
684 ngx_quic_connection_t *qc; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
685 |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
686 qc = c->quic; |
|
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
687 |
| 8223 | 688 if (qc->secrets.client.ad.key.len == 0) { |
| 689 ngx_log_error(NGX_LOG_INFO, c->log, 0, | |
| 690 "no read keys yet, packet ignored"); | |
| 691 return NGX_DECLINED; | |
| 692 } | |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
693 |
|
8224
ae35ccba7aa6
Extracted transport part of the code into separate file.
Vladimir Homutov <vl@nginx.com>
parents:
8223
diff
changeset
|
694 if (ngx_quic_parse_short_header(pkt, &qc->dcid) != NGX_OK) { |
|
8185
6a76d9657772
QUIC handshake final bits.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8184
diff
changeset
|
695 return NGX_ERROR; |
|
6a76d9657772
QUIC handshake final bits.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8184
diff
changeset
|
696 } |
|
6a76d9657772
QUIC handshake final bits.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8184
diff
changeset
|
697 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
698 pkt->secret = &qc->secrets.client.ad; |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
699 pkt->level = ssl_encryption_application; |
|
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
700 |
|
8221
69345a26ba69
Split transport and crypto parts into separate files.
Vladimir Homutov <vl@nginx.com>
parents:
8220
diff
changeset
|
701 if (ngx_quic_decrypt(c->pool, c->ssl->connection, pkt) != NGX_OK) { |
|
8199
1297dc83a6b9
Generic payload handler for quic packets.
Vladimir Homutov <vl@nginx.com>
parents:
8198
diff
changeset
|
702 return NGX_ERROR; |
|
8185
6a76d9657772
QUIC handshake final bits.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8184
diff
changeset
|
703 } |
|
6a76d9657772
QUIC handshake final bits.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8184
diff
changeset
|
704 |
|
8206
8d6ac639feac
Added support of multiple QUIC packets in single datagram.
Vladimir Homutov <vl@nginx.com>
parents:
8205
diff
changeset
|
705 return ngx_quic_payload_handler(c, pkt); |
|
8182
b28ea685a56e
Moved all QUIC code into ngx_event_quic.c
Vladimir Homutov <vl@nginx.com>
parents:
8180
diff
changeset
|
706 } |
| 8171 | 707 |
| 708 | |
| 8225 | 709 static ngx_int_t |
| 710 ngx_quic_payload_handler(ngx_connection_t *c, ngx_quic_header_t *pkt) | |
| 711 { | |
| 712 u_char *end, *p; | |
| 713 ssize_t len; | |
| 714 ngx_uint_t ack_this, do_close; | |
| 715 ngx_quic_frame_t frame, *ack_frame; | |
| 716 ngx_quic_connection_t *qc; | |
| 717 | |
| 718 qc = c->quic; | |
| 719 | |
| 720 p = pkt->payload.data; | |
| 721 end = p + pkt->payload.len; | |
| 722 | |
| 723 ack_this = 0; | |
| 724 do_close = 0; | |
| 725 | |
| 726 while (p < end) { | |
| 727 | |
|
8240
1f002206a59b
Added boundaries checks into frame parser.
Vladimir Homutov <vl@nginx.com>
parents:
8239
diff
changeset
|
728 len = ngx_quic_parse_frame(pkt, p, end, &frame); |
| 8225 | 729 if (len < 0) { |
| 730 return NGX_ERROR; | |
| 731 } | |
| 732 | |
| 733 p += len; | |
| 734 | |
| 735 switch (frame.type) { | |
| 736 | |
| 737 case NGX_QUIC_FT_ACK: | |
| 738 if (ngx_quic_handle_ack_frame(c, pkt, &frame.u.ack) != NGX_OK) { | |
| 739 return NGX_ERROR; | |
| 740 } | |
| 741 | |
| 742 break; | |
| 743 | |
| 744 case NGX_QUIC_FT_CRYPTO: | |
| 745 | |
| 746 if (ngx_quic_handle_crypto_frame(c, pkt, &frame.u.crypto) | |
| 747 != NGX_OK) | |
| 748 { | |
| 749 return NGX_ERROR; | |
| 750 } | |
| 751 | |
| 752 ack_this = 1; | |
| 753 break; | |
| 754 | |
| 755 case NGX_QUIC_FT_PADDING: | |
| 756 break; | |
| 757 | |
| 758 case NGX_QUIC_FT_PING: | |
| 759 ack_this = 1; | |
| 760 break; | |
| 761 | |
| 762 case NGX_QUIC_FT_NEW_CONNECTION_ID: | |
| 763 ack_this = 1; | |
| 764 break; | |
| 765 | |
| 766 case NGX_QUIC_FT_CONNECTION_CLOSE: | |
| 767 | |
| 768 do_close = 1; | |
| 769 break; | |
| 770 | |
| 771 case NGX_QUIC_FT_STREAM0: | |
| 772 case NGX_QUIC_FT_STREAM1: | |
| 773 case NGX_QUIC_FT_STREAM2: | |
| 774 case NGX_QUIC_FT_STREAM3: | |
| 775 case NGX_QUIC_FT_STREAM4: | |
| 776 case NGX_QUIC_FT_STREAM5: | |
| 777 case NGX_QUIC_FT_STREAM6: | |
| 778 case NGX_QUIC_FT_STREAM7: | |
| 779 | |
| 780 if (ngx_quic_handle_stream_frame(c, pkt, &frame.u.stream) | |
| 781 != NGX_OK) | |
| 782 { | |
| 783 return NGX_ERROR; | |
| 784 } | |
| 785 | |
| 786 ack_this = 1; | |
| 787 break; | |
| 788 | |
|
8237
ff540f13d95d
MAX_DATA frame parser/handler.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8236
diff
changeset
|
789 case NGX_QUIC_FT_MAX_DATA: |
|
ff540f13d95d
MAX_DATA frame parser/handler.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8236
diff
changeset
|
790 c->quic->max_data = frame.u.max_data.max_data; |
|
ff540f13d95d
MAX_DATA frame parser/handler.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8236
diff
changeset
|
791 ack_this = 1; |
|
ff540f13d95d
MAX_DATA frame parser/handler.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8236
diff
changeset
|
792 break; |
|
ff540f13d95d
MAX_DATA frame parser/handler.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8236
diff
changeset
|
793 |
|
8231
78540e2160d0
Added parsing of RESET_STREAM and STOP_SENDING frames
Vladimir Homutov <vl@nginx.com>
parents:
8229
diff
changeset
|
794 case NGX_QUIC_FT_RESET_STREAM: |
|
8240
1f002206a59b
Added boundaries checks into frame parser.
Vladimir Homutov <vl@nginx.com>
parents:
8239
diff
changeset
|
795 /* TODO: handle */ |
|
8231
78540e2160d0
Added parsing of RESET_STREAM and STOP_SENDING frames
Vladimir Homutov <vl@nginx.com>
parents:
8229
diff
changeset
|
796 break; |
|
78540e2160d0
Added parsing of RESET_STREAM and STOP_SENDING frames
Vladimir Homutov <vl@nginx.com>
parents:
8229
diff
changeset
|
797 |
|
78540e2160d0
Added parsing of RESET_STREAM and STOP_SENDING frames
Vladimir Homutov <vl@nginx.com>
parents:
8229
diff
changeset
|
798 case NGX_QUIC_FT_STOP_SENDING: |
|
8240
1f002206a59b
Added boundaries checks into frame parser.
Vladimir Homutov <vl@nginx.com>
parents:
8239
diff
changeset
|
799 /* TODO: handle; need ack ? */ |
|
8231
78540e2160d0
Added parsing of RESET_STREAM and STOP_SENDING frames
Vladimir Homutov <vl@nginx.com>
parents:
8229
diff
changeset
|
800 break; |
|
78540e2160d0
Added parsing of RESET_STREAM and STOP_SENDING frames
Vladimir Homutov <vl@nginx.com>
parents:
8229
diff
changeset
|
801 |
|
8236
d3b26c3bea22
Added parsing of STREAMS BLOCKED frames.
Vladimir Homutov <vl@nginx.com>
parents:
8235
diff
changeset
|
802 case NGX_QUIC_FT_STREAMS_BLOCKED: |
|
d3b26c3bea22
Added parsing of STREAMS BLOCKED frames.
Vladimir Homutov <vl@nginx.com>
parents:
8235
diff
changeset
|
803 case NGX_QUIC_FT_STREAMS_BLOCKED2: |
|
8245
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
804 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
805 if (ngx_quic_handle_streams_blocked_frame(c, pkt, |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
806 &frame.u.streams_blocked) |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
807 != NGX_OK) |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
808 { |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
809 return NGX_ERROR; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
810 } |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
811 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
812 ack_this = 1; |
|
8236
d3b26c3bea22
Added parsing of STREAMS BLOCKED frames.
Vladimir Homutov <vl@nginx.com>
parents:
8235
diff
changeset
|
813 break; |
|
d3b26c3bea22
Added parsing of STREAMS BLOCKED frames.
Vladimir Homutov <vl@nginx.com>
parents:
8235
diff
changeset
|
814 |
| 8225 | 815 default: |
| 816 return NGX_ERROR; | |
| 817 } | |
| 818 } | |
| 819 | |
| 820 if (p != end) { | |
| 821 ngx_log_error(NGX_LOG_INFO, c->log, 0, | |
| 822 "trailing garbage in payload: %ui bytes", end - p); | |
| 823 return NGX_ERROR; | |
| 824 } | |
| 825 | |
| 826 if (do_close) { | |
| 827 // TODO: handle stream close | |
| 828 } | |
| 829 | |
| 830 if (ack_this == 0) { | |
| 831 /* do not ack packets with ACKs and PADDING */ | |
| 832 return NGX_OK; | |
| 833 } | |
| 834 | |
| 835 // packet processed, ACK it now if required | |
| 836 // TODO: if (ack_required) ... - currently just ack each packet | |
| 837 | |
| 838 ack_frame = ngx_pcalloc(c->pool, sizeof(ngx_quic_frame_t)); | |
| 839 if (ack_frame == NULL) { | |
| 840 return NGX_ERROR; | |
| 841 } | |
| 842 | |
| 843 ack_frame->level = pkt->level; | |
| 844 ack_frame->type = NGX_QUIC_FT_ACK; | |
| 845 ack_frame->u.ack.pn = pkt->pn; | |
| 846 | |
| 847 ngx_sprintf(ack_frame->info, "ACK for PN=%d from frame handler level=%d", pkt->pn, pkt->level); | |
| 848 ngx_quic_queue_frame(qc, ack_frame); | |
| 849 | |
| 850 return ngx_quic_output(c); | |
| 851 } | |
| 852 | |
| 853 | |
| 854 static ngx_int_t | |
| 855 ngx_quic_handle_ack_frame(ngx_connection_t *c, ngx_quic_header_t *pkt, | |
| 856 ngx_quic_ack_frame_t *f) | |
| 857 { | |
| 858 /* TODO: handle ACK here */ | |
| 859 return NGX_OK; | |
| 860 } | |
| 861 | |
| 862 | |
| 863 static ngx_int_t | |
| 864 ngx_quic_handle_crypto_frame(ngx_connection_t *c, ngx_quic_header_t *pkt, | |
| 865 ngx_quic_crypto_frame_t *f) | |
| 866 { | |
| 867 int sslerr; | |
| 868 ssize_t n; | |
| 869 ngx_ssl_conn_t *ssl_conn; | |
| 870 | |
| 871 if (f->offset != 0x0) { | |
| 872 ngx_log_error(NGX_LOG_INFO, c->log, 0, | |
| 873 "crypto frame with non-zero offset"); | |
| 874 // TODO: add support for crypto frames spanning packets | |
| 875 return NGX_ERROR; | |
| 876 } | |
| 877 | |
| 878 ssl_conn = c->ssl->connection; | |
| 879 | |
| 880 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, | |
| 881 "SSL_quic_read_level: %d, SSL_quic_write_level: %d", | |
| 882 (int) SSL_quic_read_level(ssl_conn), | |
| 883 (int) SSL_quic_write_level(ssl_conn)); | |
| 884 | |
| 885 if (!SSL_provide_quic_data(ssl_conn, SSL_quic_read_level(ssl_conn), | |
| 886 f->data, f->len)) | |
| 887 { | |
| 888 ngx_ssl_error(NGX_LOG_INFO, c->log, 0, | |
| 889 "SSL_provide_quic_data() failed"); | |
| 890 return NGX_ERROR; | |
| 891 } | |
| 892 | |
| 893 n = SSL_do_handshake(ssl_conn); | |
| 894 | |
| 895 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_do_handshake: %d", n); | |
| 896 | |
| 897 if (n == -1) { | |
| 898 sslerr = SSL_get_error(ssl_conn, n); | |
| 899 | |
| 900 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", | |
| 901 sslerr); | |
| 902 | |
| 903 if (sslerr == SSL_ERROR_SSL) { | |
| 904 ngx_ssl_error(NGX_LOG_ERR, c->log, 0, "SSL_do_handshake() failed"); | |
| 905 } | |
| 906 } | |
| 907 | |
| 908 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, | |
| 909 "quic ssl cipher: %s", SSL_get_cipher(ssl_conn)); | |
| 910 | |
| 911 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, | |
| 912 "SSL_quic_read_level: %d, SSL_quic_write_level: %d", | |
| 913 (int) SSL_quic_read_level(ssl_conn), | |
| 914 (int) SSL_quic_write_level(ssl_conn)); | |
| 915 | |
| 916 return NGX_OK; | |
| 917 } | |
| 918 | |
| 919 | |
| 920 static ngx_int_t | |
| 921 ngx_quic_handle_stream_frame(ngx_connection_t *c, | |
| 922 ngx_quic_header_t *pkt, ngx_quic_stream_frame_t *f) | |
| 923 { | |
| 924 ngx_buf_t *b; | |
| 925 ngx_quic_connection_t *qc; | |
| 926 ngx_quic_stream_node_t *sn; | |
| 927 | |
| 928 qc = c->quic; | |
| 929 | |
| 930 sn = ngx_quic_find_stream(&qc->streams.tree, f->stream_id); | |
| 931 | |
| 932 if (sn) { | |
| 933 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "existing stream"); | |
| 934 b = sn->b; | |
| 935 | |
| 936 if ((size_t) (b->end - b->pos) < f->length) { | |
| 937 ngx_log_error(NGX_LOG_INFO, c->log, 0, "no space in stream buffer"); | |
| 938 return NGX_ERROR; | |
| 939 } | |
| 940 | |
| 941 ngx_memcpy(b->pos, f->data, f->length); | |
| 942 b->pos += f->length; | |
| 943 | |
| 944 // TODO: notify | |
| 945 | |
| 946 return NGX_OK; | |
| 947 } | |
| 948 | |
| 949 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "stream is new"); | |
| 950 | |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
951 sn = ngx_quic_create_stream(c, f->stream_id); |
| 8225 | 952 if (sn == NULL) { |
| 953 return NGX_ERROR; | |
| 954 } | |
| 955 | |
| 956 b = sn->b; | |
| 957 | |
| 958 ngx_memcpy(b->start, f->data, f->length); | |
| 959 b->last = b->start + f->length; | |
| 960 | |
| 961 qc->streams.handler(sn->c); | |
| 962 | |
| 963 return NGX_OK; | |
| 964 } | |
| 965 | |
| 966 | |
|
8245
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
967 static ngx_int_t |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
968 ngx_quic_handle_streams_blocked_frame(ngx_connection_t *c, |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
969 ngx_quic_header_t *pkt, ngx_quic_streams_blocked_frame_t *f) |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
970 { |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
971 ngx_quic_frame_t *frame; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
972 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
973 frame = ngx_pcalloc(c->pool, sizeof(ngx_quic_frame_t)); |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
974 if (frame == NULL) { |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
975 return NGX_ERROR; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
976 } |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
977 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
978 frame->level = pkt->level; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
979 frame->type = NGX_QUIC_FT_MAX_STREAMS; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
980 frame->u.max_streams.limit = f->limit * 2; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
981 frame->u.max_streams.bidi = f->bidi; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
982 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
983 ngx_sprintf(frame->info, "MAX_STREAMS limit:%d bidi:%d level=%d", |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
984 (int) frame->u.max_streams.limit, |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
985 (int) frame->u.max_streams.bidi, |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
986 frame->level); |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
987 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
988 ngx_quic_queue_frame(c->quic, frame); |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
989 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
990 return NGX_OK; |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
991 } |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
992 |
|
a14afe21e692
Double MAX_STREAMS on STREAMS_BLOCKED.
Roman Arutyunyan <arut@nginx.com>
parents:
8241
diff
changeset
|
993 |
| 8225 | 994 static void |
| 995 ngx_quic_queue_frame(ngx_quic_connection_t *qc, ngx_quic_frame_t *frame) | |
| 996 { | |
| 997 ngx_quic_frame_t *f; | |
| 998 | |
| 999 if (qc->frames == NULL) { | |
| 1000 qc->frames = frame; | |
| 1001 return; | |
| 1002 } | |
| 1003 | |
| 1004 for (f = qc->frames; f->next; f = f->next) { | |
| 1005 if (f->next->level > frame->level) { | |
| 1006 break; | |
| 1007 } | |
| 1008 } | |
| 1009 | |
| 1010 frame->next = f->next; | |
| 1011 f->next = frame; | |
| 1012 } | |
| 1013 | |
| 1014 | |
| 1015 static ngx_int_t | |
| 1016 ngx_quic_output(ngx_connection_t *c) | |
| 1017 { | |
| 1018 size_t len; | |
| 1019 ngx_uint_t lvl; | |
| 1020 ngx_quic_frame_t *f, *start; | |
| 1021 ngx_quic_connection_t *qc; | |
| 1022 | |
| 1023 qc = c->quic; | |
| 1024 | |
| 1025 if (qc->frames == NULL) { | |
| 1026 return NGX_OK; | |
| 1027 } | |
| 1028 | |
| 1029 lvl = qc->frames->level; | |
| 1030 start = qc->frames; | |
| 1031 f = start; | |
| 1032 | |
| 1033 do { | |
| 1034 len = 0; | |
| 1035 | |
| 1036 do { | |
| 1037 /* process same-level group of frames */ | |
| 1038 | |
|
8241
db745339e54b
The ngx_quic_frame_len() function is not really needed.
Vladimir Homutov <vl@nginx.com>
parents:
8240
diff
changeset
|
1039 len += ngx_quic_create_frame(NULL, NULL, f);// TODO: handle overflow, max size |
| 8225 | 1040 |
| 1041 f = f->next; | |
| 1042 } while (f && f->level == lvl); | |
| 1043 | |
| 1044 | |
| 1045 if (ngx_quic_frames_send(c, start, f, len) != NGX_OK) { | |
| 1046 return NGX_ERROR; | |
| 1047 } | |
| 1048 | |
| 1049 if (f == NULL) { | |
| 1050 break; | |
| 1051 } | |
| 1052 | |
| 1053 lvl = f->level; // TODO: must not decrease (ever, also between calls) | |
| 1054 start = f; | |
| 1055 | |
| 1056 } while (1); | |
| 1057 | |
| 1058 qc->frames = NULL; | |
| 1059 | |
| 1060 return NGX_OK; | |
| 1061 } | |
| 1062 | |
| 1063 | |
| 1064 /* pack a group of frames [start; end) into memory p and send as single packet */ | |
| 1065 ngx_int_t | |
| 1066 ngx_quic_frames_send(ngx_connection_t *c, ngx_quic_frame_t *start, | |
| 1067 ngx_quic_frame_t *end, size_t total) | |
| 1068 { | |
| 1069 ssize_t len; | |
| 1070 u_char *p; | |
| 1071 ngx_str_t out; | |
| 1072 ngx_quic_frame_t *f; | |
| 1073 | |
| 1074 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, | |
| 1075 "sending frames %p...%p", start, end); | |
| 1076 | |
| 1077 p = ngx_pnalloc(c->pool, total); | |
| 1078 if (p == NULL) { | |
| 1079 return NGX_ERROR; | |
| 1080 } | |
| 1081 | |
| 1082 out.data = p; | |
| 1083 | |
| 1084 for (f = start; f != end; f = f->next) { | |
| 1085 | |
| 1086 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "frame: %s", f->info); | |
| 1087 | |
| 1088 len = ngx_quic_create_frame(p, p + total, f); | |
| 1089 if (len == -1) { | |
| 1090 return NGX_ERROR; | |
| 1091 } | |
| 1092 | |
| 1093 p += len; | |
| 1094 } | |
| 1095 | |
| 1096 out.len = p - out.data; | |
| 1097 | |
| 1098 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, | |
| 1099 "packet ready: %ui bytes at level %d", | |
| 1100 out.len, start->level); | |
| 1101 | |
| 1102 // IOVEC/sendmsg_chain ? | |
| 1103 if (ngx_quic_send_packet(c, c->quic, start->level, &out) != NGX_OK) { | |
| 1104 return NGX_ERROR; | |
| 1105 } | |
| 1106 | |
| 1107 return NGX_OK; | |
| 1108 } | |
| 1109 | |
| 1110 | |
| 1111 static ngx_int_t | |
| 1112 ngx_quic_send_packet(ngx_connection_t *c, ngx_quic_connection_t *qc, | |
| 1113 enum ssl_encryption_level_t level, ngx_str_t *payload) | |
| 1114 { | |
| 1115 ngx_str_t res; | |
| 1116 ngx_quic_header_t pkt; | |
| 1117 | |
| 1118 pkt.log = c->log; | |
| 1119 | |
| 1120 static ngx_str_t initial_token = ngx_null_string; | |
| 1121 | |
| 1122 ngx_memzero(&pkt, sizeof(ngx_quic_header_t)); | |
| 1123 ngx_quic_hexdump0(c->log, "payload", payload->data, payload->len); | |
| 1124 | |
| 1125 pkt.level = level; | |
| 1126 pkt.dcid = qc->dcid; | |
| 1127 pkt.scid = qc->scid; | |
| 1128 | |
| 1129 if (level == ssl_encryption_initial) { | |
| 1130 pkt.number = &qc->initial_pn; | |
| 1131 pkt.flags = NGX_QUIC_PKT_INITIAL; | |
| 1132 pkt.secret = &qc->secrets.server.in; | |
| 1133 pkt.token = initial_token; | |
| 1134 | |
| 1135 } else if (level == ssl_encryption_handshake) { | |
| 1136 pkt.number = &qc->handshake_pn; | |
| 1137 pkt.flags = NGX_QUIC_PKT_HANDSHAKE; | |
| 1138 pkt.secret = &qc->secrets.server.hs; | |
| 1139 | |
| 1140 } else { | |
| 1141 pkt.number = &qc->appdata_pn; | |
| 1142 pkt.secret = &qc->secrets.server.ad; | |
| 1143 } | |
| 1144 | |
| 1145 if (ngx_quic_encrypt(c->pool, c->ssl->connection, &pkt, payload, &res) | |
| 1146 != NGX_OK) | |
| 1147 { | |
| 1148 return NGX_ERROR; | |
| 1149 } | |
| 1150 | |
| 1151 ngx_quic_hexdump0(c->log, "packet to send", res.data, res.len); | |
| 1152 | |
| 1153 c->send(c, res.data, res.len); // TODO: err handling | |
| 1154 | |
| 1155 (*pkt.number)++; | |
| 1156 | |
| 1157 return NGX_OK; | |
| 1158 } | |
| 1159 | |
| 1160 | |
| 1161 ngx_connection_t * | |
| 1162 ngx_quic_create_uni_stream(ngx_connection_t *c) | |
| 1163 { | |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1164 ngx_uint_t id; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1165 ngx_quic_stream_t *qs; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1166 ngx_quic_connection_t *qc; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1167 ngx_quic_stream_node_t *sn; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1168 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1169 qs = c->qs; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1170 qc = qs->parent->quic; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1171 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1172 /* |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1173 * A stream ID is a 62-bit integer that is unique for all streams |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1174 * on a connection. |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1175 * |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1176 * 0x3 | Server-Initiated, Unidirectional |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1177 */ |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1178 id = (qc->streams.id_counter << 2) | 0x3; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1179 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1180 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1181 "creating server uni stream #%ui id %ui", |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1182 qc->streams.id_counter, id); |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1183 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1184 qc->streams.id_counter++; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1185 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1186 sn = ngx_quic_create_stream(qs->parent, id); |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1187 if (sn == NULL) { |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1188 return NULL; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1189 } |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1190 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1191 return sn->c; |
| 8225 | 1192 } |
| 1193 | |
| 1194 | |
| 1195 static void | |
| 1196 ngx_quic_rbtree_insert_stream(ngx_rbtree_node_t *temp, | |
| 1197 ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel) | |
| 1198 { | |
| 1199 ngx_rbtree_node_t **p; | |
| 1200 ngx_quic_stream_node_t *qn, *qnt; | |
| 1201 | |
| 1202 for ( ;; ) { | |
| 1203 | |
| 1204 if (node->key < temp->key) { | |
| 1205 | |
| 1206 p = &temp->left; | |
| 1207 | |
| 1208 } else if (node->key > temp->key) { | |
| 1209 | |
| 1210 p = &temp->right; | |
| 1211 | |
| 1212 } else { /* node->key == temp->key */ | |
| 1213 | |
| 1214 qn = (ngx_quic_stream_node_t *) &node->color; | |
| 1215 qnt = (ngx_quic_stream_node_t *) &temp->color; | |
| 1216 | |
| 1217 if (qn->c < qnt->c) { | |
| 1218 p = &temp->left; | |
| 1219 } else { | |
| 1220 p = &temp->right; | |
| 1221 } | |
| 1222 } | |
| 1223 | |
| 1224 if (*p == sentinel) { | |
| 1225 break; | |
| 1226 } | |
| 1227 | |
| 1228 temp = *p; | |
| 1229 } | |
| 1230 | |
| 1231 *p = node; | |
| 1232 node->parent = temp; | |
| 1233 node->left = sentinel; | |
| 1234 node->right = sentinel; | |
| 1235 ngx_rbt_red(node); | |
| 1236 } | |
| 1237 | |
| 1238 | |
| 1239 static ngx_quic_stream_node_t * | |
| 1240 ngx_quic_find_stream(ngx_rbtree_t *rbtree, ngx_uint_t key) | |
| 1241 { | |
| 1242 ngx_rbtree_node_t *node, *sentinel; | |
| 1243 | |
| 1244 node = rbtree->root; | |
| 1245 sentinel = rbtree->sentinel; | |
| 1246 | |
| 1247 while (node != sentinel) { | |
| 1248 | |
| 1249 if (key == node->key) { | |
| 1250 return (ngx_quic_stream_node_t *) node; | |
| 1251 } | |
| 1252 | |
| 1253 node = (key < node->key) ? node->left : node->right; | |
| 1254 } | |
| 1255 | |
| 1256 return NULL; | |
| 1257 } | |
| 1258 | |
| 1259 | |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1260 static ngx_quic_stream_node_t * |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1261 ngx_quic_create_stream(ngx_connection_t *c, ngx_uint_t id) |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1262 { |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1263 ngx_log_t *log; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1264 ngx_pool_t *pool; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1265 ngx_event_t *rev, *wev; |
|
8239
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1266 ngx_pool_cleanup_t *cln; |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1267 ngx_quic_connection_t *qc; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1268 ngx_quic_stream_node_t *sn; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1269 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1270 qc = c->quic; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1271 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1272 sn = ngx_pcalloc(c->pool, sizeof(ngx_quic_stream_node_t)); |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1273 if (sn == NULL) { |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1274 return NULL; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1275 } |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1276 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1277 sn->c = ngx_get_connection(-1, c->log); // TODO: free on connection termination |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1278 if (sn->c == NULL) { |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1279 return NULL; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1280 } |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1281 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1282 pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, c->log); |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1283 if (pool == NULL) { |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1284 /* XXX free connection */ |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1285 // TODO: add pool cleanup handdler |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1286 return NULL; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1287 } |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1288 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1289 log = ngx_palloc(pool, sizeof(ngx_log_t)); |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1290 if (log == NULL) { |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1291 /* XXX free pool and connection */ |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1292 return NULL; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1293 } |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1294 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1295 *log = *c->log; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1296 pool->log = log; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1297 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1298 sn->c->log = log; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1299 sn->c->pool = pool; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1300 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1301 sn->c->listening = c->listening; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1302 sn->c->sockaddr = c->sockaddr; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1303 sn->c->local_sockaddr = c->local_sockaddr; |
|
8234
19bb9edcd8bd
Added copying addr_text to QUIC stream connections.
Roman Arutyunyan <arut@nginx.com>
parents:
8232
diff
changeset
|
1304 sn->c->addr_text = c->addr_text; |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1305 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1306 rev = sn->c->read; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1307 wev = sn->c->write; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1308 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1309 rev->ready = 1; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1310 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1311 rev->log = c->log; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1312 wev->log = c->log; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1313 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1314 sn->c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1); |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1315 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1316 sn->node.key =id; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1317 sn->b = ngx_create_temp_buf(pool, 16 * 1024); // XXX enough for everyone |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1318 if (sn->b == NULL) { |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1319 return NULL; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1320 } |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1321 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1322 ngx_rbtree_insert(&qc->streams.tree, &sn->node); |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1323 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1324 sn->s.id = id; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1325 sn->s.unidirectional = (sn->s.id & 0x02) ? 1 : 0; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1326 sn->s.parent = c; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1327 sn->c->qs = &sn->s; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1328 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1329 sn->c->recv = ngx_quic_stream_recv; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1330 sn->c->send = ngx_quic_stream_send; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1331 sn->c->send_chain = ngx_quic_stream_send_chain; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1332 |
|
8239
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1333 cln = ngx_pool_cleanup_add(pool, 0); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1334 if (cln == NULL) { |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1335 ngx_close_connection(sn->c); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1336 ngx_destroy_pool(pool); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1337 return NULL; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1338 } |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1339 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1340 cln->handler = ngx_quic_stream_cleanup_handler; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1341 cln->data = sn->c; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1342 |
|
8229
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1343 return sn; |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1344 } |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1345 |
|
cfc429911c0d
Implemented creation of server unidirectional streams.
Vladimir Homutov <vl@nginx.com>
parents:
8225
diff
changeset
|
1346 |
| 8225 | 1347 static ssize_t |
| 1348 ngx_quic_stream_recv(ngx_connection_t *c, u_char *buf, size_t size) | |
| 1349 { | |
| 1350 ssize_t len; | |
| 1351 ngx_buf_t *b; | |
| 1352 ngx_quic_stream_t *qs; | |
| 1353 ngx_quic_connection_t *qc; | |
| 1354 ngx_quic_stream_node_t *sn; | |
| 1355 | |
| 1356 qs = c->qs; | |
| 1357 qc = qs->parent->quic; | |
| 1358 | |
| 1359 // XXX: get direct pointer from stream structure? | |
| 1360 sn = ngx_quic_find_stream(&qc->streams.tree, qs->id); | |
| 1361 | |
| 1362 if (sn == NULL) { | |
| 1363 return NGX_ERROR; | |
| 1364 } | |
| 1365 | |
| 1366 // XXX: how to return EOF? | |
| 1367 | |
| 1368 b = sn->b; | |
| 1369 | |
| 1370 if (b->last - b->pos == 0) { | |
| 1371 c->read->ready = 0; | |
| 1372 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, | |
| 1373 "quic recv() not ready"); | |
| 1374 return NGX_AGAIN; // ? | |
| 1375 } | |
| 1376 | |
| 1377 len = ngx_min(b->last - b->pos, (ssize_t) size); | |
| 1378 | |
| 1379 ngx_memcpy(buf, b->pos, len); | |
| 1380 | |
| 1381 b->pos += len; | |
| 1382 | |
| 1383 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, | |
| 1384 "quic recv: %z of %uz", len, size); | |
| 1385 | |
| 1386 return len; | |
| 1387 } | |
| 1388 | |
| 1389 | |
| 1390 static ssize_t | |
| 1391 ngx_quic_stream_send(ngx_connection_t *c, u_char *buf, size_t size) | |
| 1392 { | |
| 1393 u_char *p; | |
| 1394 ngx_connection_t *pc; | |
| 1395 ngx_quic_frame_t *frame; | |
| 1396 ngx_quic_stream_t *qs; | |
| 1397 ngx_quic_connection_t *qc; | |
| 1398 ngx_quic_stream_node_t *sn; | |
| 1399 | |
| 1400 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic send: %uz", size); | |
| 1401 | |
| 1402 qs = c->qs; | |
| 1403 pc = qs->parent; | |
| 1404 qc = pc->quic; | |
| 1405 | |
| 1406 // XXX: get direct pointer from stream structure? | |
| 1407 sn = ngx_quic_find_stream(&qc->streams.tree, qs->id); | |
| 1408 | |
| 1409 if (sn == NULL) { | |
| 1410 return NGX_ERROR; | |
| 1411 } | |
| 1412 | |
| 1413 frame = ngx_pcalloc(pc->pool, sizeof(ngx_quic_frame_t)); | |
| 1414 if (frame == NULL) { | |
| 1415 return 0; | |
| 1416 } | |
| 1417 | |
| 1418 p = ngx_pnalloc(pc->pool, size); | |
| 1419 if (p == NULL) { | |
| 1420 return 0; | |
| 1421 } | |
| 1422 | |
| 1423 ngx_memcpy(p, buf, size); | |
| 1424 | |
| 1425 frame->level = ssl_encryption_application; | |
| 1426 frame->type = NGX_QUIC_FT_STREAM6; /* OFF=1 LEN=1 FIN=0 */ | |
| 1427 frame->u.stream.off = 1; | |
| 1428 frame->u.stream.len = 1; | |
| 1429 frame->u.stream.fin = 0; | |
| 1430 | |
| 1431 frame->u.stream.type = frame->type; | |
| 1432 frame->u.stream.stream_id = qs->id; | |
| 1433 frame->u.stream.offset = c->sent; | |
| 1434 frame->u.stream.length = size; | |
| 1435 frame->u.stream.data = p; | |
| 1436 | |
| 1437 c->sent += size; | |
| 1438 | |
| 1439 ngx_sprintf(frame->info, "stream %xi len=%ui level=%d", | |
| 1440 qs->id, size, frame->level); | |
| 1441 | |
| 1442 ngx_quic_queue_frame(qc, frame); | |
| 1443 | |
| 1444 return size; | |
| 1445 } | |
| 1446 | |
| 1447 | |
|
8239
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1448 static void |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1449 ngx_quic_stream_cleanup_handler(void *data) |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1450 { |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1451 ngx_connection_t *c = data; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1452 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1453 ngx_connection_t *pc; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1454 ngx_quic_frame_t *frame; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1455 ngx_quic_stream_t *qs; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1456 ngx_quic_connection_t *qc; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1457 ngx_quic_stream_node_t *sn; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1458 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1459 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "quic send fin"); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1460 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1461 qs = c->qs; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1462 pc = qs->parent; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1463 qc = pc->quic; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1464 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1465 if ((qs->id & 0x03) == 0x02) { |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1466 /* do not send fin for client unidirectional streams */ |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1467 return; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1468 } |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1469 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1470 // XXX: get direct pointer from stream structure? |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1471 sn = ngx_quic_find_stream(&qc->streams.tree, qs->id); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1472 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1473 if (sn == NULL) { |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1474 return; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1475 } |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1476 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1477 frame = ngx_pcalloc(pc->pool, sizeof(ngx_quic_frame_t)); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1478 if (frame == NULL) { |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1479 return; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1480 } |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1481 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1482 frame->level = ssl_encryption_application; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1483 frame->type = NGX_QUIC_FT_STREAM7; /* OFF=1 LEN=1 FIN=1 */ |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1484 frame->u.stream.off = 1; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1485 frame->u.stream.len = 1; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1486 frame->u.stream.fin = 1; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1487 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1488 frame->u.stream.type = frame->type; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1489 frame->u.stream.stream_id = qs->id; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1490 frame->u.stream.offset = c->sent; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1491 frame->u.stream.length = 0; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1492 frame->u.stream.data = NULL; |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1493 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1494 ngx_sprintf(frame->info, "stream %xi fin=1 level=%d", qs->id, frame->level); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1495 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1496 ngx_quic_queue_frame(qc, frame); |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1497 } |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1498 |
|
5ad7bffd3850
Send a FIN frame when QUIC stream is closed.
Roman Arutyunyan <arut@nginx.com>
parents:
8237
diff
changeset
|
1499 |
| 8225 | 1500 static ngx_chain_t * |
| 1501 ngx_quic_stream_send_chain(ngx_connection_t *c, ngx_chain_t *in, | |
| 1502 off_t limit) | |
| 1503 { | |
| 1504 size_t len; | |
| 1505 ssize_t n; | |
| 1506 ngx_buf_t *b; | |
| 1507 | |
| 1508 for ( /* void */; in; in = in->next) { | |
| 1509 b = in->buf; | |
| 1510 | |
| 1511 if (!ngx_buf_in_memory(b)) { | |
| 1512 continue; | |
| 1513 } | |
| 1514 | |
| 1515 if (ngx_buf_size(b) == 0) { | |
| 1516 continue; | |
| 1517 } | |
| 1518 | |
| 1519 len = b->last - b->pos; | |
| 1520 | |
| 1521 n = ngx_quic_stream_send(c, b->pos, len); | |
| 1522 | |
| 1523 if (n == NGX_ERROR) { | |
| 1524 return NGX_CHAIN_ERROR; | |
| 1525 } | |
| 1526 | |
| 1527 if (n == NGX_AGAIN) { | |
| 1528 return in; | |
| 1529 } | |
| 1530 | |
| 1531 if (n != (ssize_t) len) { | |
| 1532 b->pos += n; | |
| 1533 return in; | |
| 1534 } | |
| 1535 } | |
| 1536 | |
| 1537 return NULL; | |
| 1538 } |