Annotation of embedaddon/curl/lib/vquic/quiche.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_QUICHE
! 26: #include <quiche.h>
! 27: #include <openssl/err.h>
! 28: #include "urldata.h"
! 29: #include "sendf.h"
! 30: #include "strdup.h"
! 31: #include "rand.h"
! 32: #include "quic.h"
! 33: #include "strcase.h"
! 34: #include "multiif.h"
! 35: #include "connect.h"
! 36: #include "strerror.h"
! 37:
! 38: /* The last 3 #include files should be in this order */
! 39: #include "curl_printf.h"
! 40: #include "curl_memory.h"
! 41: #include "memdebug.h"
! 42:
! 43: #define DEBUG_HTTP3
! 44: /* #define DEBUG_QUICHE */
! 45: #ifdef DEBUG_HTTP3
! 46: #define H3BUGF(x) x
! 47: #else
! 48: #define H3BUGF(x) do { } while(0)
! 49: #endif
! 50:
! 51: #define QUIC_MAX_STREAMS (256*1024)
! 52: #define QUIC_MAX_DATA (1*1024*1024)
! 53: #define QUIC_IDLE_TIMEOUT (60 * 1000) /* milliseconds */
! 54:
! 55: static CURLcode process_ingress(struct connectdata *conn,
! 56: curl_socket_t sockfd,
! 57: struct quicsocket *qs);
! 58:
! 59: static CURLcode flush_egress(struct connectdata *conn, curl_socket_t sockfd,
! 60: struct quicsocket *qs);
! 61:
! 62: static CURLcode http_request(struct connectdata *conn, const void *mem,
! 63: size_t len);
! 64: static Curl_recv h3_stream_recv;
! 65: static Curl_send h3_stream_send;
! 66:
! 67:
! 68: static int quiche_getsock(struct connectdata *conn, curl_socket_t *socks)
! 69: {
! 70: struct SingleRequest *k = &conn->data->req;
! 71: int bitmap = GETSOCK_BLANK;
! 72:
! 73: socks[0] = conn->sock[FIRSTSOCKET];
! 74:
! 75: /* in a HTTP/2 connection we can basically always get a frame so we should
! 76: always be ready for one */
! 77: bitmap |= GETSOCK_READSOCK(FIRSTSOCKET);
! 78:
! 79: /* we're still uploading or the HTTP/2 layer wants to send data */
! 80: if((k->keepon & (KEEP_SEND|KEEP_SEND_PAUSE)) == KEEP_SEND)
! 81: bitmap |= GETSOCK_WRITESOCK(FIRSTSOCKET);
! 82:
! 83: return bitmap;
! 84: }
! 85:
! 86: static int quiche_perform_getsock(const struct connectdata *conn,
! 87: curl_socket_t *socks)
! 88: {
! 89: return quiche_getsock((struct connectdata *)conn, socks);
! 90: }
! 91:
! 92: static CURLcode quiche_disconnect(struct connectdata *conn,
! 93: bool dead_connection)
! 94: {
! 95: struct quicsocket *qs = conn->quic;
! 96: (void)dead_connection;
! 97: quiche_h3_config_free(qs->h3config);
! 98: quiche_h3_conn_free(qs->h3c);
! 99: quiche_config_free(qs->cfg);
! 100: quiche_conn_free(qs->conn);
! 101: return CURLE_OK;
! 102: }
! 103:
! 104: static unsigned int quiche_conncheck(struct connectdata *conn,
! 105: unsigned int checks_to_perform)
! 106: {
! 107: (void)conn;
! 108: (void)checks_to_perform;
! 109: return CONNRESULT_NONE;
! 110: }
! 111:
! 112: static CURLcode quiche_do(struct connectdata *conn, bool *done)
! 113: {
! 114: struct HTTP *stream = conn->data->req.protop;
! 115: stream->h3req = FALSE; /* not sent */
! 116: return Curl_http(conn, done);
! 117: }
! 118:
! 119: static const struct Curl_handler Curl_handler_http3 = {
! 120: "HTTPS", /* scheme */
! 121: ZERO_NULL, /* setup_connection */
! 122: quiche_do, /* do_it */
! 123: Curl_http_done, /* done */
! 124: ZERO_NULL, /* do_more */
! 125: ZERO_NULL, /* connect_it */
! 126: ZERO_NULL, /* connecting */
! 127: ZERO_NULL, /* doing */
! 128: quiche_getsock, /* proto_getsock */
! 129: quiche_getsock, /* doing_getsock */
! 130: ZERO_NULL, /* domore_getsock */
! 131: quiche_perform_getsock, /* perform_getsock */
! 132: quiche_disconnect, /* disconnect */
! 133: ZERO_NULL, /* readwrite */
! 134: quiche_conncheck, /* connection_check */
! 135: PORT_HTTP, /* defport */
! 136: CURLPROTO_HTTPS, /* protocol */
! 137: PROTOPT_SSL | PROTOPT_STREAM /* flags */
! 138: };
! 139:
! 140: #ifdef DEBUG_QUICHE
! 141: static void quiche_debug_log(const char *line, void *argp)
! 142: {
! 143: (void)argp;
! 144: fprintf(stderr, "%s\n", line);
! 145: }
! 146: #endif
! 147:
! 148: CURLcode Curl_quic_connect(struct connectdata *conn, curl_socket_t sockfd,
! 149: int sockindex,
! 150: const struct sockaddr *addr, socklen_t addrlen)
! 151: {
! 152: CURLcode result;
! 153: struct quicsocket *qs = &conn->hequic[sockindex];
! 154: struct Curl_easy *data = conn->data;
! 155:
! 156: #ifdef DEBUG_QUICHE
! 157: /* initialize debug log callback only once */
! 158: static int debug_log_init = 0;
! 159: if(!debug_log_init) {
! 160: quiche_enable_debug_logging(quiche_debug_log, NULL);
! 161: debug_log_init = 1;
! 162: }
! 163: #endif
! 164:
! 165: (void)addr;
! 166: (void)addrlen;
! 167:
! 168: qs->cfg = quiche_config_new(QUICHE_PROTOCOL_VERSION);
! 169: if(!qs->cfg) {
! 170: failf(data, "can't create quiche config");
! 171: return CURLE_FAILED_INIT;
! 172: }
! 173:
! 174: quiche_config_set_max_idle_timeout(qs->cfg, QUIC_IDLE_TIMEOUT);
! 175: quiche_config_set_initial_max_data(qs->cfg, QUIC_MAX_DATA);
! 176: quiche_config_set_initial_max_stream_data_bidi_local(qs->cfg, QUIC_MAX_DATA);
! 177: quiche_config_set_initial_max_stream_data_bidi_remote(qs->cfg,
! 178: QUIC_MAX_DATA);
! 179: quiche_config_set_initial_max_stream_data_uni(qs->cfg, QUIC_MAX_DATA);
! 180: quiche_config_set_initial_max_streams_bidi(qs->cfg, QUIC_MAX_STREAMS);
! 181: quiche_config_set_initial_max_streams_uni(qs->cfg, QUIC_MAX_STREAMS);
! 182: quiche_config_set_application_protos(qs->cfg,
! 183: (uint8_t *)
! 184: QUICHE_H3_APPLICATION_PROTOCOL,
! 185: sizeof(QUICHE_H3_APPLICATION_PROTOCOL)
! 186: - 1);
! 187:
! 188: result = Curl_rand(data, qs->scid, sizeof(qs->scid));
! 189: if(result)
! 190: return result;
! 191:
! 192: if(getenv("SSLKEYLOGFILE"))
! 193: quiche_config_log_keys(qs->cfg);
! 194:
! 195: qs->conn = quiche_connect(conn->host.name, (const uint8_t *) qs->scid,
! 196: sizeof(qs->scid), qs->cfg);
! 197: if(!qs->conn) {
! 198: failf(data, "can't create quiche connection");
! 199: return CURLE_OUT_OF_MEMORY;
! 200: }
! 201:
! 202: result = flush_egress(conn, sockfd, qs);
! 203: if(result)
! 204: return result;
! 205:
! 206: /* store the used address as a string */
! 207: if(!Curl_addr2string((struct sockaddr*)addr, addrlen,
! 208: conn->primary_ip, &conn->primary_port)) {
! 209: char buffer[STRERROR_LEN];
! 210: failf(data, "ssrem inet_ntop() failed with errno %d: %s",
! 211: SOCKERRNO, Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
! 212: return CURLE_BAD_FUNCTION_ARGUMENT;
! 213: }
! 214: memcpy(conn->ip_addr_str, conn->primary_ip, MAX_IPADR_LEN);
! 215: Curl_persistconninfo(conn);
! 216:
! 217: /* for connection reuse purposes: */
! 218: conn->ssl[FIRSTSOCKET].state = ssl_connection_complete;
! 219:
! 220: infof(data, "Sent QUIC client Initial, ALPN: %s\n",
! 221: QUICHE_H3_APPLICATION_PROTOCOL + 1);
! 222:
! 223: return CURLE_OK;
! 224: }
! 225:
! 226: static CURLcode quiche_has_connected(struct connectdata *conn,
! 227: int sockindex,
! 228: int tempindex)
! 229: {
! 230: CURLcode result;
! 231: struct quicsocket *qs = conn->quic = &conn->hequic[tempindex];
! 232:
! 233: conn->recv[sockindex] = h3_stream_recv;
! 234: conn->send[sockindex] = h3_stream_send;
! 235: conn->handler = &Curl_handler_http3;
! 236: conn->bits.multiplex = TRUE; /* at least potentially multiplexed */
! 237: conn->httpversion = 30;
! 238: conn->bundle->multiuse = BUNDLE_MULTIPLEX;
! 239:
! 240: qs->h3config = quiche_h3_config_new();
! 241: if(!qs->h3config)
! 242: return CURLE_OUT_OF_MEMORY;
! 243:
! 244: /* Create a new HTTP/3 connection on the QUIC connection. */
! 245: qs->h3c = quiche_h3_conn_new_with_transport(qs->conn, qs->h3config);
! 246: if(!qs->h3c) {
! 247: result = CURLE_OUT_OF_MEMORY;
! 248: goto fail;
! 249: }
! 250: if(conn->hequic[1-tempindex].cfg) {
! 251: qs = &conn->hequic[1-tempindex];
! 252: quiche_config_free(qs->cfg);
! 253: quiche_conn_free(qs->conn);
! 254: qs->cfg = NULL;
! 255: qs->conn = NULL;
! 256: }
! 257: return CURLE_OK;
! 258: fail:
! 259: quiche_h3_config_free(qs->h3config);
! 260: quiche_h3_conn_free(qs->h3c);
! 261: return result;
! 262: }
! 263:
! 264: /*
! 265: * This function gets polled to check if this QUIC connection has connected.
! 266: */
! 267: CURLcode Curl_quic_is_connected(struct connectdata *conn, int sockindex,
! 268: bool *done)
! 269: {
! 270: CURLcode result;
! 271: struct quicsocket *qs = &conn->hequic[sockindex];
! 272: curl_socket_t sockfd = conn->tempsock[sockindex];
! 273:
! 274: result = process_ingress(conn, sockfd, qs);
! 275: if(result)
! 276: return result;
! 277:
! 278: result = flush_egress(conn, sockfd, qs);
! 279: if(result)
! 280: return result;
! 281:
! 282: if(quiche_conn_is_established(qs->conn)) {
! 283: *done = TRUE;
! 284: result = quiche_has_connected(conn, 0, sockindex);
! 285: DEBUGF(infof(conn->data, "quiche established connection!\n"));
! 286: }
! 287:
! 288: return result;
! 289: }
! 290:
! 291: static CURLcode process_ingress(struct connectdata *conn, int sockfd,
! 292: struct quicsocket *qs)
! 293: {
! 294: ssize_t recvd;
! 295: struct Curl_easy *data = conn->data;
! 296: uint8_t *buf = (uint8_t *)data->state.buffer;
! 297: size_t bufsize = data->set.buffer_size;
! 298:
! 299: /* in case the timeout expired */
! 300: quiche_conn_on_timeout(qs->conn);
! 301:
! 302: do {
! 303: recvd = recv(sockfd, buf, bufsize, 0);
! 304: if((recvd < 0) && ((SOCKERRNO == EAGAIN) || (SOCKERRNO == EWOULDBLOCK)))
! 305: break;
! 306:
! 307: if(recvd < 0) {
! 308: failf(conn->data, "quiche: recv() unexpectedly returned %d "
! 309: "(errno: %d, socket %d)", recvd, SOCKERRNO, sockfd);
! 310: return CURLE_RECV_ERROR;
! 311: }
! 312:
! 313: recvd = quiche_conn_recv(qs->conn, buf, recvd);
! 314: if(recvd == QUICHE_ERR_DONE)
! 315: break;
! 316:
! 317: if(recvd < 0) {
! 318: failf(conn->data, "quiche_conn_recv() == %d", recvd);
! 319: return CURLE_RECV_ERROR;
! 320: }
! 321: } while(1);
! 322:
! 323: return CURLE_OK;
! 324: }
! 325:
! 326: /*
! 327: * flush_egress drains the buffers and sends off data.
! 328: * Calls failf() on errors.
! 329: */
! 330: static CURLcode flush_egress(struct connectdata *conn, int sockfd,
! 331: struct quicsocket *qs)
! 332: {
! 333: ssize_t sent;
! 334: static uint8_t out[1200];
! 335: int64_t timeout_ns;
! 336:
! 337: do {
! 338: sent = quiche_conn_send(qs->conn, out, sizeof(out));
! 339: if(sent == QUICHE_ERR_DONE)
! 340: break;
! 341:
! 342: if(sent < 0) {
! 343: failf(conn->data, "quiche_conn_send returned %zd\n",
! 344: sent);
! 345: return CURLE_SEND_ERROR;
! 346: }
! 347:
! 348: sent = send(sockfd, out, sent, 0);
! 349: if(sent < 0) {
! 350: failf(conn->data, "send() returned %zd\n", sent);
! 351: return CURLE_SEND_ERROR;
! 352: }
! 353: } while(1);
! 354:
! 355: /* time until the next timeout event, as nanoseconds. */
! 356: timeout_ns = quiche_conn_timeout_as_nanos(qs->conn);
! 357: if(timeout_ns)
! 358: /* expire uses milliseconds */
! 359: Curl_expire(conn->data, (timeout_ns + 999999) / 1000000, EXPIRE_QUIC);
! 360:
! 361: return CURLE_OK;
! 362: }
! 363:
! 364: struct h3h1header {
! 365: char *dest;
! 366: size_t destlen; /* left to use */
! 367: size_t nlen; /* used */
! 368: };
! 369:
! 370: static int cb_each_header(uint8_t *name, size_t name_len,
! 371: uint8_t *value, size_t value_len,
! 372: void *argp)
! 373: {
! 374: struct h3h1header *headers = (struct h3h1header *)argp;
! 375: size_t olen = 0;
! 376:
! 377: if((name_len == 7) && !strncmp(":status", (char *)name, 7)) {
! 378: msnprintf(headers->dest,
! 379: headers->destlen, "HTTP/3 %.*s\n",
! 380: (int) value_len, value);
! 381: }
! 382: else if(!headers->nlen) {
! 383: return CURLE_HTTP3;
! 384: }
! 385: else {
! 386: msnprintf(headers->dest,
! 387: headers->destlen, "%.*s: %.*s\n",
! 388: (int)name_len, name, (int) value_len, value);
! 389: }
! 390: olen = strlen(headers->dest);
! 391: headers->destlen -= olen;
! 392: headers->nlen += olen;
! 393: headers->dest += olen;
! 394: return 0;
! 395: }
! 396:
! 397: static ssize_t h3_stream_recv(struct connectdata *conn,
! 398: int sockindex,
! 399: char *buf,
! 400: size_t buffersize,
! 401: CURLcode *curlcode)
! 402: {
! 403: ssize_t recvd = -1;
! 404: ssize_t rcode;
! 405: struct quicsocket *qs = conn->quic;
! 406: curl_socket_t sockfd = conn->sock[sockindex];
! 407: quiche_h3_event *ev;
! 408: int rc;
! 409: struct h3h1header headers;
! 410: struct Curl_easy *data = conn->data;
! 411: struct HTTP *stream = data->req.protop;
! 412: headers.dest = buf;
! 413: headers.destlen = buffersize;
! 414: headers.nlen = 0;
! 415:
! 416: if(process_ingress(conn, sockfd, qs)) {
! 417: infof(data, "h3_stream_recv returns on ingress\n");
! 418: *curlcode = CURLE_RECV_ERROR;
! 419: return -1;
! 420: }
! 421:
! 422: while(recvd < 0) {
! 423: int64_t s = quiche_h3_conn_poll(qs->h3c, qs->conn, &ev);
! 424: if(s < 0)
! 425: /* nothing more to do */
! 426: break;
! 427:
! 428: if(s != stream->stream3_id) {
! 429: /* another transfer, ignore for now */
! 430: infof(data, "Got h3 for stream %u, expects %u\n",
! 431: s, stream->stream3_id);
! 432: continue;
! 433: }
! 434:
! 435: switch(quiche_h3_event_type(ev)) {
! 436: case QUICHE_H3_EVENT_HEADERS:
! 437: rc = quiche_h3_event_for_each_header(ev, cb_each_header, &headers);
! 438: if(rc) {
! 439: *curlcode = rc;
! 440: failf(data, "Error in HTTP/3 response header");
! 441: break;
! 442: }
! 443: recvd = headers.nlen;
! 444: break;
! 445: case QUICHE_H3_EVENT_DATA:
! 446: if(!stream->firstbody) {
! 447: /* add a header-body separator CRLF */
! 448: buf[0] = '\r';
! 449: buf[1] = '\n';
! 450: buf += 2;
! 451: buffersize -= 2;
! 452: stream->firstbody = TRUE;
! 453: recvd = 2; /* two bytes already */
! 454: }
! 455: else
! 456: recvd = 0;
! 457: rcode = quiche_h3_recv_body(qs->h3c, qs->conn, s, (unsigned char *)buf,
! 458: buffersize);
! 459: if(rcode <= 0) {
! 460: recvd = -1;
! 461: break;
! 462: }
! 463: recvd += rcode;
! 464: break;
! 465:
! 466: case QUICHE_H3_EVENT_FINISHED:
! 467: streamclose(conn, "End of stream");
! 468: recvd = 0; /* end of stream */
! 469: break;
! 470: default:
! 471: break;
! 472: }
! 473:
! 474: quiche_h3_event_free(ev);
! 475: }
! 476: if(flush_egress(conn, sockfd, qs)) {
! 477: *curlcode = CURLE_SEND_ERROR;
! 478: return -1;
! 479: }
! 480:
! 481: *curlcode = (-1 == recvd)? CURLE_AGAIN : CURLE_OK;
! 482: if(recvd >= 0)
! 483: /* Get this called again to drain the event queue */
! 484: Curl_expire(data, 0, EXPIRE_QUIC);
! 485:
! 486: data->state.drain = (recvd >= 0) ? 1 : 0;
! 487: return recvd;
! 488: }
! 489:
! 490: static ssize_t h3_stream_send(struct connectdata *conn,
! 491: int sockindex,
! 492: const void *mem,
! 493: size_t len,
! 494: CURLcode *curlcode)
! 495: {
! 496: ssize_t sent;
! 497: struct quicsocket *qs = conn->quic;
! 498: curl_socket_t sockfd = conn->sock[sockindex];
! 499: struct HTTP *stream = conn->data->req.protop;
! 500:
! 501: if(!stream->h3req) {
! 502: CURLcode result = http_request(conn, mem, len);
! 503: if(result) {
! 504: *curlcode = CURLE_SEND_ERROR;
! 505: return -1;
! 506: }
! 507: sent = len;
! 508: }
! 509: else {
! 510: H3BUGF(infof(conn->data, "Pass on %zd body bytes to quiche\n",
! 511: len));
! 512: sent = quiche_h3_send_body(qs->h3c, qs->conn, stream->stream3_id,
! 513: (uint8_t *)mem, len, FALSE);
! 514: if(sent < 0) {
! 515: *curlcode = CURLE_SEND_ERROR;
! 516: return -1;
! 517: }
! 518: }
! 519:
! 520: if(flush_egress(conn, sockfd, qs)) {
! 521: *curlcode = CURLE_SEND_ERROR;
! 522: return -1;
! 523: }
! 524:
! 525: *curlcode = CURLE_OK;
! 526: return sent;
! 527: }
! 528:
! 529: /*
! 530: * Store quiche version info in this buffer, Prefix with a space. Return total
! 531: * length written.
! 532: */
! 533: int Curl_quic_ver(char *p, size_t len)
! 534: {
! 535: return msnprintf(p, len, "quiche/%s", quiche_version());
! 536: }
! 537:
! 538: /* Index where :authority header field will appear in request header
! 539: field list. */
! 540: #define AUTHORITY_DST_IDX 3
! 541:
! 542: static CURLcode http_request(struct connectdata *conn, const void *mem,
! 543: size_t len)
! 544: {
! 545: /*
! 546: */
! 547: struct HTTP *stream = conn->data->req.protop;
! 548: size_t nheader;
! 549: size_t i;
! 550: size_t authority_idx;
! 551: char *hdbuf = (char *)mem;
! 552: char *end, *line_end;
! 553: int64_t stream3_id;
! 554: quiche_h3_header *nva = NULL;
! 555: struct quicsocket *qs = conn->quic;
! 556: CURLcode result = CURLE_OK;
! 557: struct Curl_easy *data = conn->data;
! 558:
! 559: stream->h3req = TRUE; /* senf off! */
! 560:
! 561: /* Calculate number of headers contained in [mem, mem + len). Assumes a
! 562: correctly generated HTTP header field block. */
! 563: nheader = 0;
! 564: for(i = 1; i < len; ++i) {
! 565: if(hdbuf[i] == '\n' && hdbuf[i - 1] == '\r') {
! 566: ++nheader;
! 567: ++i;
! 568: }
! 569: }
! 570: if(nheader < 2)
! 571: goto fail;
! 572:
! 573: /* We counted additional 2 \r\n in the first and last line. We need 3
! 574: new headers: :method, :path and :scheme. Therefore we need one
! 575: more space. */
! 576: nheader += 1;
! 577: nva = malloc(sizeof(quiche_h3_header) * nheader);
! 578: if(!nva) {
! 579: result = CURLE_OUT_OF_MEMORY;
! 580: goto fail;
! 581: }
! 582:
! 583: /* Extract :method, :path from request line
! 584: We do line endings with CRLF so checking for CR is enough */
! 585: line_end = memchr(hdbuf, '\r', len);
! 586: if(!line_end) {
! 587: result = CURLE_BAD_FUNCTION_ARGUMENT; /* internal error */
! 588: goto fail;
! 589: }
! 590:
! 591: /* Method does not contain spaces */
! 592: end = memchr(hdbuf, ' ', line_end - hdbuf);
! 593: if(!end || end == hdbuf)
! 594: goto fail;
! 595: nva[0].name = (unsigned char *)":method";
! 596: nva[0].name_len = strlen((char *)nva[0].name);
! 597: nva[0].value = (unsigned char *)hdbuf;
! 598: nva[0].value_len = (size_t)(end - hdbuf);
! 599:
! 600: hdbuf = end + 1;
! 601:
! 602: /* Path may contain spaces so scan backwards */
! 603: end = NULL;
! 604: for(i = (size_t)(line_end - hdbuf); i; --i) {
! 605: if(hdbuf[i - 1] == ' ') {
! 606: end = &hdbuf[i - 1];
! 607: break;
! 608: }
! 609: }
! 610: if(!end || end == hdbuf)
! 611: goto fail;
! 612: nva[1].name = (unsigned char *)":path";
! 613: nva[1].name_len = strlen((char *)nva[1].name);
! 614: nva[1].value = (unsigned char *)hdbuf;
! 615: nva[1].value_len = (size_t)(end - hdbuf);
! 616:
! 617: nva[2].name = (unsigned char *)":scheme";
! 618: nva[2].name_len = strlen((char *)nva[2].name);
! 619: if(conn->handler->flags & PROTOPT_SSL)
! 620: nva[2].value = (unsigned char *)"https";
! 621: else
! 622: nva[2].value = (unsigned char *)"http";
! 623: nva[2].value_len = strlen((char *)nva[2].value);
! 624:
! 625:
! 626: authority_idx = 0;
! 627: i = 3;
! 628: while(i < nheader) {
! 629: size_t hlen;
! 630:
! 631: hdbuf = line_end + 2;
! 632:
! 633: /* check for next CR, but only within the piece of data left in the given
! 634: buffer */
! 635: line_end = memchr(hdbuf, '\r', len - (hdbuf - (char *)mem));
! 636: if(!line_end || (line_end == hdbuf))
! 637: goto fail;
! 638:
! 639: /* header continuation lines are not supported */
! 640: if(*hdbuf == ' ' || *hdbuf == '\t')
! 641: goto fail;
! 642:
! 643: for(end = hdbuf; end < line_end && *end != ':'; ++end)
! 644: ;
! 645: if(end == hdbuf || end == line_end)
! 646: goto fail;
! 647: hlen = end - hdbuf;
! 648:
! 649: if(hlen == 4 && strncasecompare("host", hdbuf, 4)) {
! 650: authority_idx = i;
! 651: nva[i].name = (unsigned char *)":authority";
! 652: nva[i].name_len = strlen((char *)nva[i].name);
! 653: }
! 654: else {
! 655: nva[i].name_len = (size_t)(end - hdbuf);
! 656: /* Lower case the header name for HTTP/3 */
! 657: Curl_strntolower((char *)hdbuf, hdbuf, nva[i].name_len);
! 658: nva[i].name = (unsigned char *)hdbuf;
! 659: }
! 660: hdbuf = end + 1;
! 661: while(*hdbuf == ' ' || *hdbuf == '\t')
! 662: ++hdbuf;
! 663: end = line_end;
! 664:
! 665: #if 0 /* This should probably go in more or less like this */
! 666: switch(inspect_header((const char *)nva[i].name, nva[i].namelen, hdbuf,
! 667: end - hdbuf)) {
! 668: case HEADERINST_IGNORE:
! 669: /* skip header fields prohibited by HTTP/2 specification. */
! 670: --nheader;
! 671: continue;
! 672: case HEADERINST_TE_TRAILERS:
! 673: nva[i].value = (uint8_t*)"trailers";
! 674: nva[i].value_len = sizeof("trailers") - 1;
! 675: break;
! 676: default:
! 677: nva[i].value = (unsigned char *)hdbuf;
! 678: nva[i].value_len = (size_t)(end - hdbuf);
! 679: }
! 680: #endif
! 681: nva[i].value = (unsigned char *)hdbuf;
! 682: nva[i].value_len = (size_t)(end - hdbuf);
! 683:
! 684: ++i;
! 685: }
! 686:
! 687: /* :authority must come before non-pseudo header fields */
! 688: if(authority_idx != 0 && authority_idx != AUTHORITY_DST_IDX) {
! 689: quiche_h3_header authority = nva[authority_idx];
! 690: for(i = authority_idx; i > AUTHORITY_DST_IDX; --i) {
! 691: nva[i] = nva[i - 1];
! 692: }
! 693: nva[i] = authority;
! 694: }
! 695:
! 696: /* Warn stream may be rejected if cumulative length of headers is too
! 697: large. */
! 698: #define MAX_ACC 60000 /* <64KB to account for some overhead */
! 699: {
! 700: size_t acc = 0;
! 701:
! 702: for(i = 0; i < nheader; ++i) {
! 703: acc += nva[i].name_len + nva[i].value_len;
! 704:
! 705: H3BUGF(infof(data, "h3 [%.*s: %.*s]\n",
! 706: nva[i].name_len, nva[i].name,
! 707: nva[i].value_len, nva[i].value));
! 708: }
! 709:
! 710: if(acc > MAX_ACC) {
! 711: infof(data, "http_request: Warning: The cumulative length of all "
! 712: "headers exceeds %zu bytes and that could cause the "
! 713: "stream to be rejected.\n", MAX_ACC);
! 714: }
! 715: }
! 716:
! 717: switch(data->set.httpreq) {
! 718: case HTTPREQ_POST:
! 719: case HTTPREQ_POST_FORM:
! 720: case HTTPREQ_POST_MIME:
! 721: case HTTPREQ_PUT:
! 722: if(data->state.infilesize != -1)
! 723: stream->upload_left = data->state.infilesize;
! 724: else
! 725: /* data sending without specifying the data amount up front */
! 726: stream->upload_left = -1; /* unknown, but not zero */
! 727:
! 728: stream3_id = quiche_h3_send_request(qs->h3c, qs->conn, nva, nheader,
! 729: stream->upload_left ? FALSE: TRUE);
! 730: if((stream3_id >= 0) && data->set.postfields) {
! 731: ssize_t sent = quiche_h3_send_body(qs->h3c, qs->conn, stream3_id,
! 732: (uint8_t *)data->set.postfields,
! 733: stream->upload_left, TRUE);
! 734: if(sent <= 0) {
! 735: failf(data, "quiche_h3_send_body failed!");
! 736: result = CURLE_SEND_ERROR;
! 737: }
! 738: stream->upload_left = 0; /* nothing left to send */
! 739: }
! 740: break;
! 741: default:
! 742: stream3_id = quiche_h3_send_request(qs->h3c, qs->conn, nva, nheader,
! 743: TRUE);
! 744: break;
! 745: }
! 746:
! 747: Curl_safefree(nva);
! 748:
! 749: if(stream3_id < 0) {
! 750: H3BUGF(infof(data, "quiche_h3_send_request returned %d\n",
! 751: stream3_id));
! 752: result = CURLE_SEND_ERROR;
! 753: goto fail;
! 754: }
! 755:
! 756: infof(data, "Using HTTP/3 Stream ID: %x (easy handle %p)\n",
! 757: stream3_id, (void *)data);
! 758: stream->stream3_id = stream3_id;
! 759:
! 760: return CURLE_OK;
! 761:
! 762: fail:
! 763: free(nva);
! 764: return result;
! 765: }
! 766:
! 767: /*
! 768: * Called from transfer.c:done_sending when we stop HTTP/3 uploading.
! 769: */
! 770: CURLcode Curl_quic_done_sending(struct connectdata *conn)
! 771: {
! 772: if(conn->handler == &Curl_handler_http3) {
! 773: /* only for HTTP/3 transfers */
! 774: ssize_t sent;
! 775: struct HTTP *stream = conn->data->req.protop;
! 776: struct quicsocket *qs = conn->quic;
! 777: fprintf(stderr, "!!! Curl_quic_done_sending\n");
! 778: stream->upload_done = TRUE;
! 779: sent = quiche_h3_send_body(qs->h3c, qs->conn, stream->stream3_id,
! 780: NULL, 0, TRUE);
! 781: if(sent < 0)
! 782: return CURLE_SEND_ERROR;
! 783: }
! 784:
! 785: return CURLE_OK;
! 786: }
! 787:
! 788: /*
! 789: * Called from http.c:Curl_http_done when a request completes.
! 790: */
! 791: void Curl_quic_done(struct Curl_easy *data, bool premature)
! 792: {
! 793: (void)data;
! 794: (void)premature;
! 795: }
! 796:
! 797: /*
! 798: * Called from transfer.c:data_pending to know if we should keep looping
! 799: * to receive more data from the connection.
! 800: */
! 801: bool Curl_quic_data_pending(const struct Curl_easy *data)
! 802: {
! 803: (void)data;
! 804: return FALSE;
! 805: }
! 806:
! 807: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to quiche.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