Annotation of embedaddon/curl/lib/vquic/ngtcp2.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, 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.haxx.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: ***************************************************************************/
! 22:
! 23: #include "curl_setup.h"
! 24:
! 25: #ifdef USE_NGTCP2
! 26: #include <ngtcp2/ngtcp2.h>
! 27: #include <ngtcp2/ngtcp2_crypto.h>
! 28: #include <nghttp3/nghttp3.h>
! 29: #ifdef USE_OPENSSL
! 30: #include <openssl/err.h>
! 31: #endif
! 32: #include "urldata.h"
! 33: #include "sendf.h"
! 34: #include "strdup.h"
! 35: #include "rand.h"
! 36: #include "ngtcp2.h"
! 37: #include "multiif.h"
! 38: #include "strcase.h"
! 39: #include "connect.h"
! 40: #include "strerror.h"
! 41:
! 42: /* The last 3 #include files should be in this order */
! 43: #include "curl_printf.h"
! 44: #include "curl_memory.h"
! 45: #include "memdebug.h"
! 46:
! 47: /* #define DEBUG_NGTCP2 */
! 48: #ifdef CURLDEBUG
! 49: #define DEBUG_HTTP3
! 50: #endif
! 51: #ifdef DEBUG_HTTP3
! 52: #define H3BUGF(x) x
! 53: #else
! 54: #define H3BUGF(x) do { } while(0)
! 55: #endif
! 56:
! 57: /*
! 58: * This holds outgoing HTTP/3 stream data that is used by nghttp3 until acked.
! 59: * It is used as a circular buffer. Add new bytes at the end until it reaches
! 60: * the far end, then start over at index 0 again.
! 61: */
! 62:
! 63: #define H3_SEND_SIZE (20*1024)
! 64: struct h3out {
! 65: uint8_t buf[H3_SEND_SIZE];
! 66: size_t used; /* number of bytes used in the buffer */
! 67: size_t windex; /* index in the buffer where to start writing the next
! 68: data block */
! 69: };
! 70:
! 71: #define QUIC_MAX_STREAMS (256*1024)
! 72: #define QUIC_MAX_DATA (1*1024*1024)
! 73: #define QUIC_IDLE_TIMEOUT 60000 /* milliseconds */
! 74:
! 75: #ifdef USE_OPENSSL
! 76: #define QUIC_CIPHERS \
! 77: "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_" \
! 78: "POLY1305_SHA256:TLS_AES_128_CCM_SHA256"
! 79: #define QUIC_GROUPS "P-256:X25519:P-384:P-521"
! 80: #elif defined(USE_GNUTLS)
! 81: #define QUIC_PRIORITY \
! 82: "NORMAL:-VERS-ALL:+VERS-TLS1.3:-CIPHER-ALL:+AES-128-GCM:+AES-256-GCM:" \
! 83: "+CHACHA20-POLY1305:+AES-128-CCM:-GROUP-ALL:+GROUP-SECP256R1:" \
! 84: "+GROUP-X25519:+GROUP-SECP384R1:+GROUP-SECP521R1"
! 85: #endif
! 86:
! 87: static CURLcode ng_process_ingress(struct connectdata *conn,
! 88: curl_socket_t sockfd,
! 89: struct quicsocket *qs);
! 90: static CURLcode ng_flush_egress(struct connectdata *conn, int sockfd,
! 91: struct quicsocket *qs);
! 92: static int cb_h3_acked_stream_data(nghttp3_conn *conn, int64_t stream_id,
! 93: size_t datalen, void *user_data,
! 94: void *stream_user_data);
! 95:
! 96: static ngtcp2_tstamp timestamp(void)
! 97: {
! 98: struct curltime ct = Curl_now();
! 99: return ct.tv_sec * NGTCP2_SECONDS + ct.tv_usec * NGTCP2_MICROSECONDS;
! 100: }
! 101:
! 102: #ifdef DEBUG_NGTCP2
! 103: static void quic_printf(void *user_data, const char *fmt, ...)
! 104: {
! 105: va_list ap;
! 106: (void)user_data; /* TODO, use this to do infof() instead long-term */
! 107: va_start(ap, fmt);
! 108: vfprintf(stderr, fmt, ap);
! 109: va_end(ap);
! 110: fprintf(stderr, "\n");
! 111: }
! 112: #endif
! 113:
! 114: #ifdef USE_OPENSSL
! 115: static ngtcp2_crypto_level
! 116: quic_from_ossl_level(OSSL_ENCRYPTION_LEVEL ossl_level)
! 117: {
! 118: switch(ossl_level) {
! 119: case ssl_encryption_initial:
! 120: return NGTCP2_CRYPTO_LEVEL_INITIAL;
! 121: case ssl_encryption_early_data:
! 122: return NGTCP2_CRYPTO_LEVEL_EARLY;
! 123: case ssl_encryption_handshake:
! 124: return NGTCP2_CRYPTO_LEVEL_HANDSHAKE;
! 125: case ssl_encryption_application:
! 126: return NGTCP2_CRYPTO_LEVEL_APP;
! 127: default:
! 128: assert(0);
! 129: }
! 130: }
! 131: #elif defined(USE_GNUTLS)
! 132: static ngtcp2_crypto_level
! 133: quic_from_gtls_level(gnutls_record_encryption_level_t gtls_level)
! 134: {
! 135: switch(gtls_level) {
! 136: case GNUTLS_ENCRYPTION_LEVEL_INITIAL:
! 137: return NGTCP2_CRYPTO_LEVEL_INITIAL;
! 138: case GNUTLS_ENCRYPTION_LEVEL_EARLY:
! 139: return NGTCP2_CRYPTO_LEVEL_EARLY;
! 140: case GNUTLS_ENCRYPTION_LEVEL_HANDSHAKE:
! 141: return NGTCP2_CRYPTO_LEVEL_HANDSHAKE;
! 142: case GNUTLS_ENCRYPTION_LEVEL_APPLICATION:
! 143: return NGTCP2_CRYPTO_LEVEL_APP;
! 144: default:
! 145: assert(0);
! 146: }
! 147: }
! 148: #endif
! 149:
! 150: static int setup_initial_crypto_context(struct quicsocket *qs)
! 151: {
! 152: const ngtcp2_cid *dcid = ngtcp2_conn_get_dcid(qs->qconn);
! 153:
! 154: if(ngtcp2_crypto_derive_and_install_initial_key(
! 155: qs->qconn, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
! 156: dcid) != 0)
! 157: return -1;
! 158:
! 159: return 0;
! 160: }
! 161:
! 162: static void quic_settings(ngtcp2_settings *s,
! 163: uint64_t stream_buffer_size)
! 164: {
! 165: ngtcp2_settings_default(s);
! 166: #ifdef DEBUG_NGTCP2
! 167: s->log_printf = quic_printf;
! 168: #else
! 169: s->log_printf = NULL;
! 170: #endif
! 171: s->initial_ts = timestamp();
! 172: s->transport_params.initial_max_stream_data_bidi_local = stream_buffer_size;
! 173: s->transport_params.initial_max_stream_data_bidi_remote = QUIC_MAX_STREAMS;
! 174: s->transport_params.initial_max_stream_data_uni = QUIC_MAX_STREAMS;
! 175: s->transport_params.initial_max_data = QUIC_MAX_DATA;
! 176: s->transport_params.initial_max_streams_bidi = 1;
! 177: s->transport_params.initial_max_streams_uni = 3;
! 178: s->transport_params.max_idle_timeout = QUIC_IDLE_TIMEOUT;
! 179: }
! 180:
! 181: static FILE *keylog_file; /* not thread-safe */
! 182: #ifdef USE_OPENSSL
! 183: static void keylog_callback(const SSL *ssl, const char *line)
! 184: {
! 185: (void)ssl;
! 186: fputs(line, keylog_file);
! 187: fputc('\n', keylog_file);
! 188: fflush(keylog_file);
! 189: }
! 190: #elif defined(USE_GNUTLS)
! 191: static int keylog_callback(gnutls_session_t session, const char *label,
! 192: const gnutls_datum_t *secret)
! 193: {
! 194: gnutls_datum_t crandom;
! 195: gnutls_datum_t srandom;
! 196: gnutls_datum_t crandom_hex = { NULL, 0 };
! 197: gnutls_datum_t secret_hex = { NULL, 0 };
! 198: int rc = 0;
! 199:
! 200: gnutls_session_get_random(session, &crandom, &srandom);
! 201: if(crandom.size != 32) {
! 202: return -1;
! 203: }
! 204:
! 205: rc = gnutls_hex_encode2(&crandom, &crandom_hex);
! 206: if(rc < 0) {
! 207: fprintf(stderr, "gnutls_hex_encode2 failed: %s\n",
! 208: gnutls_strerror(rc));
! 209: goto out;
! 210: }
! 211:
! 212: rc = gnutls_hex_encode2(secret, &secret_hex);
! 213: if(rc < 0) {
! 214: fprintf(stderr, "gnutls_hex_encode2 failed: %s\n",
! 215: gnutls_strerror(rc));
! 216: goto out;
! 217: }
! 218:
! 219: fprintf(keylog_file, "%s %s %s\n", label, crandom_hex.data, secret_hex.data);
! 220: fflush(keylog_file);
! 221:
! 222: out:
! 223: gnutls_free(crandom_hex.data);
! 224: gnutls_free(secret_hex.data);
! 225: return rc;
! 226: }
! 227: #endif
! 228:
! 229: static int init_ngh3_conn(struct quicsocket *qs);
! 230:
! 231: static int write_client_handshake(struct quicsocket *qs,
! 232: ngtcp2_crypto_level level,
! 233: const uint8_t *data, size_t len)
! 234: {
! 235: struct quic_handshake *crypto_data;
! 236: int rv;
! 237:
! 238: crypto_data = &qs->crypto_data[level];
! 239: if(crypto_data->buf == NULL) {
! 240: crypto_data->buf = malloc(4096);
! 241: if(!crypto_data->buf)
! 242: return 0;
! 243: crypto_data->alloclen = 4096;
! 244: }
! 245:
! 246: /* TODO Just pretend that handshake does not grow more than 4KiB for
! 247: now */
! 248: assert(crypto_data->len + len <= crypto_data->alloclen);
! 249:
! 250: memcpy(&crypto_data->buf[crypto_data->len], data, len);
! 251: crypto_data->len += len;
! 252:
! 253: rv = ngtcp2_conn_submit_crypto_data(
! 254: qs->qconn, level, (uint8_t *)(&crypto_data->buf[crypto_data->len] - len),
! 255: len);
! 256: if(rv) {
! 257: H3BUGF(fprintf(stderr, "write_client_handshake failed\n"));
! 258: }
! 259: assert(0 == rv);
! 260:
! 261: return 1;
! 262: }
! 263:
! 264: #ifdef USE_OPENSSL
! 265: static int quic_set_encryption_secrets(SSL *ssl,
! 266: OSSL_ENCRYPTION_LEVEL ossl_level,
! 267: const uint8_t *rx_secret,
! 268: const uint8_t *tx_secret,
! 269: size_t secretlen)
! 270: {
! 271: struct quicsocket *qs = (struct quicsocket *)SSL_get_app_data(ssl);
! 272: int level = quic_from_ossl_level(ossl_level);
! 273:
! 274: if(level != NGTCP2_CRYPTO_LEVEL_EARLY &&
! 275: ngtcp2_crypto_derive_and_install_rx_key(
! 276: qs->qconn, ssl, NULL, NULL, NULL, level, rx_secret, secretlen) != 0)
! 277: return 0;
! 278:
! 279: if(ngtcp2_crypto_derive_and_install_tx_key(
! 280: qs->qconn, ssl, NULL, NULL, NULL, level, tx_secret, secretlen) != 0)
! 281: return 0;
! 282:
! 283: if(level == NGTCP2_CRYPTO_LEVEL_APP) {
! 284: if(init_ngh3_conn(qs) != CURLE_OK)
! 285: return 0;
! 286: }
! 287:
! 288: return 1;
! 289: }
! 290:
! 291: static int quic_add_handshake_data(SSL *ssl, OSSL_ENCRYPTION_LEVEL ossl_level,
! 292: const uint8_t *data, size_t len)
! 293: {
! 294: struct quicsocket *qs = (struct quicsocket *)SSL_get_app_data(ssl);
! 295: ngtcp2_crypto_level level = quic_from_ossl_level(ossl_level);
! 296:
! 297: return write_client_handshake(qs, level, data, len);
! 298: }
! 299:
! 300: static int quic_flush_flight(SSL *ssl)
! 301: {
! 302: (void)ssl;
! 303: return 1;
! 304: }
! 305:
! 306: static int quic_send_alert(SSL *ssl, enum ssl_encryption_level_t level,
! 307: uint8_t alert)
! 308: {
! 309: struct quicsocket *qs = (struct quicsocket *)SSL_get_app_data(ssl);
! 310: (void)level;
! 311:
! 312: qs->tls_alert = alert;
! 313: return 1;
! 314: }
! 315:
! 316: static SSL_QUIC_METHOD quic_method = {quic_set_encryption_secrets,
! 317: quic_add_handshake_data,
! 318: quic_flush_flight, quic_send_alert};
! 319:
! 320: static SSL_CTX *quic_ssl_ctx(struct Curl_easy *data)
! 321: {
! 322: SSL_CTX *ssl_ctx = SSL_CTX_new(TLS_method());
! 323: const char *keylog_filename;
! 324:
! 325: SSL_CTX_set_min_proto_version(ssl_ctx, TLS1_3_VERSION);
! 326: SSL_CTX_set_max_proto_version(ssl_ctx, TLS1_3_VERSION);
! 327:
! 328: SSL_CTX_set_default_verify_paths(ssl_ctx);
! 329:
! 330: if(SSL_CTX_set_ciphersuites(ssl_ctx, QUIC_CIPHERS) != 1) {
! 331: char error_buffer[256];
! 332: ERR_error_string_n(ERR_get_error(), error_buffer, sizeof(error_buffer));
! 333: failf(data, "SSL_CTX_set_ciphersuites: %s", error_buffer);
! 334: return NULL;
! 335: }
! 336:
! 337: if(SSL_CTX_set1_groups_list(ssl_ctx, QUIC_GROUPS) != 1) {
! 338: failf(data, "SSL_CTX_set1_groups_list failed");
! 339: return NULL;
! 340: }
! 341:
! 342: SSL_CTX_set_quic_method(ssl_ctx, &quic_method);
! 343:
! 344: keylog_filename = getenv("SSLKEYLOGFILE");
! 345: if(keylog_filename) {
! 346: keylog_file = fopen(keylog_filename, "wb");
! 347: if(keylog_file) {
! 348: SSL_CTX_set_keylog_callback(ssl_ctx, keylog_callback);
! 349: }
! 350: }
! 351:
! 352: return ssl_ctx;
! 353: }
! 354:
! 355: /** SSL callbacks ***/
! 356:
! 357: static int quic_init_ssl(struct quicsocket *qs)
! 358: {
! 359: const uint8_t *alpn = NULL;
! 360: size_t alpnlen = 0;
! 361: /* this will need some attention when HTTPS proxy over QUIC get fixed */
! 362: const char * const hostname = qs->conn->host.name;
! 363:
! 364: if(qs->ssl)
! 365: SSL_free(qs->ssl);
! 366:
! 367: qs->ssl = SSL_new(qs->sslctx);
! 368:
! 369: SSL_set_app_data(qs->ssl, qs);
! 370: SSL_set_connect_state(qs->ssl);
! 371:
! 372: switch(qs->version) {
! 373: #ifdef NGTCP2_PROTO_VER
! 374: case NGTCP2_PROTO_VER:
! 375: alpn = (const uint8_t *)NGTCP2_ALPN_H3;
! 376: alpnlen = sizeof(NGTCP2_ALPN_H3) - 1;
! 377: break;
! 378: #endif
! 379: }
! 380: if(alpn)
! 381: SSL_set_alpn_protos(qs->ssl, alpn, (int)alpnlen);
! 382:
! 383: /* set SNI */
! 384: SSL_set_tlsext_host_name(qs->ssl, hostname);
! 385: return 0;
! 386: }
! 387: #elif defined(USE_GNUTLS)
! 388: static int secret_func(gnutls_session_t ssl,
! 389: gnutls_record_encryption_level_t gtls_level,
! 390: const void *rx_secret,
! 391: const void *tx_secret, size_t secretlen)
! 392: {
! 393: struct quicsocket *qs = gnutls_session_get_ptr(ssl);
! 394: int level = quic_from_gtls_level(gtls_level);
! 395:
! 396: if(level != NGTCP2_CRYPTO_LEVEL_EARLY &&
! 397: ngtcp2_crypto_derive_and_install_rx_key(
! 398: qs->qconn, ssl, NULL, NULL, NULL, level, rx_secret, secretlen) != 0)
! 399: return 0;
! 400:
! 401: if(ngtcp2_crypto_derive_and_install_tx_key(
! 402: qs->qconn, ssl, NULL, NULL, NULL, level, tx_secret, secretlen) != 0)
! 403: return 0;
! 404:
! 405: if(level == NGTCP2_CRYPTO_LEVEL_APP) {
! 406: if(init_ngh3_conn(qs) != CURLE_OK)
! 407: return -1;
! 408: }
! 409:
! 410: return 0;
! 411: }
! 412:
! 413: static int read_func(gnutls_session_t ssl,
! 414: gnutls_record_encryption_level_t gtls_level,
! 415: gnutls_handshake_description_t htype, const void *data,
! 416: size_t len)
! 417: {
! 418: struct quicsocket *qs = gnutls_session_get_ptr(ssl);
! 419: ngtcp2_crypto_level level = quic_from_gtls_level(gtls_level);
! 420: int rv;
! 421:
! 422: if(htype == GNUTLS_HANDSHAKE_CHANGE_CIPHER_SPEC)
! 423: return 0;
! 424:
! 425: rv = write_client_handshake(qs, level, data, len);
! 426: if(rv == 0)
! 427: return -1;
! 428:
! 429: return 0;
! 430: }
! 431:
! 432: static int alert_read_func(gnutls_session_t ssl,
! 433: gnutls_record_encryption_level_t gtls_level,
! 434: gnutls_alert_level_t alert_level,
! 435: gnutls_alert_description_t alert_desc)
! 436: {
! 437: struct quicsocket *qs = gnutls_session_get_ptr(ssl);
! 438: (void)gtls_level;
! 439: (void)alert_level;
! 440:
! 441: qs->tls_alert = alert_desc;
! 442: return 1;
! 443: }
! 444:
! 445: static int tp_recv_func(gnutls_session_t ssl, const uint8_t *data,
! 446: size_t data_size)
! 447: {
! 448: struct quicsocket *qs = gnutls_session_get_ptr(ssl);
! 449: ngtcp2_transport_params params;
! 450:
! 451: if(ngtcp2_decode_transport_params(
! 452: ¶ms, NGTCP2_TRANSPORT_PARAMS_TYPE_ENCRYPTED_EXTENSIONS,
! 453: data, data_size) != 0)
! 454: return -1;
! 455:
! 456: if(ngtcp2_conn_set_remote_transport_params(qs->qconn, ¶ms) != 0)
! 457: return -1;
! 458:
! 459: return 0;
! 460: }
! 461:
! 462: static int tp_send_func(gnutls_session_t ssl, gnutls_buffer_t extdata)
! 463: {
! 464: struct quicsocket *qs = gnutls_session_get_ptr(ssl);
! 465: uint8_t paramsbuf[64];
! 466: ngtcp2_transport_params params;
! 467: ssize_t nwrite;
! 468: int rc;
! 469:
! 470: ngtcp2_conn_get_local_transport_params(qs->qconn, ¶ms);
! 471: nwrite = ngtcp2_encode_transport_params(
! 472: paramsbuf, sizeof(paramsbuf), NGTCP2_TRANSPORT_PARAMS_TYPE_CLIENT_HELLO,
! 473: ¶ms);
! 474: if(nwrite < 0) {
! 475: fprintf(stderr, "ngtcp2_encode_transport_params: %s\n",
! 476: ngtcp2_strerror((int)nwrite));
! 477: return -1;
! 478: }
! 479:
! 480: rc = gnutls_buffer_append_data(extdata, paramsbuf, nwrite);
! 481: if(rc < 0)
! 482: return rc;
! 483:
! 484: return (int)nwrite;
! 485: }
! 486:
! 487: static int quic_init_ssl(struct quicsocket *qs)
! 488: {
! 489: gnutls_datum_t alpn = {NULL, 0};
! 490: /* this will need some attention when HTTPS proxy over QUIC get fixed */
! 491: const char * const hostname = qs->conn->host.name;
! 492: const char *keylog_filename;
! 493: int rc;
! 494:
! 495: if(qs->ssl)
! 496: gnutls_deinit(qs->ssl);
! 497:
! 498: gnutls_init(&qs->ssl, GNUTLS_CLIENT);
! 499: gnutls_session_set_ptr(qs->ssl, qs);
! 500:
! 501: rc = gnutls_priority_set_direct(qs->ssl, QUIC_PRIORITY, NULL);
! 502: if(rc < 0) {
! 503: fprintf(stderr, "gnutls_priority_set_direct failed: %s\n",
! 504: gnutls_strerror(rc));
! 505: return 1;
! 506: }
! 507:
! 508: gnutls_handshake_set_secret_function(qs->ssl, secret_func);
! 509: gnutls_handshake_set_read_function(qs->ssl, read_func);
! 510: gnutls_alert_set_read_function(qs->ssl, alert_read_func);
! 511:
! 512: rc = gnutls_session_ext_register(qs->ssl, "QUIC Transport Parameters",
! 513: 0xffa5, GNUTLS_EXT_TLS,
! 514: tp_recv_func, tp_send_func,
! 515: NULL, NULL, NULL,
! 516: GNUTLS_EXT_FLAG_TLS |
! 517: GNUTLS_EXT_FLAG_CLIENT_HELLO |
! 518: GNUTLS_EXT_FLAG_EE);
! 519: if(rc < 0) {
! 520: fprintf(stderr, "gnutls_session_ext_register failed: %s\n",
! 521: gnutls_strerror(rc));
! 522: return 1;
! 523: }
! 524:
! 525: keylog_filename = getenv("SSLKEYLOGFILE");
! 526: if(keylog_filename) {
! 527: keylog_file = fopen(keylog_filename, "wb");
! 528: if(keylog_file) {
! 529: gnutls_session_set_keylog_function(qs->ssl, keylog_callback);
! 530: }
! 531: }
! 532:
! 533: if(qs->cred)
! 534: gnutls_certificate_free_credentials(qs->cred);
! 535:
! 536: rc = gnutls_certificate_allocate_credentials(&qs->cred);
! 537: if(rc < 0) {
! 538: fprintf(stderr, "gnutls_certificate_allocate_credentials failed: %s\n",
! 539: gnutls_strerror(rc));
! 540: return 1;
! 541: }
! 542:
! 543: rc = gnutls_certificate_set_x509_system_trust(qs->cred);
! 544: if(rc < 0) {
! 545: fprintf(stderr, "gnutls_certificate_set_x509_system_trust failed: %s\n",
! 546: gnutls_strerror(rc));
! 547: return 1;
! 548: }
! 549:
! 550: rc = gnutls_credentials_set(qs->ssl, GNUTLS_CRD_CERTIFICATE, qs->cred);
! 551: if(rc < 0) {
! 552: fprintf(stderr, "gnutls_credentials_set failed: %s\n",
! 553: gnutls_strerror(rc));
! 554: return 1;
! 555: }
! 556:
! 557: switch(qs->version) {
! 558: #ifdef NGTCP2_PROTO_VER
! 559: case NGTCP2_PROTO_VER:
! 560: /* strip the first byte from NGTCP2_ALPN_H3 */
! 561: alpn.data = (unsigned char *)NGTCP2_ALPN_H3 + 1;
! 562: alpn.size = sizeof(NGTCP2_ALPN_H3) - 2;
! 563: break;
! 564: #endif
! 565: }
! 566: if(alpn.data)
! 567: gnutls_alpn_set_protocols(qs->ssl, &alpn, 1, 0);
! 568:
! 569: /* set SNI */
! 570: gnutls_server_name_set(qs->ssl, GNUTLS_NAME_DNS, hostname, strlen(hostname));
! 571: return 0;
! 572: }
! 573: #endif
! 574:
! 575: static int cb_initial(ngtcp2_conn *quic, void *user_data)
! 576: {
! 577: struct quicsocket *qs = (struct quicsocket *)user_data;
! 578:
! 579: if(ngtcp2_crypto_read_write_crypto_data(
! 580: quic, qs->ssl, NGTCP2_CRYPTO_LEVEL_INITIAL, NULL, 0) != 0)
! 581: return NGTCP2_ERR_CALLBACK_FAILURE;
! 582:
! 583: return 0;
! 584: }
! 585:
! 586: static int
! 587: cb_recv_crypto_data(ngtcp2_conn *tconn, ngtcp2_crypto_level crypto_level,
! 588: uint64_t offset,
! 589: const uint8_t *data, size_t datalen,
! 590: void *user_data)
! 591: {
! 592: struct quicsocket *qs = (struct quicsocket *)user_data;
! 593: (void)offset;
! 594:
! 595: if(ngtcp2_crypto_read_write_crypto_data(tconn, qs->ssl, crypto_level, data,
! 596: datalen) != 0)
! 597: return NGTCP2_ERR_CRYPTO;
! 598:
! 599: return 0;
! 600: }
! 601:
! 602: static int cb_handshake_completed(ngtcp2_conn *tconn, void *user_data)
! 603: {
! 604: struct quicsocket *qs = (struct quicsocket *)user_data;
! 605: (void)tconn;
! 606: infof(qs->conn->data, "QUIC handshake is completed\n");
! 607:
! 608: return 0;
! 609: }
! 610:
! 611: static void extend_stream_window(ngtcp2_conn *tconn,
! 612: struct HTTP *stream)
! 613: {
! 614: size_t thismuch = stream->unacked_window;
! 615: ngtcp2_conn_extend_max_stream_offset(tconn, stream->stream3_id, thismuch);
! 616: ngtcp2_conn_extend_max_offset(tconn, thismuch);
! 617: stream->unacked_window = 0;
! 618: }
! 619:
! 620:
! 621: static int cb_recv_stream_data(ngtcp2_conn *tconn, int64_t stream_id,
! 622: int fin, uint64_t offset,
! 623: const uint8_t *buf, size_t buflen,
! 624: void *user_data, void *stream_user_data)
! 625: {
! 626: struct quicsocket *qs = (struct quicsocket *)user_data;
! 627: ssize_t nconsumed;
! 628: (void)offset;
! 629: (void)stream_user_data;
! 630:
! 631: nconsumed =
! 632: nghttp3_conn_read_stream(qs->h3conn, stream_id, buf, buflen, fin);
! 633: if(nconsumed < 0) {
! 634: failf(qs->conn->data, "nghttp3_conn_read_stream returned error: %s\n",
! 635: nghttp3_strerror((int)nconsumed));
! 636: return NGTCP2_ERR_CALLBACK_FAILURE;
! 637: }
! 638:
! 639: /* number of bytes inside buflen which consists of framing overhead
! 640: * including QPACK HEADERS. In other words, it does not consume payload of
! 641: * DATA frame. */
! 642: ngtcp2_conn_extend_max_stream_offset(tconn, stream_id, nconsumed);
! 643: ngtcp2_conn_extend_max_offset(tconn, nconsumed);
! 644:
! 645: return 0;
! 646: }
! 647:
! 648: static int
! 649: cb_acked_stream_data_offset(ngtcp2_conn *tconn, int64_t stream_id,
! 650: uint64_t offset, size_t datalen, void *user_data,
! 651: void *stream_user_data)
! 652: {
! 653: struct quicsocket *qs = (struct quicsocket *)user_data;
! 654: int rv;
! 655: (void)stream_id;
! 656: (void)tconn;
! 657: (void)offset;
! 658: (void)datalen;
! 659: (void)stream_user_data;
! 660:
! 661: rv = nghttp3_conn_add_ack_offset(qs->h3conn, stream_id, datalen);
! 662: if(rv != 0) {
! 663: failf(qs->conn->data, "nghttp3_conn_add_ack_offset returned error: %s\n",
! 664: nghttp3_strerror(rv));
! 665: return NGTCP2_ERR_CALLBACK_FAILURE;
! 666: }
! 667:
! 668: return 0;
! 669: }
! 670:
! 671: static int cb_stream_close(ngtcp2_conn *tconn, int64_t stream_id,
! 672: uint64_t app_error_code,
! 673: void *user_data, void *stream_user_data)
! 674: {
! 675: struct quicsocket *qs = (struct quicsocket *)user_data;
! 676: int rv;
! 677: (void)tconn;
! 678: (void)stream_user_data;
! 679: /* stream is closed... */
! 680:
! 681: rv = nghttp3_conn_close_stream(qs->h3conn, stream_id,
! 682: app_error_code);
! 683: if(rv != 0) {
! 684: failf(qs->conn->data, "nghttp3_conn_close_stream returned error: %s\n",
! 685: nghttp3_strerror(rv));
! 686: return NGTCP2_ERR_CALLBACK_FAILURE;
! 687: }
! 688:
! 689: return 0;
! 690: }
! 691:
! 692: static int cb_stream_reset(ngtcp2_conn *tconn, int64_t stream_id,
! 693: uint64_t final_size, uint64_t app_error_code,
! 694: void *user_data, void *stream_user_data)
! 695: {
! 696: struct quicsocket *qs = (struct quicsocket *)user_data;
! 697: int rv;
! 698: (void)tconn;
! 699: (void)final_size;
! 700: (void)app_error_code;
! 701: (void)stream_user_data;
! 702:
! 703: rv = nghttp3_conn_reset_stream(qs->h3conn, stream_id);
! 704: if(rv != 0) {
! 705: failf(qs->conn->data, "nghttp3_conn_reset_stream returned error: %s\n",
! 706: nghttp3_strerror(rv));
! 707: return NGTCP2_ERR_CALLBACK_FAILURE;
! 708: }
! 709:
! 710: return 0;
! 711: }
! 712:
! 713: static int cb_recv_retry(ngtcp2_conn *tconn, const ngtcp2_pkt_hd *hd,
! 714: const ngtcp2_pkt_retry *retry, void *user_data)
! 715: {
! 716: /* Re-generate handshake secrets here because connection ID might change. */
! 717: struct quicsocket *qs = (struct quicsocket *)user_data;
! 718: (void)tconn;
! 719: (void)hd;
! 720: (void)retry;
! 721:
! 722: setup_initial_crypto_context(qs);
! 723:
! 724: return 0;
! 725: }
! 726:
! 727: static int cb_extend_max_local_streams_bidi(ngtcp2_conn *tconn,
! 728: uint64_t max_streams,
! 729: void *user_data)
! 730: {
! 731: (void)tconn;
! 732: (void)max_streams;
! 733: (void)user_data;
! 734:
! 735: return 0;
! 736: }
! 737:
! 738: static int cb_extend_max_stream_data(ngtcp2_conn *tconn, int64_t stream_id,
! 739: uint64_t max_data, void *user_data,
! 740: void *stream_user_data)
! 741: {
! 742: struct quicsocket *qs = (struct quicsocket *)user_data;
! 743: int rv;
! 744: (void)tconn;
! 745: (void)max_data;
! 746: (void)stream_user_data;
! 747:
! 748: rv = nghttp3_conn_unblock_stream(qs->h3conn, stream_id);
! 749: if(rv != 0) {
! 750: failf(qs->conn->data, "nghttp3_conn_unblock_stream returned error: %s\n",
! 751: nghttp3_strerror(rv));
! 752: return NGTCP2_ERR_CALLBACK_FAILURE;
! 753: }
! 754:
! 755: return 0;
! 756: }
! 757:
! 758: static int cb_get_new_connection_id(ngtcp2_conn *tconn, ngtcp2_cid *cid,
! 759: uint8_t *token, size_t cidlen,
! 760: void *user_data)
! 761: {
! 762: struct quicsocket *qs = (struct quicsocket *)user_data;
! 763: CURLcode result;
! 764: (void)tconn;
! 765:
! 766: result = Curl_rand(qs->conn->data, cid->data, cidlen);
! 767: if(result)
! 768: return NGTCP2_ERR_CALLBACK_FAILURE;
! 769: cid->datalen = cidlen;
! 770:
! 771: result = Curl_rand(qs->conn->data, token, NGTCP2_STATELESS_RESET_TOKENLEN);
! 772: if(result)
! 773: return NGTCP2_ERR_CALLBACK_FAILURE;
! 774:
! 775: return 0;
! 776: }
! 777:
! 778: static ngtcp2_conn_callbacks ng_callbacks = {
! 779: cb_initial,
! 780: NULL, /* recv_client_initial */
! 781: cb_recv_crypto_data,
! 782: cb_handshake_completed,
! 783: NULL, /* recv_version_negotiation */
! 784: ngtcp2_crypto_encrypt_cb,
! 785: ngtcp2_crypto_decrypt_cb,
! 786: ngtcp2_crypto_hp_mask_cb,
! 787: cb_recv_stream_data,
! 788: NULL, /* acked_crypto_offset */
! 789: cb_acked_stream_data_offset,
! 790: NULL, /* stream_open */
! 791: cb_stream_close,
! 792: NULL, /* recv_stateless_reset */
! 793: cb_recv_retry,
! 794: cb_extend_max_local_streams_bidi,
! 795: NULL, /* extend_max_local_streams_uni */
! 796: NULL, /* rand */
! 797: cb_get_new_connection_id,
! 798: NULL, /* remove_connection_id */
! 799: ngtcp2_crypto_update_key_cb, /* update_key */
! 800: NULL, /* path_validation */
! 801: NULL, /* select_preferred_addr */
! 802: cb_stream_reset,
! 803: NULL, /* extend_max_remote_streams_bidi */
! 804: NULL, /* extend_max_remote_streams_uni */
! 805: cb_extend_max_stream_data,
! 806: NULL, /* dcid_status */
! 807: NULL /* handshake_confirmed */
! 808: };
! 809:
! 810: /*
! 811: * Might be called twice for happy eyeballs.
! 812: */
! 813: CURLcode Curl_quic_connect(struct connectdata *conn,
! 814: curl_socket_t sockfd,
! 815: int sockindex,
! 816: const struct sockaddr *addr,
! 817: socklen_t addrlen)
! 818: {
! 819: int rc;
! 820: int rv;
! 821: CURLcode result;
! 822: ngtcp2_path path; /* TODO: this must be initialized properly */
! 823: struct Curl_easy *data = conn->data;
! 824: struct quicsocket *qs = &conn->hequic[sockindex];
! 825: char ipbuf[40];
! 826: long port;
! 827: #ifdef USE_OPENSSL
! 828: uint8_t paramsbuf[64];
! 829: ngtcp2_transport_params params;
! 830: ssize_t nwrite;
! 831: #endif
! 832:
! 833: qs->conn = conn;
! 834:
! 835: /* extract the used address as a string */
! 836: if(!Curl_addr2string((struct sockaddr*)addr, addrlen, ipbuf, &port)) {
! 837: char buffer[STRERROR_LEN];
! 838: failf(data, "ssrem inet_ntop() failed with errno %d: %s",
! 839: SOCKERRNO, Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
! 840: return CURLE_BAD_FUNCTION_ARGUMENT;
! 841: }
! 842:
! 843: infof(data, "Connect socket %d over QUIC to %s:%ld\n",
! 844: sockfd, ipbuf, port);
! 845:
! 846: qs->version = NGTCP2_PROTO_VER;
! 847: #ifdef USE_OPENSSL
! 848: qs->sslctx = quic_ssl_ctx(data);
! 849: if(!qs->sslctx)
! 850: return CURLE_QUIC_CONNECT_ERROR;
! 851: #endif
! 852:
! 853: if(quic_init_ssl(qs))
! 854: return CURLE_QUIC_CONNECT_ERROR;
! 855:
! 856: qs->dcid.datalen = NGTCP2_MAX_CIDLEN;
! 857: result = Curl_rand(data, qs->dcid.data, NGTCP2_MAX_CIDLEN);
! 858: if(result)
! 859: return result;
! 860:
! 861: qs->scid.datalen = NGTCP2_MAX_CIDLEN;
! 862: result = Curl_rand(data, qs->scid.data, NGTCP2_MAX_CIDLEN);
! 863: if(result)
! 864: return result;
! 865:
! 866: quic_settings(&qs->settings, data->set.buffer_size);
! 867:
! 868: qs->local_addrlen = sizeof(qs->local_addr);
! 869: rv = getsockname(sockfd, (struct sockaddr *)&qs->local_addr,
! 870: &qs->local_addrlen);
! 871: if(rv == -1)
! 872: return CURLE_QUIC_CONNECT_ERROR;
! 873:
! 874: ngtcp2_addr_init(&path.local, (uint8_t *)&qs->local_addr, qs->local_addrlen,
! 875: NULL);
! 876: ngtcp2_addr_init(&path.remote, (uint8_t*)addr, addrlen, NULL);
! 877:
! 878: #ifdef NGTCP2_PROTO_VER
! 879: #define QUICVER NGTCP2_PROTO_VER
! 880: #else
! 881: #error "unsupported ngtcp2 version"
! 882: #endif
! 883: rc = ngtcp2_conn_client_new(&qs->qconn, &qs->dcid, &qs->scid, &path, QUICVER,
! 884: &ng_callbacks, &qs->settings, NULL, qs);
! 885: if(rc)
! 886: return CURLE_QUIC_CONNECT_ERROR;
! 887:
! 888: #ifdef USE_OPENSSL
! 889: ngtcp2_conn_get_local_transport_params(qs->qconn, ¶ms);
! 890: nwrite = ngtcp2_encode_transport_params(
! 891: paramsbuf, sizeof(paramsbuf), NGTCP2_TRANSPORT_PARAMS_TYPE_CLIENT_HELLO,
! 892: ¶ms);
! 893: if(nwrite < 0) {
! 894: failf(data, "ngtcp2_encode_transport_params: %s\n",
! 895: ngtcp2_strerror((int)nwrite));
! 896: return CURLE_QUIC_CONNECT_ERROR;
! 897: }
! 898:
! 899: if(!SSL_set_quic_transport_params(qs->ssl, paramsbuf, nwrite))
! 900: return CURLE_QUIC_CONNECT_ERROR;
! 901: #endif
! 902:
! 903: rc = setup_initial_crypto_context(qs);
! 904: if(rc)
! 905: return CURLE_QUIC_CONNECT_ERROR;
! 906:
! 907: return CURLE_OK;
! 908: }
! 909:
! 910: /*
! 911: * Store ngtp2 version info in this buffer, Prefix with a space. Return total
! 912: * length written.
! 913: */
! 914: int Curl_quic_ver(char *p, size_t len)
! 915: {
! 916: ngtcp2_info *ng2 = ngtcp2_version(0);
! 917: nghttp3_info *ht3 = nghttp3_version(0);
! 918: return msnprintf(p, len, "ngtcp2/%s nghttp3/%s",
! 919: ng2->version_str, ht3->version_str);
! 920: }
! 921:
! 922: static int ng_getsock(struct connectdata *conn, curl_socket_t *socks)
! 923: {
! 924: struct SingleRequest *k = &conn->data->req;
! 925: int bitmap = GETSOCK_BLANK;
! 926:
! 927: socks[0] = conn->sock[FIRSTSOCKET];
! 928:
! 929: /* in a HTTP/2 connection we can basically always get a frame so we should
! 930: always be ready for one */
! 931: bitmap |= GETSOCK_READSOCK(FIRSTSOCKET);
! 932:
! 933: /* we're still uploading or the HTTP/2 layer wants to send data */
! 934: if((k->keepon & (KEEP_SEND|KEEP_SEND_PAUSE)) == KEEP_SEND)
! 935: bitmap |= GETSOCK_WRITESOCK(FIRSTSOCKET);
! 936:
! 937: return bitmap;
! 938: }
! 939:
! 940: static int ng_perform_getsock(const struct connectdata *conn,
! 941: curl_socket_t *socks)
! 942: {
! 943: return ng_getsock((struct connectdata *)conn, socks);
! 944: }
! 945:
! 946: static CURLcode ng_disconnect(struct connectdata *conn,
! 947: bool dead_connection)
! 948: {
! 949: int i;
! 950: struct quicsocket *qs = &conn->hequic[0];
! 951: (void)dead_connection;
! 952: if(qs->ssl)
! 953: #ifdef USE_OPENSSL
! 954: SSL_free(qs->ssl);
! 955: #elif defined(USE_GNUTLS)
! 956: gnutls_deinit(qs->ssl);
! 957: #endif
! 958: #ifdef USE_GNUTLS
! 959: if(qs->cred)
! 960: gnutls_certificate_free_credentials(qs->cred);
! 961: #endif
! 962: for(i = 0; i < 3; i++)
! 963: free(qs->crypto_data[i].buf);
! 964: nghttp3_conn_del(qs->h3conn);
! 965: ngtcp2_conn_del(qs->qconn);
! 966: #ifdef USE_OPENSSL
! 967: SSL_CTX_free(qs->sslctx);
! 968: #endif
! 969: return CURLE_OK;
! 970: }
! 971:
! 972: static unsigned int ng_conncheck(struct connectdata *conn,
! 973: unsigned int checks_to_perform)
! 974: {
! 975: (void)conn;
! 976: (void)checks_to_perform;
! 977: return CONNRESULT_NONE;
! 978: }
! 979:
! 980: static const struct Curl_handler Curl_handler_http3 = {
! 981: "HTTPS", /* scheme */
! 982: ZERO_NULL, /* setup_connection */
! 983: Curl_http, /* do_it */
! 984: Curl_http_done, /* done */
! 985: ZERO_NULL, /* do_more */
! 986: ZERO_NULL, /* connect_it */
! 987: ZERO_NULL, /* connecting */
! 988: ZERO_NULL, /* doing */
! 989: ng_getsock, /* proto_getsock */
! 990: ng_getsock, /* doing_getsock */
! 991: ZERO_NULL, /* domore_getsock */
! 992: ng_perform_getsock, /* perform_getsock */
! 993: ng_disconnect, /* disconnect */
! 994: ZERO_NULL, /* readwrite */
! 995: ng_conncheck, /* connection_check */
! 996: PORT_HTTP, /* defport */
! 997: CURLPROTO_HTTPS, /* protocol */
! 998: PROTOPT_SSL | PROTOPT_STREAM /* flags */
! 999: };
! 1000:
! 1001: static int cb_h3_stream_close(nghttp3_conn *conn, int64_t stream_id,
! 1002: uint64_t app_error_code, void *user_data,
! 1003: void *stream_user_data)
! 1004: {
! 1005: struct Curl_easy *data = stream_user_data;
! 1006: struct HTTP *stream = data->req.protop;
! 1007: (void)conn;
! 1008: (void)stream_id;
! 1009: (void)app_error_code;
! 1010: (void)user_data;
! 1011: H3BUGF(infof(data, "cb_h3_stream_close CALLED\n"));
! 1012:
! 1013: stream->closed = TRUE;
! 1014: Curl_expire(data, 0, EXPIRE_QUIC);
! 1015: /* make sure that ngh3_stream_recv is called again to complete the transfer
! 1016: even if there are no more packets to be received from the server. */
! 1017: data->state.drain = 1;
! 1018: return 0;
! 1019: }
! 1020:
! 1021: /* Minimum size of the overflow buffer */
! 1022: #define OVERFLOWSIZE 1024
! 1023:
! 1024: /*
! 1025: * allocate_overflow() ensures that there is room for incoming data in the
! 1026: * overflow buffer, growing it to accommodate the new data if necessary. We
! 1027: * may need to use the overflow buffer because we can't precisely limit the
! 1028: * amount of HTTP/3 header data we receive using QUIC flow control mechanisms.
! 1029: */
! 1030: static CURLcode allocate_overflow(struct Curl_easy *data,
! 1031: struct HTTP *stream,
! 1032: size_t length)
! 1033: {
! 1034: size_t maxleft;
! 1035: size_t newsize;
! 1036: /* length can be arbitrarily large, so take care not to overflow newsize */
! 1037: maxleft = CURL_MAX_READ_SIZE - stream->overflow_buflen;
! 1038: if(length > maxleft) {
! 1039: /* The reason to have a max limit for this is to avoid the risk of a bad
! 1040: server feeding libcurl with a highly compressed list of headers that
! 1041: will cause our overflow buffer to grow too large */
! 1042: failf(data, "Rejected %zu bytes of overflow data (max is %d)!",
! 1043: stream->overflow_buflen + length, CURL_MAX_READ_SIZE);
! 1044: return CURLE_OUT_OF_MEMORY;
! 1045: }
! 1046: newsize = stream->overflow_buflen + length;
! 1047: if(newsize > stream->overflow_bufsize) {
! 1048: /* We enlarge the overflow buffer as it is too small */
! 1049: char *newbuff;
! 1050: newsize = CURLMAX(newsize * 3 / 2, stream->overflow_bufsize*2);
! 1051: newsize = CURLMIN(CURLMAX(OVERFLOWSIZE, newsize), CURL_MAX_READ_SIZE);
! 1052: newbuff = realloc(stream->overflow_buf, newsize);
! 1053: if(!newbuff) {
! 1054: failf(data, "Failed to alloc memory for overflow buffer!");
! 1055: return CURLE_OUT_OF_MEMORY;
! 1056: }
! 1057: stream->overflow_buf = newbuff;
! 1058: stream->overflow_bufsize = newsize;
! 1059: infof(data, "Grew HTTP/3 overflow buffer to %zu bytes\n", newsize);
! 1060: }
! 1061: return CURLE_OK;
! 1062: }
! 1063:
! 1064: /*
! 1065: * write_data() copies data to the stream's receive buffer. If not enough
! 1066: * space is available in the receive buffer, it copies the rest to the
! 1067: * stream's overflow buffer.
! 1068: */
! 1069: static CURLcode write_data(struct Curl_easy *data,
! 1070: struct HTTP *stream,
! 1071: const void *mem, size_t memlen)
! 1072: {
! 1073: CURLcode result = CURLE_OK;
! 1074: const char *buf = mem;
! 1075: size_t ncopy = memlen;
! 1076: /* copy as much as possible to the receive buffer */
! 1077: if(stream->len) {
! 1078: size_t len = CURLMIN(ncopy, stream->len);
! 1079: #if 0 /* extra debugging of incoming h3 data */
! 1080: fprintf(stderr, "!! Copies %zd bytes to %p (total %zd)\n",
! 1081: len, stream->mem, stream->memlen);
! 1082: #endif
! 1083: memcpy(stream->mem, buf, len);
! 1084: stream->len -= len;
! 1085: stream->memlen += len;
! 1086: stream->mem += len;
! 1087: buf += len;
! 1088: ncopy -= len;
! 1089: }
! 1090: /* copy the rest to the overflow buffer */
! 1091: if(ncopy) {
! 1092: result = allocate_overflow(data, stream, ncopy);
! 1093: if(result) {
! 1094: return result;
! 1095: }
! 1096: #if 0 /* extra debugging of incoming h3 data */
! 1097: fprintf(stderr, "!! Copies %zd overflow bytes to %p (total %zd)\n",
! 1098: ncopy, stream->overflow_buf, stream->overflow_buflen);
! 1099: #endif
! 1100: memcpy(stream->overflow_buf + stream->overflow_buflen, buf, ncopy);
! 1101: stream->overflow_buflen += ncopy;
! 1102: }
! 1103: #if 0 /* extra debugging of incoming h3 data */
! 1104: {
! 1105: size_t i;
! 1106: for(i = 0; i < memlen; i++) {
! 1107: fprintf(stderr, "!! data[%d]: %02x '%c'\n", i, buf[i], buf[i]);
! 1108: }
! 1109: }
! 1110: #endif
! 1111: return result;
! 1112: }
! 1113:
! 1114: static int cb_h3_recv_data(nghttp3_conn *conn, int64_t stream_id,
! 1115: const uint8_t *buf, size_t buflen,
! 1116: void *user_data, void *stream_user_data)
! 1117: {
! 1118: struct Curl_easy *data = stream_user_data;
! 1119: struct HTTP *stream = data->req.protop;
! 1120: CURLcode result = CURLE_OK;
! 1121: (void)conn;
! 1122:
! 1123: result = write_data(data, stream, buf, buflen);
! 1124: if(result) {
! 1125: return -1;
! 1126: }
! 1127: stream->unacked_window += buflen;
! 1128: (void)stream_id;
! 1129: (void)user_data;
! 1130: return 0;
! 1131: }
! 1132:
! 1133: static int cb_h3_deferred_consume(nghttp3_conn *conn, int64_t stream_id,
! 1134: size_t consumed, void *user_data,
! 1135: void *stream_user_data)
! 1136: {
! 1137: struct quicsocket *qs = user_data;
! 1138: (void)conn;
! 1139: (void)stream_user_data;
! 1140: (void)stream_id;
! 1141:
! 1142: ngtcp2_conn_extend_max_stream_offset(qs->qconn, stream_id, consumed);
! 1143: ngtcp2_conn_extend_max_offset(qs->qconn, consumed);
! 1144: return 0;
! 1145: }
! 1146:
! 1147: /* Decode HTTP status code. Returns -1 if no valid status code was
! 1148: decoded. (duplicate from http2.c) */
! 1149: static int decode_status_code(const uint8_t *value, size_t len)
! 1150: {
! 1151: int i;
! 1152: int res;
! 1153:
! 1154: if(len != 3) {
! 1155: return -1;
! 1156: }
! 1157:
! 1158: res = 0;
! 1159:
! 1160: for(i = 0; i < 3; ++i) {
! 1161: char c = value[i];
! 1162:
! 1163: if(c < '0' || c > '9') {
! 1164: return -1;
! 1165: }
! 1166:
! 1167: res *= 10;
! 1168: res += c - '0';
! 1169: }
! 1170:
! 1171: return res;
! 1172: }
! 1173:
! 1174: static int cb_h3_end_headers(nghttp3_conn *conn, int64_t stream_id,
! 1175: void *user_data, void *stream_user_data)
! 1176: {
! 1177: struct Curl_easy *data = stream_user_data;
! 1178: struct HTTP *stream = data->req.protop;
! 1179: CURLcode result = CURLE_OK;
! 1180: (void)conn;
! 1181: (void)stream_id;
! 1182: (void)user_data;
! 1183:
! 1184: /* add a CRLF only if we've received some headers */
! 1185: if(stream->firstheader) {
! 1186: result = write_data(data, stream, "\r\n", 2);
! 1187: if(result) {
! 1188: return -1;
! 1189: }
! 1190: }
! 1191: return 0;
! 1192: }
! 1193:
! 1194: static int cb_h3_recv_header(nghttp3_conn *conn, int64_t stream_id,
! 1195: int32_t token, nghttp3_rcbuf *name,
! 1196: nghttp3_rcbuf *value, uint8_t flags,
! 1197: void *user_data, void *stream_user_data)
! 1198: {
! 1199: nghttp3_vec h3name = nghttp3_rcbuf_get_buf(name);
! 1200: nghttp3_vec h3val = nghttp3_rcbuf_get_buf(value);
! 1201: struct Curl_easy *data = stream_user_data;
! 1202: struct HTTP *stream = data->req.protop;
! 1203: CURLcode result = CURLE_OK;
! 1204: (void)conn;
! 1205: (void)stream_id;
! 1206: (void)token;
! 1207: (void)flags;
! 1208: (void)user_data;
! 1209:
! 1210: if(h3name.len == sizeof(":status") - 1 &&
! 1211: !memcmp(":status", h3name.base, h3name.len)) {
! 1212: char line[14]; /* status line is always 13 characters long */
! 1213: size_t ncopy;
! 1214: int status = decode_status_code(h3val.base, h3val.len);
! 1215: DEBUGASSERT(status != -1);
! 1216: ncopy = msnprintf(line, sizeof(line), "HTTP/3 %03d \r\n", status);
! 1217: result = write_data(data, stream, line, ncopy);
! 1218: if(result) {
! 1219: return -1;
! 1220: }
! 1221: }
! 1222: else {
! 1223: /* store as a HTTP1-style header */
! 1224: result = write_data(data, stream, h3name.base, h3name.len);
! 1225: if(result) {
! 1226: return -1;
! 1227: }
! 1228: result = write_data(data, stream, ": ", 2);
! 1229: if(result) {
! 1230: return -1;
! 1231: }
! 1232: result = write_data(data, stream, h3val.base, h3val.len);
! 1233: if(result) {
! 1234: return -1;
! 1235: }
! 1236: result = write_data(data, stream, "\r\n", 2);
! 1237: if(result) {
! 1238: return -1;
! 1239: }
! 1240: }
! 1241:
! 1242: stream->firstheader = TRUE;
! 1243: return 0;
! 1244: }
! 1245:
! 1246: static int cb_h3_send_stop_sending(nghttp3_conn *conn, int64_t stream_id,
! 1247: uint64_t app_error_code,
! 1248: void *user_data,
! 1249: void *stream_user_data)
! 1250: {
! 1251: (void)conn;
! 1252: (void)stream_id;
! 1253: (void)app_error_code;
! 1254: (void)user_data;
! 1255: (void)stream_user_data;
! 1256: return 0;
! 1257: }
! 1258:
! 1259: static nghttp3_conn_callbacks ngh3_callbacks = {
! 1260: cb_h3_acked_stream_data, /* acked_stream_data */
! 1261: cb_h3_stream_close,
! 1262: cb_h3_recv_data,
! 1263: cb_h3_deferred_consume,
! 1264: NULL, /* begin_headers */
! 1265: cb_h3_recv_header,
! 1266: cb_h3_end_headers,
! 1267: NULL, /* begin_trailers */
! 1268: cb_h3_recv_header,
! 1269: NULL, /* end_trailers */
! 1270: NULL, /* http_begin_push_promise */
! 1271: NULL, /* http_recv_push_promise */
! 1272: NULL, /* http_end_push_promise */
! 1273: NULL, /* http_cancel_push */
! 1274: cb_h3_send_stop_sending,
! 1275: NULL, /* push_stream */
! 1276: NULL, /* end_stream */
! 1277: };
! 1278:
! 1279: static int init_ngh3_conn(struct quicsocket *qs)
! 1280: {
! 1281: CURLcode result;
! 1282: int rc;
! 1283: int64_t ctrl_stream_id, qpack_enc_stream_id, qpack_dec_stream_id;
! 1284:
! 1285: if(ngtcp2_conn_get_max_local_streams_uni(qs->qconn) < 3) {
! 1286: failf(qs->conn->data, "too few available QUIC streams");
! 1287: return CURLE_QUIC_CONNECT_ERROR;
! 1288: }
! 1289:
! 1290: nghttp3_conn_settings_default(&qs->h3settings);
! 1291:
! 1292: rc = nghttp3_conn_client_new(&qs->h3conn,
! 1293: &ngh3_callbacks,
! 1294: &qs->h3settings,
! 1295: nghttp3_mem_default(),
! 1296: qs);
! 1297: if(rc) {
! 1298: result = CURLE_OUT_OF_MEMORY;
! 1299: goto fail;
! 1300: }
! 1301:
! 1302: rc = ngtcp2_conn_open_uni_stream(qs->qconn, &ctrl_stream_id, NULL);
! 1303: if(rc) {
! 1304: result = CURLE_QUIC_CONNECT_ERROR;
! 1305: goto fail;
! 1306: }
! 1307:
! 1308: rc = nghttp3_conn_bind_control_stream(qs->h3conn, ctrl_stream_id);
! 1309: if(rc) {
! 1310: result = CURLE_QUIC_CONNECT_ERROR;
! 1311: goto fail;
! 1312: }
! 1313:
! 1314: rc = ngtcp2_conn_open_uni_stream(qs->qconn, &qpack_enc_stream_id, NULL);
! 1315: if(rc) {
! 1316: result = CURLE_QUIC_CONNECT_ERROR;
! 1317: goto fail;
! 1318: }
! 1319:
! 1320: rc = ngtcp2_conn_open_uni_stream(qs->qconn, &qpack_dec_stream_id, NULL);
! 1321: if(rc) {
! 1322: result = CURLE_QUIC_CONNECT_ERROR;
! 1323: goto fail;
! 1324: }
! 1325:
! 1326: rc = nghttp3_conn_bind_qpack_streams(qs->h3conn, qpack_enc_stream_id,
! 1327: qpack_dec_stream_id);
! 1328: if(rc) {
! 1329: result = CURLE_QUIC_CONNECT_ERROR;
! 1330: goto fail;
! 1331: }
! 1332:
! 1333: return CURLE_OK;
! 1334: fail:
! 1335:
! 1336: return result;
! 1337: }
! 1338:
! 1339: static Curl_recv ngh3_stream_recv;
! 1340: static Curl_send ngh3_stream_send;
! 1341:
! 1342: static size_t drain_overflow_buffer(struct HTTP *stream)
! 1343: {
! 1344: size_t ncopy = CURLMIN(stream->overflow_buflen, stream->len);
! 1345: if(ncopy > 0) {
! 1346: memcpy(stream->mem, stream->overflow_buf, ncopy);
! 1347: stream->len -= ncopy;
! 1348: stream->mem += ncopy;
! 1349: stream->memlen += ncopy;
! 1350: stream->overflow_buflen -= ncopy;
! 1351: memmove(stream->overflow_buf, stream->overflow_buf + ncopy,
! 1352: stream->overflow_buflen);
! 1353: }
! 1354: return ncopy;
! 1355: }
! 1356:
! 1357: /* incoming data frames on the h3 stream */
! 1358: static ssize_t ngh3_stream_recv(struct connectdata *conn,
! 1359: int sockindex,
! 1360: char *buf,
! 1361: size_t buffersize,
! 1362: CURLcode *curlcode)
! 1363: {
! 1364: curl_socket_t sockfd = conn->sock[sockindex];
! 1365: struct HTTP *stream = conn->data->req.protop;
! 1366: struct quicsocket *qs = conn->quic;
! 1367:
! 1368: if(!stream->memlen) {
! 1369: /* remember where to store incoming data for this stream and how big the
! 1370: buffer is */
! 1371: stream->mem = buf;
! 1372: stream->len = buffersize;
! 1373: }
! 1374: /* else, there's data in the buffer already */
! 1375:
! 1376: /* if there's data in the overflow buffer from a previous call, copy as much
! 1377: as possible to the receive buffer before receiving more */
! 1378: drain_overflow_buffer(stream);
! 1379:
! 1380: if(ng_process_ingress(conn, sockfd, qs)) {
! 1381: *curlcode = CURLE_RECV_ERROR;
! 1382: return -1;
! 1383: }
! 1384: if(ng_flush_egress(conn, sockfd, qs)) {
! 1385: *curlcode = CURLE_SEND_ERROR;
! 1386: return -1;
! 1387: }
! 1388:
! 1389: if(stream->memlen) {
! 1390: ssize_t memlen = stream->memlen;
! 1391: /* data arrived */
! 1392: *curlcode = CURLE_OK;
! 1393: /* reset to allow more data to come */
! 1394: stream->memlen = 0;
! 1395: stream->mem = buf;
! 1396: stream->len = buffersize;
! 1397: /* extend the stream window with the data we're consuming and send out
! 1398: any additional packets to tell the server that we can receive more */
! 1399: extend_stream_window(qs->qconn, stream);
! 1400: if(ng_flush_egress(conn, sockfd, qs)) {
! 1401: *curlcode = CURLE_SEND_ERROR;
! 1402: return -1;
! 1403: }
! 1404: return memlen;
! 1405: }
! 1406:
! 1407: if(stream->closed) {
! 1408: *curlcode = CURLE_OK;
! 1409: return 0;
! 1410: }
! 1411:
! 1412: infof(conn->data, "ngh3_stream_recv returns 0 bytes and EAGAIN\n");
! 1413: *curlcode = CURLE_AGAIN;
! 1414: return -1;
! 1415: }
! 1416:
! 1417: /* this amount of data has now been acked on this stream */
! 1418: static int cb_h3_acked_stream_data(nghttp3_conn *conn, int64_t stream_id,
! 1419: size_t datalen, void *user_data,
! 1420: void *stream_user_data)
! 1421: {
! 1422: struct Curl_easy *data = stream_user_data;
! 1423: struct HTTP *stream = data->req.protop;
! 1424: (void)conn;
! 1425: (void)stream_id;
! 1426: (void)user_data;
! 1427:
! 1428: if(!data->set.postfields) {
! 1429: stream->h3out->used -= datalen;
! 1430: H3BUGF(infof(data,
! 1431: "cb_h3_acked_stream_data, %zd bytes, %zd left unacked\n",
! 1432: datalen, stream->h3out->used));
! 1433: DEBUGASSERT(stream->h3out->used < H3_SEND_SIZE);
! 1434: }
! 1435: return 0;
! 1436: }
! 1437:
! 1438: static ssize_t cb_h3_readfunction(nghttp3_conn *conn, int64_t stream_id,
! 1439: nghttp3_vec *vec, size_t veccnt,
! 1440: uint32_t *pflags, void *user_data,
! 1441: void *stream_user_data)
! 1442: {
! 1443: struct Curl_easy *data = stream_user_data;
! 1444: size_t nread;
! 1445: struct HTTP *stream = data->req.protop;
! 1446: (void)conn;
! 1447: (void)stream_id;
! 1448: (void)user_data;
! 1449: (void)veccnt;
! 1450:
! 1451: if(data->set.postfields) {
! 1452: vec[0].base = data->set.postfields;
! 1453: vec[0].len = data->state.infilesize;
! 1454: *pflags = NGHTTP3_DATA_FLAG_EOF;
! 1455: return 1;
! 1456: }
! 1457:
! 1458: nread = CURLMIN(stream->upload_len, H3_SEND_SIZE - stream->h3out->used);
! 1459: if(nread > 0) {
! 1460: /* nghttp3 wants us to hold on to the data until it tells us it is okay to
! 1461: delete it. Append the data at the end of the h3out buffer. Since we can
! 1462: only return consecutive data, copy the amount that fits and the next
! 1463: part comes in next invoke. */
! 1464: struct h3out *out = stream->h3out;
! 1465: if(nread + out->windex > H3_SEND_SIZE)
! 1466: nread = H3_SEND_SIZE - out->windex;
! 1467:
! 1468: memcpy(&out->buf[out->windex], stream->upload_mem, nread);
! 1469: out->windex += nread;
! 1470: out->used += nread;
! 1471:
! 1472: /* that's the chunk we return to nghttp3 */
! 1473: vec[0].base = &out->buf[out->windex];
! 1474: vec[0].len = nread;
! 1475:
! 1476: if(out->windex == H3_SEND_SIZE)
! 1477: out->windex = 0; /* wrap */
! 1478: stream->upload_mem += nread;
! 1479: stream->upload_len -= nread;
! 1480: if(data->state.infilesize != -1) {
! 1481: stream->upload_left -= nread;
! 1482: if(!stream->upload_left)
! 1483: *pflags = NGHTTP3_DATA_FLAG_EOF;
! 1484: }
! 1485: H3BUGF(infof(data, "cb_h3_readfunction %zd bytes%s (at %zd unacked)\n",
! 1486: nread, *pflags == NGHTTP3_DATA_FLAG_EOF?" EOF":"",
! 1487: out->used));
! 1488: }
! 1489: if(stream->upload_done && !stream->upload_len &&
! 1490: (stream->upload_left <= 0)) {
! 1491: H3BUGF(infof(data, "!!!!!!!!! cb_h3_readfunction sets EOF\n"));
! 1492: *pflags = NGHTTP3_DATA_FLAG_EOF;
! 1493: return 0;
! 1494: }
! 1495: else if(!nread) {
! 1496: return NGHTTP3_ERR_WOULDBLOCK;
! 1497: }
! 1498: return 1;
! 1499: }
! 1500:
! 1501: /* Index where :authority header field will appear in request header
! 1502: field list. */
! 1503: #define AUTHORITY_DST_IDX 3
! 1504:
! 1505: static CURLcode http_request(struct connectdata *conn, const void *mem,
! 1506: size_t len)
! 1507: {
! 1508: struct HTTP *stream = conn->data->req.protop;
! 1509: size_t nheader;
! 1510: size_t i;
! 1511: size_t authority_idx;
! 1512: char *hdbuf = (char *)mem;
! 1513: char *end, *line_end;
! 1514: struct quicsocket *qs = conn->quic;
! 1515: CURLcode result = CURLE_OK;
! 1516: struct Curl_easy *data = conn->data;
! 1517: nghttp3_nv *nva = NULL;
! 1518: int64_t stream3_id;
! 1519: int rc;
! 1520: struct h3out *h3out = NULL;
! 1521:
! 1522: rc = ngtcp2_conn_open_bidi_stream(qs->qconn, &stream3_id, NULL);
! 1523: if(rc) {
! 1524: failf(conn->data, "can get bidi streams");
! 1525: result = CURLE_SEND_ERROR;
! 1526: goto fail;
! 1527: }
! 1528:
! 1529: stream->stream3_id = stream3_id;
! 1530: stream->h3req = TRUE; /* senf off! */
! 1531:
! 1532: /* Calculate number of headers contained in [mem, mem + len). Assumes a
! 1533: correctly generated HTTP header field block. */
! 1534: nheader = 0;
! 1535: for(i = 1; i < len; ++i) {
! 1536: if(hdbuf[i] == '\n' && hdbuf[i - 1] == '\r') {
! 1537: ++nheader;
! 1538: ++i;
! 1539: }
! 1540: }
! 1541: if(nheader < 2)
! 1542: goto fail;
! 1543:
! 1544: /* We counted additional 2 \r\n in the first and last line. We need 3
! 1545: new headers: :method, :path and :scheme. Therefore we need one
! 1546: more space. */
! 1547: nheader += 1;
! 1548: nva = malloc(sizeof(nghttp3_nv) * nheader);
! 1549: if(!nva) {
! 1550: result = CURLE_OUT_OF_MEMORY;
! 1551: goto fail;
! 1552: }
! 1553:
! 1554: /* Extract :method, :path from request line
! 1555: We do line endings with CRLF so checking for CR is enough */
! 1556: line_end = memchr(hdbuf, '\r', len);
! 1557: if(!line_end) {
! 1558: result = CURLE_BAD_FUNCTION_ARGUMENT; /* internal error */
! 1559: goto fail;
! 1560: }
! 1561:
! 1562: /* Method does not contain spaces */
! 1563: end = memchr(hdbuf, ' ', line_end - hdbuf);
! 1564: if(!end || end == hdbuf)
! 1565: goto fail;
! 1566: nva[0].name = (unsigned char *)":method";
! 1567: nva[0].namelen = strlen((char *)nva[0].name);
! 1568: nva[0].value = (unsigned char *)hdbuf;
! 1569: nva[0].valuelen = (size_t)(end - hdbuf);
! 1570: nva[0].flags = NGHTTP3_NV_FLAG_NONE;
! 1571:
! 1572: hdbuf = end + 1;
! 1573:
! 1574: /* Path may contain spaces so scan backwards */
! 1575: end = NULL;
! 1576: for(i = (size_t)(line_end - hdbuf); i; --i) {
! 1577: if(hdbuf[i - 1] == ' ') {
! 1578: end = &hdbuf[i - 1];
! 1579: break;
! 1580: }
! 1581: }
! 1582: if(!end || end == hdbuf)
! 1583: goto fail;
! 1584: nva[1].name = (unsigned char *)":path";
! 1585: nva[1].namelen = strlen((char *)nva[1].name);
! 1586: nva[1].value = (unsigned char *)hdbuf;
! 1587: nva[1].valuelen = (size_t)(end - hdbuf);
! 1588: nva[1].flags = NGHTTP3_NV_FLAG_NONE;
! 1589:
! 1590: nva[2].name = (unsigned char *)":scheme";
! 1591: nva[2].namelen = strlen((char *)nva[2].name);
! 1592: if(conn->handler->flags & PROTOPT_SSL)
! 1593: nva[2].value = (unsigned char *)"https";
! 1594: else
! 1595: nva[2].value = (unsigned char *)"http";
! 1596: nva[2].valuelen = strlen((char *)nva[2].value);
! 1597: nva[2].flags = NGHTTP3_NV_FLAG_NONE;
! 1598:
! 1599:
! 1600: authority_idx = 0;
! 1601: i = 3;
! 1602: while(i < nheader) {
! 1603: size_t hlen;
! 1604:
! 1605: hdbuf = line_end + 2;
! 1606:
! 1607: /* check for next CR, but only within the piece of data left in the given
! 1608: buffer */
! 1609: line_end = memchr(hdbuf, '\r', len - (hdbuf - (char *)mem));
! 1610: if(!line_end || (line_end == hdbuf))
! 1611: goto fail;
! 1612:
! 1613: /* header continuation lines are not supported */
! 1614: if(*hdbuf == ' ' || *hdbuf == '\t')
! 1615: goto fail;
! 1616:
! 1617: for(end = hdbuf; end < line_end && *end != ':'; ++end)
! 1618: ;
! 1619: if(end == hdbuf || end == line_end)
! 1620: goto fail;
! 1621: hlen = end - hdbuf;
! 1622:
! 1623: if(hlen == 4 && strncasecompare("host", hdbuf, 4)) {
! 1624: authority_idx = i;
! 1625: nva[i].name = (unsigned char *)":authority";
! 1626: nva[i].namelen = strlen((char *)nva[i].name);
! 1627: }
! 1628: else {
! 1629: nva[i].namelen = (size_t)(end - hdbuf);
! 1630: /* Lower case the header name for HTTP/3 */
! 1631: Curl_strntolower((char *)hdbuf, hdbuf, nva[i].namelen);
! 1632: nva[i].name = (unsigned char *)hdbuf;
! 1633: }
! 1634: nva[i].flags = NGHTTP3_NV_FLAG_NONE;
! 1635: hdbuf = end + 1;
! 1636: while(*hdbuf == ' ' || *hdbuf == '\t')
! 1637: ++hdbuf;
! 1638: end = line_end;
! 1639:
! 1640: #if 0 /* This should probably go in more or less like this */
! 1641: switch(inspect_header((const char *)nva[i].name, nva[i].namelen, hdbuf,
! 1642: end - hdbuf)) {
! 1643: case HEADERINST_IGNORE:
! 1644: /* skip header fields prohibited by HTTP/2 specification. */
! 1645: --nheader;
! 1646: continue;
! 1647: case HEADERINST_TE_TRAILERS:
! 1648: nva[i].value = (uint8_t*)"trailers";
! 1649: nva[i].value_len = sizeof("trailers") - 1;
! 1650: break;
! 1651: default:
! 1652: nva[i].value = (unsigned char *)hdbuf;
! 1653: nva[i].value_len = (size_t)(end - hdbuf);
! 1654: }
! 1655: #endif
! 1656: nva[i].value = (unsigned char *)hdbuf;
! 1657: nva[i].valuelen = (size_t)(end - hdbuf);
! 1658: nva[i].flags = NGHTTP3_NV_FLAG_NONE;
! 1659:
! 1660: ++i;
! 1661: }
! 1662:
! 1663: /* :authority must come before non-pseudo header fields */
! 1664: if(authority_idx != 0 && authority_idx != AUTHORITY_DST_IDX) {
! 1665: nghttp3_nv authority = nva[authority_idx];
! 1666: for(i = authority_idx; i > AUTHORITY_DST_IDX; --i) {
! 1667: nva[i] = nva[i - 1];
! 1668: }
! 1669: nva[i] = authority;
! 1670: }
! 1671:
! 1672: /* Warn stream may be rejected if cumulative length of headers is too
! 1673: large. */
! 1674: #define MAX_ACC 60000 /* <64KB to account for some overhead */
! 1675: {
! 1676: size_t acc = 0;
! 1677: for(i = 0; i < nheader; ++i)
! 1678: acc += nva[i].namelen + nva[i].valuelen;
! 1679:
! 1680: if(acc > MAX_ACC) {
! 1681: infof(data, "http_request: Warning: The cumulative length of all "
! 1682: "headers exceeds %zu bytes and that could cause the "
! 1683: "stream to be rejected.\n", MAX_ACC);
! 1684: }
! 1685: }
! 1686:
! 1687: switch(data->set.httpreq) {
! 1688: case HTTPREQ_POST:
! 1689: case HTTPREQ_POST_FORM:
! 1690: case HTTPREQ_POST_MIME:
! 1691: case HTTPREQ_PUT: {
! 1692: nghttp3_data_reader data_reader;
! 1693: if(data->state.infilesize != -1)
! 1694: stream->upload_left = data->state.infilesize;
! 1695: else
! 1696: /* data sending without specifying the data amount up front */
! 1697: stream->upload_left = -1; /* unknown, but not zero */
! 1698:
! 1699: data_reader.read_data = cb_h3_readfunction;
! 1700:
! 1701: h3out = calloc(sizeof(struct h3out), 1);
! 1702: if(!h3out) {
! 1703: result = CURLE_OUT_OF_MEMORY;
! 1704: goto fail;
! 1705: }
! 1706: stream->h3out = h3out;
! 1707:
! 1708: rc = nghttp3_conn_submit_request(qs->h3conn, stream->stream3_id,
! 1709: nva, nheader, &data_reader,
! 1710: conn->data);
! 1711: if(rc) {
! 1712: result = CURLE_SEND_ERROR;
! 1713: goto fail;
! 1714: }
! 1715: break;
! 1716: }
! 1717: default:
! 1718: stream->upload_left = 0; /* nothing left to send */
! 1719: rc = nghttp3_conn_submit_request(qs->h3conn, stream->stream3_id,
! 1720: nva, nheader,
! 1721: NULL, /* no body! */
! 1722: conn->data);
! 1723: if(rc) {
! 1724: result = CURLE_SEND_ERROR;
! 1725: goto fail;
! 1726: }
! 1727: break;
! 1728: }
! 1729:
! 1730: Curl_safefree(nva);
! 1731:
! 1732: infof(data, "Using HTTP/3 Stream ID: %x (easy handle %p)\n",
! 1733: stream3_id, (void *)data);
! 1734:
! 1735: return CURLE_OK;
! 1736:
! 1737: fail:
! 1738: free(nva);
! 1739: return result;
! 1740: }
! 1741: static ssize_t ngh3_stream_send(struct connectdata *conn,
! 1742: int sockindex,
! 1743: const void *mem,
! 1744: size_t len,
! 1745: CURLcode *curlcode)
! 1746: {
! 1747: ssize_t sent;
! 1748: struct quicsocket *qs = conn->quic;
! 1749: curl_socket_t sockfd = conn->sock[sockindex];
! 1750: struct HTTP *stream = conn->data->req.protop;
! 1751:
! 1752: if(!stream->h3req) {
! 1753: CURLcode result = http_request(conn, mem, len);
! 1754: if(result) {
! 1755: *curlcode = CURLE_SEND_ERROR;
! 1756: return -1;
! 1757: }
! 1758: sent = len;
! 1759: }
! 1760: else {
! 1761: H3BUGF(infof(conn->data, "ngh3_stream_send() wants to send %zd bytes\n",
! 1762: len));
! 1763: if(!stream->upload_len) {
! 1764: stream->upload_mem = mem;
! 1765: stream->upload_len = len;
! 1766: (void)nghttp3_conn_resume_stream(qs->h3conn, stream->stream3_id);
! 1767: sent = len;
! 1768: }
! 1769: else {
! 1770: *curlcode = CURLE_AGAIN;
! 1771: return -1;
! 1772: }
! 1773: }
! 1774:
! 1775: if(ng_flush_egress(conn, sockfd, qs)) {
! 1776: *curlcode = CURLE_SEND_ERROR;
! 1777: return -1;
! 1778: }
! 1779:
! 1780: *curlcode = CURLE_OK;
! 1781: return sent;
! 1782: }
! 1783:
! 1784: static void ng_has_connected(struct connectdata *conn, int tempindex)
! 1785: {
! 1786: conn->recv[FIRSTSOCKET] = ngh3_stream_recv;
! 1787: conn->send[FIRSTSOCKET] = ngh3_stream_send;
! 1788: conn->handler = &Curl_handler_http3;
! 1789: conn->bits.multiplex = TRUE; /* at least potentially multiplexed */
! 1790: conn->httpversion = 30;
! 1791: conn->bundle->multiuse = BUNDLE_MULTIPLEX;
! 1792: conn->quic = &conn->hequic[tempindex];
! 1793: DEBUGF(infof(conn->data, "ngtcp2 established connection!\n"));
! 1794: }
! 1795:
! 1796: /*
! 1797: * There can be multiple connection attempts going on in parallel.
! 1798: */
! 1799: CURLcode Curl_quic_is_connected(struct connectdata *conn,
! 1800: int sockindex,
! 1801: bool *done)
! 1802: {
! 1803: CURLcode result;
! 1804: struct quicsocket *qs = &conn->hequic[sockindex];
! 1805: curl_socket_t sockfd = conn->tempsock[sockindex];
! 1806:
! 1807: result = ng_process_ingress(conn, sockfd, qs);
! 1808: if(result)
! 1809: return result;
! 1810:
! 1811: result = ng_flush_egress(conn, sockfd, qs);
! 1812: if(result)
! 1813: return result;
! 1814:
! 1815: if(ngtcp2_conn_get_handshake_completed(qs->qconn)) {
! 1816: *done = TRUE;
! 1817: ng_has_connected(conn, sockindex);
! 1818: }
! 1819:
! 1820: return result;
! 1821: }
! 1822:
! 1823: static CURLcode ng_process_ingress(struct connectdata *conn, int sockfd,
! 1824: struct quicsocket *qs)
! 1825: {
! 1826: ssize_t recvd;
! 1827: int rv;
! 1828: uint8_t buf[65536];
! 1829: size_t bufsize = sizeof(buf);
! 1830: struct sockaddr_storage remote_addr;
! 1831: socklen_t remote_addrlen;
! 1832: ngtcp2_path path;
! 1833: ngtcp2_tstamp ts = timestamp();
! 1834:
! 1835: for(;;) {
! 1836: remote_addrlen = sizeof(remote_addr);
! 1837: while((recvd = recvfrom(sockfd, buf, bufsize, 0,
! 1838: (struct sockaddr *)&remote_addr,
! 1839: &remote_addrlen)) == -1 &&
! 1840: SOCKERRNO == EINTR)
! 1841: ;
! 1842: if(recvd == -1) {
! 1843: if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK)
! 1844: break;
! 1845:
! 1846: failf(conn->data, "ngtcp2: recvfrom() unexpectedly returned %d", recvd);
! 1847: return CURLE_RECV_ERROR;
! 1848: }
! 1849:
! 1850: ngtcp2_addr_init(&path.local, (uint8_t *)&qs->local_addr,
! 1851: qs->local_addrlen, NULL);
! 1852: ngtcp2_addr_init(&path.remote, (uint8_t *)&remote_addr, remote_addrlen,
! 1853: NULL);
! 1854:
! 1855: rv = ngtcp2_conn_read_pkt(qs->qconn, &path, buf, recvd, ts);
! 1856: if(rv != 0) {
! 1857: /* TODO Send CONNECTION_CLOSE if possible */
! 1858: return CURLE_RECV_ERROR;
! 1859: }
! 1860: }
! 1861:
! 1862: return CURLE_OK;
! 1863: }
! 1864:
! 1865: static CURLcode ng_flush_egress(struct connectdata *conn, int sockfd,
! 1866: struct quicsocket *qs)
! 1867: {
! 1868: int rv;
! 1869: ssize_t sent;
! 1870: ssize_t outlen;
! 1871: uint8_t out[NGTCP2_MAX_PKTLEN_IPV4];
! 1872: size_t pktlen;
! 1873: ngtcp2_path_storage ps;
! 1874: ngtcp2_tstamp ts = timestamp();
! 1875: struct sockaddr_storage remote_addr;
! 1876: ngtcp2_tstamp expiry;
! 1877: ngtcp2_duration timeout;
! 1878: int64_t stream_id;
! 1879: ssize_t veccnt;
! 1880: int fin;
! 1881: nghttp3_vec vec[16];
! 1882: ssize_t ndatalen;
! 1883:
! 1884: switch(qs->local_addr.ss_family) {
! 1885: case AF_INET:
! 1886: pktlen = NGTCP2_MAX_PKTLEN_IPV4;
! 1887: break;
! 1888: #ifdef ENABLE_IPV6
! 1889: case AF_INET6:
! 1890: pktlen = NGTCP2_MAX_PKTLEN_IPV6;
! 1891: break;
! 1892: #endif
! 1893: default:
! 1894: assert(0);
! 1895: }
! 1896:
! 1897: rv = ngtcp2_conn_handle_expiry(qs->qconn, ts);
! 1898: if(rv != 0) {
! 1899: failf(conn->data, "ngtcp2_conn_handle_expiry returned error: %s\n",
! 1900: ngtcp2_strerror(rv));
! 1901: return CURLE_SEND_ERROR;
! 1902: }
! 1903:
! 1904: ngtcp2_path_storage_zero(&ps);
! 1905:
! 1906: for(;;) {
! 1907: outlen = -1;
! 1908: if(qs->h3conn && ngtcp2_conn_get_max_data_left(qs->qconn)) {
! 1909: veccnt = nghttp3_conn_writev_stream(qs->h3conn, &stream_id, &fin, vec,
! 1910: sizeof(vec) / sizeof(vec[0]));
! 1911: if(veccnt < 0) {
! 1912: failf(conn->data, "nghttp3_conn_writev_stream returned error: %s\n",
! 1913: nghttp3_strerror((int)veccnt));
! 1914: return CURLE_SEND_ERROR;
! 1915: }
! 1916: else if(veccnt > 0) {
! 1917: outlen =
! 1918: ngtcp2_conn_writev_stream(qs->qconn, &ps.path,
! 1919: out, pktlen, &ndatalen,
! 1920: NGTCP2_WRITE_STREAM_FLAG_MORE,
! 1921: stream_id, fin,
! 1922: (const ngtcp2_vec *)vec, veccnt, ts);
! 1923: if(outlen == 0) {
! 1924: break;
! 1925: }
! 1926: if(outlen < 0) {
! 1927: if(outlen == NGTCP2_ERR_STREAM_DATA_BLOCKED ||
! 1928: outlen == NGTCP2_ERR_STREAM_SHUT_WR) {
! 1929: rv = nghttp3_conn_block_stream(qs->h3conn, stream_id);
! 1930: if(rv != 0) {
! 1931: failf(conn->data,
! 1932: "nghttp3_conn_block_stream returned error: %s\n",
! 1933: nghttp3_strerror(rv));
! 1934: return CURLE_SEND_ERROR;
! 1935: }
! 1936: continue;
! 1937: }
! 1938: else if(outlen == NGTCP2_ERR_WRITE_STREAM_MORE) {
! 1939: assert(ndatalen > 0);
! 1940: rv = nghttp3_conn_add_write_offset(qs->h3conn, stream_id,
! 1941: ndatalen);
! 1942: if(rv != 0) {
! 1943: failf(conn->data,
! 1944: "nghttp3_conn_add_write_offset returned error: %s\n",
! 1945: nghttp3_strerror(rv));
! 1946: return CURLE_SEND_ERROR;
! 1947: }
! 1948: continue;
! 1949: }
! 1950: else {
! 1951: failf(conn->data, "ngtcp2_conn_writev_stream returned error: %s\n",
! 1952: ngtcp2_strerror((int)outlen));
! 1953: return CURLE_SEND_ERROR;
! 1954: }
! 1955: }
! 1956: else if(ndatalen >= 0) {
! 1957: rv = nghttp3_conn_add_write_offset(qs->h3conn, stream_id, ndatalen);
! 1958: if(rv != 0) {
! 1959: failf(conn->data,
! 1960: "nghttp3_conn_add_write_offset returned error: %s\n",
! 1961: nghttp3_strerror(rv));
! 1962: return CURLE_SEND_ERROR;
! 1963: }
! 1964: }
! 1965: }
! 1966: }
! 1967: if(outlen < 0) {
! 1968: outlen = ngtcp2_conn_write_pkt(qs->qconn, &ps.path, out, pktlen, ts);
! 1969: if(outlen < 0) {
! 1970: failf(conn->data, "ngtcp2_conn_write_pkt returned error: %s\n",
! 1971: ngtcp2_strerror((int)outlen));
! 1972: return CURLE_SEND_ERROR;
! 1973: }
! 1974: if(outlen == 0)
! 1975: break;
! 1976: }
! 1977:
! 1978: memcpy(&remote_addr, ps.path.remote.addr, ps.path.remote.addrlen);
! 1979: while((sent = send(sockfd, out, outlen, 0)) == -1 &&
! 1980: SOCKERRNO == EINTR)
! 1981: ;
! 1982:
! 1983: if(sent == -1) {
! 1984: if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {
! 1985: /* TODO Cache packet */
! 1986: break;
! 1987: }
! 1988: else {
! 1989: failf(conn->data, "send() returned %zd (errno %d)\n", sent,
! 1990: SOCKERRNO);
! 1991: return CURLE_SEND_ERROR;
! 1992: }
! 1993: }
! 1994: }
! 1995:
! 1996: expiry = ngtcp2_conn_get_expiry(qs->qconn);
! 1997: if(expiry != UINT64_MAX) {
! 1998: if(expiry <= ts) {
! 1999: timeout = NGTCP2_MILLISECONDS;
! 2000: }
! 2001: else {
! 2002: timeout = expiry - ts;
! 2003: }
! 2004: Curl_expire(conn->data, timeout / NGTCP2_MILLISECONDS, EXPIRE_QUIC);
! 2005: }
! 2006:
! 2007: return CURLE_OK;
! 2008: }
! 2009:
! 2010: /*
! 2011: * Called from transfer.c:done_sending when we stop HTTP/3 uploading.
! 2012: */
! 2013: CURLcode Curl_quic_done_sending(struct connectdata *conn)
! 2014: {
! 2015: if(conn->handler == &Curl_handler_http3) {
! 2016: /* only for HTTP/3 transfers */
! 2017: struct HTTP *stream = conn->data->req.protop;
! 2018: struct quicsocket *qs = conn->quic;
! 2019: stream->upload_done = TRUE;
! 2020: (void)nghttp3_conn_resume_stream(qs->h3conn, stream->stream3_id);
! 2021: }
! 2022:
! 2023: return CURLE_OK;
! 2024: }
! 2025:
! 2026: /*
! 2027: * Called from http.c:Curl_http_done when a request completes.
! 2028: */
! 2029: void Curl_quic_done(struct Curl_easy *data, bool premature)
! 2030: {
! 2031: (void)premature;
! 2032: if(data->conn->handler == &Curl_handler_http3) {
! 2033: /* only for HTTP/3 transfers */
! 2034: struct HTTP *stream = data->req.protop;
! 2035: Curl_safefree(stream->overflow_buf);
! 2036: }
! 2037: }
! 2038:
! 2039: /*
! 2040: * Called from transfer.c:data_pending to know if we should keep looping
! 2041: * to receive more data from the connection.
! 2042: */
! 2043: bool Curl_quic_data_pending(const struct Curl_easy *data)
! 2044: {
! 2045: /* We may have received more data than we're able to hold in the receive
! 2046: buffer and allocated an overflow buffer. Since it's possible that
! 2047: there's no more data coming on the socket, we need to keep reading
! 2048: until the overflow buffer is empty. */
! 2049: const struct HTTP *stream = data->req.protop;
! 2050: return stream->overflow_buflen > 0;
! 2051: }
! 2052:
! 2053: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngtcp2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib / vquic