luna - curl/lib/vquic/curl

   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"
  25
  26#if !defined(CURL_DISABLE_HTTP) && defined(USE_QUICHE)
  27#include <quiche.h>
  28#include <openssl/err.h>
  29#include <openssl/ssl.h>
  30
  31#include "bufq.h"
  32#include "uint-hash.h"
  33#include "urldata.h"
  34#include "cfilters.h"
  35#include "cf-dns.h"
  36#include "cf-socket.h"
  37#include "curl_trc.h"
  38#include "rand.h"
  39#include "multiif.h"
  40#include "connect.h"
  41#include "progress.h"
  42#include "select.h"
  43#include "http1.h"
  44#include "vquic/vquic.h"
  45#include "vquic/vquic_int.h"
  46#include "vquic/vquic-tls.h"
  47#include "vquic/curl_quiche.h"
  48#include "transfer.h"
  49#include "url.h"
  50#include "bufref.h"
  51#include "vtls/openssl.h"
  52#include "vtls/vtls.h"
  53
  54/* HTTP/3 error values defined in RFC 9114, ch. 8.1 */
  55#define CURL_H3_NO_ERROR  0x0100
  56
  57#define MAX_PKT_BURST          10
  58
  59#define QUIC_MAX_STREAMS       100
  60
  61#define H3_STREAM_WINDOW_SIZE  (1024 * 128)
  62#define H3_STREAM_CHUNK_SIZE   (1024 * 16)
  63/* Receive and Send max number of chunks follows from the
  64 * chunk size and window size */
  65#define H3_STREAM_RECV_CHUNKS \
  66  (H3_STREAM_WINDOW_SIZE / H3_STREAM_CHUNK_SIZE)
  67
  68/*
  69 * Store quiche version info in this buffer.
  70 */
  71void Curl_quiche_ver(char *p, size_t len)
  72{
  73  (void)curl_msnprintf(p, len, "quiche/%s", quiche_version());
  74}
  75
  76struct cf_quiche_ctx {
  77  struct cf_quic_ctx q;
  78  struct ssl_peer peer;
  79  struct curl_tls_ctx tls;
  80  quiche_conn *qconn;
  81  quiche_config *cfg;
  82  quiche_h3_conn *h3c;
  83  quiche_h3_config *h3config;
  84  uint8_t scid[QUICHE_MAX_CONN_ID_LEN];
  85  struct curltime started_at;        /* time the current attempt started */
  86  struct curltime handshake_at;      /* time connect handshake finished */
  87  struct uint_hash streams;          /* hash `data->mid` to `stream_ctx` */
  88  struct dynbuf h1hdr;               /* temp buffer for header construction */
  89  struct bufq writebuf;              /* temp buffer for writing bodies */
  90  curl_off_t data_recvd;
  91  BIT(initialized);
  92  BIT(goaway);                       /* got GOAWAY from server */
  93  BIT(x509_store_setup);             /* if x509 store has been set up */
  94  BIT(shutdown_started);             /* queued shutdown packets */
  95};
  96
  97#ifdef DEBUG_QUICHE
  98/* initialize debug log callback only once */
  99static int debug_log_init = 0;
 100static void quiche_debug_log(const char *line, void *argp)
 101{
 102  (void)argp;
 103  curl_mfprintf(stderr, "%s\n", line);
 104}
 105#endif
 106
 107static void h3_stream_hash_free(unsigned int id, void *stream);
 108
 109static void cf_quiche_ctx_init(struct cf_quiche_ctx *ctx)
 110{
 111  DEBUGASSERT(!ctx->initialized);
 112#ifdef DEBUG_QUICHE
 113  if(!debug_log_init) {
 114    quiche_enable_debug_logging(quiche_debug_log, NULL);
 115    debug_log_init = 1;
 116  }
 117#endif
 118  curlx_dyn_init(&ctx->h1hdr, CURL_MAX_HTTP_HEADER);
 119  Curl_uint32_hash_init(&ctx->streams, 63, h3_stream_hash_free);
 120  Curl_bufq_init2(&ctx->writebuf, H3_STREAM_CHUNK_SIZE, H3_STREAM_RECV_CHUNKS,
 121                  BUFQ_OPT_SOFT_LIMIT);
 122  ctx->data_recvd = 0;
 123  ctx->initialized = TRUE;
 124}
 125
 126static void cf_quiche_ctx_free(struct cf_quiche_ctx *ctx)
 127{
 128  if(ctx && ctx->initialized) {
 129    /* quiche freed it */
 130    ctx->tls.ossl.ssl = NULL;
 131    Curl_vquic_tls_cleanup(&ctx->tls);
 132    Curl_ssl_peer_cleanup(&ctx->peer);
 133    vquic_ctx_free(&ctx->q);
 134    Curl_uint32_hash_destroy(&ctx->streams);
 135    curlx_dyn_free(&ctx->h1hdr);
 136    Curl_bufq_free(&ctx->writebuf);
 137  }
 138  curlx_free(ctx);
 139}
 140
 141static void cf_quiche_ctx_close(struct cf_quiche_ctx *ctx)
 142{
 143  if(ctx->h3c) {
 144    quiche_h3_conn_free(ctx->h3c);
 145    ctx->h3c = NULL;
 146  }
 147  if(ctx->h3config) {
 148    quiche_h3_config_free(ctx->h3config);
 149    ctx->h3config = NULL;
 150  }
 151  if(ctx->qconn) {
 152    quiche_conn_free(ctx->qconn);
 153    ctx->qconn = NULL;
 154  }
 155  if(ctx->cfg) {
 156    quiche_config_free(ctx->cfg);
 157    ctx->cfg = NULL;
 158  }
 159}
 160
 161static CURLcode cf_flush_egress(struct Curl_cfilter *cf,
 162                                struct Curl_easy *data);
 163
 164/**
 165 * All about the H3 internals of a stream
 166 */
 167struct h3_stream_ctx {
 168  uint64_t id;             /* HTTP/3 protocol stream identifier */
 169  struct h1_req_parser h1; /* h1 request parsing */
 170  uint64_t error3;         /* HTTP/3 stream error code */
 171  int status_code;         /* HTTP status code */
 172  CURLcode xfer_result;    /* result from cf_quiche_write_(hd/body) */
 173  BIT(opened);             /* TRUE after stream has been opened */
 174  BIT(closed);             /* TRUE on stream close */
 175  BIT(reset);              /* TRUE on stream reset */
 176  BIT(send_closed);        /* stream is locally closed */
 177  BIT(resp_hds_complete);  /* final response has been received */
 178  BIT(resp_got_header);    /* TRUE when h3 stream has recvd some HEADER */
 179  BIT(quic_flow_blocked);  /* stream is blocked by QUIC flow control */
 180};
 181
 182static void h3_stream_ctx_free(struct h3_stream_ctx *stream)
 183{
 184  Curl_h1_req_parse_free(&stream->h1);
 185  curlx_free(stream);
 186}
 187
 188static void h3_stream_hash_free(unsigned int id, void *stream)
 189{
 190  (void)id;
 191  DEBUGASSERT(stream);
 192  h3_stream_ctx_free((struct h3_stream_ctx *)stream);
 193}
 194
 195typedef bool cf_quiche_svisit(struct Curl_cfilter *cf,
 196                              struct Curl_easy *sdata,
 197                              struct h3_stream_ctx *stream,
 198                              void *user_data);
 199
 200struct cf_quiche_visit_ctx {
 201  struct Curl_cfilter *cf;
 202  struct Curl_multi *multi;
 203  cf_quiche_svisit *cb;
 204  void *user_data;
 205};
 206
 207static bool cf_quiche_stream_do(uint32_t mid, void *val, void *user_data)
 208{
 209  struct cf_quiche_visit_ctx *vctx = user_data;
 210  struct h3_stream_ctx *stream = val;
 211  struct Curl_easy *sdata = Curl_multi_get_easy(vctx->multi, mid);
 212  if(sdata)
 213    return vctx->cb(vctx->cf, sdata, stream, vctx->user_data);
 214  return TRUE;
 215}
 216
 217static void cf_quiche_for_all_streams(struct Curl_cfilter *cf,
 218                                      struct Curl_multi *multi,
 219                                      cf_quiche_svisit *do_cb,
 220                                      void *user_data)
 221{
 222  struct cf_quiche_ctx *ctx = cf->ctx;
 223  struct cf_quiche_visit_ctx vctx;
 224  vctx.cf = cf;
 225  vctx.multi = multi;
 226  vctx.cb = do_cb;
 227  vctx.user_data = user_data;
 228  Curl_uint32_hash_visit(&ctx->streams, cf_quiche_stream_do, &vctx);
 229}
 230
 231static bool cf_quiche_do_resume(struct Curl_cfilter *cf,
 232                                struct Curl_easy *sdata,
 233                                struct h3_stream_ctx *stream,
 234                                void *user_data)
 235{
 236  (void)user_data;
 237  if(stream->quic_flow_blocked) {
 238    stream->quic_flow_blocked = FALSE;
 239    Curl_multi_mark_dirty(sdata);
 240    CURL_TRC_CF(sdata, cf, "[%" PRIu64 "] unblock", stream->id);
 241  }
 242  return TRUE;
 243}
 244
 245static bool cf_quiche_do_expire(struct Curl_cfilter *cf,
 246                                struct Curl_easy *sdata,
 247                                struct h3_stream_ctx *stream,
 248                                void *user_data)
 249{
 250  (void)stream;
 251  (void)user_data;
 252  CURL_TRC_CF(sdata, cf, "conn closed, mark as dirty");
 253  stream->xfer_result = CURLE_SEND_ERROR;
 254  Curl_multi_mark_dirty(sdata);
 255  return TRUE;
 256}
 257
 258static CURLcode h3_data_setup(struct Curl_cfilter *cf,
 259                              struct Curl_easy *data)
 260{
 261  struct cf_quiche_ctx *ctx = cf->ctx;
 262  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
 263
 264  if(stream)
 265    return CURLE_OK;
 266
 267  stream = curlx_calloc(1, sizeof(*stream));
 268  if(!stream)
 269    return CURLE_OUT_OF_MEMORY;
 270
 271  stream->id = -1;
 272  Curl_h1_req_parse_init(&stream->h1, H1_PARSE_DEFAULT_MAX_LINE_LEN);
 273
 274  if(!Curl_uint32_hash_set(&ctx->streams, data->mid, stream)) {
 275    h3_stream_ctx_free(stream);
 276    return CURLE_OUT_OF_MEMORY;
 277  }
 278
 279  return CURLE_OK;
 280}
 281
 282static void cf_quiche_stream_close(struct Curl_cfilter *cf,
 283                                   struct Curl_easy *data,
 284                                   struct h3_stream_ctx *stream)
 285{
 286  struct cf_quiche_ctx *ctx = cf->ctx;
 287  CURLcode result;
 288
 289  if(ctx->qconn && !stream->closed) {
 290    quiche_conn_stream_shutdown(ctx->qconn, stream->id,
 291                                QUICHE_SHUTDOWN_READ, CURL_H3_NO_ERROR);
 292    if(!stream->send_closed) {
 293      quiche_conn_stream_shutdown(ctx->qconn, stream->id,
 294                                  QUICHE_SHUTDOWN_WRITE, CURL_H3_NO_ERROR);
 295      stream->send_closed = TRUE;
 296    }
 297    stream->closed = TRUE;
 298    result = cf_flush_egress(cf, data);
 299    if(result)
 300      CURL_TRC_CF(data, cf, "[%" PRIu64 "] stream close, flush egress -> %d",
 301                  stream->id, result);
 302  }
 303}
 304
 305static void h3_data_done(struct Curl_cfilter *cf, struct Curl_easy *data)
 306{
 307  struct cf_quiche_ctx *ctx = cf->ctx;
 308  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
 309
 310  (void)cf;
 311  if(stream) {
 312    CURL_TRC_CF(data, cf, "[%" PRIu64 "] easy handle is done", stream->id);
 313    cf_quiche_stream_close(cf, data, stream);
 314    Curl_uint32_hash_remove(&ctx->streams, data->mid);
 315  }
 316}
 317
 318static void cf_quiche_expire_conn_closed(struct Curl_cfilter *cf,
 319                                         struct Curl_easy *data)
 320{
 321  DEBUGASSERT(data->multi);
 322  CURL_TRC_CF(data, cf, "conn closed, expire all transfers");
 323  cf_quiche_for_all_streams(cf, data->multi, cf_quiche_do_expire, NULL);
 324}
 325
 326static void cf_quiche_write_hd(struct Curl_cfilter *cf,
 327                               struct Curl_easy *data,
 328                               struct h3_stream_ctx *stream,
 329                               const char *buf, size_t blen, bool eos)
 330{
 331  /* This function returns no error intentionally, but records
 332   * the result at the stream, skipping further writes once the
 333   * `result` of the transfer is known.
 334   * The stream is subsequently cancelled "higher up" in the filter's
 335   * send/recv callbacks. Closing the stream here leads to SEND/RECV
 336   * errors in other places that then overwrite the transfer's result. */
 337  if(!stream->xfer_result) {
 338    stream->xfer_result = Curl_xfer_write_resp_hd(data, buf, blen, eos);
 339    if(stream->xfer_result)
 340      CURL_TRC_CF(data, cf, "[%" PRIu64 "] error %d writing %zu "
 341                  "bytes of headers", stream->id, stream->xfer_result, blen);
 342  }
 343}
 344
 345struct cb_ctx {
 346  struct Curl_cfilter *cf;
 347  struct Curl_easy *data;
 348  struct h3_stream_ctx *stream;
 349};
 350
 351static bool is_valid_h3_header(const uint8_t *hdr, size_t hlen)
 352{
 353  while(hlen--) {
 354    switch(*hdr++) {
 355    case '\n':
 356    case '\r':
 357    case '\0':
 358      return FALSE;
 359    }
 360  }
 361  return TRUE;
 362}
 363
 364static int cb_each_header(uint8_t *name, size_t name_len,
 365                          uint8_t *value, size_t value_len,
 366                          void *argp)
 367{
 368  struct cb_ctx *x = argp;
 369  struct Curl_cfilter *cf = x->cf;
 370  struct Curl_easy *data = x->data;
 371  struct h3_stream_ctx *stream = x->stream;
 372  struct cf_quiche_ctx *ctx = cf->ctx;
 373  CURLcode result = CURLE_OK;
 374
 375  if(!stream || stream->xfer_result)
 376    return 1; /* abort iteration */
 377
 378  if((name_len == 7) && !strncmp(HTTP_PSEUDO_STATUS, (char *)name, 7) &&
 379     is_valid_h3_header(value, value_len)) {
 380    curlx_dyn_reset(&ctx->h1hdr);
 381    result = Curl_http_decode_status(&stream->status_code,
 382                                     (const char *)value, value_len);
 383    if(!result)
 384      result = curlx_dyn_addn(&ctx->h1hdr, STRCONST("HTTP/3 "));
 385    if(!result)
 386      result = curlx_dyn_addn(&ctx->h1hdr, (const char *)value, value_len);
 387    if(!result)
 388      result = curlx_dyn_addn(&ctx->h1hdr, STRCONST(" \r\n"));
 389    if(!result)
 390      cf_quiche_write_hd(cf, data, stream, curlx_dyn_ptr(&ctx->h1hdr),
 391                         curlx_dyn_len(&ctx->h1hdr), FALSE);
 392    CURL_TRC_CF(data, cf, "[%" PRIu64 "] status: %s",
 393                stream->id, curlx_dyn_ptr(&ctx->h1hdr));
 394  }
 395  else {
 396    if(is_valid_h3_header(value, value_len) &&
 397       is_valid_h3_header(name, name_len)) {
 398      /* store as an HTTP1-style header */
 399      CURL_TRC_CF(data, cf, "[%" PRIu64 "] header: %.*s: %.*s",
 400                  stream->id, (int)name_len, name,
 401                  (int)value_len, value);
 402      curlx_dyn_reset(&ctx->h1hdr);
 403      result = curlx_dyn_addn(&ctx->h1hdr, (const char *)name, name_len);
 404      if(!result)
 405        result = curlx_dyn_addn(&ctx->h1hdr, STRCONST(": "));
 406      if(!result)
 407        result = curlx_dyn_addn(&ctx->h1hdr, (const char *)value, value_len);
 408      if(!result)
 409        result = curlx_dyn_addn(&ctx->h1hdr, STRCONST("\r\n"));
 410      if(!result)
 411        cf_quiche_write_hd(cf, data, stream, curlx_dyn_ptr(&ctx->h1hdr),
 412                           curlx_dyn_len(&ctx->h1hdr), FALSE);
 413    }
 414    else
 415      CURL_TRC_CF(x->data, x->cf, "[%" PRIu64 "] ignore %zu bytes bad header",
 416                  stream->id, value_len + name_len);
 417  }
 418
 419  if(result) {
 420    CURL_TRC_CF(x->data, x->cf, "[%" PRIu64 "] on header error %d",
 421                stream->id, result);
 422    if(!stream->xfer_result)
 423      stream->xfer_result = result;
 424  }
 425  return stream->xfer_result ? 1 : 0;
 426}
 427
 428static CURLcode stream_resp_read(void *reader_ctx,
 429                                 unsigned char *buf, size_t len,
 430                                 size_t *pnread)
 431{
 432  struct cb_ctx *x = reader_ctx;
 433  struct cf_quiche_ctx *ctx = x->cf->ctx;
 434  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, x->data);
 435  ssize_t nread;
 436
 437  *pnread = 0;
 438  if(!stream)
 439    return CURLE_RECV_ERROR;
 440
 441  nread = quiche_h3_recv_body(ctx->h3c, ctx->qconn, stream->id, buf, len);
 442  if(!curlx_sztouz(nread, pnread))
 443    return CURLE_AGAIN;
 444  return CURLE_OK;
 445}
 446
 447static void cf_quiche_flush_body(struct Curl_cfilter *cf,
 448                                 struct Curl_easy *data,
 449                                 struct h3_stream_ctx *stream)
 450{
 451  struct cf_quiche_ctx *ctx = cf->ctx;
 452  const uint8_t *buf;
 453  size_t blen;
 454
 455  while(stream && !stream->xfer_result) {
 456    if(Curl_bufq_peek(&ctx->writebuf, &buf, &blen)) {
 457      stream->xfer_result = Curl_xfer_write_resp(
 458        data, (const char *)buf, blen, FALSE);
 459      Curl_bufq_skip(&ctx->writebuf, blen);
 460      if(stream->xfer_result) {
 461        CURL_TRC_CF(data, cf, "[%" PRIu64 "] error %d writing %zu bytes"
 462                    " of data", stream->id, stream->xfer_result, blen);
 463      }
 464    }
 465    else
 466      break;
 467  }
 468  Curl_bufq_reset(&ctx->writebuf);
 469}
 470
 471static void cf_quiche_recv_body(struct Curl_cfilter *cf,
 472                                struct Curl_easy *data,
 473                                struct h3_stream_ctx *stream)
 474{
 475  struct cf_quiche_ctx *ctx = cf->ctx;
 476  size_t nread;
 477  struct cb_ctx cb_ctx;
 478  CURLcode result = CURLE_OK;
 479
 480  if(!stream)
 481    return;
 482
 483  /* Even when the transfer has already errored, we need to receive
 484   * the data from quiche, as quiche otherwise gets stuck and
 485   * raise events to receive over and over again. */
 486  cb_ctx.cf = cf;
 487  cb_ctx.data = data;
 488  cb_ctx.stream = stream;
 489  Curl_bufq_reset(&ctx->writebuf);
 490  while(!result) {
 491    result = Curl_bufq_slurp(&ctx->writebuf,
 492                             stream_resp_read, &cb_ctx, &nread);
 493    if(!result)
 494      cf_quiche_flush_body(cf, data, stream);
 495    else if(result == CURLE_AGAIN)
 496      break;
 497    else if(result) {
 498      CURL_TRC_CF(data, cf, "[%" PRIu64 "] recv_body error %d",
 499                  stream->id, result);
 500      failf(data, "[%" PRIu64 "] Error %d in HTTP/3 response body for stream",
 501            stream->id, result);
 502      stream->closed = TRUE;
 503      stream->reset = TRUE;
 504      stream->send_closed = TRUE;
 505      if(!stream->xfer_result)
 506        stream->xfer_result = result;
 507    }
 508  }
 509  cf_quiche_flush_body(cf, data, stream);
 510}
 511
 512static void cf_quiche_process_ev(struct Curl_cfilter *cf,
 513                                 struct Curl_easy *data,
 514                                 struct h3_stream_ctx *stream,
 515                                 quiche_h3_event *ev)
 516{
 517  if(!stream)
 518    return;
 519
 520  switch(quiche_h3_event_type(ev)) {
 521  case QUICHE_H3_EVENT_HEADERS: {
 522    struct cb_ctx cb_ctx;
 523    stream->resp_got_header = TRUE;
 524    cb_ctx.cf = cf;
 525    cb_ctx.data = data;
 526    cb_ctx.stream = stream;
 527    quiche_h3_event_for_each_header(ev, cb_each_header, &cb_ctx);
 528    CURL_TRC_CF(data, cf, "[%" PRIu64 "] <- [HEADERS]", stream->id);
 529    Curl_multi_mark_dirty(data);
 530    break;
 531  }
 532  case QUICHE_H3_EVENT_DATA:
 533    if(!stream->resp_hds_complete) {
 534      stream->resp_hds_complete = TRUE;
 535      cf_quiche_write_hd(cf, data, stream, "\r\n", 2, FALSE);
 536    }
 537    cf_quiche_recv_body(cf, data, stream);
 538    CURL_TRC_CF(data, cf, "[%" PRIu64 "] <- [DATA]", stream->id);
 539    Curl_multi_mark_dirty(data);
 540    break;
 541
 542  case QUICHE_H3_EVENT_RESET:
 543    CURL_TRC_CF(data, cf, "[%" PRIu64 "] RESET", stream->id);
 544    stream->closed = TRUE;
 545    stream->reset = TRUE;
 546    stream->send_closed = TRUE;
 547    Curl_multi_mark_dirty(data);
 548    break;
 549
 550  case QUICHE_H3_EVENT_FINISHED:
 551    CURL_TRC_CF(data, cf, "[%" PRIu64 "] CLOSED", stream->id);
 552    if(!stream->resp_hds_complete) {
 553      stream->resp_hds_complete = TRUE;
 554      cf_quiche_write_hd(cf, data, stream, "\r\n", 2, TRUE);
 555    }
 556    stream->closed = TRUE;
 557    Curl_multi_mark_dirty(data);
 558    break;
 559
 560  case QUICHE_H3_EVENT_GOAWAY:
 561    CURL_TRC_CF(data, cf, "[%" PRIu64 "] <- [GOAWAY]", stream->id);
 562    break;
 563
 564  default:
 565    CURL_TRC_CF(data, cf, "[%" PRIu64 "] recv, unhandled event %d",
 566                stream->id, quiche_h3_event_type(ev));
 567    break;
 568  }
 569}
 570
 571struct cf_quich_disp_ctx {
 572  uint64_t stream_id;
 573  struct Curl_cfilter *cf;
 574  struct Curl_multi *multi;
 575  quiche_h3_event *ev;
 576};
 577
 578static bool cf_quiche_disp_event(uint32_t mid, void *val, void *user_data)
 579{
 580  struct cf_quich_disp_ctx *dctx = user_data;
 581  struct h3_stream_ctx *stream = val;
 582
 583  if(stream->id == dctx->stream_id) {
 584    struct Curl_easy *sdata = Curl_multi_get_easy(dctx->multi, mid);
 585    if(sdata)
 586      cf_quiche_process_ev(dctx->cf, sdata, stream, dctx->ev);
 587    return FALSE; /* stop iterating */
 588  }
 589  return TRUE;
 590}
 591
 592static CURLcode cf_poll_events(struct Curl_cfilter *cf,
 593                               struct Curl_easy *data)
 594{
 595  struct cf_quiche_ctx *ctx = cf->ctx;
 596  struct h3_stream_ctx *stream = NULL;
 597  quiche_h3_event *ev;
 598
 599  /* Take in the events and distribute them to the transfers. */
 600  while(ctx->h3c) {
 601    int64_t rv = quiche_h3_conn_poll(ctx->h3c, ctx->qconn, &ev);
 602    if(rv == QUICHE_H3_ERR_DONE) {
 603      break;
 604    }
 605    else if(rv < 0) {
 606      CURL_TRC_CF(data, cf, "error poll: %" PRId64, rv);
 607      return CURLE_HTTP3;
 608    }
 609    else {
 610      stream = H3_STREAM_CTX(ctx, data);
 611      if(stream && stream->id == (uint64_t)rv) {
 612        /* event for calling transfer */
 613        cf_quiche_process_ev(cf, data, stream, ev);
 614        quiche_h3_event_free(ev);
 615        if(stream->xfer_result)
 616          return stream->xfer_result;
 617      }
 618      else {
 619        /* another transfer, do not return errors, as they are not for
 620         * the calling transfer */
 621        struct cf_quich_disp_ctx dctx;
 622        dctx.stream_id = (uint64_t)rv;
 623        dctx.cf = cf;
 624        dctx.multi = data->multi;
 625        dctx.ev = ev;
 626        Curl_uint32_hash_visit(&ctx->streams, cf_quiche_disp_event, &dctx);
 627        quiche_h3_event_free(ev);
 628      }
 629    }
 630  }
 631  return CURLE_OK;
 632}
 633
 634struct recv_ctx {
 635  struct Curl_cfilter *cf;
 636  struct Curl_easy *data;
 637  int pkts;
 638};
 639
 640static CURLcode cf_quiche_recv_pkts(const unsigned char *buf, size_t buflen,
 641                                    size_t gso_size,
 642                                    struct sockaddr_storage *remote_addr,
 643                                    socklen_t remote_addrlen, int ecn,
 644                                    void *userp)
 645{
 646  struct recv_ctx *r = userp;
 647  struct cf_quiche_ctx *ctx = r->cf->ctx;
 648  quiche_recv_info recv_info;
 649  size_t pktlen, offset, nread;
 650  ssize_t rv;
 651
 652  (void)ecn;
 653
 654  recv_info.to = (struct sockaddr *)&ctx->q.local_addr;
 655  recv_info.to_len = ctx->q.local_addrlen;
 656  recv_info.from = (struct sockaddr *)remote_addr;
 657  recv_info.from_len = remote_addrlen;
 658
 659  for(offset = 0; offset < buflen; offset += gso_size) {
 660    pktlen = ((offset + gso_size) <= buflen) ? gso_size : (buflen - offset);
 661    rv = quiche_conn_recv(ctx->qconn,
 662                          (unsigned char *)CURL_UNCONST(buf + offset),
 663                          pktlen, &recv_info);
 664    if(!curlx_sztouz(rv, &nread)) {
 665      if(QUICHE_ERR_DONE == rv) {
 666        if(quiche_conn_is_draining(ctx->qconn)) {
 667          CURL_TRC_CF(r->data, r->cf, "ingress, connection is draining");
 668          return CURLE_RECV_ERROR;
 669        }
 670        if(quiche_conn_is_closed(ctx->qconn)) {
 671          CURL_TRC_CF(r->data, r->cf, "ingress, connection is closed");
 672          return CURLE_RECV_ERROR;
 673        }
 674        CURL_TRC_CF(r->data, r->cf, "ingress, quiche is DONE");
 675        return CURLE_OK;
 676      }
 677      else if(QUICHE_ERR_TLS_FAIL == rv) {
 678        long verify_ok = SSL_get_verify_result(ctx->tls.ossl.ssl);
 679        if(verify_ok != X509_V_OK) {
 680          failf(r->data, "SSL certificate problem: %s",
 681                X509_verify_cert_error_string(verify_ok));
 682          return CURLE_PEER_FAILED_VERIFICATION;
 683        }
 684        failf(r->data, "ingress, quiche reports TLS fail");
 685        return CURLE_RECV_ERROR;
 686      }
 687      else {
 688        failf(r->data, "quiche reports error %zd on receive", rv);
 689        return CURLE_RECV_ERROR;
 690      }
 691    }
 692    else if(nread < pktlen) {
 693      CURL_TRC_CF(r->data, r->cf, "ingress, quiche only read %zu/%zu bytes",
 694                  nread, pktlen);
 695    }
 696    ++r->pkts;
 697  }
 698
 699  return CURLE_OK;
 700}
 701
 702static CURLcode cf_process_ingress(struct Curl_cfilter *cf,
 703                                   struct Curl_easy *data)
 704{
 705  struct cf_quiche_ctx *ctx = cf->ctx;
 706  struct recv_ctx rctx;
 707  CURLcode result;
 708
 709  DEBUGASSERT(ctx->qconn);
 710  result = Curl_vquic_tls_before_recv(&ctx->tls, cf, data);
 711  if(result)
 712    return result;
 713
 714  rctx.cf = cf;
 715  rctx.data = data;
 716  rctx.pkts = 0;
 717
 718  result = vquic_recv_packets(cf, data, &ctx->q, 1000,
 719                              cf_quiche_recv_pkts, &rctx);
 720  if(result)
 721    return result;
 722
 723  if(rctx.pkts > 0) {
 724    /* quiche digested ingress packets. It might have opened flow control
 725     * windows again. */
 726    DEBUGASSERT(data->multi);
 727    cf_quiche_for_all_streams(cf, data->multi, cf_quiche_do_resume, NULL);
 728  }
 729  return cf_poll_events(cf, data);
 730}
 731
 732struct read_ctx {
 733  struct Curl_cfilter *cf;
 734  struct Curl_easy *data;
 735  quiche_send_info send_info;
 736};
 737
 738static CURLcode read_pkt_to_send(void *userp,
 739                                 unsigned char *buf, size_t buflen,
 740                                 size_t *pnread)
 741{
 742  struct read_ctx *x = userp;
 743  struct cf_quiche_ctx *ctx = x->cf->ctx;
 744  ssize_t rv;
 745
 746  *pnread = 0;
 747  rv = quiche_conn_send(ctx->qconn, buf, buflen, &x->send_info);
 748  if(rv == QUICHE_ERR_DONE)
 749    return CURLE_AGAIN;
 750
 751  if(!curlx_sztouz(rv, pnread)) {
 752    failf(x->data, "quiche_conn_send returned %zd", rv);
 753    return CURLE_SEND_ERROR;
 754  }
 755  return CURLE_OK;
 756}
 757
 758/*
 759 * flush_egress drains the buffers and sends off data.
 760 * Calls failf() on errors.
 761 */
 762static CURLcode cf_flush_egress(struct Curl_cfilter *cf,
 763                                struct Curl_easy *data)
 764{
 765  struct cf_quiche_ctx *ctx = cf->ctx;
 766  size_t nread;
 767  CURLcode result;
 768  int64_t expiry_ns;
 769  int64_t timeout_ns;
 770  struct read_ctx readx;
 771  size_t pkt_count, gsolen;
 772
 773  expiry_ns = quiche_conn_timeout_as_nanos(ctx->qconn);
 774  if(!expiry_ns) {
 775    quiche_conn_on_timeout(ctx->qconn);
 776    if(quiche_conn_is_closed(ctx->qconn)) {
 777      if(quiche_conn_is_timed_out(ctx->qconn))
 778        failf(data, "connection closed by idle timeout");
 779      else
 780        failf(data, "connection closed by server");
 781      /* Connection timed out, expire all transfers belonging to it
 782       * as it does not get any more POLL events here. */
 783      cf_quiche_expire_conn_closed(cf, data);
 784      return CURLE_SEND_ERROR;
 785    }
 786  }
 787
 788  result = vquic_flush(cf, data, &ctx->q);
 789  if(result) {
 790    if(result == CURLE_AGAIN) {
 791      Curl_expire(data, 1, EXPIRE_QUIC);
 792      return CURLE_OK;
 793    }
 794    return result;
 795  }
 796
 797  readx.cf = cf;
 798  readx.data = data;
 799  memset(&readx.send_info, 0, sizeof(readx.send_info));
 800  pkt_count = 0;
 801  gsolen = quiche_conn_max_send_udp_payload_size(ctx->qconn);
 802  for(;;) {
 803    /* add the next packet to send, if any, to our buffer */
 804    result = Curl_bufq_sipn(&ctx->q.sendbuf, 0,
 805                            read_pkt_to_send, &readx, &nread);
 806    if(result) {
 807      if(result != CURLE_AGAIN)
 808        return result;
 809      /* Nothing more to add, flush and leave */
 810      result = vquic_send(cf, data, &ctx->q, gsolen);
 811      if(result) {
 812        if(result == CURLE_AGAIN) {
 813          Curl_expire(data, 1, EXPIRE_QUIC);
 814          return CURLE_OK;
 815        }
 816        return result;
 817      }
 818      goto out;
 819    }
 820
 821    ++pkt_count;
 822    if(nread < gsolen || pkt_count >= MAX_PKT_BURST) {
 823      result = vquic_send(cf, data, &ctx->q, gsolen);
 824      if(result) {
 825        if(result == CURLE_AGAIN) {
 826          Curl_expire(data, 1, EXPIRE_QUIC);
 827          return CURLE_OK;
 828        }
 829        goto out;
 830      }
 831      pkt_count = 0;
 832    }
 833  }
 834
 835out:
 836  timeout_ns = quiche_conn_timeout_as_nanos(ctx->qconn);
 837  if(timeout_ns % 1000000)
 838    timeout_ns += 1000000;
 839  /* expire resolution is milliseconds */
 840  Curl_expire(data, (timeout_ns / 1000000), EXPIRE_QUIC);
 841  return result;
 842}
 843
 844static CURLcode recv_closed_stream(struct Curl_cfilter *cf,
 845                                   struct Curl_easy *data,
 846                                   size_t *pnread)
 847{
 848  struct cf_quiche_ctx *ctx = cf->ctx;
 849  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
 850  CURLcode result = CURLE_OK;
 851
 852  DEBUGASSERT(stream);
 853  *pnread = 0;
 854  if(stream->reset) {
 855    if(stream->error3 == CURL_H3_ERR_REQUEST_REJECTED) {
 856      infof(data, "HTTP/3 stream %" PRIu64 " refused by server, try again "
 857            "on a new connection", stream->id);
 858      connclose(cf->conn, "REFUSED_STREAM"); /* do not use this anymore */
 859      data->state.refused_stream = TRUE;
 860      return CURLE_RECV_ERROR; /* trigger Curl_retry_request() later */
 861    }
 862    else if(stream->resp_hds_complete && data->req.no_body) {
 863        CURL_TRC_CF(data, cf, "[%" PRIu64 "] error after response headers, "
 864                    "but we did not want a body anyway, ignore error 0x%"
 865                    PRIx64 " %s", stream->id, stream->error3,
 866                    vquic_h3_err_str(stream->error3));
 867        return CURLE_OK;
 868    }
 869    failf(data, "HTTP/3 stream %" PRIu64 " reset by server (error 0x%" PRIx64
 870          " %s)", stream->id, stream->error3,
 871          vquic_h3_err_str(stream->error3));
 872    result = data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP3;
 873    CURL_TRC_CF(data, cf, "[%" PRIu64 "] cf_recv, was reset -> %d",
 874                stream->id, result);
 875  }
 876  else if(!stream->resp_got_header) {
 877    failf(data, "HTTP/3 stream %" PRIu64 " was closed cleanly, but before "
 878          "getting all response header fields, treated as error",
 879          stream->id);
 880    result = CURLE_HTTP3;
 881  }
 882  return result;
 883}
 884
 885static CURLcode cf_quiche_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
 886                               char *buf, size_t blen, size_t *pnread)
 887{
 888  struct cf_quiche_ctx *ctx = cf->ctx;
 889  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
 890  CURLcode result = CURLE_OK;
 891
 892  *pnread = 0;
 893  (void)buf;
 894  (void)blen;
 895  vquic_ctx_update_time(&ctx->q, Curl_pgrs_now(data));
 896
 897  if(!stream)
 898    return CURLE_RECV_ERROR;
 899
 900  result = cf_process_ingress(cf, data);
 901  if(result) {
 902    CURL_TRC_CF(data, cf, "cf_recv, error on ingress");
 903    goto out;
 904  }
 905
 906  if(stream->xfer_result) {
 907    cf_quiche_stream_close(cf, data, stream);
 908    result = stream->xfer_result;
 909    goto out;
 910  }
 911  else if(stream->closed)
 912    result = recv_closed_stream(cf, data, pnread);
 913  else if(quiche_conn_is_draining(ctx->qconn)) {
 914    failf(data, "QUIC connection is draining");
 915    result = CURLE_HTTP3;
 916  }
 917  else
 918    result = CURLE_AGAIN;
 919
 920out:
 921  result = Curl_1st_fatal(result, cf_flush_egress(cf, data));
 922  if(*pnread > 0)
 923    ctx->data_recvd += *pnread;
 924  CURL_TRC_CF(data, cf, "[%" PRIu64 "] cf_recv(len=%zu) -> %d, %zu, total=%"
 925              FMT_OFF_T, stream->id, blen, result, *pnread, ctx->data_recvd);
 926  return result;
 927}
 928
 929static CURLcode cf_quiche_send_body(struct Curl_cfilter *cf,
 930                                    struct Curl_easy *data,
 931                                    struct h3_stream_ctx *stream,
 932                                    const uint8_t *buf, size_t len, bool eos,
 933                                    size_t *pnwritten)
 934{
 935  struct cf_quiche_ctx *ctx = cf->ctx;
 936  ssize_t rv;
 937
 938  *pnwritten = 0;
 939  rv = quiche_h3_send_body(ctx->h3c, ctx->qconn, stream->id,
 940                           (uint8_t *)CURL_UNCONST(buf), len, eos);
 941  if(rv == QUICHE_H3_ERR_DONE || (rv == 0 && len > 0)) {
 942    /* Blocked on flow control and should HOLD sending.
 943       When do we open again? */
 944    if(!quiche_conn_stream_writable(ctx->qconn, stream->id, len)) {
 945      CURL_TRC_CF(data, cf, "[%" PRIu64 "] send_body(len=%zu) "
 946                  "-> window exhausted", stream->id, len);
 947      stream->quic_flow_blocked = TRUE;
 948    }
 949    return CURLE_AGAIN;
 950  }
 951  else if(rv == QUICHE_H3_TRANSPORT_ERR_INVALID_STREAM_STATE) {
 952    CURL_TRC_CF(data, cf, "[%" PRIu64 "] send_body(len=%zu) "
 953                "-> invalid stream state", stream->id, len);
 954    return CURLE_HTTP3;
 955  }
 956  else if(rv == QUICHE_H3_TRANSPORT_ERR_FINAL_SIZE) {
 957    CURL_TRC_CF(data, cf, "[%" PRIu64 "] send_body(len=%zu) -> exceeds size",
 958                stream->id, len);
 959    return CURLE_SEND_ERROR;
 960  }
 961  else if(!curlx_sztouz(rv, pnwritten)) {
 962    CURL_TRC_CF(data, cf, "[%" PRIu64 "] send_body(len=%zu) -> quiche err %zd",
 963                stream->id, len, rv);
 964    return CURLE_SEND_ERROR;
 965  }
 966  else {
 967    if(eos && (len == *pnwritten))
 968      stream->send_closed = TRUE;
 969    CURL_TRC_CF(data, cf, "[%" PRIu64 "] send body(len=%zu, eos=%d) -> %zu",
 970                stream->id, len, stream->send_closed, *pnwritten);
 971    return CURLE_OK;
 972  }
 973}
 974
 975static CURLcode h3_open_stream(struct Curl_cfilter *cf,
 976                               struct Curl_easy *data,
 977                               const uint8_t *buf, size_t blen, bool eos,
 978                               size_t *pnwritten)
 979{
 980  struct cf_quiche_ctx *ctx = cf->ctx;
 981  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
 982  size_t nheader, i;
 983  int64_t rv;
 984  struct dynhds h2_headers;
 985  quiche_h3_header *nva = NULL;
 986  CURLcode result = CURLE_OK;
 987
 988  *pnwritten = 0;
 989  if(!stream) {
 990    result = h3_data_setup(cf, data);
 991    if(result)
 992      return result;
 993    stream = H3_STREAM_CTX(ctx, data);
 994    DEBUGASSERT(stream);
 995  }
 996
 997  Curl_dynhds_init(&h2_headers, 0, DYN_HTTP_REQUEST);
 998
 999  DEBUGASSERT(stream);
1000
1001  result = Curl_h1_req_parse_read(&stream->h1, buf, blen, NULL,
1002                                  !data->state.http_ignorecustom ?
1003                                  data->set.str[STRING_CUSTOMREQUEST] : NULL,
1004                                  0, pnwritten);
1005  if(result)
1006    goto out;
1007  if(!stream->h1.done) {
1008    /* need more data */
1009    goto out;
1010  }
1011  DEBUGASSERT(stream->h1.req);
1012
1013  result = Curl_http_req_to_h2(&h2_headers, stream->h1.req, data);
1014  if(result)
1015    goto out;
1016
1017  /* no longer needed */
1018  Curl_h1_req_parse_free(&stream->h1);
1019
1020  nheader = Curl_dynhds_count(&h2_headers);
1021  nva = curlx_malloc(sizeof(quiche_h3_header) * nheader);
1022  if(!nva) {
1023    result = CURLE_OUT_OF_MEMORY;
1024    goto out;
1025  }
1026
1027  for(i = 0; i < nheader; ++i) {
1028    struct dynhds_entry *e = Curl_dynhds_getn(&h2_headers, i);
1029    nva[i].name = (unsigned char *)e->name;
1030    nva[i].name_len = e->namelen;
1031    nva[i].value = (unsigned char *)e->value;
1032    nva[i].value_len = e->valuelen;
1033  }
1034
1035  buf += *pnwritten;
1036  blen -= *pnwritten;
1037
1038  if(eos && !blen)
1039    stream->send_closed = TRUE;
1040
1041  rv = quiche_h3_send_request(ctx->h3c, ctx->qconn, nva, nheader,
1042                              stream->send_closed);
1043  CURL_TRC_CF(data, cf, "quiche_send_request() -> %" PRId64, rv);
1044  if(rv < 0) {
1045    if(QUICHE_H3_ERR_STREAM_BLOCKED == rv) {
1046      /* quiche seems to report this error if the connection window is
1047       * exhausted. Which happens frequently and intermittent. */
1048      CURL_TRC_CF(data, cf, "[%" PRIu64 "] blocked", stream->id);
1049      stream->quic_flow_blocked = TRUE;
1050      result = CURLE_AGAIN;
1051      goto out;
1052    }
1053    else {
1054      CURL_TRC_CF(data, cf, "send_request(%s) -> %" PRId64,
1055                  Curl_bufref_ptr(&data->state.url), rv);
1056    }
1057    result = CURLE_SEND_ERROR;
1058    goto out;
1059  }
1060
1061  DEBUGASSERT(!stream->opened);
1062  stream->id = (uint64_t)rv;
1063  stream->opened = TRUE;
1064  stream->closed = FALSE;
1065  stream->reset = FALSE;
1066
1067  if(Curl_trc_is_verbose(data)) {
1068    infof(data, "[HTTP/3] [%" PRIu64 "] OPENED stream for %s",
1069          stream->id, Curl_bufref_ptr(&data->state.url));
1070    for(i = 0; i < nheader; ++i) {
1071      infof(data, "[HTTP/3] [%" PRIu64 "] [%.*s: %.*s]", stream->id,
1072            (int)nva[i].name_len, nva[i].name,
1073            (int)nva[i].value_len, nva[i].value);
1074    }
1075  }
1076
1077  if(blen) {  /* after the headers, there was request BODY data */
1078    size_t nwritten;
1079    CURLcode r2 = CURLE_OK;
1080
1081    r2 = cf_quiche_send_body(cf, data, stream, buf, blen, eos, &nwritten);
1082    if(r2 && (r2 != CURLE_AGAIN)) {  /* real error, fail */
1083      result = r2;
1084    }
1085    else if(nwritten > 0) {
1086      *pnwritten += nwritten;
1087    }
1088  }
1089
1090out:
1091  curlx_free(nva);
1092  Curl_dynhds_free(&h2_headers);
1093  return result;
1094}
1095
1096static CURLcode cf_quiche_send(struct Curl_cfilter *cf, struct Curl_easy *data,
1097                               const uint8_t *buf, size_t len, bool eos,
1098                               size_t *pnwritten)
1099{
1100  struct cf_quiche_ctx *ctx = cf->ctx;
1101  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
1102  CURLcode result;
1103
1104  *pnwritten = 0;
1105  vquic_ctx_update_time(&ctx->q, Curl_pgrs_now(data));
1106
1107  result = cf_process_ingress(cf, data);
1108  if(result)
1109    goto out;
1110
1111  if(!stream || !stream->opened) {
1112    result = h3_open_stream(cf, data, buf, len, eos, pnwritten);
1113    if(result)
1114      goto out;
1115    stream = H3_STREAM_CTX(ctx, data);
1116  }
1117  else if(stream->xfer_result) {
1118    cf_quiche_stream_close(cf, data, stream);
1119    result = stream->xfer_result;
1120  }
1121  else if(stream->closed) {
1122    if(stream->resp_hds_complete) {
1123      /* sending request body on a stream that has been closed by the
1124       * server. If the server has send us a final response, we should
1125       * silently discard the send data.
1126       * This happens for example on redirects where the server, instead
1127       * of reading the full request body closed the stream after
1128       * sending the 30x response.
1129       * This is sort of a race: had the transfer loop called recv first,
1130       * it would see the response and stop/discard sending on its own- */
1131      CURL_TRC_CF(data, cf, "[%" PRIu64 "] discarding data"
1132                  "on closed stream with response", stream->id);
1133      result = CURLE_OK;
1134      *pnwritten = len;
1135      goto out;
1136    }
1137    CURL_TRC_CF(data, cf, "[%" PRIu64 "] send_body(len=%zu) "
1138                "-> stream closed", stream->id, len);
1139    result = CURLE_HTTP3;
1140    goto out;
1141  }
1142  else {
1143    result = cf_quiche_send_body(cf, data, stream, buf, len, eos, pnwritten);
1144  }
1145
1146out:
1147  result = Curl_1st_fatal(result, cf_flush_egress(cf, data));
1148
1149  CURL_TRC_CF(data, cf, "[%" PRIu64 "] cf_send(len=%zu) -> %d, %zu",
1150              stream ? stream->id : (uint64_t)~0, len,
1151              result, *pnwritten);
1152  return result;
1153}
1154
1155static bool stream_is_writable(struct Curl_cfilter *cf,
1156                               struct Curl_easy *data)
1157{
1158  struct cf_quiche_ctx *ctx = cf->ctx;
1159  struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
1160
1161  return stream && (quiche_conn_stream_writable(
1162    ctx->qconn, stream->id, 1) > 0);
1163}
1164
1165static CURLcode cf_quiche_adjust_pollset(struct Curl_cfilter *cf,
1166                                         struct Curl_easy *data,
1167                                         struct easy_pollset *ps)
1168{
1169  struct cf_quiche_ctx *ctx = cf->ctx;
1170  bool want_recv, want_send;
1171  CURLcode result = CURLE_OK;
1172
1173  if(!ctx->qconn)
1174    return CURLE_OK;
1175
1176  Curl_pollset_check(data, ps, ctx->q.sockfd, &want_recv, &want_send);
1177  if(want_recv || want_send) {
1178    struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
1179    bool c_exhaust, s_exhaust;
1180
1181    c_exhaust = FALSE; /* Have not found any call in quiche that tells
1182                          us if the connection itself is blocked */
1183    s_exhaust = want_send && stream && stream->opened &&
1184                (stream->quic_flow_blocked || !stream_is_writable(cf, data));
1185    want_recv = (want_recv || c_exhaust || s_exhaust);
1186    want_send = (!s_exhaust && want_send) ||
1187                 !Curl_bufq_is_empty(&ctx->q.sendbuf);
1188
1189    result = Curl_pollset_set(data, ps, ctx->q.sockfd, want_recv, want_send);
1190  }
1191  return result;
1192}
1193
1194static CURLcode h3_data_pause(struct Curl_cfilter *cf,
1195                              struct Curl_easy *data,
1196                              bool pause)
1197{
1198  /* There seems to exist no API in quiche to shrink/enlarge the streams
1199   * windows. As we do in HTTP/2. */
1200  (void)cf;
1201  if(!pause) {
1202    Curl_multi_mark_dirty(data);
1203  }
1204  return CURLE_OK;
1205}
1206
1207static CURLcode cf_quiche_cntrl(struct Curl_cfilter *cf,
1208                                struct Curl_easy *data,
1209                                int event, int arg1, void *arg2)
1210{
1211  struct cf_quiche_ctx *ctx = cf->ctx;
1212  CURLcode result = CURLE_OK;
1213
1214  (void)arg1;
1215  (void)arg2;
1216  switch(event) {
1217  case CF_CTRL_DATA_SETUP:
1218    break;
1219  case CF_CTRL_DATA_PAUSE:
1220    result = h3_data_pause(cf, data, (arg1 != 0));
1221    break;
1222  case CF_CTRL_DATA_DONE:
1223    h3_data_done(cf, data);
1224    break;
1225  case CF_CTRL_DATA_DONE_SEND: {
1226    struct h3_stream_ctx *stream = H3_STREAM_CTX(ctx, data);
1227    if(stream && !stream->send_closed) {
1228      unsigned char body[1];
1229      size_t sent;
1230
1231      stream->send_closed = TRUE;
1232      body[0] = 'X';
1233      result = cf_quiche_send(cf, data, body, 0, TRUE, &sent);
1234      CURL_TRC_CF(data, cf, "[%" PRIu64 "] DONE_SEND -> %d, %zu",
1235                  stream->id, result, sent);
1236    }
1237    break;
1238  }
1239  case CF_CTRL_CONN_INFO_UPDATE:
1240    if(!cf->sockindex && cf->connected) {
1241      cf->conn->httpversion_seen = 30;
1242      Curl_conn_set_multiplex(cf->conn);
1243    }
1244    break;
1245  default:
1246    break;
1247  }
1248  return result;
1249}
1250
1251static CURLcode cf_quiche_ctx_open(struct Curl_cfilter *cf,
1252                                   struct Curl_easy *data)
1253{
1254  struct cf_quiche_ctx *ctx = cf->ctx;
1255  int rv;
1256  CURLcode result;
1257  const struct Curl_sockaddr_ex *sockaddr;
1258  static const struct alpn_spec ALPN_SPEC_H3 = { { "h3" }, 1 };
1259
1260  DEBUGASSERT(ctx->q.sockfd != CURL_SOCKET_BAD);
1261  DEBUGASSERT(ctx->initialized);
1262
1263  result = vquic_ctx_init(data, &ctx->q);
1264  if(result)
1265    return result;
1266
1267  ctx->cfg = quiche_config_new(QUICHE_PROTOCOL_VERSION);
1268  if(!ctx->cfg) {
1269    failf(data, "cannot create quiche config");
1270    return CURLE_FAILED_INIT;
1271  }
1272  quiche_config_enable_pacing(ctx->cfg, FALSE);
1273  quiche_config_set_initial_max_data(ctx->cfg, (1 * 1024 * 1024)
1274    /* (QUIC_MAX_STREAMS/2) * H3_STREAM_WINDOW_SIZE */);
1275  quiche_config_set_initial_max_streams_bidi(ctx->cfg, QUIC_MAX_STREAMS);
1276  quiche_config_set_initial_max_streams_uni(ctx->cfg, QUIC_MAX_STREAMS);
1277  quiche_config_set_initial_max_stream_data_bidi_local(ctx->cfg,
1278    H3_STREAM_WINDOW_SIZE);
1279  quiche_config_set_initial_max_stream_data_bidi_remote(ctx->cfg,
1280    H3_STREAM_WINDOW_SIZE);
1281  quiche_config_set_initial_max_stream_data_uni(ctx->cfg,
1282    H3_STREAM_WINDOW_SIZE);
1283  quiche_config_set_disable_active_migration(ctx->cfg, TRUE);
1284
1285  quiche_config_set_max_connection_window(ctx->cfg,
1286    10 * QUIC_MAX_STREAMS * H3_STREAM_WINDOW_SIZE);
1287  quiche_config_set_max_stream_window(ctx->cfg, 10 * H3_STREAM_WINDOW_SIZE);
1288  quiche_config_set_application_protos(ctx->cfg,
1289                       (uint8_t *)CURL_UNCONST(QUICHE_H3_APPLICATION_PROTOCOL),
1290                                       sizeof(QUICHE_H3_APPLICATION_PROTOCOL)
1291                                       - 1);
1292
1293  result = Curl_vquic_tls_init(&ctx->tls, cf, data, &ctx->peer,
1294                               &ALPN_SPEC_H3, NULL, NULL, cf, NULL);
1295  if(result)
1296    return result;
1297
1298  result = Curl_rand(data, ctx->scid, sizeof(ctx->scid));
1299  if(result)
1300    return result;
1301
1302  if(Curl_cf_socket_peek(cf->next, data, &ctx->q.sockfd, &sockaddr, NULL))
1303    return CURLE_QUIC_CONNECT_ERROR;
1304
1305  ctx->q.local_addrlen = sizeof(ctx->q.local_addr);
1306  rv = getsockname(ctx->q.sockfd, (struct sockaddr *)&ctx->q.local_addr,
1307                   &ctx->q.local_addrlen);
1308  if(rv == -1)
1309    return CURLE_QUIC_CONNECT_ERROR;
1310
1311  ctx->qconn = quiche_conn_new_with_tls((const uint8_t *)ctx->scid,
1312                                        sizeof(ctx->scid), NULL, 0,
1313                                        (struct sockaddr *)&ctx->q.local_addr,
1314                                        ctx->q.local_addrlen,
1315                                        &sockaddr->curl_sa_addr,
1316                                        sockaddr->addrlen,
1317                                        ctx->cfg, ctx->tls.ossl.ssl, FALSE);
1318  if(!ctx->qconn) {
1319    failf(data, "cannot create quiche connection");
1320    return CURLE_OUT_OF_MEMORY;
1321  }
1322
1323  /* Known to not work on Windows */
1324#if !defined(_WIN32) && defined(HAVE_QUICHE_CONN_SET_QLOG_FD)
1325  {
1326    int qfd;
1327    (void)Curl_qlogdir(data, ctx->scid, sizeof(ctx->scid), &qfd);
1328    if(qfd != -1)
1329      quiche_conn_set_qlog_fd(ctx->qconn, qfd, "qlog title", "curl qlog");
1330  }
1331#endif
1332
1333  result = cf_flush_egress(cf, data);
1334  if(result)
1335    return result;
1336
1337  {
1338    unsigned char alpn_protocols[] = QUICHE_H3_APPLICATION_PROTOCOL;
1339    unsigned alpn_len, offset = 0;
1340
1341    /* Replace each ALPN length prefix by a comma. */
1342    while(offset < sizeof(alpn_protocols) - 1) {
1343      alpn_len = alpn_protocols[offset];
1344      alpn_protocols[offset] = ',';
1345      offset += 1 + alpn_len;
1346    }
1347
1348    CURL_TRC_CF(data, cf, "Sent QUIC client Initial, ALPN: %s",
1349                alpn_protocols + 1);
1350  }
1351
1352  return CURLE_OK;
1353}
1354
1355static CURLcode cf_quiche_verify_peer(struct Curl_cfilter *cf,
1356                                      struct Curl_easy *data)
1357{
1358  struct cf_quiche_ctx *ctx = cf->ctx;
1359  return Curl_vquic_tls_verify_peer(&ctx->tls, cf, data, &ctx->peer);
1360}
1361
1362static CURLcode cf_quiche_connect(struct Curl_cfilter *cf,
1363                                  struct Curl_easy *data,
1364                                  bool *done)
1365{
1366  struct cf_quiche_ctx *ctx = cf->ctx;
1367  CURLcode result = CURLE_OK;
1368
1369  if(cf->connected) {
1370    *done = TRUE;
1371    return CURLE_OK;
1372  }
1373
1374  /* Connect the UDP filter first */
1375  if(!cf->next->connected) {
1376    result = Curl_conn_cf_connect(cf->next, data, done);
1377    if(result || !*done)
1378      return result;
1379  }
1380
1381  *done = FALSE;
1382  if(Curl_ossl_need_httpsrr(data) &&
1383     !Curl_conn_dns_resolved_https(data, cf->sockindex)) {
1384    CURL_TRC_CF(data, cf, "need HTTPS-RR, delaying connect");
1385    return CURLE_OK;
1386  }
1387
1388  vquic_ctx_update_time(&ctx->q, Curl_pgrs_now(data));
1389
1390  if(!ctx->qconn) {
1391    result = cf_quiche_ctx_open(cf, data);
1392    if(result)
1393      goto out;
1394    ctx->started_at = ctx->q.last_op;
1395    result = cf_flush_egress(cf, data);
1396    /* we do not expect to be able to recv anything yet */
1397    goto out;
1398  }
1399
1400  result = cf_process_ingress(cf, data);
1401  if(result)
1402    goto out;
1403
1404  result = cf_flush_egress(cf, data);
1405  if(result)
1406    goto out;
1407
1408  if(quiche_conn_is_established(ctx->qconn)) {
1409    ctx->handshake_at = ctx->q.last_op;
1410    CURL_TRC_CF(data, cf, "handshake complete after %" FMT_TIMEDIFF_T "ms",
1411                curlx_ptimediff_ms(&ctx->handshake_at, &ctx->started_at));
1412    result = cf_quiche_verify_peer(cf, data);
1413    if(!result) {
1414      CURL_TRC_CF(data, cf, "peer verified");
1415      ctx->h3config = quiche_h3_config_new();
1416      if(!ctx->h3config) {
1417        result = CURLE_OUT_OF_MEMORY;
1418        goto out;
1419      }
1420
1421      /* Create a new HTTP/3 connection on the QUIC connection. */
1422      ctx->h3c = quiche_h3_conn_new_with_transport(ctx->qconn, ctx->h3config);
1423      if(!ctx->h3c) {
1424        result = CURLE_OUT_OF_MEMORY;
1425        goto out;
1426      }
1427      cf->connected = TRUE;
1428      *done = TRUE;
1429    }
1430  }
1431  else if(quiche_conn_is_draining(ctx->qconn)) {
1432    /* When a QUIC server instance is shutting down, it may send us a
1433     * CONNECTION_CLOSE right away. Our connection then enters the DRAINING
1434     * state. The CONNECT may work in the near future again. Indicate
1435     * that as a "weird" reply. */
1436    result = CURLE_WEIRD_SERVER_REPLY;
1437  }
1438
1439out:
1440#ifdef CURLVERBOSE
1441  if(result && result != CURLE_AGAIN) {
1442    struct ip_quadruple ip;
1443
1444    if(!Curl_cf_socket_peek(cf->next, data, NULL, NULL, &ip))
1445      infof(data, "connect to %s port %u failed: %s",
1446            ip.remote_ip, ip.remote_port, curl_easy_strerror(result));
1447    else
1448      infof(data, "connect failed: %s", curl_easy_strerror(result));
1449  }
1450#endif
1451  return result;
1452}
1453
1454static CURLcode cf_quiche_shutdown(struct Curl_cfilter *cf,
1455                                   struct Curl_easy *data, bool *done)
1456{
1457  struct cf_quiche_ctx *ctx = cf->ctx;
1458  CURLcode result = CURLE_OK;
1459
1460  if(cf->shutdown || !ctx || !ctx->qconn) {
1461    *done = TRUE;
1462    return CURLE_OK;
1463  }
1464
1465  *done = FALSE;
1466  if(!ctx->shutdown_started) {
1467    int err;
1468
1469    ctx->shutdown_started = TRUE;
1470    vquic_ctx_update_time(&ctx->q, Curl_pgrs_now(data));
1471    err = quiche_conn_close(ctx->qconn, TRUE, 0, NULL, 0);
1472    if(err) {
1473      CURL_TRC_CF(data, cf, "error %d adding shutdown packet, "
1474                  "aborting shutdown", err);
1475      result = CURLE_SEND_ERROR;
1476      goto out;
1477    }
1478  }
1479
1480  if(!Curl_bufq_is_empty(&ctx->q.sendbuf)) {
1481    CURL_TRC_CF(data, cf, "shutdown, flushing sendbuf");
1482    result = cf_flush_egress(cf, data);
1483    if(result)
1484      goto out;
1485  }
1486
1487  if(Curl_bufq_is_empty(&ctx->q.sendbuf)) {
1488    /* sent everything, quiche does not seem to support a graceful
1489     * shutdown waiting for a reply, so ware done. */
1490    CURL_TRC_CF(data, cf, "shutdown completely sent off, done");
1491    *done = TRUE;
1492  }
1493  else {
1494    CURL_TRC_CF(data, cf, "shutdown sending blocked");
1495  }
1496
1497out:
1498  return result;
1499}
1500
1501static void cf_quiche_close(struct Curl_cfilter *cf, struct Curl_easy *data)
1502{
1503  if(cf->ctx) {
1504    bool done;
1505    (void)cf_quiche_shutdown(cf, data, &done);
1506    cf_quiche_ctx_close(cf->ctx);
1507    cf->connected = FALSE;
1508  }
1509}
1510
1511static void cf_quiche_destroy(struct Curl_cfilter *cf, struct Curl_easy *data)
1512{
1513  (void)data;
1514  if(cf->ctx) {
1515    cf_quiche_ctx_close(cf->ctx);
1516    cf_quiche_ctx_free(cf->ctx);
1517    cf->ctx = NULL;
1518  }
1519}
1520
1521static CURLcode cf_quiche_query(struct Curl_cfilter *cf,
1522                                struct Curl_easy *data,
1523                                int query, int *pres1, void *pres2)
1524{
1525  struct cf_quiche_ctx *ctx = cf->ctx;
1526
1527  switch(query) {
1528  case CF_QUERY_MAX_CONCURRENT: {
1529    uint64_t max_streams = cf->conn->attached_xfers;
1530    if(!ctx->goaway && ctx->qconn) {
1531      max_streams += quiche_conn_peer_streams_left_bidi(ctx->qconn);
1532    }
1533    *pres1 = (max_streams > INT_MAX) ? INT_MAX : (int)max_streams;
1534    CURL_TRC_CF(data, cf, "query conn[%" FMT_OFF_T "]: "
1535                "MAX_CONCURRENT -> %d (%u in use)",
1536                cf->conn->connection_id, *pres1, cf->conn->attached_xfers);
1537    return CURLE_OK;
1538  }
1539  case CF_QUERY_CONNECT_REPLY_MS:
1540    if(ctx->q.got_first_byte) {
1541      timediff_t ms = curlx_ptimediff_ms(&ctx->q.first_byte_at,
1542                                         &ctx->started_at);
1543      *pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
1544    }
1545    else
1546      *pres1 = -1;
1547    return CURLE_OK;
1548  case CF_QUERY_TIMER_CONNECT: {
1549    struct curltime *when = pres2;
1550    if(ctx->q.got_first_byte)
1551      *when = ctx->q.first_byte_at;
1552    return CURLE_OK;
1553  }
1554  case CF_QUERY_TIMER_APPCONNECT: {
1555    struct curltime *when = pres2;
1556    if(cf->connected)
1557      *when = ctx->handshake_at;
1558    return CURLE_OK;
1559  }
1560  case CF_QUERY_HTTP_VERSION:
1561    *pres1 = 30;
1562    return CURLE_OK;
1563  case CF_QUERY_SSL_INFO:
1564  case CF_QUERY_SSL_CTX_INFO: {
1565    struct curl_tlssessioninfo *info = pres2;
1566    if(Curl_vquic_tls_get_ssl_info(&ctx->tls,
1567                                   (query == CF_QUERY_SSL_CTX_INFO), info))
1568      return CURLE_OK;
1569    break;
1570  }
1571  case CF_QUERY_ALPN_NEGOTIATED: {
1572    const char **palpn = pres2;
1573    DEBUGASSERT(palpn);
1574    *palpn = cf->connected ? "h3" : NULL;
1575    return CURLE_OK;
1576  }
1577  default:
1578    break;
1579  }
1580  return cf->next ?
1581    cf->next->cft->query(cf->next, data, query, pres1, pres2) :
1582    CURLE_UNKNOWN_OPTION;
1583}
1584
1585static bool cf_quiche_conn_is_alive(struct Curl_cfilter *cf,
1586                                    struct Curl_easy *data,
1587                                    bool *input_pending)
1588{
1589  struct cf_quiche_ctx *ctx = cf->ctx;
1590  bool alive = TRUE;
1591
1592  *input_pending = FALSE;
1593  if(!ctx->qconn)
1594    return FALSE;
1595
1596  if(quiche_conn_is_closed(ctx->qconn)) {
1597    if(quiche_conn_is_timed_out(ctx->qconn))
1598      CURL_TRC_CF(data, cf, "connection was closed due to idle timeout");
1599    else
1600      CURL_TRC_CF(data, cf, "connection is closed");
1601    return FALSE;
1602  }
1603
1604  if(!cf->next || !cf->next->cft->is_alive(cf->next, data, input_pending))
1605    return FALSE;
1606
1607  if(*input_pending) {
1608    /* This happens before we have sent off a request and the connection is
1609       not in use by any other transfer, there should not be any data here,
1610       only "protocol frames" */
1611    *input_pending = FALSE;
1612    if(cf_process_ingress(cf, data))
1613      alive = FALSE;
1614    else {
1615      alive = TRUE;
1616    }
1617  }
1618
1619  return alive;
1620}
1621
1622struct Curl_cftype Curl_cft_http3 = {
1623  "HTTP/3",
1624  CF_TYPE_IP_CONNECT | CF_TYPE_SSL | CF_TYPE_MULTIPLEX | CF_TYPE_HTTP,
1625  0,
1626  cf_quiche_destroy,
1627  cf_quiche_connect,
1628  cf_quiche_close,
1629  cf_quiche_shutdown,
1630  cf_quiche_adjust_pollset,
1631  Curl_cf_def_data_pending,
1632  cf_quiche_send,
1633  cf_quiche_recv,
1634  cf_quiche_cntrl,
1635  cf_quiche_conn_is_alive,
1636  Curl_cf_def_conn_keep_alive,
1637  cf_quiche_query,
1638};
1639
1640CURLcode Curl_cf_quiche_create(struct Curl_cfilter **pcf,
1641                               struct Curl_easy *data,
1642                               struct connectdata *conn,
1643                               struct Curl_sockaddr_ex *addr)
1644{
1645  struct cf_quiche_ctx *ctx = NULL;
1646  struct Curl_cfilter *cf = NULL;
1647  CURLcode result;
1648
1649  ctx = curlx_calloc(1, sizeof(*ctx));
1650  if(!ctx) {
1651    result = CURLE_OUT_OF_MEMORY;
1652    goto out;
1653  }
1654  cf_quiche_ctx_init(ctx);
1655
1656  result = Curl_cf_create(&cf, &Curl_cft_http3, ctx);
1657  if(result)
1658    goto out;
1659  cf->conn = conn;
1660
1661  result = Curl_cf_udp_create(&cf->next, data, conn, addr, TRNSPRT_QUIC);
1662  if(result)
1663    goto out;
1664  cf->next->conn = cf->conn;
1665  cf->next->sockindex = cf->sockindex;
1666
1667out:
1668  *pcf = (!result) ? cf : NULL;
1669  if(result) {
1670    if(cf)
1671      Curl_conn_cf_discard_chain(&cf, data);
1672    else if(ctx)
1673      cf_quiche_ctx_free(ctx);
1674  }
1675
1676  return result;
1677}
1678
1679#endif