Artifactspublic-v0

curl

master
ply4 git calls163 ms305 KiB2 cachedprotocol v2
2128 lines68 KiBRaw
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24#include "curl_setup.h"
26#if !defined(CURL_DISABLE_HTTP) && defined(USE_NGTCP2) && defined(USE_NGHTTP3)
28#include <ngtcp2/ngtcp2.h>
30#ifdef USE_OPENSSL
31#include <openssl/err.h>
32#if defined(OPENSSL_IS_AWSLC) || defined(OPENSSL_IS_BORINGSSL)
33#include <ngtcp2/ngtcp2_crypto_boringssl.h>
34#elif defined(OPENSSL_QUIC_API2)
35#include <ngtcp2/ngtcp2_crypto_ossl.h>
36#else
37#include <ngtcp2/ngtcp2_crypto_quictls.h>
38#endif
39#include "vtls/openssl.h"
40#elif defined(USE_GNUTLS)
41#include <ngtcp2/ngtcp2_crypto_gnutls.h>
42#include "vtls/gtls.h"
43#elif defined(USE_WOLFSSL)
44#include <ngtcp2/ngtcp2_crypto_wolfssl.h>
45#include "vtls/wolfssl.h"
46#endif
48#include <nghttp3/nghttp3.h>
50#include "urldata.h"
51#include "url.h"
52#include "u32_ptrset.h"
53#include "curl_trc.h"
54#include "rand.h"
55#include "multiif.h"
56#include "cfilters.h"
57#include "cf-socket.h"
58#include "connect.h"
59#include "progress.h"
60#include "curlx/win32-fopen.h"
61#include "curlx/dynbuf.h"
62#include "http1.h"
63#include "select.h"
64#include "sockaddr.h"
65#include "transfer.h"
66#include "bufref.h"
67#include "vdns/cf-dns.h"
68#include "vquic/vquic.h"
69#include "vquic/vquic_int.h"
70#include "vquic/vquic-tls.h"
71#include "vtls/vtls.h"
72#include "vtls/vtls_scache.h"
73#include "vquic/cf-ngtcp2-cmn.h"
75/*
76 * Store ngtcp2 version info in this buffer.
77 */
78void Curl_ngtcp2_ver(char *p, size_t len)
80 const ngtcp2_info *ng2 = ngtcp2_version(0);
81 const nghttp3_info *ht3 = nghttp3_version(0);
82 (void)curl_msnprintf(p, len, "ngtcp2/%s nghttp3/%s",
83 ng2->version_str, ht3->version_str);
86void Curl_cf_ngtcp2_h3_stream_ctx_free(struct h3_stream_ctx *stream)
88 Curl_bufq_free(&stream->sendbuf);
89 Curl_h1_req_parse_free(&stream->h1);
90 curlx_free(stream);
93static void h3_stream_set_free(uint32_t id, void *stream)
95 (void)id;
96 DEBUGASSERT(stream);
97 Curl_cf_ngtcp2_h3_stream_ctx_free((struct h3_stream_ctx *)stream);
100static bool cf_ngtcp2_h3_err_is_fatal(int code)
102 return (NGHTTP3_ERR_FATAL >= code) ||
103 (NGHTTP3_ERR_H3_CLOSED_CRITICAL_STREAM == code);
106void Curl_cf_ngtcp2_h3_err_set(struct Curl_cfilter *cf,
107 struct Curl_easy *data, int code)
109 struct cf_ngtcp2_ctx *ctx = cf->ctx;
110 if(!ctx->last_error.error_code) {
111 ngtcp2_ccerr_set_application_error(&ctx->last_error,
112 nghttp3_err_infer_quic_app_error_code(code), NULL, 0);
113 }
114 if(cf_ngtcp2_h3_err_is_fatal(code))
115 Curl_cf_ngtcp2_cmn_conn_close(cf, data);
118CURLcode Curl_cf_ngtcp2_ctx_init(struct cf_ngtcp2_ctx *ctx,
119 struct Curl_peer *origin,
120 struct Curl_peer *peer,
121 struct ssl_filter_config *sslc,
122 cf_ngtcp2_init_h3_conn *init_h3_conn_cb)
124 DEBUGASSERT(!ctx->initialized);
125 ctx->qlogfd = -1;
126 ctx->tunnel_inbuf = NULL;
127 ctx->tunnel_inbuf_len = 0;
128 ctx->version = NGTCP2_PROTO_VER_MAX;
129 Curl_bufcp_init(&ctx->stream_bufcp, H3_STREAM_CHUNK_SIZE,
130 H3_STREAM_POOL_SPARES);
131 curlx_dyn_init(&ctx->scratch, CURL_MAX_HTTP_HEADER);
132 Curl_u32_ptrset_init(&ctx->streams, h3_stream_set_free);
133 ctx->init_h3_conn_cb = init_h3_conn_cb;
134 ctx->initialized = TRUE;
135 return Curl_vquic_tls_peer_init(origin, peer, sslc, &ctx->ssl_peer);
138void Curl_cf_ngtcp2_ctx_cleanup(struct cf_ngtcp2_ctx *ctx)
140 if(ctx && ctx->initialized) {
141 if(ctx->qlogfd != -1) {
142 curlx_close(ctx->qlogfd);
143 ctx->qlogfd = -1;
144 }
145 /* Cleanup TLS instances first as ngtcp2 objects
146 * might be registered there. */
147 Curl_vquic_tls_cleanup(&ctx->tls);
148 Curl_vquic_ctx_free(&ctx->q);
149 if(ctx->h3conn) {
150 nghttp3_conn_del(ctx->h3conn);
151 ctx->h3conn = NULL;
152 }
153 if(ctx->qconn) {
154 ngtcp2_conn_del(ctx->qconn);
155 ctx->qconn = NULL;
156 }
157#ifdef OPENSSL_QUIC_API2
158 if(ctx->ossl_ctx) {
159 ngtcp2_crypto_ossl_ctx_del(ctx->ossl_ctx);
160 ctx->ossl_ctx = NULL;
161 }
162#endif
163 Curl_bufcp_free(&ctx->stream_bufcp);
164 curlx_dyn_free(&ctx->scratch);
165 Curl_u32_ptrset_clear(&ctx->streams);
166 Curl_ssl_peer_cleanup(&ctx->ssl_peer);
167 curlx_safefree(ctx->tunnel_inbuf);
168 ctx->tunnel_inbuf_len = 0;
169 }
172struct Curl_easy *Curl_cf_ngtcp2_get_xfer(struct Curl_cfilter *cf,
173 void *stream_user_data,
174 struct h3_stream_ctx **pstream)
176 struct h3_stream_ctx *stream = stream_user_data;
178 if(pstream)
179 *pstream = stream;
180 if(stream && (stream->mid != UINT32_MAX)) {
181 struct Curl_easy *data, *call_data = CF_DATA_CURRENT(cf);
182 if(!call_data || !call_data->multi) {
183 DEBUGASSERT(0);
184 return NULL;
185 }
186 data = Curl_multi_get_easy(call_data->multi, stream->mid);
187 if(data && (data->id == stream->xfer_id))
188 return data;
189 DEBUGASSERT(0);
190 }
191 return NULL;
194static ngtcp2_conn *get_conn(ngtcp2_crypto_conn_ref *conn_ref)
196 struct Curl_cfilter *cf = conn_ref->user_data;
197 struct cf_ngtcp2_ctx *ctx = cf->ctx;
198 return ctx->qconn;
201#ifdef DEBUG_NGTCP2
202static void quic_printf(void *user_data, const char *fmt, ...)
204 va_list ap;
205 (void)user_data;
206 va_start(ap, fmt);
207 curl_mvfprintf(stderr, fmt, ap);
208 va_end(ap);
209 curl_mfprintf(stderr, "\n");
211#endif
213static void qlog_callback(void *user_data, uint32_t flags,
214 const void *data, size_t datalen)
216 struct Curl_cfilter *cf = user_data;
217 struct cf_ngtcp2_ctx *ctx = cf->ctx;
218 (void)flags;
219 if(ctx->qlogfd != -1) {
220 ssize_t rc = write(ctx->qlogfd, data, datalen);
221 if(rc == -1) {
222 /* on write error, stop further write attempts */
223 curlx_close(ctx->qlogfd);
224 ctx->qlogfd = -1;
225 }
226 }
229static void quic_settings(struct cf_ngtcp2_ctx *ctx,
230 struct Curl_easy *data,
231 struct cf_ngtcp2_io_ctx *pktx)
233 ngtcp2_settings *s = &ctx->settings;
234 ngtcp2_transport_params *t = &ctx->transport_params;
236 ngtcp2_settings_default(s);
237 ngtcp2_transport_params_default(t);
238#ifdef DEBUG_NGTCP2
239 s->log_printf = quic_printf;
240#else
241 s->log_printf = NULL;
242#endif
244 s->initial_ts = pktx->ts;
245 s->handshake_timeout = (data->set.connecttimeout > 0) ?
246 data->set.connecttimeout * NGTCP2_MILLISECONDS : QUIC_HANDSHAKE_TIMEOUT;
247 s->max_window = H3_CONN_WINDOW_SIZE_MAX;
248 s->max_stream_window = 0; /* disable ngtcp2 auto-tuning of window */
249 s->no_pmtud = FALSE;
250#ifdef NGTCP2_SETTINGS_V3
251 /* try ten times the ngtcp2 defaults here for problems with Caddy */
252 s->glitch_ratelim_burst = 1000 * 10;
253 s->glitch_ratelim_rate = 33 * 10;
254#endif
255 t->initial_max_data = s->max_window;
256 t->initial_max_stream_data_bidi_local = H3_STREAM_WINDOW_SIZE_INITIAL;
257 t->initial_max_stream_data_bidi_remote = H3_STREAM_WINDOW_SIZE_INITIAL;
258 t->initial_max_stream_data_uni = t->initial_max_data;
259 t->initial_max_streams_bidi = QUIC_MAX_STREAMS;
260 t->initial_max_streams_uni = QUIC_MAX_STREAMS;
261 t->max_idle_timeout = 0; /* no idle timeout from our side */
262 if(ctx->qlogfd != -1) {
263 s->qlog_write = qlog_callback;
264 }
267#if defined(_MSC_VER) && defined(_DLL)
268#pragma warning(push)
269#pragma warning(disable:4232) /* MSVC extension, dllimport identity */
270#endif
272static int cb_ngtcp2_handshake_completed(ngtcp2_conn *tconn, void *user_data)
274 struct Curl_cfilter *cf = user_data;
275 struct cf_ngtcp2_ctx *ctx = cf ? cf->ctx : NULL;
276 struct Curl_easy *data;
278 (void)tconn;
279 DEBUGASSERT(ctx);
280 data = CF_DATA_CURRENT(cf);
281 DEBUGASSERT(data);
282 if(!ctx || !data)
283 return NGTCP2_ERR_CALLBACK_FAILURE;
285 ctx->handshake_at = *Curl_pgrs_now(data);
286 ctx->tls_handshake_complete = TRUE;
287 Curl_vquic_report_handshake(&ctx->tls, cf, data);
289 ctx->tls_vrfy_result = Curl_vquic_tls_verify_peer(&ctx->tls, cf,
290 data, &ctx->ssl_peer);
291 if(ctx->tls_vrfy_result)
292 return NGTCP2_ERR_CALLBACK_FAILURE;
294#ifdef CURLVERBOSE
295 if(Curl_trc_is_verbose(data)) {
296 const ngtcp2_transport_params *rp;
297 rp = ngtcp2_conn_get_remote_transport_params(ctx->qconn);
298 CURL_TRC_CF(data, cf, "handshake complete after %" FMT_TIMEDIFF_T
299 "ms, remote transport[max_udp_payload=%" PRIu64
300 ", initial_max_data=%" PRIu64 "]",
301 curlx_ptimediff_ms(&ctx->handshake_at, &ctx->started_at),
302 rp->max_udp_payload_size, rp->initial_max_data);
303 }
304#endif
306 /* In case of earlydata, where we simulate being connected, update
307 * the handshake time when we really did connect */
308 if(ctx->use_earlydata && !ctx->stats_reported &&
309 !(cf->cft->flags & CF_TYPE_PROXY)) {
310 Curl_pgrsTimeWas(data, TIMER_APPCONNECT, ctx->handshake_at);
311 ctx->stats_reported = TRUE;
312 }
313 if(ctx->use_earlydata) {
314#if defined(USE_OPENSSL) && defined(HAVE_OPENSSL_EARLYDATA)
315 /* Check for bug that OpenSSL did not even send the early data. */
316 if(SSL_get_early_data_status(ctx->tls.ossl.ssl) == SSL_EARLY_DATA_NOT_SENT)
317 CURL_TRC_CF(data, cf, "OpenSSL did not send early data");
318#endif
320#if NGTCP2_VERSION_NUM >= 0x011700
321 ctx->earlydata_accepted =
322 !ngtcp2_conn_get_tls_early_data_rejected2(ctx->qconn);
323#else /* older NGTCP2 */
324 {
325#if defined(USE_OPENSSL) && defined(HAVE_OPENSSL_EARLYDATA)
326 int ossl_early_status = SSL_get_early_data_status(ctx->tls.ossl.ssl);
327 if(ossl_early_status == SSL_EARLY_DATA_NOT_SENT)
328 CURL_TRC_CF(data, cf, "OpenSSL did not send early data");
329 ctx->earlydata_accepted = (ossl_early_status == SSL_EARLY_DATA_ACCEPTED);
330#elif defined(USE_GNUTLS)
331 int flags = gnutls_session_get_flags(ctx->tls.gtls.session);
332 ctx->earlydata_accepted = !!(flags & GNUTLS_SFLAGS_EARLY_DATA);
333#elif defined(USE_WOLFSSL)
334#ifdef WOLFSSL_EARLY_DATA
335 ctx->earlydata_accepted =
336 (wolfSSL_get_early_data_status(ctx->tls.wssl.ssl) !=
337 WOLFSSL_EARLY_DATA_REJECTED);
338#else
339 DEBUGASSERT(0); /* should not come here if ED is disabled. */
340 ctx->earlydata_accepted = FALSE;
341#endif /* WOLFSSL_EARLY_DATA */
342#endif /* OPENSSL or GNUTLS or WOLFSSL */
343 }
344#endif /* older NGTCP2 */
345 CURL_TRC_CF(data, cf, "server did%s accept %zu bytes of early data",
346 ctx->earlydata_accepted ? "" : " not", ctx->earlydata_skip);
347 Curl_pgrsEarlyData(data, ctx->earlydata_accepted ?
348 (curl_off_t)ctx->earlydata_skip :
349 -(curl_off_t)ctx->earlydata_skip);
350 }
351 return 0;
354static int cb_recv_stream_data(ngtcp2_conn *tconn, uint32_t flags,
355 int64_t stream_id, uint64_t offset,
356 const uint8_t *buf, size_t buflen,
357 void *user_data, void *stream_user_data)
359 struct Curl_cfilter *cf = user_data;
360 struct cf_ngtcp2_ctx *ctx = cf->ctx;
361 nghttp3_ssize rc;
362 uint64_t nconsumed;
363 int fin = (flags & NGTCP2_STREAM_DATA_FLAG_FIN) ? 1 : 0;
364 struct h3_stream_ctx *stream;
365 struct Curl_easy *data =
366 Curl_cf_ngtcp2_get_xfer(cf, stream_user_data, &stream);
368 (void)offset;
369 rc = nghttp3_conn_read_stream(ctx->h3conn, stream_id, buf, buflen, fin);
370 if(rc < 0) {
371 if(data && stream) {
372 CURL_TRC_CF(data, cf, "[%" PRId64 "] error on known stream, "
373 "reset=%d, closed=%d",
374 stream_id, stream->reset, stream->closed);
375 }
376 return NGTCP2_ERR_CALLBACK_FAILURE;
377 }
378 nconsumed = (uint64_t)rc;
379 if(nconsumed) {
380 /* number of bytes inside buflen which consists of framing overhead
381 * including QPACK HEADERS. In other words, it does not consume payload of
382 * DATA frame. */
383 ngtcp2_conn_extend_max_stream_offset(tconn, stream_id, nconsumed);
384 ngtcp2_conn_extend_max_offset(tconn, nconsumed);
385 if(stream) {
386 stream->rx_offset += nconsumed;
387 stream->rx_offset_max += nconsumed;
388 }
389 }
390 return 0;
393static int cb_acked_stream_data_offset(ngtcp2_conn *tconn, int64_t stream_id,
394 uint64_t offset, uint64_t datalen,
395 void *user_data, void *stream_user_data)
397 struct Curl_cfilter *cf = user_data;
398 struct cf_ngtcp2_ctx *ctx = cf->ctx;
399 int rv;
400 (void)stream_id;
401 (void)tconn;
402 (void)offset;
403 (void)datalen;
404 (void)stream_user_data;
406 rv = nghttp3_conn_add_ack_offset(ctx->h3conn, stream_id, datalen);
407 if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
408 return NGTCP2_ERR_CALLBACK_FAILURE;
409 }
411 return 0;
414static int cb_stream_close(ngtcp2_conn *tconn, uint32_t flags,
415 int64_t stream_id, uint64_t app_error_code,
416 void *user_data, void *stream_user_data)
418 struct Curl_cfilter *cf = user_data;
419 struct cf_ngtcp2_ctx *ctx = cf->ctx;
420 struct Curl_easy *data = Curl_cf_ngtcp2_get_xfer(cf, stream_user_data, NULL);
421 int rv;
423 (void)tconn;
424 /* stream is closed... */
425 if(!data)
426 data = CF_DATA_CURRENT(cf);
427 if(!data)
428 return NGTCP2_ERR_CALLBACK_FAILURE;
430 if(!(flags & NGTCP2_STREAM_CLOSE_FLAG_APP_ERROR_CODE_SET)) {
431 app_error_code = NGHTTP3_H3_NO_ERROR;
432 }
434 rv = nghttp3_conn_close_stream(ctx->h3conn, stream_id, app_error_code);
435 CURL_TRC_CF(data, cf, "[%" PRId64 "] quic close(app_error=%"
436 PRIu64 ") -> %d", stream_id, app_error_code, rv);
437 if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
438 Curl_cf_ngtcp2_h3_err_set(cf, data, rv);
439 return NGTCP2_ERR_CALLBACK_FAILURE;
440 }
442 return 0;
445#ifdef NGTCP2_CALLBACKS_V5 /* ngtcp2 v1.25.0+ */
446static int cb_stream_close2(ngtcp2_conn *tconn, uint32_t flags,
447 int64_t stream_id,
448 uint64_t rx_app_error_code,
449 uint64_t tx_app_error_code,
450 void *user_data, void *stream_user_data)
452 struct Curl_cfilter *cf = user_data;
453 struct cf_ngtcp2_ctx *ctx = cf->ctx;
454 struct Curl_easy *data = Curl_cf_ngtcp2_get_xfer(cf, stream_user_data, NULL);
455 uint64_t h3_app_error_code = NGHTTP3_H3_NO_ERROR;
456 int rv;
458 (void)tconn;
459 (void)tx_app_error_code;
460 /* stream is closed... */
461 if(!data)
462 data = CF_DATA_CURRENT(cf);
463 if(!data)
464 return NGTCP2_ERR_CALLBACK_FAILURE;
466 if(flags & NGTCP2_STREAM_CLOSE2_FLAG_RX_APP_ERROR_CODE_SET)
467 h3_app_error_code = rx_app_error_code;
469 rv = nghttp3_conn_close_stream(ctx->h3conn, stream_id, h3_app_error_code);
470 CURL_TRC_CF(data, cf, "[%" PRId64 "] quic close(app_error=%"
471 PRIu64 ") -> %d", stream_id, h3_app_error_code, rv);
472 if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
473 Curl_cf_ngtcp2_h3_err_set(cf, data, rv);
474 return NGTCP2_ERR_CALLBACK_FAILURE;
475 }
477 return 0;
479#endif
481static int cb_stream_reset(ngtcp2_conn *tconn, int64_t stream_id,
482 uint64_t final_size, uint64_t app_error_code,
483 void *user_data, void *stream_user_data)
485 struct Curl_cfilter *cf = user_data;
486 struct cf_ngtcp2_ctx *ctx = cf->ctx;
487 struct Curl_easy *data = Curl_cf_ngtcp2_get_xfer(cf, stream_user_data, NULL);
488 int rv;
489 (void)tconn;
490 (void)final_size;
491 (void)app_error_code;
493 rv = nghttp3_conn_shutdown_stream_read(ctx->h3conn, stream_id);
494 if(data)
495 CURL_TRC_CF(data, cf, "[%" PRId64 "] reset -> %d", stream_id, rv);
496 if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
497 return NGTCP2_ERR_CALLBACK_FAILURE;
498 }
500 return 0;
503static int cb_stream_stop_sending(ngtcp2_conn *tconn, int64_t stream_id,
504 uint64_t app_error_code, void *user_data,
505 void *stream_user_data)
507 struct Curl_cfilter *cf = user_data;
508 struct cf_ngtcp2_ctx *ctx = cf->ctx;
509 int rv;
510 (void)tconn;
511 (void)app_error_code;
512 (void)stream_user_data;
514 rv = nghttp3_conn_shutdown_stream_read(ctx->h3conn, stream_id);
515 if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
516 return NGTCP2_ERR_CALLBACK_FAILURE;
517 }
519 return 0;
522static int cb_extend_max_local_streams_bidi(ngtcp2_conn *tconn,
523 uint64_t max_streams,
524 void *user_data)
526 struct Curl_cfilter *cf = user_data;
527 struct cf_ngtcp2_ctx *ctx = cf->ctx;
528 struct Curl_easy *data = CF_DATA_CURRENT(cf);
530 (void)tconn;
531 ctx->max_bidi_streams = max_streams;
532 if(data)
533 CURL_TRC_CF(data, cf, "max bidi streams now %" PRIu64 ", used %" PRIu64,
534 ctx->max_bidi_streams, ctx->used_bidi_streams);
535 return 0;
538static int cb_extend_max_stream_data(ngtcp2_conn *tconn, int64_t stream_id,
539 uint64_t max_data, void *user_data,
540 void *stream_user_data)
542 struct Curl_cfilter *cf = user_data;
543 struct cf_ngtcp2_ctx *ctx = cf->ctx;
544 struct h3_stream_ctx *stream;
545 struct Curl_easy *data =
546 Curl_cf_ngtcp2_get_xfer(cf, stream_user_data, &stream);
547 int rv;
548 (void)tconn;
549 (void)max_data;
551 rv = nghttp3_conn_unblock_stream(ctx->h3conn, stream_id);
552 if(rv && rv != NGHTTP3_ERR_STREAM_NOT_FOUND) {
553 return NGTCP2_ERR_CALLBACK_FAILURE;
554 }
555 if(stream && stream->quic_flow_blocked) {
556 CURL_TRC_CF(data, cf, "[%" PRId64 "] unblock quic flow", stream_id);
557 stream->quic_flow_blocked = FALSE;
558 if(data)
559 Curl_multi_mark_dirty(data);
560 }
561 return 0;
564static void cb_rand(uint8_t *dest, size_t destlen,
565 const ngtcp2_rand_ctx *rand_ctx)
567 CURLcode result;
568 (void)rand_ctx;
570 result = Curl_rand(NULL, dest, destlen);
571 if(result) {
572 /* cb_rand is only used for non-cryptographic context. If Curl_rand
573 failed, fill 0 and call it *random*. */
574 memset(dest, 0, destlen);
575 }
578/* for ngtcp2 <v1.22.0 */
579static int cb_get_new_connection_id(ngtcp2_conn *tconn, ngtcp2_cid *cid,
580 uint8_t *token, size_t cidlen,
581 void *user_data)
583 CURLcode result;
584 (void)tconn;
585 (void)user_data;
587 result = Curl_rand(NULL, cid->data, cidlen);
588 if(result)
589 return NGTCP2_ERR_CALLBACK_FAILURE;
590 cid->datalen = cidlen;
592 result = Curl_rand(NULL, token, NGTCP2_STATELESS_RESET_TOKENLEN);
593 if(result)
594 return NGTCP2_ERR_CALLBACK_FAILURE;
596 return 0;
599#ifdef NGTCP2_CALLBACKS_V3 /* ngtcp2 v1.22.0+ */
600static int cb_get_new_connection_id2(
601 ngtcp2_conn *tconn, ngtcp2_cid *cid,
602 struct ngtcp2_stateless_reset_token *token, size_t cidlen, void *user_data)
604 CURLcode result;
605 (void)tconn;
606 (void)user_data;
608 result = Curl_rand(NULL, cid->data, cidlen);
609 if(result)
610 return NGTCP2_ERR_CALLBACK_FAILURE;
611 cid->datalen = cidlen;
613 result = Curl_rand(NULL, token->data, sizeof(token->data));
614 if(result)
615 return NGTCP2_ERR_CALLBACK_FAILURE;
617 return 0;
619#endif
621static int cb_recv_rx_key(ngtcp2_conn *tconn, ngtcp2_encryption_level level,
622 void *user_data)
624 struct Curl_cfilter *cf = user_data;
625 struct cf_ngtcp2_ctx *ctx = cf ? cf->ctx : NULL;
626 struct Curl_easy *data = CF_DATA_CURRENT(cf);
627 (void)tconn;
629 if(level != NGTCP2_ENCRYPTION_LEVEL_1RTT)
630 return 0;
632 DEBUGASSERT(ctx);
633 DEBUGASSERT(data);
634 if(ctx && data && !ctx->h3conn && ctx->init_h3_conn_cb) {
635 if(ctx->init_h3_conn_cb(cf, data, ctx))
636 return NGTCP2_ERR_CALLBACK_FAILURE;
637 }
638 return 0;
641#ifdef CURL_HAVE_DIAG
642#pragma GCC diagnostic push
643#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
644#endif
645static ngtcp2_callbacks ng_callbacks = {
646 ngtcp2_crypto_client_initial_cb,
647 NULL, /* recv_client_initial */
648 ngtcp2_crypto_recv_crypto_data_cb,
649 cb_ngtcp2_handshake_completed,
650 NULL, /* recv_version_negotiation */
651 ngtcp2_crypto_encrypt_cb,
652 ngtcp2_crypto_decrypt_cb,
653 ngtcp2_crypto_hp_mask_cb,
654 cb_recv_stream_data,
655 cb_acked_stream_data_offset,
656 NULL, /* stream_open */
657 cb_stream_close,
658 NULL, /* recv_stateless_reset */
659 ngtcp2_crypto_recv_retry_cb,
660 cb_extend_max_local_streams_bidi,
661 NULL, /* extend_max_local_streams_uni */
662 cb_rand,
663 cb_get_new_connection_id, /* for ngtcp2 <v1.22.0 */
664 NULL, /* remove_connection_id */
665 ngtcp2_crypto_update_key_cb, /* update_key */
666 NULL, /* path_validation */
667 NULL, /* select_preferred_addr */
668 cb_stream_reset,
669 NULL, /* extend_max_remote_streams_bidi */
670 NULL, /* extend_max_remote_streams_uni */
671 cb_extend_max_stream_data,
672 NULL, /* dcid_status */
673 NULL, /* handshake_confirmed */
674 NULL, /* recv_new_token */
675 ngtcp2_crypto_delete_crypto_aead_ctx_cb,
676 ngtcp2_crypto_delete_crypto_cipher_ctx_cb,
677 NULL, /* recv_datagram */
678 NULL, /* ack_datagram */
679 NULL, /* lost_datagram */
680 ngtcp2_crypto_get_path_challenge_data_cb,
681 cb_stream_stop_sending,
682 NULL, /* version_negotiation */
683 cb_recv_rx_key,
684 NULL, /* recv_tx_key */
685 NULL, /* early_data_rejected */
686#ifdef NGTCP2_CALLBACKS_V2 /* ngtcp2 v1.14.0+ */
687 NULL, /* begin_path_validation */
688#endif
689#ifdef NGTCP2_CALLBACKS_V3 /* ngtcp2 v1.22.0+ */
690 NULL, /* recv_stateless_reset2 */
691 cb_get_new_connection_id2, /* get_new_connection_id2 */
692 NULL, /* dcid_status2 */
693 ngtcp2_crypto_get_path_challenge_data2_cb, /* get_path_challenge_data2 */
694#endif
695#ifdef NGTCP2_CALLBACKS_V4 /* ngtcp2 v1.24.0+ */
696 NULL, /* recv_stop_sending */
697#endif
698#ifdef NGTCP2_CALLBACKS_V5 /* ngtcp2 v1.25.0+ */
699 cb_stream_close2, /* is called instead of cb_stream_close when set */
700#endif
701};
702#ifdef CURL_HAVE_DIAG
703#pragma GCC diagnostic pop
704#endif
706#if defined(_MSC_VER) && defined(_DLL)
707#pragma warning(pop)
708#endif
710#ifdef USE_OPENSSL
711/* The "new session" callback must return zero if the session can be removed
712 * or non-zero if the session has been put into the session cache.
713 */
714static int quic_ossl_new_session_cb(SSL *ssl, SSL_SESSION *ssl_sessionid)
716 struct Curl_cfilter *cf;
717 struct cf_ngtcp2_ctx *ctx;
718 struct Curl_easy *data;
719 ngtcp2_crypto_conn_ref *cref;
721 cref = (ngtcp2_crypto_conn_ref *)SSL_get_app_data(ssl);
722 cf = cref ? cref->user_data : NULL;
723 ctx = cf ? cf->ctx : NULL;
724 data = cf ? CF_DATA_CURRENT(cf) : NULL;
725 if(cf && data && ctx) {
726 unsigned char *quic_tp = NULL;
727 size_t quic_tp_len = 0;
728#ifdef HAVE_OPENSSL_EARLYDATA
729 ngtcp2_ssize tplen;
730 uint8_t tpbuf[256];
732 tplen = ngtcp2_conn_encode_0rtt_transport_params(ctx->qconn, tpbuf,
733 sizeof(tpbuf));
734 if(tplen < 0)
735 CURL_TRC_CF(data, cf, "error encoding 0RTT transport data: %s",
736 ngtcp2_strerror((int)tplen));
737 else {
738 quic_tp = (unsigned char *)tpbuf;
739 quic_tp_len = (size_t)tplen;
740 }
741#endif
742 Curl_ossl_add_session(cf, data, &ctx->tls.ossl, ctx->ssl_peer.scache_key,
743 ssl_sessionid, "h3", quic_tp, quic_tp_len, NULL);
744 }
745 return 0;
747#endif /* USE_OPENSSL */
749#ifdef USE_GNUTLS
751#ifdef CURLVERBOSE
752static const char *gtls_hs_msg_name(int mtype)
754 switch(mtype) {
755 case 1:
756 return "ClientHello";
757 case 2:
758 return "ServerHello";
759 case 4:
760 return "SessionTicket";
761 case 8:
762 return "EncryptedExtensions";
763 case 11:
764 return "Certificate";
765 case 13:
766 return "CertificateRequest";
767 case 15:
768 return "CertificateVerify";
769 case 20:
770 return "Finished";
771 case 24:
772 return "KeyUpdate";
773 case 254:
774 return "MessageHash";
775 }
776 return "Unknown";
778#endif
780static int quic_gtls_handshake_cb(gnutls_session_t session, unsigned int htype,
781 unsigned when, unsigned int incoming,
782 const gnutls_datum_t *msg)
784 ngtcp2_crypto_conn_ref *conn_ref = gnutls_session_get_ptr(session);
785 struct Curl_cfilter *cf = conn_ref ? conn_ref->user_data : NULL;
786 struct cf_ngtcp2_ctx *ctx = cf ? cf->ctx : NULL;
788 (void)msg;
789 (void)incoming;
790 if(when && cf && ctx) { /* after message has been processed */
791 struct Curl_easy *data = CF_DATA_CURRENT(cf);
792 DEBUGASSERT(data);
793 if(!data)
794 return 0;
795 CURL_TRC_CF(data, cf, "SSL message: %s %s [%u]",
796 incoming ? "<-" : "->", gtls_hs_msg_name(htype), htype);
797 switch(htype) {
798 case GNUTLS_HANDSHAKE_NEW_SESSION_TICKET: {
799 ngtcp2_ssize tplen;
800 uint8_t tpbuf[256];
801 unsigned char *quic_tp = NULL;
802 size_t quic_tp_len = 0;
804 tplen = ngtcp2_conn_encode_0rtt_transport_params(ctx->qconn, tpbuf,
805 sizeof(tpbuf));
806 if(tplen < 0)
807 CURL_TRC_CF(data, cf, "error encoding 0RTT transport data: %s",
808 ngtcp2_strerror((int)tplen));
809 else {
810 quic_tp = (unsigned char *)tpbuf;
811 quic_tp_len = (size_t)tplen;
812 }
813 (void)Curl_gtls_cache_session(cf, data, ctx->ssl_peer.scache_key,
814 session, 0, "h3", quic_tp, quic_tp_len,
815 NULL);
816 break;
817 }
818 default:
819 break;
820 }
821 }
822 return 0;
824#endif /* USE_GNUTLS */
826#ifdef USE_WOLFSSL
827static int wssl_quic_new_session_cb(WOLFSSL *ssl, WOLFSSL_SESSION *session)
829 ngtcp2_crypto_conn_ref *conn_ref = wolfSSL_get_app_data(ssl);
830 struct Curl_cfilter *cf = conn_ref ? conn_ref->user_data : NULL;
832 DEBUGASSERT(cf);
833 if(cf && session) {
834 struct cf_ngtcp2_ctx *ctx = cf->ctx;
835 struct Curl_easy *data = CF_DATA_CURRENT(cf);
836 DEBUGASSERT(data);
837 if(data && ctx) {
838 ngtcp2_ssize tplen;
839 uint8_t tpbuf[256];
840 unsigned char *quic_tp = NULL;
841 size_t quic_tp_len = 0;
843 tplen = ngtcp2_conn_encode_0rtt_transport_params(ctx->qconn, tpbuf,
844 sizeof(tpbuf));
845 if(tplen < 0)
846 CURL_TRC_CF(data, cf, "error encoding 0RTT transport data: %s",
847 ngtcp2_strerror((int)tplen));
848 else {
849 quic_tp = (unsigned char *)tpbuf;
850 quic_tp_len = (size_t)tplen;
851 }
852 (void)Curl_wssl_cache_session(cf, data, ctx->ssl_peer.scache_key,
853 session, wolfSSL_version(ssl),
854 "h3", quic_tp, quic_tp_len, NULL);
855 }
856 }
857 return 0;
859#endif /* USE_WOLFSSL */
861static CURLcode cf_ngtcp2_tls_ctx_setup(struct Curl_cfilter *cf,
862 struct Curl_easy *data,
863 void *user_data)
865 struct curl_tls_ctx *ctx = user_data;
867#ifdef USE_OPENSSL
868#if defined(OPENSSL_IS_AWSLC) || defined(OPENSSL_IS_BORINGSSL)
869 if(ngtcp2_crypto_boringssl_configure_client_context(ctx->ossl.ssl_ctx)
870 != 0) {
871 failf(data, "ngtcp2_crypto_boringssl_configure_client_context failed");
872 return CURLE_FAILED_INIT;
873 }
874#elif defined(OPENSSL_QUIC_API2)
875 /* nothing to do */
876#else
877 if(ngtcp2_crypto_quictls_configure_client_context(ctx->ossl.ssl_ctx) != 0) {
878 failf(data, "ngtcp2_crypto_quictls_configure_client_context failed");
879 return CURLE_FAILED_INIT;
880 }
881#endif /* !OPENSSL_IS_AWSLC && !OPENSSL_IS_BORINGSSL */
882 if(Curl_ssl_scache_use(cf, data)) {
883 /* Enable the session cache because it is a prerequisite for the
884 * "new session" callback. Use the "external storage" mode to prevent
885 * OpenSSL from creating an internal session cache.
886 */
887 SSL_CTX_set_session_cache_mode(ctx->ossl.ssl_ctx,
888 SSL_SESS_CACHE_CLIENT |
889 SSL_SESS_CACHE_NO_INTERNAL);
890 SSL_CTX_sess_set_new_cb(ctx->ossl.ssl_ctx, quic_ossl_new_session_cb);
891 }
893#elif defined(USE_GNUTLS)
894 if(ngtcp2_crypto_gnutls_configure_client_session(ctx->gtls.session) != 0) {
895 failf(data, "ngtcp2_crypto_gnutls_configure_client_session failed");
896 return CURLE_FAILED_INIT;
897 }
898 if(Curl_ssl_scache_use(cf, data)) {
899 gnutls_handshake_set_hook_function(ctx->gtls.session,
900 GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST,
901 quic_gtls_handshake_cb);
902 }
904#elif defined(USE_WOLFSSL)
905 if(ngtcp2_crypto_wolfssl_configure_client_context(ctx->wssl.ssl_ctx) != 0) {
906 failf(data, "ngtcp2_crypto_wolfssl_configure_client_context failed");
907 return CURLE_FAILED_INIT;
908 }
909 if(Curl_ssl_scache_use(cf, data)) {
910 /* Register to get notified when a new session is received */
911 wolfSSL_CTX_sess_set_new_cb(ctx->wssl.ssl_ctx, wssl_quic_new_session_cb);
912 }
913#endif
914 return CURLE_OK;
917static CURLcode cf_ngtcp2_on_session_reuse(struct Curl_cfilter *cf,
918 struct Curl_easy *data,
919 struct alpn_spec *alpns,
920 struct Curl_ssl_session *scs,
921 bool *do_early_data)
923 struct cf_ngtcp2_ctx *ctx = cf->ctx;
924 CURLcode result = CURLE_OK;
926 *do_early_data = FALSE;
927#if defined(USE_OPENSSL) && defined(HAVE_OPENSSL_EARLYDATA)
928 ctx->earlydata_max = scs->earlydata_max;
929#endif
930#ifdef USE_GNUTLS
931 ctx->earlydata_max =
932 gnutls_record_get_max_early_data_size(ctx->tls.gtls.session);
933#endif
934#ifdef USE_WOLFSSL
935#ifdef WOLFSSL_EARLY_DATA
936 ctx->earlydata_max = scs->earlydata_max;
937#else
938 ctx->earlydata_max = 0;
939#endif /* WOLFSSL_EARLY_DATA */
940#endif
941#if defined(USE_GNUTLS) || defined(USE_WOLFSSL) || \
942 (defined(USE_OPENSSL) && defined(HAVE_OPENSSL_EARLYDATA))
943 if(!ctx->earlydata_max) {
944 CURL_TRC_CF(data, cf, "SSL session does not allow earlydata");
945 }
946 else if(!Curl_alpn_contains_proto(alpns, scs->alpn)) {
947 CURL_TRC_CF(data, cf, "SSL session from different ALPN, no early data");
948 }
949 else if(!scs->quic_tp || !scs->quic_tp_len) {
950 CURL_TRC_CF(data, cf, "no 0RTT transport parameters, no early data");
951 }
952 else {
953 int rv;
954 rv = ngtcp2_conn_decode_and_set_0rtt_transport_params(
955 ctx->qconn, (const uint8_t *)scs->quic_tp, scs->quic_tp_len);
956 if(rv)
957 CURL_TRC_CF(data, cf, "no early data, failed to set 0RTT transport "
958 "parameters: %s", ngtcp2_strerror(rv));
959 else if(ctx->init_h3_conn_cb) {
960 infof(data, "SSL session allows %zu bytes of early data, "
961 "reusing ALPN '%s'", ctx->earlydata_max, scs->alpn);
962 result = ctx->init_h3_conn_cb(cf, data, ctx);
963 if(!result) {
964 ctx->use_earlydata = TRUE;
965 cf->connected = TRUE;
966 *do_early_data = TRUE;
967 }
968 }
969 else { /* init_h3_conn_cb not set, assume done */
970 ctx->use_earlydata = TRUE;
971 cf->connected = TRUE;
972 *do_early_data = TRUE;
973 }
974 }
975#else /* not supported in the TLS backend */
976 (void)data;
977 (void)ctx;
978 (void)scs;
979 (void)alpns;
980#endif
981 return result;
984/*
985 * Might be called twice for happy eyeballs.
986 */
987static CURLcode cf_connect_start(struct Curl_cfilter *cf,
988 struct Curl_easy *data,
989 struct cf_ngtcp2_io_ctx *pktx)
991 struct cf_ngtcp2_ctx *ctx = cf->ctx;
992 int rc;
993 int rv;
994 CURLcode result;
995 const struct Curl_sockaddr_ex *sockaddr = NULL;
996 int qfd;
997 static const struct alpn_spec ALPN_SPEC_H3 = { { "h3", "h3-29" }, 2 };
999 DEBUGASSERT(ctx->initialized);
1000 ctx->dcid.datalen = NGTCP2_MAX_CIDLEN;
1001 result = Curl_rand(data, ctx->dcid.data, NGTCP2_MAX_CIDLEN);
1002 if(result)
1003 return result;
1005 ctx->scid.datalen = NGTCP2_MAX_CIDLEN;
1006 result = Curl_rand(data, ctx->scid.data, NGTCP2_MAX_CIDLEN);
1007 if(result)
1008 return result;
1010 (void)Curl_qlogdir(data, ctx->scid.data, NGTCP2_MAX_CIDLEN, &qfd);
1011 ctx->qlogfd = qfd; /* -1 if failure above */
1012 quic_settings(ctx, data, pktx);
1014 result = Curl_vquic_ctx_init(data, &ctx->q);
1015 if(result)
1016 return result;
1018 /* Query socket and remote address from sub-chain */
1019 if(Curl_cf_socket_peek(cf->next, data, &ctx->q.sockfd, &sockaddr, NULL)) {
1020 /* No direct socket - must be tunneled QUIC (CONNECT-UDP through proxy) */
1021 ctx->q.sockfd = CURL_SOCKET_BAD;
1024 if(ctx->q.sockfd != CURL_SOCKET_BAD) {
1025 /* Direct UDP socket - get local address for ngtcp2 */
1026 ctx->q.local_addrlen = sizeof(ctx->q.local_addr);
1027 rv = getsockname(ctx->q.sockfd, (struct sockaddr *)&ctx->q.local_addr,
1028 &ctx->q.local_addrlen);
1029 if(rv == -1)
1030 return CURLE_QUIC_CONNECT_ERROR;
1032 ngtcp2_addr_init(&ctx->connected_path.local,
1033 (struct sockaddr *)&ctx->q.local_addr,
1034 ctx->q.local_addrlen);
1035 ngtcp2_addr_init(&ctx->connected_path.remote,
1036 &sockaddr->curl_sa_addr, (socklen_t)sockaddr->addrlen);
1038 else {
1039 /* Tunneled QUIC (e.g. CONNECT-UDP): get remote address
1040 from the connected filter below */
1041 const struct Curl_sockaddr_ex *remote = NULL;
1042 if(cf->next->cft->query(cf->next, data, CF_QUERY_REMOTE_ADDR, NULL,
1043 CURL_UNCONST(&remote)))
1044 return CURLE_QUIC_CONNECT_ERROR;
1045 if(!remote)
1046 return CURLE_QUIC_CONNECT_ERROR;
1048 memset(&ctx->q.local_addr, 0, sizeof(ctx->q.local_addr));
1049 switch(remote->family) {
1050 case AF_INET:
1051 ((struct sockaddr_in *)&ctx->q.local_addr)->sin_family = AF_INET;
1052 ctx->q.local_addrlen = sizeof(struct sockaddr_in);
1053 break;
1054#ifdef USE_IPV6
1055 case AF_INET6:
1056 ((struct sockaddr_in6 *)&ctx->q.local_addr)->sin6_family = AF_INET6;
1057 ctx->q.local_addrlen = sizeof(struct sockaddr_in6);
1058 break;
1059#endif
1060 default:
1061 return CURLE_QUIC_CONNECT_ERROR;
1064 ngtcp2_addr_init(&ctx->connected_path.local,
1065 (struct sockaddr *)&ctx->q.local_addr,
1066 ctx->q.local_addrlen);
1067 ngtcp2_addr_init(&ctx->connected_path.remote,
1068 &remote->curl_sa_addr,
1069 (socklen_t)remote->addrlen);
1072 rc = ngtcp2_conn_client_new(&ctx->qconn, &ctx->dcid, &ctx->scid,
1073 &ctx->connected_path,
1074 NGTCP2_PROTO_VER_V1, &ng_callbacks,
1075 &ctx->settings, &ctx->transport_params,
1076 Curl_ngtcp2_mem(), cf);
1077 if(rc)
1078 return CURLE_QUIC_CONNECT_ERROR;
1080 ctx->conn_ref.get_conn = get_conn;
1081 ctx->conn_ref.user_data = cf;
1083 result = Curl_vquic_tls_init(&ctx->tls, cf, data,
1084 &ctx->ssl_peer, &ALPN_SPEC_H3,
1085 cf_ngtcp2_tls_ctx_setup, &ctx->tls,
1086 &ctx->conn_ref,
1087 cf_ngtcp2_on_session_reuse);
1088 if(result)
1089 return result;
1091#if defined(USE_OPENSSL) && defined(OPENSSL_QUIC_API2)
1092 if(ngtcp2_crypto_ossl_ctx_new(&ctx->ossl_ctx, ctx->tls.ossl.ssl) != 0) {
1093 failf(data, "ngtcp2_crypto_ossl_ctx_new failed");
1094 return CURLE_FAILED_INIT;
1096 ngtcp2_conn_set_tls_native_handle(ctx->qconn, ctx->ossl_ctx);
1097 if(ngtcp2_crypto_ossl_configure_client_session(ctx->tls.ossl.ssl) != 0) {
1098 failf(data, "ngtcp2_crypto_ossl_configure_client_session failed");
1099 return CURLE_FAILED_INIT;
1101#elif defined(USE_OPENSSL)
1102 SSL_set_quic_use_legacy_codepoint(ctx->tls.ossl.ssl, 0);
1103 ngtcp2_conn_set_tls_native_handle(ctx->qconn, ctx->tls.ossl.ssl);
1104#elif defined(USE_GNUTLS)
1105 ngtcp2_conn_set_tls_native_handle(ctx->qconn, ctx->tls.gtls.session);
1106#elif defined(USE_WOLFSSL)
1107 ngtcp2_conn_set_tls_native_handle(ctx->qconn, ctx->tls.wssl.ssl);
1108#else
1109#error "ngtcp2 TLS backend not defined"
1110#endif
1112#if defined(USE_OPENSSL) && defined(HAVE_OPENSSL_EARLYDATA) && \
1113 defined(OPENSSL_QUIC_API2)
1114 /* We need to tell OpenSSL to *really* use Early Data for QUIC and
1115 * this only works *after* ngtcp2 has tweaked all SSL parameters,
1116 * otherwise OpenSSL does not accept it. */
1117 if(ctx->use_earlydata &&
1118 !SSL_set_quic_tls_early_data_enabled(ctx->tls.ossl.ssl, 1)) {
1119 CURL_TRC_CF(data, cf, "OpenSSL refused to use early data");
1120 ctx->use_earlydata = FALSE;
1121 cf->connected = FALSE;
1123#endif
1124 ngtcp2_ccerr_default(&ctx->last_error);
1126 return CURLE_OK;
1129CURLcode Curl_cf_ngtcp2_cmn_connect(struct Curl_cfilter *cf,
1130 struct Curl_easy *data,
1131 bool *done)
1133 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1134 CURLcode result = CURLE_OK;
1135 struct cf_call_data save;
1136 struct cf_ngtcp2_io_ctx pktx;
1138 if(cf->connected) {
1139 *done = TRUE;
1140 return CURLE_OK;
1143 /* Connect the sub-chain */
1144 if(cf->next && !cf->next->connected) {
1145 result = Curl_conn_cf_connect(cf->next, data, done);
1146 if(result || !*done)
1147 return result;
1150 *done = FALSE;
1152 if(Curl_ssl_need_httpsrr(cf) &&
1153 !Curl_conn_dns_resolved_https(data, cf->sockindex, ctx->ssl_peer.peer)) {
1154 CURL_TRC_CF(data, cf, "need HTTPS-RR, delaying connect");
1155 return CURLE_OK;
1158 Curl_cf_ngtcp2_io_ctx_init(&pktx, cf, data);
1159 CF_DATA_SAVE(save, cf, data);
1161 if(!ctx->qconn) {
1162 ctx->started_at = *Curl_pgrs_now(data);
1163 result = cf_connect_start(cf, data, &pktx);
1164 if(result)
1165 goto out;
1166 if(cf->connected) {
1167 *done = TRUE;
1168 goto out;
1170 result = Curl_cf_ngtcp2_progress_egress(cf, data, &pktx);
1171 /* we do not expect to be able to recv anything yet */
1172 goto out;
1175 result = Curl_cf_ngtcp2_progress_ingress(cf, data, &pktx);
1176 if(result)
1177 goto out;
1179 result = Curl_cf_ngtcp2_progress_egress(cf, data, &pktx);
1180 if(result)
1181 goto out;
1183 if(ngtcp2_conn_get_handshake_completed(ctx->qconn)) {
1184 result = ctx->tls_vrfy_result;
1185 if(!result) {
1186 CURL_TRC_CF(data, cf, "peer verified");
1187 cf->connected = TRUE;
1188 *done = TRUE;
1192out:
1193 if(ctx->tls_vrfy_result)
1194 result = ctx->tls_vrfy_result;
1195 if(ctx->qconn &&
1196 ((result == CURLE_RECV_ERROR) || (result == CURLE_SEND_ERROR)) &&
1197 ngtcp2_conn_in_draining_period(ctx->qconn)) {
1198 const ngtcp2_ccerr *cerr = ngtcp2_conn_get_ccerr(ctx->qconn);
1200 result = CURLE_COULDNT_CONNECT;
1201 if(cerr) {
1202 CURL_TRC_CF(data, cf, "connect error, type=%d, code=%" PRIu64,
1203 (int)cerr->type, cerr->error_code);
1204 switch(cerr->type) {
1205 case NGTCP2_CCERR_TYPE_VERSION_NEGOTIATION:
1206 CURL_TRC_CF(data, cf, "error in version negotiation");
1207 break;
1208 default:
1209 if(cerr->error_code >= NGTCP2_CRYPTO_ERROR) {
1210 CURL_TRC_CF(data, cf, "crypto error, tls alert=%u",
1211 (unsigned int)(cerr->error_code & 0xffU));
1213 else if(cerr->error_code == NGTCP2_CONNECTION_REFUSED) {
1214 CURL_TRC_CF(data, cf, "connection refused by server");
1215 /* When a QUIC server instance is shutting down, it may send us a
1216 * CONNECTION_CLOSE with this code right away. We want
1217 * to keep on trying in this case. */
1218 result = CURLE_WEIRD_SERVER_REPLY;
1224#ifdef CURLVERBOSE
1225 if(result) {
1226 if(ctx->q.sockfd != CURL_SOCKET_BAD) {
1227 /* Direct UDP socket - get IP info for error reporting */
1228 struct ip_quadruple ip;
1230 if(!Curl_cf_socket_peek(cf->next, data, NULL, NULL, &ip))
1231 infof(data, "QUIC connect to %s port %u failed: %s",
1232 ip.remote_ip, ip.remote_port, curl_easy_strerror(result));
1235#endif
1236 if(!result && ctx->qconn) {
1237 result = Curl_cf_ngtcp2_cmn_set_expiry(cf, data, &pktx);
1239 if(result || *done)
1240 CURL_TRC_CF(data, cf, "connect -> %d, done=%d", (int)result, *done);
1241 CF_DATA_RESTORE(cf, save);
1242 return result;
1245CURLcode Curl_cf_ngtcp2_cmn_shutdown(struct Curl_cfilter *cf,
1246 struct Curl_easy *data, bool *done)
1248 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1249 struct cf_call_data save;
1250 struct cf_ngtcp2_io_ctx pktx;
1251 CURLcode result = CURLE_OK;
1253 if(cf->shutdown || !ctx->qconn) {
1254 *done = TRUE;
1255 return CURLE_OK;
1258 if(!cf->next) {
1259 Curl_bufq_reset(&ctx->q.sendbuf);
1260 *done = TRUE;
1261 return CURLE_OK;
1264 CF_DATA_SAVE(save, cf, data);
1265 *done = FALSE;
1266 Curl_cf_ngtcp2_io_ctx_init(&pktx, cf, data);
1268 if(!ctx->shutdown_started) {
1269 char buffer[NGTCP2_MAX_UDP_PAYLOAD_SIZE];
1270 ngtcp2_ssize nwritten;
1272 if(!Curl_bufq_is_empty(&ctx->q.sendbuf)) {
1273 CURL_TRC_CF(data, cf, "shutdown, flushing sendbuf");
1274 result = Curl_cf_ngtcp2_progress_egress(cf, data, &pktx);
1275 if(!Curl_bufq_is_empty(&ctx->q.sendbuf)) {
1276 CURL_TRC_CF(data, cf, "sending shutdown packets blocked");
1277 result = CURLE_OK;
1278 goto out;
1280 else if(result) {
1281 CURL_TRC_CF(data, cf, "shutdown, error %d flushing sendbuf",
1282 (int)result);
1283 *done = TRUE;
1284 goto out;
1288 DEBUGASSERT(Curl_bufq_is_empty(&ctx->q.sendbuf));
1289 ctx->shutdown_started = TRUE;
1290 nwritten = ngtcp2_conn_write_connection_close(
1291 ctx->qconn, NULL, /* path */
1292 NULL, /* pkt_info */
1293 (uint8_t *)buffer, sizeof(buffer),
1294 &ctx->last_error, pktx.ts);
1295 CURL_TRC_CF(data, cf, "start shutdown(err_type=%d, err_code=%"
1296 PRIu64 ") -> %zd", (int)ctx->last_error.type,
1297 ctx->last_error.error_code, (ssize_t)nwritten);
1298 /* there are cases listed in ngtcp2 documentation where this call
1299 * may fail. Since we are doing a connection shutdown as graceful
1300 * as we can, such an error is ignored here. */
1301 if(nwritten > 0) {
1302 /* Ignore amount written. sendbuf was empty and has always room for
1303 * NGTCP2_MAX_UDP_PAYLOAD_SIZE. It can only completely fail, in which
1304 * case `result` is set non zero. */
1305 size_t n;
1306 result = Curl_bufq_write(&ctx->q.sendbuf, (const unsigned char *)buffer,
1307 (size_t)nwritten, &n);
1308 if(result) {
1309 CURL_TRC_CF(data, cf, "error %d adding shutdown packets to sendbuf, "
1310 "aborting shutdown", (int)result);
1311 goto out;
1314 ctx->q.no_gso = TRUE;
1315 ctx->q.gsolen = (size_t)nwritten;
1316 ctx->q.split_len = 0;
1320 if(!Curl_bufq_is_empty(&ctx->q.sendbuf)) {
1321 CURL_TRC_CF(data, cf, "shutdown, flushing egress");
1322 result = Curl_vquic_flush(cf, data, &ctx->q);
1323 if(result == CURLE_AGAIN) {
1324 CURL_TRC_CF(data, cf, "sending shutdown packets blocked");
1325 result = CURLE_OK;
1326 goto out;
1328 else if(result) {
1329 CURL_TRC_CF(data, cf, "shutdown, error %d flushing sendbuf",
1330 (int)result);
1331 *done = TRUE;
1332 goto out;
1336 if(Curl_bufq_is_empty(&ctx->q.sendbuf)) {
1337 /* Sent everything off. ngtcp2 seems to have no support for graceful
1338 * shutdowns. We are done. */
1339 CURL_TRC_CF(data, cf, "shutdown completely sent off, done");
1340 *done = TRUE;
1341 result = CURLE_OK;
1343out:
1344 CF_DATA_RESTORE(cf, save);
1345 return result;
1348void Curl_cf_ngtcp2_cmn_conn_close(struct Curl_cfilter *cf,
1349 struct Curl_easy *data)
1351 bool done;
1352 Curl_cf_ngtcp2_cmn_shutdown(cf, data, &done);
1355static bool cf_ngtcp2_err_is_fatal(int code)
1357 return (NGTCP2_ERR_FATAL >= code) ||
1358 (NGTCP2_ERR_DROP_CONN == code) ||
1359 (NGTCP2_ERR_IDLE_CLOSE == code);
1362void Curl_cf_ngtcp2_cmn_err_set(struct Curl_cfilter *cf,
1363 struct Curl_easy *data, int code)
1365 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1366 if(!ctx->last_error.error_code) {
1367 if(NGTCP2_ERR_CRYPTO == code) {
1368 ngtcp2_ccerr_set_tls_alert(&ctx->last_error,
1369 ngtcp2_conn_get_tls_alert(ctx->qconn),
1370 NULL, 0);
1372 else {
1373 ngtcp2_ccerr_set_liberr(&ctx->last_error, code, NULL, 0);
1376 if(cf_ngtcp2_err_is_fatal(code))
1377 Curl_cf_ngtcp2_cmn_conn_close(cf, data);
1380void Curl_cf_ngtcp2_io_ctx_init(struct cf_ngtcp2_io_ctx *io_ctx,
1381 struct Curl_cfilter *cf,
1382 struct Curl_easy *data)
1384 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1386 io_ctx->cf = cf;
1387 io_ctx->data = data;
1388 io_ctx->now = *Curl_pgrs_now(data);
1389 ngtcp2_path_storage_zero(&io_ctx->ps);
1390 Curl_vquic_ctx_set_time(&ctx->q, &io_ctx->now);
1391 io_ctx->ts = ((ngtcp2_tstamp)io_ctx->now.tv_sec * NGTCP2_SECONDS) +
1392 ((ngtcp2_tstamp)io_ctx->now.tv_usec * NGTCP2_MICROSECONDS);
1395void Curl_cf_ngtcp2_io_ctx_update_time(struct Curl_easy *data,
1396 struct cf_ngtcp2_io_ctx *io_ctx,
1397 struct Curl_cfilter *cf)
1399 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1401 io_ctx->now = *Curl_pgrs_now(data);
1402 Curl_vquic_ctx_update_time(&ctx->q, &io_ctx->now);
1403 io_ctx->ts = ((ngtcp2_tstamp)io_ctx->now.tv_sec * NGTCP2_SECONDS) +
1404 ((ngtcp2_tstamp)io_ctx->now.tv_usec * NGTCP2_MICROSECONDS);
1407#if NGTCP2_VERSION_NUM < 0x011100
1408struct cf_ngtcp2_sfind_ctx {
1409 int64_t stream_id;
1410 struct h3_stream_ctx *stream;
1411 uint32_t mid;
1414static bool cf_ngtcp2_sfind(uint32_t mid, void *value, void *user_data)
1416 struct cf_ngtcp2_sfind_ctx *fctx = user_data;
1417 struct h3_stream_ctx *stream = value;
1419 if(fctx->stream_id == stream->id) {
1420 fctx->mid = mid;
1421 fctx->stream = stream;
1422 return FALSE;
1424 return TRUE; /* continue */
1427static struct h3_stream_ctx *cf_ngtcp2_get_stream(struct cf_ngtcp2_ctx *ctx,
1428 int64_t stream_id)
1430 struct cf_ngtcp2_sfind_ctx fctx;
1431 fctx.stream_id = stream_id;
1432 fctx.stream = NULL;
1433 Curl_u32_ptrset_visit(&ctx->streams, cf_ngtcp2_sfind, &fctx);
1434 return fctx.stream;
1436#else
1437static struct h3_stream_ctx *cf_ngtcp2_get_stream(struct cf_ngtcp2_ctx *ctx,
1438 int64_t stream_id)
1440 return ngtcp2_conn_get_stream_user_data(ctx->qconn, stream_id);
1442#endif
1444/**
1445 * Read a network packet to send from ngtcp2 into `buf`.
1446 * Return number of bytes written or -1 with *err set.
1447 */
1448static CURLcode read_pkt_to_send(void *userp,
1449 unsigned char *buf, size_t buflen,
1450 size_t *pnread)
1452 struct cf_ngtcp2_io_ctx *x = userp;
1453 struct cf_ngtcp2_ctx *ctx = x->cf->ctx;
1454 nghttp3_vec vec[16];
1455 nghttp3_ssize veccnt;
1456 ngtcp2_ssize ndatalen;
1457 uint32_t flags;
1458 int64_t stream_id;
1459 int fin;
1460 ssize_t n;
1462 *pnread = 0;
1463 veccnt = 0;
1464 stream_id = -1;
1465 fin = 0;
1467 /* ngtcp2 may want to put several frames from different streams into
1468 * this packet. `NGTCP2_WRITE_STREAM_FLAG_MORE` tells it to do so.
1469 * When `NGTCP2_ERR_WRITE_MORE` is returned, we *need* to make
1470 * another iteration.
1471 * When ngtcp2 is happy (because it has no other frame that would fit
1472 * or it has nothing more to send), it returns the total length
1473 * of the assembled packet. This may be 0 if there was nothing to send. */
1474 for(;;) {
1476 if(ctx->h3conn && ngtcp2_conn_get_max_data_left(ctx->qconn)) {
1477 veccnt = nghttp3_conn_writev_stream(ctx->h3conn, &stream_id, &fin, vec,
1478 CURL_ARRAYSIZE(vec));
1479 if(veccnt < 0) {
1480 failf(x->data, "nghttp3_conn_writev_stream returned error: %s",
1481 nghttp3_strerror((int)veccnt));
1482 Curl_cf_ngtcp2_h3_err_set(x->cf, x->data, (int)veccnt);
1483 return CURLE_SEND_ERROR;
1487 flags = NGTCP2_WRITE_STREAM_FLAG_MORE |
1488 (fin ? NGTCP2_WRITE_STREAM_FLAG_FIN : 0);
1489 n = ngtcp2_conn_writev_stream(ctx->qconn, &x->ps.path,
1490 NULL, buf, buflen,
1491 &ndatalen, flags, stream_id,
1492 (const ngtcp2_vec *)vec, veccnt, x->ts);
1493 if(n == 0) {
1494 /* nothing to send */
1495 return CURLE_AGAIN;
1497 else if(n < 0) {
1498 switch(n) {
1499 case NGTCP2_ERR_STREAM_DATA_BLOCKED: {
1500 struct h3_stream_ctx *stream;
1501 DEBUGASSERT(ndatalen == -1);
1502 nghttp3_conn_block_stream(ctx->h3conn, stream_id);
1503 CURL_TRC_CF(x->data, x->cf, "[%" PRId64 "] block quic flow",
1504 stream_id);
1505 stream = cf_ngtcp2_get_stream(ctx, stream_id);
1506 if(stream) /* it might be not one of our h3 streams? */
1507 stream->quic_flow_blocked = TRUE;
1508 n = 0;
1509 break;
1511 case NGTCP2_ERR_STREAM_SHUT_WR:
1512 DEBUGASSERT(ndatalen == -1);
1513 nghttp3_conn_shutdown_stream_write(ctx->h3conn, stream_id);
1514 n = 0;
1515 break;
1516 case NGTCP2_ERR_WRITE_MORE:
1517 /* ngtcp2 wants to send more. update the flow of the stream whose data
1518 * is in the buffer and continue */
1519 DEBUGASSERT(ndatalen >= 0);
1520 n = 0;
1521 break;
1522 default:
1523 DEBUGASSERT(ndatalen == -1);
1524 failf(x->data, "ngtcp2_conn_writev_stream returned error: %s",
1525 ngtcp2_strerror((int)n));
1526 Curl_cf_ngtcp2_cmn_err_set(x->cf, x->data, (int)n);
1527 return CURLE_SEND_ERROR;
1531 if(ndatalen >= 0) {
1532 /* we add the amount of data bytes to the flow windows */
1533 int rv = nghttp3_conn_add_write_offset(ctx->h3conn, stream_id, ndatalen);
1534 if(rv) {
1535 failf(x->data, "nghttp3_conn_add_write_offset returned error: %s",
1536 nghttp3_strerror(rv));
1537 return CURLE_SEND_ERROR;
1541 if(n > 0) {
1542 /* packet assembled, leave */
1543 *pnread = (size_t)n;
1544 return CURLE_OK;
1549CURLcode Curl_cf_ngtcp2_progress_egress(struct Curl_cfilter *cf,
1550 struct Curl_easy *data,
1551 struct cf_ngtcp2_io_ctx *pktx)
1553 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1554 size_t nread;
1555 size_t max_payload_size, path_max_payload_size;
1556 size_t pktcnt = 0;
1557 size_t gsolen = 0; /* this disables gso until we have a clue */
1558 size_t send_quantum;
1559 CURLcode result;
1560 struct cf_ngtcp2_io_ctx local_pktx;
1562 if(!pktx) {
1563 Curl_cf_ngtcp2_io_ctx_init(&local_pktx, cf, data);
1564 pktx = &local_pktx;
1566 else {
1567 Curl_cf_ngtcp2_io_ctx_update_time(data, pktx, cf);
1568 ngtcp2_path_storage_zero(&pktx->ps);
1571 result = Curl_vquic_flush(cf, data, &ctx->q);
1572 if(result) {
1573 if(result == CURLE_AGAIN) {
1574 Curl_expire_set(data, EXPIRE_QUIC, 1, &pktx->now);
1575 return CURLE_OK;
1577 return result;
1580 /* In UDP, there is a maximum theoretical packet payload length and
1581 * a minimum payload length that is "guaranteed" to work.
1582 * To detect if this minimum payload can be increased, ngtcp2 sends
1583 * now and then a packet payload larger than the minimum. It that
1584 * is ACKed by the peer, both parties know that it works and
1585 * the subsequent packets can use a larger one.
1586 * This is called PMTUD (Path Maximum Transmission Unit Discovery).
1587 * Since a PMTUD might be rejected right on send, we do not want it
1588 * be followed by other packets of lesser size. Because those would
1589 * also fail then. If we detect a PMTUD while buffering, we flush.
1590 */
1591 max_payload_size = ngtcp2_conn_get_max_tx_udp_payload_size(ctx->qconn);
1592 path_max_payload_size =
1593 ngtcp2_conn_get_path_max_tx_udp_payload_size(ctx->qconn);
1594 send_quantum = ngtcp2_conn_get_send_quantum(ctx->qconn);
1595 CURL_TRC_CF(data, cf, "egress, collect and send packets, quantum=%zu",
1596 send_quantum);
1597 for(;;) {
1598 /* add the next packet to send, if any, to our buffer */
1599 result = Curl_bufq_sipn(&ctx->q.sendbuf, max_payload_size,
1600 read_pkt_to_send, pktx, &nread);
1601 if(result == CURLE_AGAIN)
1602 break;
1603 else if(result)
1604 return result;
1605 else {
1606 size_t buflen = Curl_bufq_len(&ctx->q.sendbuf);
1607 if((buflen >= send_quantum) ||
1608 ((buflen + gsolen) >= ctx->q.sendbuf.chunk_size))
1609 break;
1610 DEBUGASSERT(nread > 0);
1611 ++pktcnt;
1612 if(pktcnt == 1) {
1613 /* first packet in buffer. This is either of a known, "good"
1614 * payload size or it is a PMTUD. We shall see. */
1615 gsolen = nread;
1617 else if(nread > gsolen ||
1618 (gsolen > path_max_payload_size && nread != gsolen)) {
1619 /* The added packet is a PMTUD *or* the one(s) before the added were
1620 * PMTUD and the last one is smaller. Flush the buffer before the last
1621 * add. */
1622 result = Curl_vquic_send_tail_split(cf, data, &ctx->q,
1623 gsolen, nread, nread);
1624 if(result) {
1625 if(result == CURLE_AGAIN) {
1626 Curl_expire_set(data, EXPIRE_QUIC, 1, &pktx->now);
1627 return CURLE_OK;
1629 return result;
1631 pktcnt = 0;
1633 else if(nread < gsolen) {
1634 /* Reached capacity of our buffer *or*
1635 * last add was shorter than the previous ones, flush */
1636 break;
1641 if(!Curl_bufq_is_empty(&ctx->q.sendbuf)) {
1642 /* time to send */
1643 CURL_TRC_CF(data, cf, "egress, send collected %zu packets in %zu bytes",
1644 pktcnt, Curl_bufq_len(&ctx->q.sendbuf));
1645 result = Curl_vquic_send(cf, data, &ctx->q, gsolen);
1646 if(result) {
1647 if(result == CURLE_AGAIN) {
1648 Curl_expire_set(data, EXPIRE_QUIC, 1, &pktx->now);
1649 return CURLE_OK;
1651 return result;
1653 Curl_cf_ngtcp2_io_ctx_update_time(data, pktx, cf);
1654 ngtcp2_conn_update_pkt_tx_time(ctx->qconn, pktx->ts);
1656 return CURLE_OK;
1659struct cf_ngtcp2_recv_ctx {
1660 struct cf_ngtcp2_io_ctx *pktx;
1661 size_t pkt_count;
1664static CURLcode cf_ngtcp2_recv_pkts(const unsigned char *buf, size_t buflen,
1665 size_t gso_size,
1666 struct sockaddr_storage *remote_addr,
1667 socklen_t remote_addrlen, uint8_t ecn,
1668 void *userp)
1670 struct cf_ngtcp2_recv_ctx *rctx = userp;
1671 struct cf_ngtcp2_io_ctx *pktx = rctx->pktx;
1672 struct cf_ngtcp2_ctx *ctx = pktx->cf->ctx;
1673 ngtcp2_pkt_info pi;
1674 ngtcp2_path path;
1675 size_t offset, pktlen;
1676 int rv;
1678 if(!rctx->pkt_count) {
1679 Curl_cf_ngtcp2_io_ctx_update_time(pktx->data, pktx, pktx->cf);
1680 ngtcp2_path_storage_zero(&pktx->ps);
1683 if(ecn)
1684 CURL_TRC_CF(pktx->data, pktx->cf, "vquic_recv(len=%zu, gso=%zu, ecn=%x)",
1685 buflen, gso_size, (unsigned)ecn);
1686 ngtcp2_addr_init(&path.local, (struct sockaddr *)&ctx->q.local_addr,
1687 ctx->q.local_addrlen);
1688 ngtcp2_addr_init(&path.remote, (struct sockaddr *)remote_addr,
1689 remote_addrlen);
1690 pi.ecn = (uint8_t)ecn;
1692 for(offset = 0; offset < buflen; offset += gso_size) {
1693 rctx->pkt_count++;
1694 pktlen = ((offset + gso_size) <= buflen) ? gso_size : (buflen - offset);
1695 rv = ngtcp2_conn_read_pkt(ctx->qconn, &path, &pi,
1696 buf + offset, pktlen, pktx->ts);
1697 if(rv) {
1698 CURL_TRC_CF(pktx->data, pktx->cf, "ingress, read_pkt -> %s (%d)",
1699 ngtcp2_strerror(rv), rv);
1700 Curl_cf_ngtcp2_cmn_err_set(pktx->cf, pktx->data, rv);
1702 if(rv == NGTCP2_ERR_CRYPTO)
1703 /* this is a "TLS problem", but a failed certificate verification
1704 is a common reason for this */
1705 return CURLE_PEER_FAILED_VERIFICATION;
1706 return CURLE_RECV_ERROR;
1709 return CURLE_OK;
1712CURLcode Curl_cf_ngtcp2_progress_ingress(struct Curl_cfilter *cf,
1713 struct Curl_easy *data,
1714 struct cf_ngtcp2_io_ctx *pktx)
1716 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1717 struct cf_ngtcp2_io_ctx local_pktx;
1718 struct cf_ngtcp2_recv_ctx rctx;
1719 CURLcode result = CURLE_OK;
1721 if(!pktx) {
1722 Curl_cf_ngtcp2_io_ctx_init(&local_pktx, cf, data);
1723 pktx = &local_pktx;
1726 result = Curl_vquic_tls_before_recv(&ctx->tls, cf, data);
1727 if(result)
1728 return result;
1730 rctx.pktx = pktx;
1731 rctx.pkt_count = 0;
1733 if(ctx->q.sockfd != CURL_SOCKET_BAD) {
1734 /* Direct UDP socket (via happy eyeballs) */
1735 CURL_TRC_CF(data, cf, "progress_ingress(socket)");
1736 return Curl_vquic_recv_packets(cf, data, &ctx->q, 1000,
1737 cf_ngtcp2_recv_pkts, &rctx);
1739 else {
1740 /* Tunneled QUIC (CONNECT-UDP through proxy) */
1741 unsigned char *buf;
1742 size_t max_udp_payload = QUIC_TUNNEL_INBUF_SIZE;
1743 size_t pkt_limit = QUIC_TUNNEL_INGRESS_PKT_LIMIT;
1744 size_t nread;
1745 struct sockaddr_storage remote_addr;
1746 socklen_t remote_addrlen;
1748 CURL_TRC_CF(data, cf, "progress_ingress(sub-filters)");
1749 if(ctx->qconn) {
1750 size_t max_path_payload;
1751 max_path_payload =
1752 ngtcp2_conn_get_path_max_tx_udp_payload_size(ctx->qconn);
1753 if(max_path_payload > max_udp_payload)
1754 max_udp_payload = max_path_payload;
1757 if(ctx->tunnel_inbuf_len < max_udp_payload) {
1758 unsigned char *newbuf = curlx_realloc(ctx->tunnel_inbuf,
1759 max_udp_payload);
1760 if(!newbuf)
1761 return CURLE_OUT_OF_MEMORY;
1762 ctx->tunnel_inbuf = newbuf;
1763 ctx->tunnel_inbuf_len = max_udp_payload;
1765 buf = ctx->tunnel_inbuf;
1767 while(pkt_limit--) {
1768 result = Curl_conn_cf_recv(cf->next, data, (char *)buf,
1769 ctx->tunnel_inbuf_len, &nread);
1770 if(result == CURLE_AGAIN) {
1771 /* no more data available at the moment */
1772 return CURLE_OK;
1774 if(result) {
1775 CURL_TRC_CF(data, cf, "ingress, recv from tunnel failed: %d",
1776 (int)result);
1777 return result;
1779 if(nread == 0) {
1780 /* tunnel closed */
1781 return CURLE_OK;
1784 memcpy(&remote_addr, ctx->connected_path.remote.addr,
1785 ctx->connected_path.remote.addrlen);
1786 remote_addrlen = (socklen_t)ctx->connected_path.remote.addrlen;
1787 result = cf_ngtcp2_recv_pkts(buf, nread, nread, &remote_addr,
1788 remote_addrlen, 0, &rctx);
1789 if(result)
1790 return result;
1792 if(!ctx->q.got_first_byte) {
1793 ctx->q.got_first_byte = TRUE;
1794 ctx->q.first_byte_at = ctx->q.last_op;
1796 ctx->q.last_io = ctx->q.last_op;
1798 return CURLE_OK;
1802/**
1803 * Connection maintenance like timeouts on packet ACKs etc. are done by us, not
1804 * the OS like for TCP. POLL events on the socket therefore are not
1805 * sufficient.
1806 * ngtcp2 tells us when it wants to be invoked again. We handle that via
1807 * the `Curl_expire()` mechanisms.
1808 */
1809CURLcode Curl_cf_ngtcp2_cmn_set_expiry(struct Curl_cfilter *cf,
1810 struct Curl_easy *data,
1811 struct cf_ngtcp2_io_ctx *pktx)
1813 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1814 struct cf_ngtcp2_io_ctx local_pktx;
1815 ngtcp2_tstamp expiry;
1817 if(!pktx) {
1818 Curl_cf_ngtcp2_io_ctx_init(&local_pktx, cf, data);
1819 pktx = &local_pktx;
1821 else {
1822 Curl_cf_ngtcp2_io_ctx_update_time(data, pktx, cf);
1825 expiry = ngtcp2_conn_get_expiry(ctx->qconn);
1826 if(expiry != UINT64_MAX) {
1827 if(expiry <= pktx->ts) {
1828 CURLcode result;
1829 int rv = ngtcp2_conn_handle_expiry(ctx->qconn, pktx->ts);
1830 if(rv) {
1831 failf(data, "ngtcp2_conn_handle_expiry returned error: %s",
1832 ngtcp2_strerror(rv));
1833 Curl_cf_ngtcp2_cmn_err_set(cf, data, rv);
1834 return CURLE_SEND_ERROR;
1836 result = Curl_cf_ngtcp2_progress_ingress(cf, data, pktx);
1837 if(!result)
1838 result = Curl_cf_ngtcp2_progress_egress(cf, data, pktx);
1839 if(result) {
1840 /* a verify failure during ingress must win over generic errors */
1841 if(ctx->tls_vrfy_result)
1842 result = ctx->tls_vrfy_result;
1843 return result;
1845 /* ask again, things might have changed */
1846 expiry = ngtcp2_conn_get_expiry(ctx->qconn);
1849 if(expiry > pktx->ts) {
1850 ngtcp2_duration timeout = expiry - pktx->ts;
1851 if(timeout % NGTCP2_MILLISECONDS) {
1852 timeout += NGTCP2_MILLISECONDS;
1854 Curl_expire_set(data, EXPIRE_QUIC,
1855 (timediff_t)(timeout / NGTCP2_MILLISECONDS),
1856 &pktx->now);
1859 return CURLE_OK;
1862static void cf_ngtcp2_setup_keep_alive(struct Curl_cfilter *cf,
1863 struct Curl_easy *data)
1865 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1866 const ngtcp2_transport_params *rp;
1867 /* Peer should have sent us its transport parameters. If it
1868 * announces a positive `max_idle_timeout` it closes the
1869 * connection when it does not hear from us for that time.
1871 * Some servers use this as a keep-alive timer at a rather low
1872 * value. We are doing HTTP/3 here and waiting for the response
1873 * to a request may take a considerable amount of time. We need
1874 * to prevent the peer's QUIC stack from closing in this case.
1875 */
1876 if(!ctx->qconn)
1877 return;
1879 rp = ngtcp2_conn_get_remote_transport_params(ctx->qconn);
1880 if(!rp || !rp->max_idle_timeout) {
1881 ngtcp2_conn_set_keep_alive_timeout(ctx->qconn, UINT64_MAX);
1882 CURL_TRC_CF(data, cf, "no peer idle timeout, unset keep-alive");
1884 else if(!Curl_u32_ptrset_count(&ctx->streams)) {
1885 ngtcp2_conn_set_keep_alive_timeout(ctx->qconn, UINT64_MAX);
1886 CURL_TRC_CF(data, cf, "no active streams, unset keep-alive");
1888 else {
1889 ngtcp2_duration keep_ns;
1890 keep_ns = (rp->max_idle_timeout > 1) ? (rp->max_idle_timeout / 2) : 1;
1891 ngtcp2_conn_set_keep_alive_timeout(ctx->qconn, keep_ns);
1892 CURL_TRC_CF(data, cf, "peer idle timeout is %" PRIu64 "ms, "
1893 "set keep-alive to %" PRIu64 " ms.",
1894 (rp->max_idle_timeout / NGTCP2_MILLISECONDS),
1895 (keep_ns / NGTCP2_MILLISECONDS));
1899CURLcode Curl_cf_ngtcp2_h3_stream_setup(struct Curl_cfilter *cf,
1900 struct Curl_easy *data,
1901 struct h3_stream_ctx **pstream)
1903 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1904 struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
1906 *pstream = NULL;
1907 if(!data)
1908 return CURLE_FAILED_INIT;
1910 if(stream) {
1911 *pstream = stream;
1912 return CURLE_OK;
1915 stream = curlx_calloc(1, sizeof(*stream));
1916 if(!stream)
1917 return CURLE_OUT_OF_MEMORY;
1919 stream->id = -1;
1920 stream->xfer_id = data->id;
1921 stream->mid = data->mid;
1922 stream->rx_offset = 0;
1923 stream->rx_offset_max = H3_STREAM_WINDOW_SIZE_INITIAL;
1924 stream->tx_in_flight_ideal = H3_STREAM_SEND_BUF_INITIAL;
1926 /* on send, we control how much we put into the buffer */
1927 Curl_bufq_initp(&stream->sendbuf, &ctx->stream_bufcp,
1928 H3_STREAM_SEND_CHUNKS, BUFQ_OPT_NONE);
1929 stream->tx_in_flight_size = 0;
1930 Curl_h1_req_parse_init(&stream->h1, H1_PARSE_DEFAULT_MAX_LINE_LEN);
1932 if(Curl_u32_ptrset_set(&ctx->streams, data->mid, stream)) {
1933 Curl_cf_ngtcp2_h3_stream_ctx_free(stream);
1934 return CURLE_OUT_OF_MEMORY;
1937 if(Curl_u32_ptrset_count(&ctx->streams) == 1)
1938 cf_ngtcp2_setup_keep_alive(cf, data);
1940 *pstream = stream;
1941 return CURLE_OK;
1944void Curl_cf_ngtcp2_h3_stream_close(struct Curl_cfilter *cf,
1945 struct Curl_easy *data,
1946 struct h3_stream_ctx *stream)
1948 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1949 DEBUGASSERT(data);
1950 DEBUGASSERT(stream);
1951 if(!stream->closed && ctx->qconn && ctx->h3conn) {
1952 CURLcode result;
1954 nghttp3_conn_set_stream_user_data(ctx->h3conn, stream->id, NULL);
1955 ngtcp2_conn_set_stream_user_data(ctx->qconn, stream->id, NULL);
1956 stream->closed = TRUE;
1957 (void)ngtcp2_conn_shutdown_stream(ctx->qconn, 0, stream->id,
1958 NGHTTP3_H3_REQUEST_CANCELLED);
1959 result = Curl_cf_ngtcp2_progress_egress(cf, data, NULL);
1960 if(result)
1961 CURL_TRC_CF(data, cf, "[%" PRId64 "] cancel stream -> %d",
1962 stream->id, (int)result);
1966void Curl_cf_ngtcp2_h3_stream_done(struct Curl_cfilter *cf,
1967 struct Curl_easy *data)
1969 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1970 struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
1971 (void)cf;
1972 if(stream) {
1973 CURL_TRC_CF(data, cf, "[%" PRId64 "] easy handle is done", stream->id);
1974 Curl_cf_ngtcp2_h3_stream_close(cf, data, stream);
1975 Curl_u32_ptrset_unset(&ctx->streams, data->mid);
1976 if(!Curl_u32_ptrset_count(&ctx->streams))
1977 cf_ngtcp2_setup_keep_alive(cf, data);
1981bool Curl_cf_ngtcp2_cmn_conn_is_alive(struct Curl_cfilter *cf,
1982 struct Curl_easy *data,
1983 bool *input_pending)
1985 struct cf_ngtcp2_ctx *ctx = cf->ctx;
1986 bool alive = FALSE;
1987 const ngtcp2_transport_params *rp;
1988 struct cf_call_data save;
1990 CF_DATA_SAVE(save, cf, data);
1991 *input_pending = FALSE;
1992 if(!ctx->qconn || ctx->shutdown_started)
1993 goto out;
1995 /* We do not announce a max idle timeout, but when the peer does
1996 * it closes the connection when it expires. */
1997 rp = ngtcp2_conn_get_remote_transport_params(ctx->qconn);
1998 if(rp && rp->max_idle_timeout) {
1999 timediff_t idletime_ms =
2000 curlx_ptimediff_ms(Curl_pgrs_now(data), &ctx->q.last_io);
2001 if(idletime_ms > 0) {
2002 uint64_t max_idle_ms =
2003 (uint64_t)(rp->max_idle_timeout / NGTCP2_MILLISECONDS);
2004 if((uint64_t)idletime_ms > max_idle_ms)
2005 goto out;
2009 if(!cf->next || !cf->next->cft->is_alive(cf->next, data, input_pending))
2010 goto out;
2012 alive = TRUE;
2013 if(*input_pending) {
2014 CURLcode result;
2015 /* This happens before we have sent off a request and the connection is
2016 not in use by any other transfer, there should not be any data here,
2017 only "protocol frames" */
2018 *input_pending = FALSE;
2019 result = Curl_cf_ngtcp2_progress_ingress(cf, data, NULL);
2020 CURL_TRC_CF(data, cf, "is_alive, progress ingress -> %d", (int)result);
2021 alive = result ? FALSE : TRUE;
2024out:
2025 CF_DATA_RESTORE(cf, save);
2026 return alive;
2029CURLcode Curl_cf_ngtcp2_h3_init_ctrls(struct cf_ngtcp2_ctx *ctx,
2030 struct Curl_easy *data)
2032 int64_t ctrl_stream_id, qpack_enc_stream_id, qpack_dec_stream_id;
2033 int rc;
2035 rc = ngtcp2_conn_open_uni_stream(ctx->qconn, &ctrl_stream_id, NULL);
2036 if(rc) {
2037 failf(data, "error creating HTTP/3 control stream: %s",
2038 ngtcp2_strerror(rc));
2039 return CURLE_QUIC_CONNECT_ERROR;
2041 rc = nghttp3_conn_bind_control_stream(ctx->h3conn, ctrl_stream_id);
2042 if(rc) {
2043 failf(data, "error binding HTTP/3 control stream: %s",
2044 ngtcp2_strerror(rc));
2045 return CURLE_QUIC_CONNECT_ERROR;
2047 rc = ngtcp2_conn_open_uni_stream(ctx->qconn, &qpack_enc_stream_id, NULL);
2048 if(rc) {
2049 failf(data, "error creating HTTP/3 qpack encoding stream: %s",
2050 ngtcp2_strerror(rc));
2051 return CURLE_QUIC_CONNECT_ERROR;
2053 rc = ngtcp2_conn_open_uni_stream(ctx->qconn, &qpack_dec_stream_id, NULL);
2054 if(rc) {
2055 failf(data, "error creating HTTP/3 qpack decoding stream: %s",
2056 ngtcp2_strerror(rc));
2057 return CURLE_QUIC_CONNECT_ERROR;
2059 rc = nghttp3_conn_bind_qpack_streams(ctx->h3conn, qpack_enc_stream_id,
2060 qpack_dec_stream_id);
2061 if(rc) {
2062 failf(data, "error binding HTTP/3 qpack streams: %s", ngtcp2_strerror(rc));
2063 return CURLE_QUIC_CONNECT_ERROR;
2065 return CURLE_OK;
2068CURLcode Curl_cf_ngtcp2_cmn_query(struct Curl_cfilter *cf,
2069 struct Curl_easy *data,
2070 int query, int *pres1, void *pres2)
2072 struct cf_ngtcp2_ctx *ctx = cf->ctx;
2074 switch(query) {
2075 case CF_QUERY_CONNECT_REPLY_MS:
2076 if((ctx->q.sockfd != CURL_SOCKET_BAD) && ctx->q.got_first_byte) {
2077 timediff_t ms = curlx_ptimediff_ms(&ctx->q.first_byte_at,
2078 &ctx->started_at);
2079 *pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
2080 return CURLE_OK;
2082 break;
2083 case CF_QUERY_REALLY_CONNECTED:
2084 if(ctx->q.sockfd != CURL_SOCKET_BAD) {
2085 *pres1 = ctx->q.got_first_byte;
2086 return CURLE_OK;
2088 break;
2089 default:
2090 break;
2092 return cf->next ?
2093 cf->next->cft->query(cf->next, data, query, pres1, pres2) :
2094 CURLE_UNKNOWN_OPTION;
2097CURLcode Curl_cf_ngtcp2_cmn_cntrl(struct Curl_cfilter *cf,
2098 struct Curl_easy *data,
2099 int event, int arg1, void *arg2)
2101 struct cf_ngtcp2_ctx *ctx = cf->ctx;
2102 CURLcode result = CURLE_OK;
2104 (void)arg1;
2105 (void)arg2;
2106 switch(event) {
2107 case CF_CTRL_REPORT_STATS:
2108 if(cf->connected && !ctx->stats_reported) {
2109 if((cf->cft->flags & CF_TYPE_PROXY) &&
2110 (ctx->q.sockfd != CURL_SOCKET_BAD) && ctx->q.got_first_byte) {
2111 Curl_pgrsTimeWas(data, TIMER_CONNECT, ctx->q.first_byte_at);
2112 ctx->stats_reported = TRUE;
2114 else if(ctx->handshake_at.tv_sec || ctx->handshake_at.tv_usec) {
2115 if(ctx->q.sockfd != CURL_SOCKET_BAD)
2116 Curl_pgrsTimeWas(data, TIMER_CONNECT, ctx->q.first_byte_at);
2117 Curl_pgrsTimeWas(data, TIMER_APPCONNECT, ctx->handshake_at);
2118 ctx->stats_reported = TRUE;
2121 break;
2122 default:
2123 break;
2125 return result;
2128#endif /* !CURL_DISABLE_HTTP && USE_NGTCP2 && USE_NGHTTP3 */
Diagnostics4 git calls · 163 ms
CallStatusSizeTime0163 ms
discover200152 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=152
git.server.agent=gitty/1.0
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch object-format
git.server.fetch=shallow filter sideband-all
git.protocol.version=2
git.pkt.frames=8
git.pkt.data=6
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=152
git.pkt.payload.max=34
ls-refs200149 B · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=149
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=149
git.pkt.payload.max=78
git.ls_refs.count=2
git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=293470
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=blob:none
git.fetch.filter.requested=tree:0
git.fetch.filter.fallback=blob:none
git.fetch.filter.learned=false
git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=10
git.pkt.data=8
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=293470
git.pkt.payload.max=65516
git.sideband.band1.bytes=293354
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=87
git.pack.bytes=293354
git.pack.ofs_delta=0
git.pack.ref_delta=1
git.pack.chain.max=1
git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0
git.pack.full=86
Open pack map
fetch20018 KiB157 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=157
git.response.bytes=18785
git.response.cache=MISS
git.response.duration_ms=157
git.fetch.wants=12a4d2b06b19d3fd127ed191a2804eb50821b2f9
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=18785
git.pkt.payload.max=18764
git.sideband.band1.bytes=18763
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
Ref
refs/heads/master
Commit
31c911efe5652725e930f4d2e60c9060e5f6646d
cf-ray
a5e3876b6c22a691
Request
207b0580…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format