Mercurial > hg > nginx-quic
comparison src/event/ngx_event_quic.c @ 7808:bda817d16cc2 quic
Rename types and variables used for packet number space.
Quote: Conceptually, a packet number space is the context in which a packet
can be processed and acknowledged.
ngx_quic_namespace_t => ngx_quic_send_ctx_t
qc->ns => qc->send_ctx
ns->largest => send_ctx->largest_ack
The ngx_quic_ns(level) macro now returns pointer, not just index:
ngx_quic_get_send_ctx(c->quic, level)
ngx_quic_retransmit_ns() => ngx_quic_retransmit()
ngx_quic_output_ns() => ngx_quic_output_frames()
author | Vladimir Homutov <vl@nginx.com> |
---|---|
date | Tue, 14 Apr 2020 12:06:32 +0300 |
parents | e76be8639621 |
children | 6ad871b63422 |
comparison
equal
deleted
inserted
replaced
7807:5b7ec588de48 | 7808:bda817d16cc2 |
---|---|
14 * | 14 * |
15 * 0 - Initial | 15 * 0 - Initial |
16 * 1 - Handshake | 16 * 1 - Handshake |
17 * 2 - 0-RTT and 1-RTT | 17 * 2 - 0-RTT and 1-RTT |
18 */ | 18 */ |
19 #define ngx_quic_ns(level) \ | 19 #define ngx_quic_get_send_ctx(qc, level) \ |
20 ((level) == ssl_encryption_initial) ? 0 \ | 20 ((level) == ssl_encryption_initial) ? &((qc)->send_ctx[0]) \ |
21 : (((level) == ssl_encryption_handshake) ? 1 : 2) | 21 : (((level) == ssl_encryption_handshake) ? &((qc)->send_ctx[1]) \ |
22 | 22 : &((qc)->send_ctx[2])) |
23 #define NGX_QUIC_NAMESPACE_LAST (NGX_QUIC_ENCRYPTION_LAST - 1) | 23 |
24 #define NGX_QUIC_SEND_CTX_LAST (NGX_QUIC_ENCRYPTION_LAST - 1) | |
24 | 25 |
25 #define NGX_QUIC_STREAMS_INC 16 | 26 #define NGX_QUIC_STREAMS_INC 16 |
26 #define NGX_QUIC_STREAMS_LIMIT (1ULL < 60) | 27 #define NGX_QUIC_STREAMS_LIMIT (1ULL < 60) |
27 | 28 |
28 | 29 |
41 | 42 |
42 ngx_uint_t id_counter; | 43 ngx_uint_t id_counter; |
43 } ngx_quic_streams_t; | 44 } ngx_quic_streams_t; |
44 | 45 |
45 | 46 |
47 /* | |
48 * 12.3. Packet Numbers | |
49 * | |
50 * Conceptually, a packet number space is the context in which a packet | |
51 * can be processed and acknowledged. Initial packets can only be sent | |
52 * with Initial packet protection keys and acknowledged in packets which | |
53 * are also Initial packets. | |
54 */ | |
46 typedef struct { | 55 typedef struct { |
47 ngx_quic_secret_t client_secret; | 56 ngx_quic_secret_t client_secret; |
48 ngx_quic_secret_t server_secret; | 57 ngx_quic_secret_t server_secret; |
49 | 58 |
50 uint64_t pnum; | 59 uint64_t pnum; |
51 uint64_t largest; /* number received from peer */ | 60 uint64_t largest_ack; /* number received from peer */ |
52 | 61 |
53 ngx_queue_t frames; | 62 ngx_queue_t frames; |
54 ngx_queue_t sent; | 63 ngx_queue_t sent; |
55 } ngx_quic_namespace_t; | 64 } ngx_quic_send_ctx_t; |
56 | 65 |
57 | 66 |
58 struct ngx_quic_connection_s { | 67 struct ngx_quic_connection_s { |
59 ngx_str_t scid; | 68 ngx_str_t scid; |
60 ngx_str_t dcid; | 69 ngx_str_t dcid; |
64 ngx_quic_tp_t tp; | 73 ngx_quic_tp_t tp; |
65 ngx_quic_tp_t ctp; | 74 ngx_quic_tp_t ctp; |
66 | 75 |
67 ngx_quic_state_t state; | 76 ngx_quic_state_t state; |
68 | 77 |
69 ngx_quic_namespace_t ns[NGX_QUIC_NAMESPACE_LAST]; | 78 ngx_quic_send_ctx_t send_ctx[NGX_QUIC_SEND_CTX_LAST]; |
70 ngx_quic_secrets_t keys[NGX_QUIC_ENCRYPTION_LAST]; | 79 ngx_quic_secrets_t keys[NGX_QUIC_ENCRYPTION_LAST]; |
71 ngx_quic_secrets_t next_key; | 80 ngx_quic_secrets_t next_key; |
72 uint64_t crypto_offset_out[NGX_QUIC_ENCRYPTION_LAST]; | 81 uint64_t crypto_offset_out[NGX_QUIC_ENCRYPTION_LAST]; |
73 uint64_t crypto_offset_in[NGX_QUIC_ENCRYPTION_LAST]; | 82 uint64_t crypto_offset_in[NGX_QUIC_ENCRYPTION_LAST]; |
74 | 83 |
134 ngx_quic_header_t *pkt); | 143 ngx_quic_header_t *pkt); |
135 | 144 |
136 static ngx_int_t ngx_quic_handle_ack_frame(ngx_connection_t *c, | 145 static ngx_int_t ngx_quic_handle_ack_frame(ngx_connection_t *c, |
137 ngx_quic_header_t *pkt, ngx_quic_ack_frame_t *f); | 146 ngx_quic_header_t *pkt, ngx_quic_ack_frame_t *f); |
138 static ngx_int_t ngx_quic_handle_ack_frame_range(ngx_connection_t *c, | 147 static ngx_int_t ngx_quic_handle_ack_frame_range(ngx_connection_t *c, |
139 ngx_quic_namespace_t *ns, uint64_t min, uint64_t max); | 148 ngx_quic_send_ctx_t *ctx, uint64_t min, uint64_t max); |
140 static ngx_int_t ngx_quic_handle_crypto_frame(ngx_connection_t *c, | 149 static ngx_int_t ngx_quic_handle_crypto_frame(ngx_connection_t *c, |
141 ngx_quic_header_t *pkt, ngx_quic_crypto_frame_t *frame); | 150 ngx_quic_header_t *pkt, ngx_quic_crypto_frame_t *frame); |
142 static ngx_int_t ngx_quic_handle_stream_frame(ngx_connection_t *c, | 151 static ngx_int_t ngx_quic_handle_stream_frame(ngx_connection_t *c, |
143 ngx_quic_header_t *pkt, ngx_quic_stream_frame_t *frame); | 152 ngx_quic_header_t *pkt, ngx_quic_stream_frame_t *frame); |
144 static ngx_int_t ngx_quic_handle_max_streams(ngx_connection_t *c); | 153 static ngx_int_t ngx_quic_handle_max_streams(ngx_connection_t *c); |
149 | 158 |
150 static void ngx_quic_queue_frame(ngx_quic_connection_t *qc, | 159 static void ngx_quic_queue_frame(ngx_quic_connection_t *qc, |
151 ngx_quic_frame_t *frame); | 160 ngx_quic_frame_t *frame); |
152 | 161 |
153 static ngx_int_t ngx_quic_output(ngx_connection_t *c); | 162 static ngx_int_t ngx_quic_output(ngx_connection_t *c); |
154 static ngx_int_t ngx_quic_output_ns(ngx_connection_t *c, | 163 static ngx_int_t ngx_quic_output_frames(ngx_connection_t *c, |
155 ngx_quic_namespace_t *ns, ngx_uint_t nsi); | 164 ngx_quic_send_ctx_t *ctx, ngx_uint_t nsi); |
156 static void ngx_quic_free_frames(ngx_connection_t *c, ngx_queue_t *frames); | 165 static void ngx_quic_free_frames(ngx_connection_t *c, ngx_queue_t *frames); |
157 static ngx_int_t ngx_quic_send_frames(ngx_connection_t *c, ngx_queue_t *frames); | 166 static ngx_int_t ngx_quic_send_frames(ngx_connection_t *c, ngx_queue_t *frames); |
158 | 167 |
159 static void ngx_quic_set_packet_number(ngx_quic_header_t *pkt, | 168 static void ngx_quic_set_packet_number(ngx_quic_header_t *pkt, |
160 ngx_quic_namespace_t *ns); | 169 ngx_quic_send_ctx_t *ctx); |
161 static void ngx_quic_retransmit_handler(ngx_event_t *ev); | 170 static void ngx_quic_retransmit_handler(ngx_event_t *ev); |
162 static ngx_int_t ngx_quic_retransmit_ns(ngx_connection_t *c, | 171 static ngx_int_t ngx_quic_retransmit(ngx_connection_t *c, |
163 ngx_quic_namespace_t *ns, ngx_msec_t *waitp); | 172 ngx_quic_send_ctx_t *ctx, ngx_msec_t *waitp); |
164 static void ngx_quic_push_handler(ngx_event_t *ev); | 173 static void ngx_quic_push_handler(ngx_event_t *ev); |
165 | 174 |
166 static void ngx_quic_rbtree_insert_stream(ngx_rbtree_node_t *temp, | 175 static void ngx_quic_rbtree_insert_stream(ngx_rbtree_node_t *temp, |
167 ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel); | 176 ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel); |
168 static ngx_quic_stream_t *ngx_quic_find_stream(ngx_rbtree_t *rbtree, | 177 static ngx_quic_stream_t *ngx_quic_find_stream(ngx_rbtree_t *rbtree, |
468 | 477 |
469 ngx_rbtree_init(&qc->streams.tree, &qc->streams.sentinel, | 478 ngx_rbtree_init(&qc->streams.tree, &qc->streams.sentinel, |
470 ngx_quic_rbtree_insert_stream); | 479 ngx_quic_rbtree_insert_stream); |
471 | 480 |
472 for (i = 0; i < 3; i++) { | 481 for (i = 0; i < 3; i++) { |
473 ngx_queue_init(&qc->ns[i].frames); | 482 ngx_queue_init(&qc->send_ctx[i].frames); |
474 ngx_queue_init(&qc->ns[i].sent); | 483 ngx_queue_init(&qc->send_ctx[i].sent); |
475 } | 484 } |
476 | 485 |
477 ngx_queue_init(&qc->free_frames); | 486 ngx_queue_init(&qc->free_frames); |
478 | 487 |
479 qc->retry.log = c->log; | 488 qc->retry.log = c->log; |
1243 | 1252 |
1244 static ngx_int_t | 1253 static ngx_int_t |
1245 ngx_quic_handle_ack_frame(ngx_connection_t *c, ngx_quic_header_t *pkt, | 1254 ngx_quic_handle_ack_frame(ngx_connection_t *c, ngx_quic_header_t *pkt, |
1246 ngx_quic_ack_frame_t *ack) | 1255 ngx_quic_ack_frame_t *ack) |
1247 { | 1256 { |
1248 ssize_t n; | 1257 ssize_t n; |
1249 u_char *pos, *end; | 1258 u_char *pos, *end; |
1250 uint64_t gap, range; | 1259 uint64_t gap, range; |
1251 ngx_uint_t i, min, max; | 1260 ngx_uint_t i, min, max; |
1252 ngx_quic_namespace_t *ns; | 1261 ngx_quic_send_ctx_t *ctx; |
1253 | 1262 |
1254 ns = &c->quic->ns[ngx_quic_ns(pkt->level)]; | 1263 ctx = ngx_quic_get_send_ctx(c->quic, pkt->level); |
1255 | 1264 |
1256 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, | 1265 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, |
1257 "ngx_quic_handle_ack_frame in namespace %d", | 1266 "ngx_quic_handle_ack_frame level %d", pkt->level); |
1258 ngx_quic_ns(pkt->level)); | |
1259 | 1267 |
1260 /* | 1268 /* |
1261 * TODO: If any computed packet number is negative, an endpoint MUST | 1269 * TODO: If any computed packet number is negative, an endpoint MUST |
1262 * generate a connection error of type FRAME_ENCODING_ERROR. | 1270 * generate a connection error of type FRAME_ENCODING_ERROR. |
1263 * (19.3.1) | 1271 * (19.3.1) |
1270 } | 1278 } |
1271 | 1279 |
1272 min = ack->largest - ack->first_range; | 1280 min = ack->largest - ack->first_range; |
1273 max = ack->largest; | 1281 max = ack->largest; |
1274 | 1282 |
1275 if (ngx_quic_handle_ack_frame_range(c, ns, min, max) != NGX_OK) { | 1283 if (ngx_quic_handle_ack_frame_range(c, ctx, min, max) != NGX_OK) { |
1276 return NGX_ERROR; | 1284 return NGX_ERROR; |
1277 } | 1285 } |
1278 | 1286 |
1279 /* 13.2.3. Receiver Tracking of ACK Frames */ | 1287 /* 13.2.3. Receiver Tracking of ACK Frames */ |
1280 if (ns->largest < max) { | 1288 if (ctx->largest_ack < max) { |
1281 ns->largest = max; | 1289 ctx->largest_ack = max; |
1282 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, | 1290 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, |
1283 "updated largest received: %ui", max); | 1291 "updated largest received: %ui", max); |
1284 } | 1292 } |
1285 | 1293 |
1286 pos = ack->ranges_start; | 1294 pos = ack->ranges_start; |
1308 return NGX_ERROR; | 1316 return NGX_ERROR; |
1309 } | 1317 } |
1310 | 1318 |
1311 min = max - range + 1; | 1319 min = max - range + 1; |
1312 | 1320 |
1313 if (ngx_quic_handle_ack_frame_range(c, ns, min, max) != NGX_OK) { | 1321 if (ngx_quic_handle_ack_frame_range(c, ctx, min, max) != NGX_OK) { |
1314 return NGX_ERROR; | 1322 return NGX_ERROR; |
1315 } | 1323 } |
1316 } | 1324 } |
1317 | 1325 |
1318 return NGX_OK; | 1326 return NGX_OK; |
1319 } | 1327 } |
1320 | 1328 |
1321 | 1329 |
1322 static ngx_int_t | 1330 static ngx_int_t |
1323 ngx_quic_handle_ack_frame_range(ngx_connection_t *c, ngx_quic_namespace_t *ns, | 1331 ngx_quic_handle_ack_frame_range(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
1324 uint64_t min, uint64_t max) | 1332 uint64_t min, uint64_t max) |
1325 { | 1333 { |
1326 ngx_uint_t found; | 1334 ngx_uint_t found; |
1327 ngx_queue_t *q, range; | 1335 ngx_queue_t *q; |
1328 ngx_quic_frame_t *f; | 1336 ngx_quic_frame_t *f; |
1329 | 1337 |
1330 found = 0; | 1338 found = 0; |
1331 | 1339 |
1332 ngx_queue_init(&range); | 1340 q = ngx_queue_head(&ctx->sent); |
1333 | 1341 |
1334 q = ngx_queue_head(&ns->sent); | 1342 while (q != ngx_queue_sentinel(&ctx->sent)) { |
1335 | |
1336 while (q != ngx_queue_sentinel(&ns->sent)) { | |
1337 | 1343 |
1338 f = ngx_queue_data(q, ngx_quic_frame_t, queue); | 1344 f = ngx_queue_data(q, ngx_quic_frame_t, queue); |
1339 | 1345 |
1340 if (f->pnum >= min && f->pnum <= max) { | 1346 if (f->pnum >= min && f->pnum <= max) { |
1341 q = ngx_queue_next(q); | 1347 q = ngx_queue_next(q); |
1348 } | 1354 } |
1349 } | 1355 } |
1350 | 1356 |
1351 if (!found) { | 1357 if (!found) { |
1352 | 1358 |
1353 if (max <= ns->pnum) { | 1359 if (max <= ctx->pnum) { |
1354 /* duplicate ACK or ACK for non-ack-eliciting frame */ | 1360 /* duplicate ACK or ACK for non-ack-eliciting frame */ |
1355 return NGX_OK; | 1361 return NGX_OK; |
1356 } | 1362 } |
1357 | 1363 |
1358 ngx_log_error(NGX_LOG_INFO, c->log, 0, | 1364 ngx_log_error(NGX_LOG_INFO, c->log, 0, |
1660 | 1666 |
1661 | 1667 |
1662 static void | 1668 static void |
1663 ngx_quic_queue_frame(ngx_quic_connection_t *qc, ngx_quic_frame_t *frame) | 1669 ngx_quic_queue_frame(ngx_quic_connection_t *qc, ngx_quic_frame_t *frame) |
1664 { | 1670 { |
1665 ngx_quic_namespace_t *ns; | 1671 ngx_quic_send_ctx_t *ctx; |
1666 | 1672 |
1667 ns = &qc->ns[ngx_quic_ns(frame->level)]; | 1673 ctx = ngx_quic_get_send_ctx(qc, frame->level); |
1668 | 1674 |
1669 ngx_queue_insert_tail(&ns->frames, &frame->queue); | 1675 ngx_queue_insert_tail(&ctx->frames, &frame->queue); |
1670 | 1676 |
1671 /* TODO: check PUSH flag on stream and call output */ | 1677 /* TODO: check PUSH flag on stream and call output */ |
1672 | 1678 |
1673 if (!qc->push.timer_set && !qc->closing) { | 1679 if (!qc->push.timer_set && !qc->closing) { |
1674 ngx_add_timer(&qc->push, qc->tp.max_ack_delay); | 1680 ngx_add_timer(&qc->push, qc->tp.max_ack_delay); |
1678 | 1684 |
1679 static ngx_int_t | 1685 static ngx_int_t |
1680 ngx_quic_output(ngx_connection_t *c) | 1686 ngx_quic_output(ngx_connection_t *c) |
1681 { | 1687 { |
1682 ngx_uint_t i; | 1688 ngx_uint_t i; |
1683 ngx_quic_namespace_t *ns; | |
1684 ngx_quic_connection_t *qc; | 1689 ngx_quic_connection_t *qc; |
1685 | 1690 |
1686 c->log->action = "sending frames"; | 1691 c->log->action = "sending frames"; |
1687 | 1692 |
1688 qc = c->quic; | 1693 qc = c->quic; |
1689 | 1694 |
1690 for (i = 0; i < 3; i++) { | 1695 for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) { |
1691 ns = &qc->ns[i]; | 1696 if (ngx_quic_output_frames(c, &qc->send_ctx[i], i) != NGX_OK) { |
1692 if (ngx_quic_output_ns(c, ns, i) != NGX_OK) { | |
1693 return NGX_ERROR; | 1697 return NGX_ERROR; |
1694 } | 1698 } |
1695 } | 1699 } |
1696 | 1700 |
1697 if (!qc->send_timer_set && !qc->closing) { | 1701 if (!qc->send_timer_set && !qc->closing) { |
1706 return NGX_OK; | 1710 return NGX_OK; |
1707 } | 1711 } |
1708 | 1712 |
1709 | 1713 |
1710 static ngx_int_t | 1714 static ngx_int_t |
1711 ngx_quic_output_ns(ngx_connection_t *c, ngx_quic_namespace_t *ns, | 1715 ngx_quic_output_frames(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
1712 ngx_uint_t nsi) | 1716 ngx_uint_t nsi) |
1713 { | 1717 { |
1714 size_t len, hlen, n; | 1718 size_t len, hlen, n; |
1715 ngx_int_t rc; | 1719 ngx_int_t rc; |
1716 ngx_queue_t *q, range; | 1720 ngx_queue_t *q, range; |
1717 ngx_quic_frame_t *f; | 1721 ngx_quic_frame_t *f; |
1718 ngx_quic_connection_t *qc; | 1722 ngx_quic_connection_t *qc; |
1719 | 1723 |
1720 qc = c->quic; | 1724 qc = c->quic; |
1721 | 1725 |
1722 if (ngx_queue_empty(&ns->frames)) { | 1726 if (ngx_queue_empty(&ctx->frames)) { |
1723 return NGX_OK; | 1727 return NGX_OK; |
1724 } | 1728 } |
1725 | 1729 |
1726 hlen = (nsi == 2) ? NGX_QUIC_MAX_SHORT_HEADER | 1730 hlen = (nsi == 2) ? NGX_QUIC_MAX_SHORT_HEADER |
1727 : NGX_QUIC_MAX_LONG_HEADER; | 1731 : NGX_QUIC_MAX_LONG_HEADER; |
1728 | 1732 |
1729 hlen += EVP_GCM_TLS_TAG_LEN; | 1733 hlen += EVP_GCM_TLS_TAG_LEN; |
1730 | 1734 |
1731 q = ngx_queue_head(&ns->frames); | 1735 q = ngx_queue_head(&ctx->frames); |
1732 | 1736 |
1733 do { | 1737 do { |
1734 len = 0; | 1738 len = 0; |
1735 ngx_queue_init(&range); | 1739 ngx_queue_init(&range); |
1736 | 1740 |
1751 ngx_queue_remove(&f->queue); | 1755 ngx_queue_remove(&f->queue); |
1752 ngx_queue_insert_tail(&range, &f->queue); | 1756 ngx_queue_insert_tail(&range, &f->queue); |
1753 | 1757 |
1754 len += n; | 1758 len += n; |
1755 | 1759 |
1756 } while (q != ngx_queue_sentinel(&ns->frames)); | 1760 } while (q != ngx_queue_sentinel(&ctx->frames)); |
1757 | 1761 |
1758 rc = ngx_quic_send_frames(c, &range); | 1762 rc = ngx_quic_send_frames(c, &range); |
1759 | 1763 |
1760 if (rc == NGX_OK) { | 1764 if (rc == NGX_OK) { |
1761 /* | 1765 /* |
1762 * frames are moved into the sent queue | 1766 * frames are moved into the sent queue |
1763 * to wait for ack/be retransmitted | 1767 * to wait for ack/be retransmitted |
1764 */ | 1768 */ |
1765 ngx_queue_add(&ns->sent, &range); | 1769 ngx_queue_add(&ctx->sent, &range); |
1766 | 1770 |
1767 } else if (rc == NGX_DONE) { | 1771 } else if (rc == NGX_DONE) { |
1768 | 1772 |
1769 /* no ack is expected for this frames, can free them */ | 1773 /* no ack is expected for this frames, can free them */ |
1770 ngx_quic_free_frames(c, &range); | 1774 ngx_quic_free_frames(c, &range); |
1772 } else { | 1776 } else { |
1773 return NGX_ERROR; | 1777 return NGX_ERROR; |
1774 } | 1778 } |
1775 | 1779 |
1776 | 1780 |
1777 } while (q != ngx_queue_sentinel(&ns->frames)); | 1781 } while (q != ngx_queue_sentinel(&ctx->frames)); |
1778 | 1782 |
1779 return NGX_OK; | 1783 return NGX_OK; |
1780 } | 1784 } |
1781 | 1785 |
1782 | 1786 |
1808 ngx_str_t out, res; | 1812 ngx_str_t out, res; |
1809 ngx_queue_t *q; | 1813 ngx_queue_t *q; |
1810 ngx_quic_frame_t *f, *start; | 1814 ngx_quic_frame_t *f, *start; |
1811 ngx_quic_header_t pkt; | 1815 ngx_quic_header_t pkt; |
1812 ngx_quic_secrets_t *keys; | 1816 ngx_quic_secrets_t *keys; |
1813 ngx_quic_namespace_t *ns; | 1817 ngx_quic_send_ctx_t *ctx; |
1814 ngx_quic_connection_t *qc; | 1818 ngx_quic_connection_t *qc; |
1815 static ngx_str_t initial_token = ngx_null_string; | 1819 static ngx_str_t initial_token = ngx_null_string; |
1816 static u_char src[NGX_QUIC_DEFAULT_MAX_PACKET_SIZE]; | 1820 static u_char src[NGX_QUIC_DEFAULT_MAX_PACKET_SIZE]; |
1817 static u_char dst[NGX_QUIC_DEFAULT_MAX_PACKET_SIZE]; | 1821 static u_char dst[NGX_QUIC_DEFAULT_MAX_PACKET_SIZE]; |
1818 | 1822 |
1819 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "ngx_quic_send_frames"); | 1823 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0, "ngx_quic_send_frames"); |
1820 | 1824 |
1821 q = ngx_queue_head(frames); | 1825 q = ngx_queue_head(frames); |
1822 start = ngx_queue_data(q, ngx_quic_frame_t, queue); | 1826 start = ngx_queue_data(q, ngx_quic_frame_t, queue); |
1823 | 1827 |
1824 ns = &c->quic->ns[ngx_quic_ns(start->level)]; | 1828 ctx = ngx_quic_get_send_ctx(c->quic, start->level); |
1825 | 1829 |
1826 ngx_memzero(&pkt, sizeof(ngx_quic_header_t)); | 1830 ngx_memzero(&pkt, sizeof(ngx_quic_header_t)); |
1827 | 1831 |
1828 p = src; | 1832 p = src; |
1829 out.data = src; | 1833 out.data = src; |
1844 if (f->need_ack) { | 1848 if (f->need_ack) { |
1845 pkt.need_ack = 1; | 1849 pkt.need_ack = 1; |
1846 } | 1850 } |
1847 | 1851 |
1848 p += len; | 1852 p += len; |
1849 f->pnum = ns->pnum; | 1853 f->pnum = ctx->pnum; |
1850 } | 1854 } |
1851 | 1855 |
1852 if (start->level == ssl_encryption_initial) { | 1856 if (start->level == ssl_encryption_initial) { |
1853 /* ack will not be sent in initial packets due to initial keys being | 1857 /* ack will not be sent in initial packets due to initial keys being |
1854 * discarded when handshake start. | 1858 * discarded when handshake start. |
1884 } else { | 1888 } else { |
1885 // TODO: macro, set FIXED bit | 1889 // TODO: macro, set FIXED bit |
1886 pkt.flags = 0x40 | (c->quic->key_phase ? NGX_QUIC_PKT_KPHASE : 0); | 1890 pkt.flags = 0x40 | (c->quic->key_phase ? NGX_QUIC_PKT_KPHASE : 0); |
1887 } | 1891 } |
1888 | 1892 |
1889 ngx_quic_set_packet_number(&pkt, ns); | 1893 ngx_quic_set_packet_number(&pkt, ctx); |
1890 | 1894 |
1891 pkt.log = c->log; | 1895 pkt.log = c->log; |
1892 pkt.level = start->level; | 1896 pkt.level = start->level; |
1893 pkt.dcid = qc->dcid; | 1897 pkt.dcid = qc->dcid; |
1894 pkt.scid = qc->scid; | 1898 pkt.scid = qc->scid; |
1906 if (len == NGX_ERROR || (size_t) len != res.len) { | 1910 if (len == NGX_ERROR || (size_t) len != res.len) { |
1907 return NGX_ERROR; | 1911 return NGX_ERROR; |
1908 } | 1912 } |
1909 | 1913 |
1910 /* len == NGX_OK || NGX_AGAIN */ | 1914 /* len == NGX_OK || NGX_AGAIN */ |
1911 ns->pnum++; | 1915 ctx->pnum++; |
1912 | 1916 |
1913 now = ngx_current_msec; | 1917 now = ngx_current_msec; |
1914 start->last = now; | 1918 start->last = now; |
1915 | 1919 |
1916 return pkt.need_ack ? NGX_OK : NGX_DONE; | 1920 return pkt.need_ack ? NGX_OK : NGX_DONE; |
1917 } | 1921 } |
1918 | 1922 |
1919 | 1923 |
1920 static void | 1924 static void |
1921 ngx_quic_set_packet_number(ngx_quic_header_t *pkt, ngx_quic_namespace_t *ns) | 1925 ngx_quic_set_packet_number(ngx_quic_header_t *pkt, ngx_quic_send_ctx_t *ctx) |
1922 { | 1926 { |
1923 uint64_t delta; | 1927 uint64_t delta; |
1924 | 1928 |
1925 delta = ns->pnum - ns->largest; | 1929 delta = ctx->pnum - ctx->largest_ack; |
1926 pkt->number = ns->pnum; | 1930 pkt->number = ctx->pnum; |
1927 | 1931 |
1928 if (delta <= 0x7F) { | 1932 if (delta <= 0x7F) { |
1929 pkt->num_len = 1; | 1933 pkt->num_len = 1; |
1930 pkt->trunc = ns->pnum & 0xff; | 1934 pkt->trunc = ctx->pnum & 0xff; |
1931 | 1935 |
1932 } else if (delta <= 0x7FFF) { | 1936 } else if (delta <= 0x7FFF) { |
1933 pkt->num_len = 2; | 1937 pkt->num_len = 2; |
1934 pkt->flags |= 0x1; | 1938 pkt->flags |= 0x1; |
1935 pkt->trunc = ns->pnum & 0xffff; | 1939 pkt->trunc = ctx->pnum & 0xffff; |
1936 | 1940 |
1937 } else if (delta <= 0x7FFFFF) { | 1941 } else if (delta <= 0x7FFFFF) { |
1938 pkt->num_len = 3; | 1942 pkt->num_len = 3; |
1939 pkt->flags |= 0x2; | 1943 pkt->flags |= 0x2; |
1940 pkt->trunc = ns->pnum & 0xffffff; | 1944 pkt->trunc = ctx->pnum & 0xffffff; |
1941 | 1945 |
1942 } else { | 1946 } else { |
1943 pkt->num_len = 4; | 1947 pkt->num_len = 4; |
1944 pkt->flags |= 0x3; | 1948 pkt->flags |= 0x3; |
1945 pkt->trunc = ns->pnum & 0xffffffff; | 1949 pkt->trunc = ctx->pnum & 0xffffffff; |
1946 } | 1950 } |
1947 } | 1951 } |
1948 | 1952 |
1949 | 1953 |
1950 static void | 1954 static void |
1961 c = ev->data; | 1965 c = ev->data; |
1962 qc = c->quic; | 1966 qc = c->quic; |
1963 | 1967 |
1964 wait = 0; | 1968 wait = 0; |
1965 | 1969 |
1966 for (i = 0; i < NGX_QUIC_NAMESPACE_LAST; i++) { | 1970 for (i = 0; i < NGX_QUIC_SEND_CTX_LAST; i++) { |
1967 if (ngx_quic_retransmit_ns(c, &qc->ns[i], &nswait) != NGX_OK) { | 1971 if (ngx_quic_retransmit(c, &qc->send_ctx[i], &nswait) != NGX_OK) { |
1968 ngx_quic_close_connection(c); | 1972 ngx_quic_close_connection(c); |
1969 return; | 1973 return; |
1970 } | 1974 } |
1971 | 1975 |
1972 if (i == 0) { | 1976 if (i == 0) { |
1998 } | 2002 } |
1999 } | 2003 } |
2000 | 2004 |
2001 | 2005 |
2002 static ngx_int_t | 2006 static ngx_int_t |
2003 ngx_quic_retransmit_ns(ngx_connection_t *c, ngx_quic_namespace_t *ns, | 2007 ngx_quic_retransmit(ngx_connection_t *c, ngx_quic_send_ctx_t *ctx, |
2004 ngx_msec_t *waitp) | 2008 ngx_msec_t *waitp) |
2005 { | 2009 { |
2006 uint64_t pn; | 2010 uint64_t pn; |
2007 ngx_msec_t now, wait; | 2011 ngx_msec_t now, wait; |
2008 ngx_queue_t *q, range; | 2012 ngx_queue_t *q, range; |
2012 qc = c->quic; | 2016 qc = c->quic; |
2013 | 2017 |
2014 now = ngx_current_msec; | 2018 now = ngx_current_msec; |
2015 wait = 0; | 2019 wait = 0; |
2016 | 2020 |
2017 if (ngx_queue_empty(&ns->sent)) { | 2021 if (ngx_queue_empty(&ctx->sent)) { |
2018 *waitp = 0; | 2022 *waitp = 0; |
2019 return NGX_OK; | 2023 return NGX_OK; |
2020 } | 2024 } |
2021 | 2025 |
2022 q = ngx_queue_head(&ns->sent); | 2026 q = ngx_queue_head(&ctx->sent); |
2023 start = ngx_queue_data(q, ngx_quic_frame_t, queue); | 2027 start = ngx_queue_data(q, ngx_quic_frame_t, queue); |
2024 pn = start->pnum; | 2028 pn = start->pnum; |
2025 f = start; | 2029 f = start; |
2026 | 2030 |
2027 do { | 2031 do { |
2044 q = ngx_queue_next(q); | 2048 q = ngx_queue_next(q); |
2045 | 2049 |
2046 ngx_queue_remove(&f->queue); | 2050 ngx_queue_remove(&f->queue); |
2047 ngx_queue_insert_tail(&range, &f->queue); | 2051 ngx_queue_insert_tail(&range, &f->queue); |
2048 | 2052 |
2049 } while (q != ngx_queue_sentinel(&ns->sent)); | 2053 } while (q != ngx_queue_sentinel(&ctx->sent)); |
2050 | 2054 |
2051 wait = start->last + qc->tp.max_ack_delay - now; | 2055 wait = start->last + qc->tp.max_ack_delay - now; |
2052 | 2056 |
2053 if ((ngx_msec_int_t) wait > 0) { | 2057 if ((ngx_msec_int_t) wait > 0) { |
2054 break; | 2058 break; |
2058 if (ngx_quic_send_frames(c, &range) != NGX_OK) { | 2062 if (ngx_quic_send_frames(c, &range) != NGX_OK) { |
2059 return NGX_ERROR; | 2063 return NGX_ERROR; |
2060 } | 2064 } |
2061 | 2065 |
2062 /* move frames group to the end of queue */ | 2066 /* move frames group to the end of queue */ |
2063 ngx_queue_add(&ns->sent, &range); | 2067 ngx_queue_add(&ctx->sent, &range); |
2064 | 2068 |
2065 } while (q != ngx_queue_sentinel(&ns->sent)); | 2069 } while (q != ngx_queue_sentinel(&ctx->sent)); |
2066 | 2070 |
2067 *waitp = wait; | 2071 *waitp = wait; |
2068 | 2072 |
2069 return NGX_OK; | 2073 return NGX_OK; |
2070 } | 2074 } |