luna - curl/lib/http2.c

   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_NGHTTP2)
  27#include <nghttp2/nghttp2.h>
  28
  29#include "urldata.h"
  30#include "bufq.h"
  31#include "uint-hash.h"
  32#include "http1.h"
  33#include "http2.h"
  34#include "http.h"
  35#include "sendf.h"
  36#include "curl_trc.h"
  37#include "select.h"
  38#include "curlx/base64.h"
  39#include "multiif.h"
  40#include "progress.h"
  41#include "url.h"
  42#include "urlapi-int.h"
  43#include "cfilters.h"
  44#include "connect.h"
  45#include "transfer.h"
  46#include "bufref.h"
  47#include "curlx/dynbuf.h"
  48#include "headers.h"
  49
  50#if (NGHTTP2_VERSION_NUM < 0x010c00)
  51#error too old nghttp2 version, upgrade!
  52#endif
  53
  54#if (NGHTTP2_VERSION_NUM >= 0x010c00)
  55#define NGHTTP2_HAS_SET_LOCAL_WINDOW_SIZE 1
  56#endif
  57
  58
  59/* buffer dimensioning:
  60 * use 16K as chunk size, as that fits H2 DATA frames well */
  61#define H2_CHUNK_SIZE           (16 * 1024)
  62/* connection window size */
  63#define H2_CONN_WINDOW_SIZE     (10 * 1024 * 1024)
  64/* on receiving from TLS, we prep for holding a full stream window */
  65#define H2_NW_RECV_CHUNKS       (H2_CONN_WINDOW_SIZE / H2_CHUNK_SIZE)
  66/* on send into TLS, we want to accumulate small frames */
  67#define H2_NW_SEND_CHUNKS       1
  68/* this is how much we want "in flight" for a stream, unthrottled */
  69#define H2_STREAM_WINDOW_SIZE_MAX   (10 * 1024 * 1024)
  70/* this is how much we want "in flight" for a stream, initially, IFF
  71 * nghttp2 allows us to tweak the local window size. */
  72#if NGHTTP2_HAS_SET_LOCAL_WINDOW_SIZE
  73#define H2_STREAM_WINDOW_SIZE_INITIAL  (64 * 1024)
  74#else
  75#define H2_STREAM_WINDOW_SIZE_INITIAL H2_STREAM_WINDOW_SIZE_MAX
  76#endif
  77/* keep smaller stream upload buffer (default h2 window size) to have
  78 * our progress bars and "upload done" reporting closer to reality */
  79#define H2_STREAM_SEND_CHUNKS   ((64 * 1024) / H2_CHUNK_SIZE)
  80/* spare chunks we keep for a full window */
  81#define H2_STREAM_POOL_SPARES   (H2_CONN_WINDOW_SIZE / H2_CHUNK_SIZE)
  82
  83/* We need to accommodate the max number of streams with their window sizes on
  84 * the overall connection. Streams might become PAUSED which will block their
  85 * received QUOTA in the connection window. If we run out of space, the server
  86 * is blocked from sending us any data. See #10988 for an issue with this. */
  87#define HTTP2_HUGE_WINDOW_SIZE (100 * H2_STREAM_WINDOW_SIZE_MAX)
  88
  89#define H2_SETTINGS_IV_LEN 3
  90#define H2_BINSETTINGS_LEN 80
  91
  92struct cf_h2_ctx {
  93  nghttp2_session *h2;
  94  /* The easy handle used in the current filter call, cleared at return */
  95  struct cf_call_data call_data;
  96
  97  struct bufq inbufq;           /* network input */
  98  struct bufq outbufq;          /* network output */
  99  struct bufc_pool stream_bufcp; /* spares for stream buffers */
 100  struct dynbuf scratch;        /* scratch buffer for temp use */
 101
 102  struct uint_hash streams; /* hash of `data->mid` to `h2_stream_ctx` */
 103  size_t drain_total; /* sum of all stream's UrlState drain */
 104  uint32_t initial_win_size; /* current initial window size (settings) */
 105  uint32_t max_concurrent_streams;
 106  uint32_t goaway_error;        /* goaway error code from server */
 107  int32_t remote_max_sid;       /* max id processed by server */
 108  int32_t local_max_sid;        /* max id processed by us */
 109  BIT(initialized);
 110  BIT(via_h1_upgrade);
 111  BIT(conn_closed);
 112  BIT(rcvd_goaway);
 113  BIT(sent_goaway);
 114  BIT(enable_push);
 115  BIT(nw_out_blocked);
 116};
 117
 118/* How to access `call_data` from a cf_h2 filter */
 119#undef CF_CTX_CALL_DATA
 120#define CF_CTX_CALL_DATA(cf) ((struct cf_h2_ctx *)(cf)->ctx)->call_data
 121
 122/**
 123 * All about the H2 internals of a stream
 124 */
 125struct h2_stream_ctx {
 126  struct bufq sendbuf; /* request buffer */
 127  struct h1_req_parser h1; /* parsing the request */
 128  struct dynhds resp_trailers; /* response trailer fields */
 129  size_t resp_hds_len; /* amount of response header bytes in recvbuf */
 130  curl_off_t nrcvd_data;  /* number of DATA bytes received */
 131
 132  char **push_headers;       /* allocated array */
 133  size_t push_headers_used;  /* number of entries filled in */
 134  size_t push_headers_alloc; /* number of entries allocated */
 135
 136  int status_code; /* HTTP response status code */
 137  uint32_t error; /* stream error code */
 138  CURLcode xfer_result; /* Result of writing out response */
 139  int32_t local_window_size; /* the local recv window size */
 140  int32_t id; /* HTTP/2 protocol identifier for stream */
 141  BIT(resp_hds_complete); /* we have a complete, final response */
 142  BIT(closed); /* TRUE on stream close */
 143  BIT(reset);  /* TRUE on stream reset */
 144  BIT(reset_by_server);  /* TRUE on stream reset by server */
 145  BIT(close_handled); /* TRUE if stream closure is handled by libcurl */
 146  BIT(bodystarted);
 147  BIT(body_eos);    /* the complete body has been added to `sendbuf` and
 148                     * is being/has been processed from there. */
 149  BIT(write_paused);  /* stream write is paused */
 150};
 151
 152static void free_push_headers(struct h2_stream_ctx *stream)
 153{
 154  size_t i;
 155  for(i = 0; i < stream->push_headers_used; i++)
 156    curlx_free(stream->push_headers[i]);
 157  curlx_safefree(stream->push_headers);
 158  stream->push_headers_used = 0;
 159}
 160
 161static void h2_stream_ctx_free(struct h2_stream_ctx *stream)
 162{
 163  Curl_bufq_free(&stream->sendbuf);
 164  Curl_h1_req_parse_free(&stream->h1);
 165  Curl_dynhds_free(&stream->resp_trailers);
 166  free_push_headers(stream);
 167  curlx_free(stream);
 168}
 169
 170static void h2_stream_hash_free(unsigned int id, void *stream)
 171{
 172  (void)id;
 173  DEBUGASSERT(stream);
 174  h2_stream_ctx_free((struct h2_stream_ctx *)stream);
 175}
 176
 177static void cf_h2_ctx_init(struct cf_h2_ctx *ctx, bool via_h1_upgrade)
 178{
 179  Curl_bufcp_init(&ctx->stream_bufcp, H2_CHUNK_SIZE, H2_STREAM_POOL_SPARES);
 180  Curl_bufq_initp(&ctx->inbufq, &ctx->stream_bufcp, H2_NW_RECV_CHUNKS, 0);
 181  Curl_bufq_initp(&ctx->outbufq, &ctx->stream_bufcp, H2_NW_SEND_CHUNKS, 0);
 182  curlx_dyn_init(&ctx->scratch, CURL_MAX_HTTP_HEADER);
 183  Curl_uint32_hash_init(&ctx->streams, 63, h2_stream_hash_free);
 184  ctx->remote_max_sid = 2147483647;
 185  ctx->via_h1_upgrade = via_h1_upgrade;
 186  ctx->initialized = TRUE;
 187}
 188
 189static void cf_h2_ctx_free(struct cf_h2_ctx *ctx)
 190{
 191  if(ctx && ctx->initialized) {
 192    Curl_bufq_free(&ctx->inbufq);
 193    Curl_bufq_free(&ctx->outbufq);
 194    Curl_bufcp_free(&ctx->stream_bufcp);
 195    curlx_dyn_free(&ctx->scratch);
 196    Curl_uint32_hash_destroy(&ctx->streams);
 197    memset(ctx, 0, sizeof(*ctx));
 198  }
 199  curlx_free(ctx);
 200}
 201
 202static void cf_h2_ctx_close(struct cf_h2_ctx *ctx)
 203{
 204  if(ctx->h2) {
 205    nghttp2_session_del(ctx->h2);
 206    ctx->h2 = NULL;
 207  }
 208}
 209
 210static uint32_t cf_h2_initial_win_size(struct Curl_easy *data)
 211{
 212#if NGHTTP2_HAS_SET_LOCAL_WINDOW_SIZE
 213  /* If the transfer has a rate-limit lower than the default initial
 214   * stream window size, use that. It needs to be at least 8k or servers
 215   * may be unhappy. */
 216  curl_off_t rps = Curl_rlimit_per_step(&data->progress.dl.rlimit);
 217  if((rps > 0) && (rps < H2_STREAM_WINDOW_SIZE_INITIAL))
 218    return CURLMAX((uint32_t)rps, 8192);
 219#endif
 220  return H2_STREAM_WINDOW_SIZE_INITIAL;
 221}
 222
 223static size_t populate_settings(nghttp2_settings_entry *iv,
 224                                  struct Curl_easy *data,
 225                                  struct cf_h2_ctx *ctx)
 226{
 227  iv[0].settings_id = NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS;
 228  iv[0].value = Curl_multi_max_concurrent_streams(data->multi);
 229
 230  iv[1].settings_id = NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
 231  iv[1].value = cf_h2_initial_win_size(data);
 232  if(ctx)
 233    ctx->initial_win_size = iv[1].value;
 234  iv[2].settings_id = NGHTTP2_SETTINGS_ENABLE_PUSH;
 235  iv[2].value = data->multi->push_cb != NULL;
 236
 237  return 3;
 238}
 239
 240static ssize_t populate_binsettings(uint8_t *binsettings,
 241                                    struct Curl_easy *data)
 242{
 243  nghttp2_settings_entry iv[H2_SETTINGS_IV_LEN];
 244  size_t ivlen;
 245
 246  ivlen = populate_settings(iv, data, NULL);
 247  /* this returns number of bytes it wrote or a negative number on error. */
 248  return nghttp2_pack_settings_payload(binsettings, H2_BINSETTINGS_LEN,
 249                                       iv, ivlen);
 250}
 251
 252static CURLcode cf_h2_update_settings(struct cf_h2_ctx *ctx,
 253                                      uint32_t initial_win_size)
 254{
 255  nghttp2_settings_entry entry;
 256  entry.settings_id = NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
 257  entry.value = initial_win_size;
 258  if(nghttp2_submit_settings(ctx->h2, NGHTTP2_FLAG_NONE, &entry, 1))
 259    return CURLE_SEND_ERROR;
 260  ctx->initial_win_size = initial_win_size;
 261  return CURLE_OK;
 262}
 263
 264#define H2_STREAM_CTX(ctx, data)                                         \
 265  ((struct h2_stream_ctx *)(                                             \
 266    (data) ? Curl_uint32_hash_get(&(ctx)->streams, (data)->mid) : NULL))
 267
 268static struct h2_stream_ctx *h2_stream_ctx_create(struct cf_h2_ctx *ctx)
 269{
 270  struct h2_stream_ctx *stream;
 271
 272  (void)ctx;
 273  stream = curlx_calloc(1, sizeof(*stream));
 274  if(!stream)
 275    return NULL;
 276
 277  stream->id = -1;
 278  Curl_bufq_initp(&stream->sendbuf, &ctx->stream_bufcp,
 279                  H2_STREAM_SEND_CHUNKS, BUFQ_OPT_NONE);
 280  Curl_h1_req_parse_init(&stream->h1, H1_PARSE_DEFAULT_MAX_LINE_LEN);
 281  Curl_dynhds_init(&stream->resp_trailers, 0, DYN_HTTP_REQUEST);
 282  stream->bodystarted = FALSE;
 283  stream->status_code = -1;
 284  stream->closed = FALSE;
 285  stream->close_handled = FALSE;
 286  stream->error = NGHTTP2_NO_ERROR;
 287  stream->local_window_size = H2_STREAM_WINDOW_SIZE_INITIAL;
 288  stream->nrcvd_data = 0;
 289  return stream;
 290}
 291
 292#ifdef NGHTTP2_HAS_SET_LOCAL_WINDOW_SIZE
 293static int32_t cf_h2_get_desired_local_win(struct Curl_cfilter *cf,
 294                                           struct Curl_easy *data)
 295{
 296  curl_off_t avail = Curl_rlimit_avail(&data->progress.dl.rlimit,
 297                                       Curl_pgrs_now(data));
 298
 299  (void)cf;
 300  if(avail < CURL_OFF_T_MAX) { /* limit in place */
 301    if(avail <= 0)
 302      return 0;
 303    else if(avail < INT32_MAX)
 304      return (int32_t)avail;
 305  }
 306  return H2_STREAM_WINDOW_SIZE_MAX;
 307}
 308
 309static CURLcode cf_h2_update_local_win(struct Curl_cfilter *cf,
 310                                       struct Curl_easy *data,
 311                                       struct h2_stream_ctx *stream)
 312{
 313  struct cf_h2_ctx *ctx = cf->ctx;
 314  int32_t dwsize;
 315  int rv;
 316
 317  dwsize = (stream->write_paused || stream->xfer_result) ?
 318           0 : cf_h2_get_desired_local_win(cf, data);
 319  if(dwsize != stream->local_window_size) {
 320    int32_t wsize = nghttp2_session_get_stream_effective_local_window_size(
 321                      ctx->h2, stream->id);
 322    if(dwsize > wsize) {
 323      rv = nghttp2_session_set_local_window_size(ctx->h2, NGHTTP2_FLAG_NONE,
 324                                                 stream->id, dwsize);
 325      if(rv) {
 326        failf(data, "[%d] nghttp2 set_local_window_size(%d) failed: "
 327              "%s(%d)", stream->id, dwsize, nghttp2_strerror(rv), rv);
 328        return CURLE_HTTP2;
 329      }
 330      rv = nghttp2_submit_window_update(ctx->h2, NGHTTP2_FLAG_NONE,
 331                                        stream->id, dwsize - wsize);
 332      if(rv) {
 333        failf(data, "[%d] nghttp2_submit_window_update() failed: "
 334              "%s(%d)", stream->id, nghttp2_strerror(rv), rv);
 335        return CURLE_HTTP2;
 336      }
 337      stream->local_window_size = dwsize;
 338      CURL_TRC_CF(data, cf, "[%d] local window update by %d",
 339                  stream->id, dwsize - wsize);
 340    }
 341    else {
 342      rv = nghttp2_session_set_local_window_size(ctx->h2, NGHTTP2_FLAG_NONE,
 343                                                 stream->id, dwsize);
 344      if(rv) {
 345        failf(data, "[%d] nghttp2_session_set_local_window_size() failed: "
 346              "%s(%d)", stream->id, nghttp2_strerror(rv), rv);
 347        return CURLE_HTTP2;
 348      }
 349      stream->local_window_size = dwsize;
 350      CURL_TRC_CF(data, cf, "[%d] local window size now %d",
 351                  stream->id, dwsize);
 352    }
 353  }
 354  return CURLE_OK;
 355}
 356
 357#else /* NGHTTP2_HAS_SET_LOCAL_WINDOW_SIZE */
 358
 359static CURLcode cf_h2_update_local_win(struct Curl_cfilter *cf,
 360                                       struct Curl_easy *data,
 361                                       struct h2_stream_ctx *stream)
 362{
 363  (void)cf;
 364  (void)data;
 365  (void)stream;
 366  return CURLE_OK;
 367}
 368#endif /* !NGHTTP2_HAS_SET_LOCAL_WINDOW_SIZE */
 369
 370static CURLcode http2_data_setup(struct Curl_cfilter *cf,
 371                                 struct Curl_easy *data,
 372                                 struct h2_stream_ctx **pstream)
 373{
 374  struct cf_h2_ctx *ctx = cf->ctx;
 375  struct h2_stream_ctx *stream;
 376
 377  (void)cf;
 378  DEBUGASSERT(data);
 379
 380  if(!data)
 381    return CURLE_BAD_FUNCTION_ARGUMENT;
 382
 383  stream = H2_STREAM_CTX(ctx, data);
 384  if(stream) {
 385    *pstream = stream;
 386    return CURLE_OK;
 387  }
 388
 389  stream = h2_stream_ctx_create(ctx);
 390  if(!stream)
 391    return CURLE_OUT_OF_MEMORY;
 392
 393  if(!Curl_uint32_hash_set(&ctx->streams, data->mid, stream)) {
 394    h2_stream_ctx_free(stream);
 395    return CURLE_OUT_OF_MEMORY;
 396  }
 397
 398  *pstream = stream;
 399  return CURLE_OK;
 400}
 401
 402static CURLcode nw_out_flush(struct Curl_cfilter *cf,
 403                             struct Curl_easy *data)
 404{
 405  struct cf_h2_ctx *ctx = cf->ctx;
 406  size_t nwritten;
 407  CURLcode result;
 408
 409  if(Curl_bufq_is_empty(&ctx->outbufq))
 410    return CURLE_OK;
 411
 412  result = Curl_cf_send_bufq(cf->next, data, &ctx->outbufq, NULL, 0,
 413                             &nwritten);
 414  if(result) {
 415    if(result == CURLE_AGAIN) {
 416      CURL_TRC_CF(data, cf, "flush nw send buffer(%zu) -> EAGAIN",
 417                  Curl_bufq_len(&ctx->outbufq));
 418      ctx->nw_out_blocked = 1;
 419    }
 420    return result;
 421  }
 422  return Curl_bufq_is_empty(&ctx->outbufq) ? CURLE_OK : CURLE_AGAIN;
 423}
 424
 425static void http2_data_done(struct Curl_cfilter *cf, struct Curl_easy *data)
 426{
 427  struct cf_h2_ctx *ctx = cf->ctx;
 428  struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
 429
 430  DEBUGASSERT(ctx);
 431  if(!stream || !ctx->initialized)
 432    return;
 433
 434  if(ctx->h2) {
 435    bool flush_egress = FALSE;
 436    /* returns error if stream not known, which is fine here */
 437    (void)nghttp2_session_set_stream_user_data(ctx->h2, stream->id, NULL);
 438
 439    if(!stream->closed && stream->id > 0) {
 440      /* RST_STREAM */
 441      CURL_TRC_CF(data, cf, "[%d] premature DATA_DONE, RST stream",
 442                  stream->id);
 443      stream->closed = TRUE;
 444      stream->reset = TRUE;
 445      nghttp2_submit_rst_stream(ctx->h2, NGHTTP2_FLAG_NONE,
 446                                stream->id, NGHTTP2_STREAM_CLOSED);
 447      flush_egress = TRUE;
 448    }
 449
 450    if(flush_egress) {
 451      (void)nghttp2_session_send(ctx->h2);
 452      (void)nw_out_flush(cf, data);
 453    }
 454  }
 455
 456  Curl_uint32_hash_remove(&ctx->streams, data->mid);
 457}
 458
 459static int h2_client_new(struct Curl_cfilter *cf,
 460                         nghttp2_session_callbacks *cbs)
 461{
 462  struct cf_h2_ctx *ctx = cf->ctx;
 463  nghttp2_option *o;
 464  nghttp2_mem mem = { NULL, Curl_nghttp2_malloc, Curl_nghttp2_free,
 465                      Curl_nghttp2_calloc, Curl_nghttp2_realloc };
 466
 467  int rc = nghttp2_option_new(&o);
 468  if(rc)
 469    return rc;
 470  /* We handle window updates ourself to enforce buffer limits */
 471  nghttp2_option_set_no_auto_window_update(o, 1);
 472#if NGHTTP2_VERSION_NUM >= 0x013200
 473  /* with 1.50.0 */
 474  /* turn off RFC 9113 leading and trailing white spaces validation against
 475     HTTP field value. */
 476  nghttp2_option_set_no_rfc9113_leading_and_trailing_ws_validation(o, 1);
 477#endif
 478  rc = nghttp2_session_client_new3(&ctx->h2, cbs, cf, o, &mem);
 479  nghttp2_option_del(o);
 480  return rc;
 481}
 482
 483/*
 484 * Returns nonzero if current HTTP/2 session should be closed.
 485 */
 486static int should_close_session(struct cf_h2_ctx *ctx)
 487{
 488  return ctx->drain_total == 0 && !nghttp2_session_want_read(ctx->h2) &&
 489    !nghttp2_session_want_write(ctx->h2);
 490}
 491
 492/*
 493 * Processes pending input left in network input buffer.
 494 * This function returns 0 if it succeeds, or -1 and error code will
 495 * be assigned to *err.
 496 */
 497static CURLcode h2_process_pending_input(struct Curl_cfilter *cf,
 498                                         struct Curl_easy *data)
 499{
 500  struct cf_h2_ctx *ctx = cf->ctx;
 501  const unsigned char *buf;
 502  size_t blen, nread;
 503  ssize_t rv;
 504
 505  while(Curl_bufq_peek(&ctx->inbufq, &buf, &blen)) {
 506    rv = nghttp2_session_mem_recv(ctx->h2, (const uint8_t *)buf, blen);
 507    if(!curlx_sztouz(rv, &nread)) {
 508      failf(data, "nghttp2 recv error %zd: %s", rv, nghttp2_strerror((int)rv));
 509      return CURLE_HTTP2;
 510    }
 511    Curl_bufq_skip(&ctx->inbufq, nread);
 512    if(Curl_bufq_is_empty(&ctx->inbufq)) {
 513      break;
 514    }
 515    else {
 516      CURL_TRC_CF(data, cf, "process_pending_input: %zu bytes left "
 517                  "in connection buffer", Curl_bufq_len(&ctx->inbufq));
 518    }
 519  }
 520
 521  if(nghttp2_session_check_request_allowed(ctx->h2) == 0) {
 522    /* No more requests are allowed in the current session, so
 523       the connection may not be reused. This is set when a
 524       GOAWAY frame has been received or when the limit of stream
 525       identifiers has been reached. */
 526    connclose(cf->conn, "http/2: No new requests allowed");
 527  }
 528
 529  return CURLE_OK;
 530}
 531
 532/*
 533 * The server may send us data at any point (e.g. PING frames). Therefore, we
 534 * cannot assume that an HTTP/2 socket is dead because it is readable.
 535 *
 536 * Check the lower filters first and, if successful, peek at the socket
 537 * and distinguish between closed and data.
 538 */
 539static bool http2_connisalive(struct Curl_cfilter *cf, struct Curl_easy *data,
 540                              bool *input_pending)
 541{
 542  struct cf_h2_ctx *ctx = cf->ctx;
 543  bool alive = TRUE;
 544
 545  *input_pending = FALSE;
 546  if(!cf->next || !cf->next->cft->is_alive(cf->next, data, input_pending))
 547    return FALSE;
 548
 549  if(*input_pending) {
 550    /* This happens before we have sent off a request and the connection is
 551       not in use by any other transfer, there should not be any data here,
 552       only "protocol frames" */
 553    CURLcode result;
 554    size_t nread;
 555
 556    *input_pending = FALSE;
 557    result = Curl_cf_recv_bufq(cf->next, data, &ctx->inbufq, 0, &nread);
 558    if(!result) {
 559      CURL_TRC_CF(data, cf, "%zu bytes stray data read before trying "
 560                  "h2 connection", nread);
 561      result = h2_process_pending_input(cf, data);
 562      if(result)
 563        /* immediate error, considered dead */
 564        alive = FALSE;
 565      else {
 566        alive = !should_close_session(ctx);
 567      }
 568    }
 569    else if(result != CURLE_AGAIN) {
 570      /* the read failed so let's say this is dead anyway */
 571      alive = FALSE;
 572    }
 573  }
 574
 575  return alive;
 576}
 577
 578static CURLcode http2_send_ping(struct Curl_cfilter *cf,
 579                                struct Curl_easy *data)
 580{
 581  struct cf_h2_ctx *ctx = cf->ctx;
 582  int rc;
 583
 584  rc = nghttp2_submit_ping(ctx->h2, 0, ZERO_NULL);
 585  if(rc) {
 586    failf(data, "nghttp2_submit_ping() failed: %s(%d)",
 587          nghttp2_strerror(rc), rc);
 588    return CURLE_HTTP2;
 589  }
 590
 591  rc = nghttp2_session_send(ctx->h2);
 592  if(rc) {
 593    failf(data, "nghttp2_session_send() failed: %s(%d)",
 594          nghttp2_strerror(rc), rc);
 595    return CURLE_SEND_ERROR;
 596  }
 597  return CURLE_OK;
 598}
 599
 600/*
 601 * Store nghttp2 version info in this buffer.
 602 */
 603void Curl_http2_ver(char *p, size_t len)
 604{
 605  nghttp2_info *h2 = nghttp2_version(0);
 606  (void)curl_msnprintf(p, len, "nghttp2/%s", h2->version_str);
 607}
 608
 609/*
 610 * The implementation of nghttp2_send_callback type. Here we write |data| with
 611 * size |length| to the network and return the number of bytes actually
 612 * written. See the documentation of nghttp2_send_callback for the details.
 613 */
 614static ssize_t send_callback(nghttp2_session *h2,
 615                             const uint8_t *buf, size_t blen, int flags,
 616                             void *userp)
 617{
 618  struct Curl_cfilter *cf = userp;
 619  struct cf_h2_ctx *ctx = cf->ctx;
 620  struct Curl_easy *data = CF_DATA_CURRENT(cf);
 621  size_t nwritten;
 622  CURLcode result = CURLE_OK;
 623
 624  (void)h2;
 625  (void)flags;
 626  DEBUGASSERT(data);
 627
 628  if(!cf->connected)
 629    result = Curl_bufq_write(&ctx->outbufq, buf, blen, &nwritten);
 630  else
 631    result = Curl_cf_send_bufq(cf->next, data, &ctx->outbufq, buf, blen,
 632                               &nwritten);
 633
 634  if(result) {
 635    if(result == CURLE_AGAIN) {
 636      ctx->nw_out_blocked = 1;
 637      return NGHTTP2_ERR_WOULDBLOCK;
 638    }
 639    failf(data, "Failed sending HTTP2 data");
 640    return NGHTTP2_ERR_CALLBACK_FAILURE;
 641  }
 642
 643  if(!nwritten) {
 644    ctx->nw_out_blocked = 1;
 645    return NGHTTP2_ERR_WOULDBLOCK;
 646  }
 647  return (nwritten > SSIZE_MAX) ?
 648    NGHTTP2_ERR_CALLBACK_FAILURE : (ssize_t)nwritten;
 649}
 650
 651/* We pass a pointer to this struct in the push callback, but the contents of
 652   the struct are hidden from the user. */
 653struct curl_pushheaders {
 654  struct Curl_easy *data;
 655  struct h2_stream_ctx *stream;
 656  const nghttp2_push_promise *frame;
 657};
 658
 659/*
 660 * push header access function. Only to be used from within the push callback
 661 */
 662char *curl_pushheader_bynum(struct curl_pushheaders *h, size_t num)
 663{
 664  /* Verify that we got a good easy handle in the push header struct, mostly to
 665     detect rubbish input fast(er). */
 666  if(!h || !GOOD_EASY_HANDLE(h->data))
 667    return NULL;
 668  else {
 669    if(h->stream && num < h->stream->push_headers_used)
 670      return h->stream->push_headers[num];
 671  }
 672  return NULL;
 673}
 674
 675/*
 676 * push header access function. Only to be used from within the push callback
 677 */
 678char *curl_pushheader_byname(struct curl_pushheaders *h, const char *name)
 679{
 680  struct h2_stream_ctx *stream;
 681  size_t len;
 682  size_t i;
 683  /* Verify that we got a good easy handle in the push header struct,
 684     mostly to detect rubbish input fast(er). Also empty header name
 685     is rubbish too. We have to allow ":" at the beginning of
 686     the header, but header == ":" must be rejected. If we have ':' in
 687     the middle of header, it could be matched in middle of the value,
 688     this is because we do prefix match.*/
 689  if(!h || !GOOD_EASY_HANDLE(h->data) || !name || !name[0] ||
 690     !strcmp(name, ":") || strchr(name + 1, ':'))
 691    return NULL;
 692
 693  stream = h->stream;
 694  if(!stream)
 695    return NULL;
 696
 697  len = strlen(name);
 698  for(i = 0; i < stream->push_headers_used; i++) {
 699    if(!strncmp(name, stream->push_headers[i], len)) {
 700      /* sub-match, make sure that it is followed by a colon */
 701      if(stream->push_headers[i][len] != ':')
 702        continue;
 703      return &stream->push_headers[i][len + 1];
 704    }
 705  }
 706  return NULL;
 707}
 708
 709static struct Curl_easy *h2_duphandle(struct Curl_cfilter *cf,
 710                                      struct Curl_easy *data)
 711{
 712  struct Curl_easy *second = curl_easy_duphandle(data);
 713  if(second) {
 714    struct h2_stream_ctx *second_stream;
 715    http2_data_setup(cf, second, &second_stream);
 716    second->state.priority.weight = data->state.priority.weight;
 717  }
 718  return second;
 719}
 720
 721static int set_transfer_url(struct Curl_easy *newhandle,
 722                            struct curl_pushheaders *hp,
 723                            struct Curl_easy *data)
 724{
 725  const char *v;
 726  CURLUcode uc;
 727  char *url = NULL;
 728  int rc = 0;
 729  CURLU *u = curl_url();
 730
 731  if(!u)
 732    return 5;
 733
 734  v = curl_pushheader_byname(hp, HTTP_PSEUDO_SCHEME);
 735  if(v) {
 736    uc = curl_url_set(u, CURLUPART_SCHEME, v, 0);
 737    if(uc) {
 738      rc = 1;
 739      goto fail;
 740    }
 741  }
 742
 743  v = curl_pushheader_byname(hp, HTTP_PSEUDO_AUTHORITY);
 744  if(v) {
 745    uc = Curl_url_set_authority(u, v);
 746    if(uc) {
 747      rc = 2;
 748      goto fail;
 749    }
 750  }
 751
 752  v = curl_pushheader_byname(hp, HTTP_PSEUDO_PATH);
 753  if(v) {
 754    uc = curl_url_set(u, CURLUPART_PATH, v, 0);
 755    if(uc) {
 756      rc = 3;
 757      goto fail;
 758    }
 759  }
 760
 761  /* We can only allow PUSH of resource from the same origin, e.g.
 762   * scheme + hostname + port */
 763  if(!Curl_url_same_origin(data->state.uh, u)) {
 764    rc = 1;
 765    goto fail;
 766  }
 767
 768  uc = curl_url_get(u, CURLUPART_URL, &url, 0);
 769  if(uc)
 770    rc = 4;
 771fail:
 772  curl_url_cleanup(u);
 773  if(rc)
 774    return rc;
 775
 776  Curl_bufref_set(&newhandle->state.url, url, 0, curl_free);
 777  return 0;
 778}
 779
 780static void discard_newhandle(struct Curl_cfilter *cf,
 781                              struct Curl_easy *newhandle)
 782{
 783  http2_data_done(cf, newhandle);
 784  (void)Curl_close(&newhandle);
 785}
 786
 787static int push_promise(struct Curl_cfilter *cf,
 788                        struct Curl_easy *data,
 789                        const nghttp2_push_promise *frame)
 790{
 791  struct cf_h2_ctx *ctx = cf->ctx;
 792  int rv; /* one of the CURL_PUSH_* defines */
 793
 794  CURL_TRC_CF(data, cf, "[%d] PUSH_PROMISE received",
 795              frame->promised_stream_id);
 796  if(data->multi->push_cb) {
 797    struct h2_stream_ctx *stream;
 798    struct h2_stream_ctx *newstream;
 799    struct curl_pushheaders heads;
 800    CURLMcode mresult;
 801    CURLcode result;
 802    /* clone the parent */
 803    struct Curl_easy *newhandle = h2_duphandle(cf, data);
 804    if(!newhandle) {
 805      infof(data, "failed to duplicate handle");
 806      rv = CURL_PUSH_DENY; /* FAIL HARD */
 807      goto fail;
 808    }
 809
 810    stream = H2_STREAM_CTX(ctx, data);
 811    if(!stream) {
 812      failf(data, "Internal NULL stream");
 813      discard_newhandle(cf, newhandle);
 814      rv = CURL_PUSH_DENY;
 815      goto fail;
 816    }
 817
 818    heads.data = data;
 819    heads.stream = stream;
 820    heads.frame = frame;
 821
 822    rv = set_transfer_url(newhandle, &heads, data);
 823    if(rv) {
 824      CURL_TRC_CF(data, cf, "[%d] PUSH_PROMISE, failed to set URL -> %d",
 825                  frame->promised_stream_id, rv);
 826      discard_newhandle(cf, newhandle);
 827      rv = CURL_PUSH_DENY;
 828      goto fail;
 829    }
 830
 831    Curl_set_in_callback(data, TRUE);
 832    rv = data->multi->push_cb(data, newhandle,
 833                              stream->push_headers_used, &heads,
 834                              data->multi->push_userp);
 835    Curl_set_in_callback(data, FALSE);
 836
 837    /* free the headers again */
 838    free_push_headers(stream);
 839
 840    if(rv) {
 841      DEBUGASSERT((rv > CURL_PUSH_OK) && (rv <= CURL_PUSH_ERROROUT));
 842      /* denied, kill off the new handle again */
 843      CURL_TRC_CF(data, cf, "[%d] PUSH_PROMISE, denied by application -> %d",
 844                  frame->promised_stream_id, rv);
 845      discard_newhandle(cf, newhandle);
 846      goto fail;
 847    }
 848
 849    /* approved, add to the multi handle for processing. This
 850     * assigns newhandle->mid. For the new `mid` we assign the
 851     * h2_stream instance and remember the stream_id already known. */
 852    mresult = Curl_multi_add_perform(data->multi, newhandle, cf->conn);
 853    if(mresult) {
 854      infof(data, "failed to add handle to multi");
 855      discard_newhandle(cf, newhandle);
 856      rv = CURL_PUSH_DENY;
 857      goto fail;
 858    }
 859
 860    result = http2_data_setup(cf, newhandle, &newstream);
 861    if(result) {
 862      failf(data, "error setting up stream: %d", result);
 863      discard_newhandle(cf, newhandle);
 864      rv = CURL_PUSH_DENY;
 865      goto fail;
 866    }
 867
 868    DEBUGASSERT(newstream);
 869    newstream->id = frame->promised_stream_id;
 870    newhandle->req.maxdownload = -1;
 871    newhandle->req.size = -1;
 872
 873    CURL_TRC_CF(data, cf, "promise easy handle added to multi, mid=%u",
 874                newhandle->mid);
 875    rv = nghttp2_session_set_stream_user_data(ctx->h2,
 876                                              newstream->id,
 877                                              newhandle);
 878    if(rv) {
 879      infof(data, "failed to set user_data for stream %d",
 880            newstream->id);
 881      DEBUGASSERT(0);
 882      discard_newhandle(cf, newhandle);
 883      rv = CURL_PUSH_DENY;
 884      goto fail;
 885    }
 886
 887    /* success, remember max stream id processed */
 888    if(newstream->id > ctx->local_max_sid)
 889      ctx->local_max_sid = newstream->id;
 890  }
 891  else {
 892    CURL_TRC_CF(data, cf, "Got PUSH_PROMISE, ignore it");
 893    rv = CURL_PUSH_DENY;
 894  }
 895fail:
 896  return rv;
 897}
 898
 899static void h2_xfer_write_resp_hd(struct Curl_cfilter *cf,
 900                                  struct Curl_easy *data,
 901                                  struct h2_stream_ctx *stream,
 902                                  const char *buf, size_t blen, bool eos)
 903{
 904  /* If we already encountered an error, skip further writes */
 905  if(!stream->xfer_result) {
 906    stream->xfer_result = Curl_xfer_write_resp_hd(data, buf, blen, eos);
 907    if(!stream->xfer_result && !eos)
 908      stream->xfer_result = cf_h2_update_local_win(cf, data, stream);
 909    if(stream->xfer_result)
 910      CURL_TRC_CF(data, cf, "[%d] error %d writing %zu bytes of headers",
 911                  stream->id, stream->xfer_result, blen);
 912  }
 913}
 914
 915static void h2_xfer_write_resp(struct Curl_cfilter *cf,
 916                               struct Curl_easy *data,
 917                               struct h2_stream_ctx *stream,
 918                               const char *buf, size_t blen, bool eos)
 919{
 920  /* If we already encountered an error, skip further writes */
 921  if(!stream->xfer_result)
 922    stream->xfer_result = Curl_xfer_write_resp(data, buf, blen, eos);
 923  /* If the transfer write is errored, we do not want any more data */
 924  if(stream->xfer_result) {
 925    struct cf_h2_ctx *ctx = cf->ctx;
 926    CURL_TRC_CF(data, cf, "[%d] error %d writing %zu bytes of data, "
 927                "RST-ing stream",
 928                stream->id, stream->xfer_result, blen);
 929    nghttp2_submit_rst_stream(ctx->h2, 0, stream->id,
 930                              (uint32_t)NGHTTP2_ERR_CALLBACK_FAILURE);
 931  }
 932  else if(!stream->write_paused && Curl_xfer_write_is_paused(data)) {
 933    CURL_TRC_CF(data, cf, "[%d] stream output paused", stream->id);
 934    stream->write_paused = TRUE;
 935  }
 936  else if(stream->write_paused && !Curl_xfer_write_is_paused(data)) {
 937    CURL_TRC_CF(data, cf, "[%d] stream output unpaused", stream->id);
 938    stream->write_paused = FALSE;
 939  }
 940
 941  if(!stream->xfer_result && !eos)
 942    stream->xfer_result = cf_h2_update_local_win(cf, data, stream);
 943}
 944
 945static CURLcode on_stream_frame(struct Curl_cfilter *cf,
 946                                struct Curl_easy *data,
 947                                const nghttp2_frame *frame)
 948{
 949  struct cf_h2_ctx *ctx = cf->ctx;
 950  struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
 951  int32_t stream_id = frame->hd.stream_id;
 952  int rv;
 953
 954  if(!stream) {
 955    CURL_TRC_CF(data, cf, "[%d] No stream_ctx set", stream_id);
 956    return CURLE_FAILED_INIT;
 957  }
 958
 959  switch(frame->hd.type) {
 960  case NGHTTP2_DATA:
 961    CURL_TRC_CF(data, cf, "[%d] DATA, window=%d/%d",
 962                stream_id,
 963                nghttp2_session_get_stream_effective_recv_data_length(
 964                  ctx->h2, stream->id),
 965                nghttp2_session_get_stream_effective_local_window_size(
 966                  ctx->h2, stream->id));
 967    /* If !body started on this stream, then receiving DATA is illegal. */
 968    if(!stream->bodystarted) {
 969      rv = nghttp2_submit_rst_stream(ctx->h2, NGHTTP2_FLAG_NONE,
 970                                     stream_id, NGHTTP2_PROTOCOL_ERROR);
 971
 972      if(nghttp2_is_fatal(rv)) {
 973        return CURLE_RECV_ERROR;
 974      }
 975    }
 976    break;
 977  case NGHTTP2_HEADERS:
 978    if(stream->bodystarted) {
 979      /* Only valid HEADERS after body started is trailer HEADERS. We
 980         buffer them in on_header callback. */
 981      break;
 982    }
 983
 984    /* nghttp2 guarantees that :status is received, and we store it to
 985       stream->status_code. Fuzzing has proven this can still be reached
 986       without status code having been set. */
 987    if(stream->status_code == -1)
 988      return CURLE_RECV_ERROR;
 989
 990    /* Only final status code signals the end of header */
 991    if(stream->status_code / 100 != 1)
 992      stream->bodystarted = TRUE;
 993    else
 994      stream->status_code = -1;
 995
 996    h2_xfer_write_resp_hd(cf, data, stream, STRCONST("\r\n"),
 997                          (bool)stream->closed);
 998
 999    if(stream->status_code / 100 != 1) {
1000      stream->resp_hds_complete = TRUE;
1001    }
1002    Curl_multi_mark_dirty(data);
1003    break;
1004  case NGHTTP2_PUSH_PROMISE:
1005    rv = push_promise(cf, data, &frame->push_promise);
1006    if(rv) { /* deny! */
1007      DEBUGASSERT((rv > CURL_PUSH_OK) && (rv <= CURL_PUSH_ERROROUT));
1008      rv = nghttp2_submit_rst_stream(ctx->h2, NGHTTP2_FLAG_NONE,
1009                                     frame->push_promise.promised_stream_id,
1010                                     NGHTTP2_CANCEL);
1011      if(nghttp2_is_fatal(rv))
1012        return CURLE_SEND_ERROR;
1013      else if(rv == CURL_PUSH_ERROROUT) {
1014        CURL_TRC_CF(data, cf, "[%d] fail in PUSH_PROMISE received",
1015                    stream_id);
1016        return CURLE_RECV_ERROR;
1017      }
1018    }
1019    break;
1020  case NGHTTP2_RST_STREAM:
1021    if(frame->rst_stream.error_code)
1022      stream->reset_by_server = TRUE;
1023    Curl_multi_mark_dirty(data);
1024    break;
1025  case NGHTTP2_WINDOW_UPDATE:
1026    if(CURL_REQ_WANT_SEND(data) && Curl_bufq_is_empty(&stream->sendbuf)) {
1027      /* need more data, force processing of transfer */
1028      Curl_multi_mark_dirty(data);
1029    }
1030    else if(!Curl_bufq_is_empty(&stream->sendbuf)) {
1031      /* resume the potentially suspended stream */
1032      rv = nghttp2_session_resume_data(ctx->h2, stream->id);
1033      if(nghttp2_is_fatal(rv))
1034        return CURLE_SEND_ERROR;
1035    }
1036    break;
1037  default:
1038    break;
1039  }
1040
1041  if(frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
1042    if(!stream->closed && !stream->body_eos &&
1043       ((stream->status_code >= 400) || (stream->status_code < 200))) {
1044      /* The server did not give us a positive response and we are not
1045       * done uploading the request body. We need to stop doing that and
1046       * also inform the server that we aborted our side. */
1047      CURL_TRC_CF(data, cf, "[%d] EOS frame with unfinished upload and "
1048                  "HTTP status %d, abort upload by RST",
1049                  stream_id, stream->status_code);
1050      nghttp2_submit_rst_stream(ctx->h2, NGHTTP2_FLAG_NONE,
1051                                stream->id, NGHTTP2_STREAM_CLOSED);
1052      stream->closed = TRUE;
1053    }
1054    Curl_multi_mark_dirty(data);
1055  }
1056  return CURLE_OK;
1057}
1058
1059#ifdef CURLVERBOSE
1060int Curl_nghttp2_fr_print(const nghttp2_frame *frame, char *buffer,
1061                          size_t blen)
1062{
1063  switch(frame->hd.type) {
1064  case NGHTTP2_DATA: {
1065    return curl_msnprintf(buffer, blen,
1066                          "FRAME[DATA, len=%d, eos=%d, padlen=%d]",
1067                          (int)frame->hd.length,
1068                          !!(frame->hd.flags & NGHTTP2_FLAG_END_STREAM),
1069                          (int)frame->data.padlen);
1070  }
1071  case NGHTTP2_HEADERS: {
1072    return curl_msnprintf(buffer, blen,
1073                          "FRAME[HEADERS, len=%d, hend=%d, eos=%d]",
1074                          (int)frame->hd.length,
1075                          !!(frame->hd.flags & NGHTTP2_FLAG_END_HEADERS),
1076                          !!(frame->hd.flags & NGHTTP2_FLAG_END_STREAM));
1077  }
1078  case NGHTTP2_PRIORITY: {
1079    return curl_msnprintf(buffer, blen,
1080                          "FRAME[PRIORITY, len=%d, flags=%d]",
1081                          (int)frame->hd.length, frame->hd.flags);
1082  }
1083  case NGHTTP2_RST_STREAM: {
1084    return curl_msnprintf(buffer, blen,
1085                          "FRAME[RST_STREAM, len=%d, flags=%d, error=%u]",
1086                          (int)frame->hd.length, frame->hd.flags,
1087                          frame->rst_stream.error_code);
1088  }
1089  case NGHTTP2_SETTINGS: {
1090    if(frame->hd.flags & NGHTTP2_FLAG_ACK) {
1091      return curl_msnprintf(buffer, blen, "FRAME[SETTINGS, ack=1]");
1092    }
1093    return curl_msnprintf(buffer, blen,
1094                          "FRAME[SETTINGS, len=%d]", (int)frame->hd.length);
1095  }
1096  case NGHTTP2_PUSH_PROMISE:
1097    return curl_msnprintf(buffer, blen,
1098                          "FRAME[PUSH_PROMISE, len=%d, hend=%d]",
1099                          (int)frame->hd.length,
1100                          !!(frame->hd.flags & NGHTTP2_FLAG_END_HEADERS));
1101  case NGHTTP2_PING:
1102    return curl_msnprintf(buffer, blen,
1103                          "FRAME[PING, len=%d, ack=%d]",
1104                          (int)frame->hd.length,
1105                          frame->hd.flags & NGHTTP2_FLAG_ACK);
1106  case NGHTTP2_GOAWAY: {
1107    char scratch[128];
1108    size_t s_len = CURL_ARRAYSIZE(scratch);
1109    size_t len = (frame->goaway.opaque_data_len < s_len) ?
1110      frame->goaway.opaque_data_len : s_len - 1;
1111    if(len)
1112      memcpy(scratch, frame->goaway.opaque_data, len);
1113    scratch[len] = '\0';
1114    return curl_msnprintf(buffer, blen,
1115                          "FRAME[GOAWAY, error=%u, reason='%s', "
1116                          "last_stream=%d]", frame->goaway.error_code,
1117                          scratch, frame->goaway.last_stream_id);
1118  }
1119  case NGHTTP2_WINDOW_UPDATE: {
1120    return curl_msnprintf(buffer, blen,
1121                          "FRAME[WINDOW_UPDATE, incr=%d]",
1122                          frame->window_update.window_size_increment);
1123  }
1124  default:
1125    return curl_msnprintf(buffer, blen, "FRAME[%d, len=%d, flags=%d]",
1126                          frame->hd.type, (int)frame->hd.length,
1127                          frame->hd.flags);
1128  }
1129}
1130
1131static int on_frame_send(nghttp2_session *session, const nghttp2_frame *frame,
1132                         void *userp)
1133{
1134  struct Curl_cfilter *cf = userp;
1135  struct cf_h2_ctx *ctx = cf->ctx;
1136  struct Curl_easy *data = CF_DATA_CURRENT(cf);
1137
1138  (void)session;
1139  DEBUGASSERT(data);
1140  if(Curl_trc_cf_is_verbose(cf, data)) {
1141    char buffer[256];
1142    int len;
1143    len = Curl_nghttp2_fr_print(frame, buffer, sizeof(buffer) - 1);
1144    buffer[len] = 0;
1145    CURL_TRC_CF(data, cf, "[%d] -> %s", frame->hd.stream_id, buffer);
1146  }
1147  if((frame->hd.type == NGHTTP2_GOAWAY) && !ctx->sent_goaway) {
1148    /* A GOAWAY not initiated by us, but by nghttp2 itself on detecting
1149     * a protocol error on the connection */
1150    failf(data, "nghttp2 shuts down connection with error %u: %s",
1151          frame->goaway.error_code,
1152          nghttp2_http2_strerror(frame->goaway.error_code));
1153  }
1154  return 0;
1155}
1156#endif /* CURLVERBOSE */
1157
1158static int on_frame_recv(nghttp2_session *session, const nghttp2_frame *frame,
1159                         void *userp)
1160{
1161  struct Curl_cfilter *cf = userp;
1162  struct cf_h2_ctx *ctx = cf->ctx;
1163  struct Curl_easy *data = CF_DATA_CURRENT(cf), *data_s;
1164  int32_t stream_id = frame->hd.stream_id;
1165
1166  DEBUGASSERT(data);
1167#ifdef CURLVERBOSE
1168  if(Curl_trc_cf_is_verbose(cf, data)) {
1169    char buffer[256];
1170    int len;
1171    len = Curl_nghttp2_fr_print(frame, buffer, sizeof(buffer) - 1);
1172    buffer[len] = 0;
1173    CURL_TRC_CF(data, cf, "[%d] <- %s", frame->hd.stream_id, buffer);
1174  }
1175#endif /* CURLVERBOSE */
1176
1177  if(!stream_id) {
1178    /* stream ID zero is for connection-oriented stuff */
1179    DEBUGASSERT(data);
1180    switch(frame->hd.type) {
1181    case NGHTTP2_SETTINGS: {
1182      if(!(frame->hd.flags & NGHTTP2_FLAG_ACK)) {
1183        uint32_t max_conn = ctx->max_concurrent_streams;
1184        ctx->max_concurrent_streams = nghttp2_session_get_remote_settings(
1185          session, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS);
1186        ctx->enable_push = nghttp2_session_get_remote_settings(
1187          session, NGHTTP2_SETTINGS_ENABLE_PUSH) != 0;
1188        CURL_TRC_CF(data, cf, "[0] MAX_CONCURRENT_STREAMS: %u",
1189                    ctx->max_concurrent_streams);
1190        CURL_TRC_CF(data, cf, "[0] ENABLE_PUSH: %s",
1191                    ctx->enable_push ? "TRUE" : "false");
1192        if(data && max_conn != ctx->max_concurrent_streams) {
1193          /* only signal change if the value actually changed */
1194          CURL_TRC_CF(data, cf, "[0] notify MAX_CONCURRENT_STREAMS: %u",
1195                      ctx->max_concurrent_streams);
1196          Curl_multi_connchanged(data->multi);
1197        }
1198        /* Since the initial stream window is 64K, a request might be on HOLD,
1199         * due to exhaustion. The (initial) SETTINGS may announce a much larger
1200         * window and *assume* that we treat this like a WINDOW_UPDATE. Some
1201         * servers send an explicit WINDOW_UPDATE, but not all seem to do that.
1202         * To be safe, we UNHOLD a stream in order not to stall. */
1203        if(CURL_REQ_WANT_SEND(data))
1204          Curl_multi_mark_dirty(data);
1205      }
1206      break;
1207    }
1208    case NGHTTP2_GOAWAY:
1209      ctx->rcvd_goaway = TRUE;
1210      ctx->goaway_error = frame->goaway.error_code;
1211      ctx->remote_max_sid = frame->goaway.last_stream_id;
1212      if(data) {
1213        infof(data, "received GOAWAY, error=%u, last_stream=%d",
1214              ctx->goaway_error, ctx->remote_max_sid);
1215        Curl_multi_connchanged(data->multi);
1216      }
1217      break;
1218    default:
1219      break;
1220    }
1221    return 0;
1222  }
1223
1224  data_s = nghttp2_session_get_stream_user_data(session, stream_id);
1225  if(!data_s) {
1226    CURL_TRC_CF(data, cf, "[%d] No Curl_easy associated", stream_id);
1227    return 0;
1228  }
1229
1230  return on_stream_frame(cf, data_s, frame) ? NGHTTP2_ERR_CALLBACK_FAILURE : 0;
1231}
1232
1233static int cf_h2_on_invalid_frame_recv(nghttp2_session *session,
1234                                       const nghttp2_frame *frame,
1235                                       int ngerr, void *userp)
1236{
1237  struct Curl_cfilter *cf = userp;
1238  struct cf_h2_ctx *ctx = cf->ctx;
1239  struct Curl_easy *data;
1240  int32_t stream_id = frame->hd.stream_id;
1241
1242  data = nghttp2_session_get_stream_user_data(session, stream_id);
1243  if(data) {
1244    struct h2_stream_ctx *stream;
1245#ifdef CURLVERBOSE
1246    char buffer[256];
1247    int len;
1248    len = Curl_nghttp2_fr_print(frame, buffer, sizeof(buffer) - 1);
1249    buffer[len] = 0;
1250    failf(data, "[HTTP2] [%d] received invalid frame: %s, error %d: %s",
1251          stream_id, buffer, ngerr, nghttp2_strerror(ngerr));
1252#endif /* CURLVERBOSE */
1253    stream = H2_STREAM_CTX(ctx, data);
1254    if(stream) {
1255      nghttp2_submit_rst_stream(ctx->h2, NGHTTP2_FLAG_NONE,
1256                                stream->id, NGHTTP2_STREAM_CLOSED);
1257      stream->error = ngerr;
1258      stream->closed = TRUE;
1259      stream->reset = TRUE;
1260      return 0;  /* keep the connection alive */
1261    }
1262  }
1263  return NGHTTP2_ERR_CALLBACK_FAILURE;
1264}
1265
1266static int on_data_chunk_recv(nghttp2_session *session, uint8_t flags,
1267                              int32_t stream_id,
1268                              const uint8_t *mem, size_t len, void *userp)
1269{
1270  struct Curl_cfilter *cf = userp;
1271  struct cf_h2_ctx *ctx = cf->ctx;
1272  struct h2_stream_ctx *stream;
1273  struct Curl_easy *data_s;
1274  (void)flags;
1275
1276  DEBUGASSERT(stream_id); /* should never be a zero stream ID here */
1277  DEBUGASSERT(CF_DATA_CURRENT(cf));
1278
1279  /* get the stream from the hash based on Stream ID */
1280  data_s = nghttp2_session_get_stream_user_data(session, stream_id);
1281  if(!data_s) {
1282    /* Receiving a Stream ID not in the hash should not happen - unless
1283       we have aborted a transfer artificially and there were more data
1284       in the pipeline. Silently ignore. */
1285    CURL_TRC_CF(CF_DATA_CURRENT(cf), cf, "[%d] Data for unknown", stream_id);
1286    /* consumed explicitly as no one will read it */
1287    nghttp2_session_consume(session, stream_id, len);
1288    return 0;
1289  }
1290
1291  stream = H2_STREAM_CTX(ctx, data_s);
1292  if(!stream)
1293    return NGHTTP2_ERR_CALLBACK_FAILURE;
1294
1295  h2_xfer_write_resp(cf, data_s, stream, (const char *)mem, len, FALSE);
1296
1297  nghttp2_session_consume(ctx->h2, stream_id, len);
1298  stream->nrcvd_data += (curl_off_t)len;
1299  return 0;
1300}
1301
1302static int on_stream_close(nghttp2_session *session, int32_t stream_id,
1303                           uint32_t error_code, void *userp)
1304{
1305  struct Curl_cfilter *cf = userp;
1306  struct cf_h2_ctx *ctx = cf->ctx;
1307  struct Curl_easy *data_s, *call_data = CF_DATA_CURRENT(cf);
1308  struct h2_stream_ctx *stream;
1309  int rv;
1310  (void)session;
1311
1312  DEBUGASSERT(call_data);
1313  /* stream id 0 is the connection, do not look there for streams. */
1314  data_s = stream_id ?
1315    nghttp2_session_get_stream_user_data(session, stream_id) : NULL;
1316  if(!data_s) {
1317    CURL_TRC_CF(call_data, cf,
1318                "[%d] on_stream_close, no easy set on stream", stream_id);
1319    return 0;
1320  }
1321  if(!GOOD_EASY_HANDLE(data_s)) {
1322    /* nghttp2 still has an easy registered for the stream which has
1323     * been freed be libcurl. This points to a code path that does not
1324     * trigger DONE or DETACH events as it must. */
1325    CURL_TRC_CF(call_data, cf,
1326                "[%d] on_stream_close, not a GOOD easy on stream", stream_id);
1327    (void)nghttp2_session_set_stream_user_data(session, stream_id, 0);
1328    return NGHTTP2_ERR_CALLBACK_FAILURE;
1329  }
1330  stream = H2_STREAM_CTX(ctx, data_s);
1331  if(!stream) {
1332    CURL_TRC_CF(data_s, cf,
1333                "[%d] on_stream_close, GOOD easy but no stream", stream_id);
1334    return NGHTTP2_ERR_CALLBACK_FAILURE;
1335  }
1336
1337  stream->closed = TRUE;
1338  stream->error = error_code;
1339  if(stream->error)
1340    stream->reset = TRUE;
1341
1342  if(stream->error)
1343    CURL_TRC_CF(data_s, cf, "[%d] RESET: %s (err %u)",
1344              stream_id, nghttp2_http2_strerror(error_code), error_code);
1345  else
1346    CURL_TRC_CF(data_s, cf, "[%d] CLOSED", stream_id);
1347  Curl_multi_mark_dirty(data_s);
1348
1349  /* remove `data_s` from the nghttp2 stream */
1350  rv = nghttp2_session_set_stream_user_data(session, stream_id, 0);
1351  if(rv) {
1352    infof(data_s, "http/2: failed to clear user_data for stream %d",
1353          stream_id);
1354    DEBUGASSERT(0);
1355  }
1356  return 0;
1357}
1358
1359static int on_begin_headers(nghttp2_session *session,
1360                            const nghttp2_frame *frame, void *userp)
1361{
1362  struct Curl_cfilter *cf = userp;
1363  struct cf_h2_ctx *ctx = cf->ctx;
1364  struct h2_stream_ctx *stream;
1365  struct Curl_easy *data_s = NULL;
1366
1367  (void)cf;
1368  data_s = nghttp2_session_get_stream_user_data(session, frame->hd.stream_id);
1369  if(!data_s) {
1370    return 0;
1371  }
1372
1373  if(frame->hd.type != NGHTTP2_HEADERS) {
1374    return 0;
1375  }
1376
1377  stream = H2_STREAM_CTX(ctx, data_s);
1378  if(!stream || !stream->bodystarted) {
1379    return 0;
1380  }
1381
1382  return 0;
1383}
1384
1385static void cf_h2_header_error(struct Curl_cfilter *cf,
1386                               struct Curl_easy *data,
1387                               struct h2_stream_ctx *stream,
1388                               CURLcode result)
1389{
1390  struct cf_h2_ctx *ctx = cf->ctx;
1391
1392  failf(data, "Error receiving HTTP2 header: %d(%s)", result,
1393        curl_easy_strerror(result));
1394  if(stream) {
1395    nghttp2_submit_rst_stream(ctx->h2, NGHTTP2_FLAG_NONE,
1396                              stream->id, NGHTTP2_STREAM_CLOSED);
1397    stream->closed = TRUE;
1398    stream->reset = TRUE;
1399  }
1400}
1401
1402/* frame->hd.type is either NGHTTP2_HEADERS or NGHTTP2_PUSH_PROMISE */
1403static int on_header(nghttp2_session *session, const nghttp2_frame *frame,
1404                     const uint8_t *name, size_t namelen,
1405                     const uint8_t *value, size_t valuelen,
1406                     uint8_t flags,
1407                     void *userp)
1408{
1409  struct Curl_cfilter *cf = userp;
1410  struct cf_h2_ctx *ctx = cf->ctx;
1411  struct h2_stream_ctx *stream;
1412  struct Curl_easy *data_s;
1413  int32_t stream_id = frame->hd.stream_id;
1414  CURLcode result;
1415  (void)flags;
1416
1417  DEBUGASSERT(stream_id); /* should never be a zero stream ID here */
1418
1419  /* get the stream from the hash based on Stream ID */
1420  data_s = nghttp2_session_get_stream_user_data(session, stream_id);
1421  if(!GOOD_EASY_HANDLE(data_s))
1422    /* Receiving a Stream ID not in the hash should not happen, this is an
1423       internal error more than anything else! */
1424    return NGHTTP2_ERR_CALLBACK_FAILURE;
1425
1426  stream = H2_STREAM_CTX(ctx, data_s);
1427  if(!stream) {
1428    failf(data_s, "Internal NULL stream");
1429    return NGHTTP2_ERR_CALLBACK_FAILURE;
1430  }
1431
1432  /* Store received PUSH_PROMISE headers to be used when the subsequent
1433     PUSH_PROMISE callback comes */
1434  if(frame->hd.type == NGHTTP2_PUSH_PROMISE) {
1435    char *h;
1436
1437    if((namelen == (sizeof(HTTP_PSEUDO_AUTHORITY) - 1)) &&
1438       !strncmp(HTTP_PSEUDO_AUTHORITY, (const char *)name, namelen)) {
1439      /* pseudo headers are lower case */
1440      int rc = 0;
1441      char *check = curl_maprintf("%s:%d", cf->conn->origin->hostname,
1442                                  cf->conn->origin->port);
1443      if(!check)
1444        /* no memory */
1445        return NGHTTP2_ERR_CALLBACK_FAILURE;
1446      if(!curl_strequal(check, (const char *)value) &&
1447         ((cf->conn->origin->port != cf->conn->given->defport) ||
1448          !curl_strequal(cf->conn->origin->hostname, (const char *)value))) {
1449        /* This is push is not for the same authority that was asked for in
1450         * the URL. RFC 7540 section 8.2 says: "A client MUST treat a
1451         * PUSH_PROMISE for which the server is not authoritative as a stream
1452         * error of type PROTOCOL_ERROR."
1453         */
1454        (void)nghttp2_submit_rst_stream(session, NGHTTP2_FLAG_NONE,
1455                                        stream_id, NGHTTP2_PROTOCOL_ERROR);
1456        rc = NGHTTP2_ERR_CALLBACK_FAILURE;
1457      }
1458      curlx_free(check);
1459      if(rc)
1460        return rc;
1461    }
1462
1463    if(!stream->push_headers) {
1464      stream->push_headers_alloc = 10;
1465      stream->push_headers = curlx_malloc(stream->push_headers_alloc *
1466                                          sizeof(char *));
1467      if(!stream->push_headers)
1468        return NGHTTP2_ERR_CALLBACK_FAILURE;
1469      stream->push_headers_used = 0;
1470    }
1471    else if(stream->push_headers_used ==
1472            stream->push_headers_alloc) {
1473      char **headp;
1474      if(stream->push_headers_alloc > 1000) {
1475        /* this is beyond crazy many headers, bail out */
1476        failf(data_s, "Too many PUSH_PROMISE headers");
1477        free_push_headers(stream);
1478        return NGHTTP2_ERR_CALLBACK_FAILURE;
1479      }
1480      stream->push_headers_alloc *= 2;
1481      headp = curlx_realloc(stream->push_headers,
1482                            stream->push_headers_alloc * sizeof(char *));
1483      if(!headp) {
1484        free_push_headers(stream);
1485        return NGHTTP2_ERR_CALLBACK_FAILURE;
1486      }
1487      stream->push_headers = headp;
1488    }
1489    h = curl_maprintf("%s:%s", name, value);
1490    if(!h) {
1491      free_push_headers(stream);
1492      return NGHTTP2_ERR_CALLBACK_FAILURE;
1493    }
1494    stream->push_headers[stream->push_headers_used++] = h;
1495    return 0;
1496  }
1497
1498  if(stream->bodystarted) {
1499    /* This is a trailer */
1500    CURL_TRC_CF(data_s, cf, "[%d] trailer: %.*s: %.*s",
1501                stream->id, (int)namelen, name, (int)valuelen, value);
1502    result = Curl_dynhds_add(&stream->resp_trailers,
1503                             (const char *)name, namelen,
1504                             (const char *)value, valuelen);
1505    if(result) {
1506      cf_h2_header_error(cf, data_s, stream, result);
1507      return NGHTTP2_ERR_CALLBACK_FAILURE;
1508    }
1509
1510    return 0;
1511  }
1512
1513  if(namelen == sizeof(HTTP_PSEUDO_STATUS) - 1 &&
1514     memcmp(HTTP_PSEUDO_STATUS, name, namelen) == 0) {
1515    /* nghttp2 guarantees :status is received first and only once. */
1516    char buffer[32];
1517    size_t hlen;
1518    result = Curl_http_decode_status(&stream->status_code,
1519                                     (const char *)value, valuelen);
1520    if(result) {
1521      cf_h2_header_error(cf, data_s, stream, result);
1522      return NGHTTP2_ERR_CALLBACK_FAILURE;
1523    }
1524    hlen = curl_msnprintf(buffer, sizeof(buffer), HTTP_PSEUDO_STATUS ":%d\r",
1525                          stream->status_code);
1526    result = Curl_headers_push(data_s, buffer, hlen, CURLH_PSEUDO);
1527    if(result) {
1528      cf_h2_header_error(cf, data_s, stream, result);
1529      return NGHTTP2_ERR_CALLBACK_FAILURE;
1530    }
1531    curlx_dyn_reset(&ctx->scratch);
1532    result = curlx_dyn_addn(&ctx->scratch, STRCONST("HTTP/2 "));
1533    if(!result)
1534      result = curlx_dyn_addn(&ctx->scratch, value, valuelen);
1535    if(!result)
1536      result = curlx_dyn_addn(&ctx->scratch, STRCONST(" \r\n"));
1537    if(!result)
1538      h2_xfer_write_resp_hd(cf, data_s, stream, curlx_dyn_ptr(&ctx->scratch),
1539                            curlx_dyn_len(&ctx->scratch), FALSE);
1540    if(result) {
1541      cf_h2_header_error(cf, data_s, stream, result);
1542      return NGHTTP2_ERR_CALLBACK_FAILURE;
1543    }
1544    /* if we receive data for another handle, wake that up */
1545    if(CF_DATA_CURRENT(cf) != data_s)
1546      Curl_multi_mark_dirty(data_s);
1547
1548    CURL_TRC_CF(data_s, cf, "[%d] status: HTTP/2 %03d",
1549                stream->id, stream->status_code);
1550    return 0;
1551  }
1552
1553  /* nghttp2 guarantees that namelen > 0, and :status was already
1554     received, and this is not pseudo-header field . */
1555  /* convert to an HTTP1-style header */
1556  curlx_dyn_reset(&ctx->scratch);
1557  result = curlx_dyn_addn(&ctx->scratch, (const char *)name, namelen);
1558  if(!result)
1559    result = curlx_dyn_addn(&ctx->scratch, STRCONST(": "));
1560  if(!result)
1561    result = curlx_dyn_addn(&ctx->scratch, (const char *)value, valuelen);
1562  if(!result)
1563    result = curlx_dyn_addn(&ctx->scratch, STRCONST("\r\n"));
1564  if(!result)
1565    h2_xfer_write_resp_hd(cf, data_s, stream, curlx_dyn_ptr(&ctx->scratch),
1566                          curlx_dyn_len(&ctx->scratch), FALSE);
1567  if(result) {
1568    cf_h2_header_error(cf, data_s, stream, result);
1569    return NGHTTP2_ERR_CALLBACK_FAILURE;
1570  }
1571  /* if we receive data for another handle, wake that up */
1572  if(CF_DATA_CURRENT(cf) != data_s)
1573    Curl_multi_mark_dirty(data_s);
1574
1575  CURL_TRC_CF(data_s, cf, "[%d] header: %.*s: %.*s",
1576              stream->id, (int)namelen, name, (int)valuelen, value);
1577
1578  return 0; /* 0 is successful */
1579}
1580
1581static ssize_t req_body_read_callback(nghttp2_session *session,
1582                                      int32_t stream_id,
1583                                      uint8_t *buf, size_t length,
1584                                      uint32_t *data_flags,
1585                                      nghttp2_data_source *source,
1586                                      void *userp)
1587{
1588  struct Curl_cfilter *cf = userp;
1589  struct cf_h2_ctx *ctx = cf->ctx;
1590  struct Curl_easy *data_s;
1591  struct h2_stream_ctx *stream = NULL;
1592  CURLcode result;
1593  ssize_t nread;
1594  size_t n;
1595  (void)source;
1596
1597  (void)cf;
1598  if(!stream_id)
1599    return NGHTTP2_ERR_INVALID_ARGUMENT;
1600
1601  /* get the stream from the hash based on Stream ID, stream ID zero is for
1602     connection-oriented stuff */
1603  data_s = nghttp2_session_get_stream_user_data(session, stream_id);
1604  if(!data_s)
1605    /* Receiving a Stream ID not in the hash should not happen, this is an
1606       internal error more than anything else! */
1607    return NGHTTP2_ERR_CALLBACK_FAILURE;
1608
1609  stream = H2_STREAM_CTX(ctx, data_s);
1610  if(!stream)
1611    return NGHTTP2_ERR_CALLBACK_FAILURE;
1612
1613  result = Curl_bufq_read(&stream->sendbuf, buf, length, &n);
1614  if(result) {
1615    if(result != CURLE_AGAIN)
1616      return NGHTTP2_ERR_CALLBACK_FAILURE;
1617    nread = 0;
1618  }
1619  else
1620    nread = (ssize_t)n;
1621
1622  CURL_TRC_CF(data_s, cf, "[%d] req_body_read(len=%zu) eos=%d -> %zd, %d",
1623              stream_id, length, stream->body_eos, nread, result);
1624
1625  if(stream->body_eos && Curl_bufq_is_empty(&stream->sendbuf)) {
1626    *data_flags = NGHTTP2_DATA_FLAG_EOF;
1627    return nread;
1628  }
1629  return (nread == 0) ? NGHTTP2_ERR_DEFERRED : nread;
1630}
1631
1632#ifdef CURLVERBOSE
1633static int error_callback(nghttp2_session *session,
1634                          const char *msg,
1635                          size_t len,
1636                          void *userp)
1637{
1638  struct Curl_cfilter *cf = userp;
1639  struct Curl_easy *data = CF_DATA_CURRENT(cf);
1640  (void)session;
1641  failf(data, "%.*s", (int)len, msg);
1642  return 0;
1643}
1644#endif
1645
1646/*
1647 * Append headers to ask for an HTTP1.1 to HTTP2 upgrade.
1648 */
1649CURLcode Curl_http2_request_upgrade(struct dynbuf *req,
1650                                    struct Curl_easy *data)
1651{
1652  CURLcode result;
1653  char *base64;
1654  size_t blen;
1655  struct SingleRequest *k = &data->req;
1656  uint8_t binsettings[H2_BINSETTINGS_LEN];
1657  ssize_t rc;
1658  size_t binlen; /* length of the binsettings data */
1659
1660  rc = populate_binsettings(binsettings, data);
1661  if(!curlx_sztouz(rc, &binlen) || !binlen) {
1662    failf(data, "nghttp2 unexpectedly failed on pack_settings_payload");
1663    curlx_dyn_free(req);
1664    return CURLE_FAILED_INIT;
1665  }
1666
1667  result = curlx_base64url_encode(binsettings, binlen, &base64, &blen);
1668  if(result) {
1669    curlx_dyn_free(req);
1670    return result;
1671  }
1672
1673  data->state.http_hd_upgrade = TRUE;
1674  data->state.http_hd_h2_settings = TRUE;
1675  result = curlx_dyn_addf(req,
1676                          "Upgrade: %s\r\n"
1677                          "HTTP2-Settings: %s\r\n",
1678                          NGHTTP2_CLEARTEXT_PROTO_VERSION_ID, base64);
1679  curlx_free(base64);
1680
1681  k->upgr101 = UPGR101_H2;
1682  data->conn->bits.upgrade_in_progress = TRUE;
1683
1684  return result;
1685}
1686
1687static CURLcode http2_handle_stream_close(struct Curl_cfilter *cf,
1688                                          struct Curl_easy *data,
1689                                          struct h2_stream_ctx *stream,
1690                                          size_t *pnlen)
1691{
1692  CURLcode result;
1693
1694  *pnlen = 0;
1695  if(stream->reset) {
1696    if(stream->error == NGHTTP2_REFUSED_STREAM) {
1697      infof(data, "HTTP/2 stream %d refused by server, try again on a new "
1698                  "connection", stream->id);
1699      connclose(cf->conn, "REFUSED_STREAM"); /* do not use this anymore */
1700      data->state.refused_stream = TRUE;
1701      return CURLE_RECV_ERROR; /* trigger Curl_retry_request() later */
1702    }
1703    else if(stream->resp_hds_complete && data->req.no_body) {
1704        CURL_TRC_CF(data, cf, "[%d] error after response headers, but we did "
1705                    "not want a body anyway, ignore: %s (err %u)",
1706                    stream->id, nghttp2_http2_strerror(stream->error),
1707                    stream->error);
1708        stream->close_handled = TRUE;
1709        return CURLE_OK;
1710    }
1711    failf(data, "HTTP/2 stream %d reset by %s (error 0x%x %s)",
1712          stream->id, stream->reset_by_server ? "server" : "curl",
1713          stream->error, nghttp2_http2_strerror(stream->error));
1714    return stream->error ? CURLE_HTTP2_STREAM :
1715           (data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP2);
1716  }
1717  else if(!stream->bodystarted) {
1718    failf(data, "HTTP/2 stream %d was closed cleanly, but before getting "
1719          "all response header fields, treated as error", stream->id);
1720    return CURLE_HTTP2_STREAM;
1721  }
1722
1723  if(Curl_dynhds_count(&stream->resp_trailers)) {
1724    struct dynhds_entry *e;
1725    struct dynbuf dbuf;
1726    size_t i;
1727
1728    result = CURLE_OK;
1729    curlx_dyn_init(&dbuf, DYN_TRAILERS);
1730    for(i = 0; i < Curl_dynhds_count(&stream->resp_trailers); ++i) {
1731      e = Curl_dynhds_getn(&stream->resp_trailers, i);
1732      if(!e)
1733        break;
1734      curlx_dyn_reset(&dbuf);
1735      result = curlx_dyn_addf(&dbuf, "%.*s: %.*s\x0d\x0a",
1736                              (int)e->namelen, e->name,
1737                              (int)e->valuelen, e->value);
1738      if(result)
1739        break;
1740      Curl_debug(data, CURLINFO_HEADER_IN, curlx_dyn_ptr(&dbuf),
1741                 curlx_dyn_len(&dbuf));
1742      result = Curl_client_write(data,
1743                                 CLIENTWRITE_HEADER | CLIENTWRITE_TRAILER,
1744                                 curlx_dyn_ptr(&dbuf), curlx_dyn_len(&dbuf));
1745      if(result)
1746        break;
1747    }
1748    curlx_dyn_free(&dbuf);
1749    if(result)
1750      goto out;
1751  }
1752
1753  stream->close_handled = TRUE;
1754  result = CURLE_OK;
1755
1756out:
1757  CURL_TRC_CF(data, cf, "handle_stream_close -> %d, %zu", result, *pnlen);
1758  return result;
1759}
1760
1761static int sweight_wanted(const struct Curl_easy *data)
1762{
1763  /* 0 weight is not set by user and we take the nghttp2 default one */
1764  return data->set.priority.weight ?
1765    data->set.priority.weight : NGHTTP2_DEFAULT_WEIGHT;
1766}
1767
1768static int sweight_in_effect(const struct Curl_easy *data)
1769{
1770  /* 0 weight is not set by user and we take the nghttp2 default one */
1771  return data->state.priority.weight ?
1772    data->state.priority.weight : NGHTTP2_DEFAULT_WEIGHT;
1773}
1774
1775/*
1776 * h2_pri_spec() fills in the pri_spec struct, used by nghttp2 to send weight
1777 * and dependency to the peer. It also stores the updated values in the state
1778 * struct.
1779 */
1780
1781static void h2_pri_spec(struct cf_h2_ctx *ctx,
1782                        struct Curl_easy *data,
1783                        nghttp2_priority_spec *pri_spec)
1784{
1785  struct Curl_data_priority *prio = &data->set.priority;
1786  struct h2_stream_ctx *depstream = H2_STREAM_CTX(ctx, prio->parent);
1787  int32_t depstream_id = depstream ? depstream->id : 0;
1788  nghttp2_priority_spec_init(pri_spec, depstream_id,
1789                             sweight_wanted(data),
1790                             data->set.priority.exclusive);
1791  data->state.priority = *prio;
1792}
1793
1794/*
1795 * Check if there is been an update in the priority /
1796 * dependency settings and if so it submits a PRIORITY frame with the updated
1797 * info.
1798 * Flush any out data pending in the network buffer.
1799 */
1800static CURLcode h2_progress_egress(struct Curl_cfilter *cf,
1801                                   struct Curl_easy *data)
1802{
1803  struct cf_h2_ctx *ctx = cf->ctx;
1804  struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
1805  int rv = 0;
1806
1807  if(stream && stream->id > 0 &&
1808     ((sweight_wanted(data) != sweight_in_effect(data)) ||
1809      (data->set.priority.exclusive != data->state.priority.exclusive) ||
1810      (data->set.priority.parent != data->state.priority.parent))) {
1811    /* send new weight and/or dependency */
1812    nghttp2_priority_spec pri_spec;
1813
1814    h2_pri_spec(ctx, data, &pri_spec);
1815    CURL_TRC_CF(data, cf, "[%d] Queuing PRIORITY", stream->id);
1816    DEBUGASSERT(stream->id != -1);
1817    rv = nghttp2_submit_priority(ctx->h2, NGHTTP2_FLAG_NONE,
1818                                 stream->id, &pri_spec);
1819    if(rv)
1820      goto out;
1821  }
1822
1823  ctx->nw_out_blocked = 0;
1824  while(!rv && !ctx->nw_out_blocked && nghttp2_session_want_write(ctx->h2))
1825    rv = nghttp2_session_send(ctx->h2);
1826
1827out:
1828  if(nghttp2_is_fatal(rv)) {
1829    CURL_TRC_CF(data, cf, "nghttp2_session_send error (%s)%d",
1830                nghttp2_strerror(rv), rv);
1831    return CURLE_SEND_ERROR;
1832  }
1833  /* Defer flushing during the connect phase so that the SETTINGS and
1834   * other initial frames are sent together with the first request.
1835   * Unless we are 'connect_only' where the request will never come. */
1836  if(!cf->connected && !cf->conn->bits.connect_only)
1837    return CURLE_OK;
1838  return nw_out_flush(cf, data);
1839}
1840
1841static CURLcode stream_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
1842                            struct h2_stream_ctx *stream,
1843                            char *buf, size_t len, size_t *pnread)
1844{
1845  struct cf_h2_ctx *ctx = cf->ctx;
1846  CURLcode result = CURLE_AGAIN;
1847
1848  (void)buf;
1849  (void)len;
1850  *pnread = 0;
1851
1852  if(!stream->xfer_result)
1853    stream->xfer_result = cf_h2_update_local_win(cf, data, stream);
1854
1855  if(stream->xfer_result) {
1856    CURL_TRC_CF(data, cf, "[%d] xfer write failed", stream->id);
1857    result = stream->xfer_result;
1858  }
1859  else if(stream->closed) {
1860    CURL_TRC_CF(data, cf, "[%d] returning CLOSE", stream->id);
1861    result = http2_handle_stream_close(cf, data, stream, pnread);
1862  }
1863  else if(stream->reset ||
1864          (ctx->conn_closed && Curl_bufq_is_empty(&ctx->inbufq)) ||
1865          (ctx->rcvd_goaway && ctx->remote_max_sid < stream->id)) {
1866    CURL_TRC_CF(data, cf, "[%d] returning ERR", stream->id);
1867    result = data->req.bytecount ? CURLE_PARTIAL_FILE : CURLE_HTTP2;
1868  }
1869
1870  if(result && (result != CURLE_AGAIN))
1871    CURL_TRC_CF(data, cf, "[%d] stream_recv(len=%zu) -> %d, %zu",
1872                stream->id, len, result, *pnread);
1873  return result;
1874}
1875
1876static CURLcode h2_progress_ingress(struct Curl_cfilter *cf,
1877                                    struct Curl_easy *data,
1878                                    size_t data_max_bytes)
1879{
1880  struct cf_h2_ctx *ctx = cf->ctx;
1881  struct h2_stream_ctx *stream;
1882  CURLcode result = CURLE_OK;
1883  size_t nread;
1884
1885  if(should_close_session(ctx)) {
1886    CURL_TRC_CF(data, cf, "[0] ingress: session is closed");
1887    return CURLE_HTTP2;
1888  }
1889
1890  /* Process network input buffer first */
1891  if(!Curl_bufq_is_empty(&ctx->inbufq)) {
1892    CURL_TRC_CF(data, cf, "Process %zu bytes in connection buffer",
1893                Curl_bufq_len(&ctx->inbufq));
1894    result = h2_process_pending_input(cf, data);
1895    if(result)
1896      return result;
1897  }
1898
1899  if(!data_max_bytes)
1900    data_max_bytes = H2_CHUNK_SIZE;
1901
1902  /* Receive data from the "lower" filters, e.g. network until
1903   * it is time to stop due to connection close or us not processing
1904   * all network input */
1905  while(!ctx->conn_closed && Curl_bufq_is_empty(&ctx->inbufq)) {
1906    stream = H2_STREAM_CTX(ctx, data);
1907    if(stream && (stream->closed || !data_max_bytes)) {
1908      /* We would like to abort here and stop processing, so that the transfer
1909       * loop can handle the data/close here. This may leave data in
1910       * underlying buffers that will not be consumed. */
1911      if(!cf->next || !cf->next->cft->has_data_pending(cf->next, data))
1912        Curl_multi_mark_dirty(data);
1913      break;
1914    }
1915    else if(!stream) {
1916      DEBUGASSERT(0);
1917      break;
1918    }
1919
1920    result = Curl_cf_recv_bufq(cf->next, data, &ctx->inbufq, 0, &nread);
1921    if(result) {
1922      if(result != CURLE_AGAIN) {
1923        failf(data, "Failed receiving HTTP2 data: %d(%s)", result,
1924              curl_easy_strerror(result));
1925        return result;
1926      }
1927      break;
1928    }
1929    else if(nread == 0) {
1930      CURL_TRC_CF(data, cf, "[0] ingress: connection closed");
1931      ctx->conn_closed = TRUE;
1932      break;
1933    }
1934    else {
1935      CURL_TRC_CF(data, cf, "[0] ingress: read %zu bytes", nread);
1936      data_max_bytes = (data_max_bytes > nread) ? (data_max_bytes - nread) : 0;
1937    }
1938
1939    result = h2_process_pending_input(cf, data);
1940    if(result)
1941      return result;
1942    CURL_TRC_CF(data, cf, "[0] ingress: nw-in buffered %zu",
1943                Curl_bufq_len(&ctx->inbufq));
1944  }
1945
1946  if(ctx->conn_closed && Curl_bufq_is_empty(&ctx->inbufq)) {
1947    connclose(cf->conn, ctx->rcvd_goaway ? "server closed with GOAWAY" :
1948              "server closed abruptly");
1949  }
1950
1951  CURL_TRC_CF(data, cf, "[0] ingress: done");
1952  return CURLE_OK;
1953}
1954
1955static CURLcode cf_h2_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
1956                           char *buf, size_t len, size_t *pnread)
1957{
1958  struct cf_h2_ctx *ctx = cf->ctx;
1959  struct h2_stream_ctx *stream;
1960  CURLcode result, r2;
1961  struct cf_call_data save;
1962
1963  if(!data)
1964    return CURLE_HTTP2;
1965
1966  stream = H2_STREAM_CTX(ctx, data);
1967
1968  *pnread = 0;
1969  if(!stream) {
1970    /* Abnormal call sequence: either this transfer has never opened a stream
1971     * (unlikely) or the transfer has been done, cleaned up its resources, but
1972     * a read() is called anyway. It is not clear what the calling sequence
1973     * is for such a case. */
1974    failf(data, "http/2 recv on a transfer never opened "
1975          "or already cleared, mid=%u", data->mid);
1976    return CURLE_HTTP2;
1977  }
1978
1979  CF_DATA_SAVE(save, cf, data);
1980
1981  result = stream_recv(cf, data, stream, buf, len, pnread);
1982  if(result && (result != CURLE_AGAIN))
1983    goto out;
1984
1985  if(result) {
1986    result = h2_progress_ingress(cf, data, len);
1987    if(result)
1988      goto out;
1989
1990    result = stream_recv(cf, data, stream, buf, len, pnread);
1991  }
1992
1993  if(*pnread > 0) {
1994    /* Now that we transferred this to the upper layer, we report
1995     * the actual amount of DATA consumed to the H2 session, so
1996     * that it adjusts stream flow control */
1997    nghttp2_session_consume(ctx->h2, stream->id, *pnread);
1998    if(stream->closed) {
1999      CURL_TRC_CF(data, cf, "[%d] DRAIN closed stream", stream->id);
2000      Curl_multi_mark_dirty(data);
2001    }
2002  }
2003
2004out:
2005  r2 = h2_progress_egress(cf, data);
2006  if(r2 == CURLE_AGAIN) {
2007    /* pending data to send, need to be called again. Ideally, we
2008     * monitor the socket for POLLOUT, but when not SENDING
2009     * any more, we force processing of the transfer. */
2010    if(!CURL_REQ_WANT_SEND(data))
2011      Curl_multi_mark_dirty(data);
2012  }
2013  else if(r2) {
2014    result = r2;
2015  }
2016  CURL_TRC_CF(data, cf, "[%d] cf_recv(len=%zu) -> %d, %zu, "
2017              "window=%d/%d, connection %d/%d",
2018              stream->id, len, result, *pnread,
2019              nghttp2_session_get_stream_effective_recv_data_length(
2020                ctx->h2, stream->id),
2021              nghttp2_session_get_stream_effective_local_window_size(
2022                ctx->h2, stream->id),
2023              nghttp2_session_get_local_window_size(ctx->h2),
2024              HTTP2_HUGE_WINDOW_SIZE);
2025
2026  CF_DATA_RESTORE(cf, save);
2027  return result;
2028}
2029
2030static CURLcode cf_h2_body_send(struct Curl_cfilter *cf,
2031                                struct Curl_easy *data,
2032                                struct h2_stream_ctx *stream,
2033                                const void *buf, size_t blen, bool eos,
2034                                size_t *pnwritten)
2035{
2036  struct cf_h2_ctx *ctx = cf->ctx;
2037  CURLcode result;
2038
2039  *pnwritten = 0;
2040  if(stream->closed) {
2041    if(stream->resp_hds_complete) {
2042      /* Server decided to close the stream after having sent us a final
2043       * response. This is valid if it is not interested in the request
2044       * body. This happens on 30x or 40x responses.
2045       * We silently discard the data sent, since this is not a transport
2046       * error situation. */
2047      CURL_TRC_CF(data, cf, "[%d] discarding data"
2048                  "on closed stream with response", stream->id);
2049      if(eos)
2050        stream->body_eos = TRUE;
2051      *pnwritten = blen;
2052      return CURLE_OK;
2053    }
2054    /* Server closed before we got a response, this is an error */
2055    infof(data, "stream %d closed", stream->id);
2056    return CURLE_SEND_ERROR;
2057  }
2058
2059  result = Curl_bufq_write(&stream->sendbuf, buf, blen, pnwritten);
2060  if(result)
2061    return result;
2062
2063  if(eos && (blen == *pnwritten))
2064    stream->body_eos = TRUE;
2065
2066  if(eos || !Curl_bufq_is_empty(&stream->sendbuf)) {
2067    /* resume the potentially suspended stream */
2068    int rv = nghttp2_session_resume_data(ctx->h2, stream->id);
2069    if(nghttp2_is_fatal(rv))
2070      return CURLE_SEND_ERROR;
2071  }
2072
2073  return CURLE_OK;
2074}
2075
2076static CURLcode h2_submit(struct h2_stream_ctx **pstream,
2077                          struct Curl_cfilter *cf, struct Curl_easy *data,
2078                          const uint8_t *buf, size_t len,
2079                          bool eos, size_t *pnwritten)
2080{
2081  struct cf_h2_ctx *ctx = cf->ctx;
2082  struct h2_stream_ctx *stream = NULL;
2083  struct dynhds h2_headers;
2084  nghttp2_nv *nva = NULL;
2085  const void *body = NULL;
2086  size_t nheader, bodylen;
2087  nghttp2_data_provider data_prd;
2088  int32_t stream_id;
2089  nghttp2_priority_spec pri_spec;
2090  size_t nwritten;
2091  CURLcode result = CURLE_OK;
2092  uint32_t initial_win_size;
2093
2094  *pnwritten = 0;
2095  Curl_dynhds_init(&h2_headers, 0, DYN_HTTP_REQUEST);
2096
2097  result = http2_data_setup(cf, data, &stream);
2098  if(result)
2099    goto out;
2100
2101  result = Curl_h1_req_parse_read(&stream->h1, buf, len, NULL,
2102                                  !data->state.http_ignorecustom ?
2103                                  data->set.str[STRING_CUSTOMREQUEST] : NULL,
2104                                  0, &nwritten);
2105  if(result)
2106    goto out;
2107  *pnwritten = nwritten;
2108  if(!stream->h1.done) {
2109    /* need more data */
2110    goto out;
2111  }
2112  DEBUGASSERT(stream->h1.req);
2113
2114  result = Curl_http_req_to_h2(&h2_headers, stream->h1.req, data);
2115  if(result)
2116    goto out;
2117  /* no longer needed */
2118  Curl_h1_req_parse_free(&stream->h1);
2119
2120  nva = Curl_dynhds_to_nva(&h2_headers, &nheader);
2121  if(!nva) {
2122    result = CURLE_OUT_OF_MEMORY;
2123    goto out;
2124  }
2125
2126  h2_pri_spec(ctx, data, &pri_spec);
2127  if(!nghttp2_session_check_request_allowed(ctx->h2))
2128    CURL_TRC_CF(data, cf, "send request NOT allowed (via nghttp2)");
2129
2130  /* Check the initial windows size of the transfer (rate-limits?) and
2131   * send an updated settings on changes from previous value. */
2132  initial_win_size = cf_h2_initial_win_size(data);
2133  if(initial_win_size != ctx->initial_win_size) {
2134    result = cf_h2_update_settings(ctx, initial_win_size);
2135    if(result)
2136      goto out;
2137  }
2138
2139  switch(data->state.httpreq) {
2140  case HTTPREQ_POST:
2141  case HTTPREQ_POST_FORM:
2142  case HTTPREQ_POST_MIME:
2143  case HTTPREQ_PUT:
2144    data_prd.read_callback = req_body_read_callback;
2145    data_prd.source.ptr = NULL;
2146    stream_id = nghttp2_submit_request(ctx->h2, &pri_spec, nva, nheader,
2147                                       &data_prd, data);
2148    break;
2149  default:
2150    stream_id = nghttp2_submit_request(ctx->h2, &pri_spec, nva, nheader,
2151                                       NULL, data);
2152  }
2153
2154  if(stream_id < 0) {
2155    CURL_TRC_CF(data, cf, "send: nghttp2_submit_request error (%s)%d",
2156                nghttp2_strerror(stream_id), stream_id);
2157    result = CURLE_SEND_ERROR;
2158    goto out;
2159  }
2160
2161#ifdef CURLVERBOSE
2162#define MAX_ACC 60000  /* <64KB to account for some overhead */
2163  if(Curl_trc_is_verbose(data)) {
2164    size_t acc = 0, i;
2165
2166    infof(data, "[HTTP/2] [%d] OPENED stream for %s",
2167          stream_id, Curl_bufref_ptr(&data->state.url));
2168    for(i = 0; i < nheader; ++i) {
2169      acc += nva[i].namelen + nva[i].valuelen;
2170
2171      infof(data, "[HTTP/2] [%d] [%.*s: %.*s]", stream_id,
2172            (int)nva[i].namelen, nva[i].name,
2173            (int)nva[i].valuelen, nva[i].value);
2174    }
2175
2176    if(acc > MAX_ACC) {
2177      infof(data, "[HTTP/2] Warning: The cumulative length of all "
2178            "headers exceeds %d bytes and that could cause the "
2179            "stream to be rejected.", MAX_ACC);
2180    }
2181  }
2182#endif
2183
2184  stream->id = stream_id;
2185
2186  body = (const char *)buf + *pnwritten;
2187  bodylen = len - *pnwritten;
2188
2189  if(bodylen || eos) {
2190    size_t n;
2191    result = cf_h2_body_send(cf, data, stream, body, bodylen, eos, &n);
2192    if(!result)
2193      *pnwritten += n;
2194    else if(result == CURLE_AGAIN)
2195      result = CURLE_OK;
2196    else {
2197      result = CURLE_SEND_ERROR;
2198    }
2199  }
2200
2201out:
2202  CURL_TRC_CF(data, cf, "[%d] submit -> %d, %zu",
2203              stream ? stream->id : -1, result, *pnwritten);
2204  curlx_safefree(nva);
2205  *pstream = stream;
2206  Curl_dynhds_free(&h2_headers);
2207  return result;
2208}
2209
2210static CURLcode cf_h2_send(struct Curl_cfilter *cf, struct Curl_easy *data,
2211                           const uint8_t *buf, size_t len, bool eos,
2212                           size_t *pnwritten)
2213{
2214  struct cf_h2_ctx *ctx = cf->ctx;
2215  struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
2216  struct cf_call_data save;
2217  CURLcode result = CURLE_OK, r2;
2218
2219  CF_DATA_SAVE(save, cf, data);
2220  *pnwritten = 0;
2221
2222  if(!stream || stream->id == -1) {
2223    result = h2_submit(&stream, cf, data, buf, len, eos, pnwritten);
2224    if(result)
2225      goto out;
2226    DEBUGASSERT(stream);
2227  }
2228  else if(stream->body_eos) {
2229    /* We already wrote this, but CURLE_AGAIN-ed the call due to not
2230     * being able to flush stream->sendbuf. Make a 0-length write
2231     * to trigger flushing again.
2232     * If this works, we report to have written `len` bytes. */
2233    size_t n;
2234    DEBUGASSERT(eos);
2235    result = cf_h2_body_send(cf, data, stream, buf, 0, eos, &n);
2236    CURL_TRC_CF(data, cf, "[%d] cf_body_send last CHUNK -> %d, %zu, eos=%d",
2237                stream->id, result, n, eos);
2238    if(result)
2239      goto out;
2240    *pnwritten = len;
2241  }
2242  else {
2243    result = cf_h2_body_send(cf, data, stream, buf, len, eos, pnwritten);
2244    CURL_TRC_CF(data, cf, "[%d] cf_body_send(len=%zu) -> %d, %zu, eos=%d",
2245                stream->id, len, result, *pnwritten, eos);
2246  }
2247
2248  /* Call the nghttp2 send loop and flush to write ALL buffered data,
2249   * headers and/or request body completely out to the network */
2250  r2 = h2_progress_egress(cf, data);
2251
2252  /* if the stream has been closed in egress handling (nghttp2 does that
2253   * when it does not like the headers, for example */
2254  if(stream && stream->closed) {
2255    infof(data, "stream %d closed", stream->id);
2256    result = CURLE_SEND_ERROR;
2257    goto out;
2258  }
2259  else if(r2 && (r2 != CURLE_AGAIN)) {
2260    result = r2;
2261    goto out;
2262  }
2263
2264  if(should_close_session(ctx)) {
2265    /* nghttp2 thinks this session is done. If the stream has not been
2266     * closed, this is an error state for out transfer */
2267    if(stream && stream->closed) {
2268      result = http2_handle_stream_close(cf, data, stream, pnwritten);
2269    }
2270    else {
2271      CURL_TRC_CF(data, cf, "send: nothing to do in this session");
2272      result = CURLE_HTTP2;
2273    }
2274  }
2275
2276out:
2277  if(stream) {
2278    CURL_TRC_CF(data, cf, "[%d] cf_send(len=%zu) -> %d, %zu, "
2279                "eos=%d, h2 windows %d-%d (stream-conn), "
2280                "buffers %zu-%zu (stream-conn)",
2281                stream->id, len, result, *pnwritten,
2282                stream->body_eos,
2283                nghttp2_session_get_stream_remote_window_size(
2284                  ctx->h2, stream->id),
2285                nghttp2_session_get_remote_window_size(ctx->h2),
2286                Curl_bufq_len(&stream->sendbuf),
2287                Curl_bufq_len(&ctx->outbufq));
2288  }
2289  else {
2290    CURL_TRC_CF(data, cf, "cf_send(len=%zu) -> %d, %zu, "
2291                "connection-window=%d, nw_send_buffer(%zu)",
2292                len, result, *pnwritten,
2293                nghttp2_session_get_remote_window_size(ctx->h2),
2294                Curl_bufq_len(&ctx->outbufq));
2295  }
2296  CF_DATA_RESTORE(cf, save);
2297  return result;
2298}
2299
2300static CURLcode cf_h2_flush(struct Curl_cfilter *cf,
2301                            struct Curl_easy *data)
2302{
2303  struct cf_h2_ctx *ctx = cf->ctx;
2304  struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
2305  struct cf_call_data save;
2306  CURLcode result = CURLE_OK;
2307
2308  CF_DATA_SAVE(save, cf, data);
2309  if(stream && !Curl_bufq_is_empty(&stream->sendbuf)) {
2310    /* resume the potentially suspended stream */
2311    int rv = nghttp2_session_resume_data(ctx->h2, stream->id);
2312    if(nghttp2_is_fatal(rv)) {
2313      result = CURLE_SEND_ERROR;
2314      goto out;
2315    }
2316  }
2317
2318  result = h2_progress_egress(cf, data);
2319
2320out:
2321  if(stream) {
2322    CURL_TRC_CF(data, cf, "[%d] flush -> %d, "
2323                "h2 windows %d-%d (stream-conn), "
2324                "buffers %zu-%zu (stream-conn)",
2325                stream->id, result,
2326                nghttp2_session_get_stream_remote_window_size(
2327                  ctx->h2, stream->id),
2328                nghttp2_session_get_remote_window_size(ctx->h2),
2329                Curl_bufq_len(&stream->sendbuf),
2330                Curl_bufq_len(&ctx->outbufq));
2331  }
2332  else {
2333    CURL_TRC_CF(data, cf, "flush -> %d, "
2334                "connection-window=%d, nw_send_buffer(%zu)",
2335                result, nghttp2_session_get_remote_window_size(ctx->h2),
2336                Curl_bufq_len(&ctx->outbufq));
2337  }
2338  CF_DATA_RESTORE(cf, save);
2339  return result;
2340}
2341
2342static CURLcode cf_h2_adjust_pollset(struct Curl_cfilter *cf,
2343                                     struct Curl_easy *data,
2344                                     struct easy_pollset *ps)
2345{
2346  struct cf_h2_ctx *ctx = cf->ctx;
2347  struct cf_call_data save;
2348  curl_socket_t sock;
2349  bool want_recv, want_send;
2350  CURLcode result = CURLE_OK;
2351
2352  if(!ctx->h2)
2353    return CURLE_OK;
2354
2355  sock = Curl_conn_cf_get_socket(cf, data);
2356  Curl_pollset_check(data, ps, sock, &want_recv, &want_send);
2357  if(want_recv || want_send) {
2358    struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
2359    bool c_exhaust, s_exhaust;
2360
2361    CF_DATA_SAVE(save, cf, data);
2362    c_exhaust = want_send && !nghttp2_session_get_remote_window_size(ctx->h2);
2363    s_exhaust = want_send && stream && stream->id >= 0 &&
2364                !nghttp2_session_get_stream_remote_window_size(ctx->h2,
2365                                                               stream->id);
2366    want_recv = (want_recv || c_exhaust || s_exhaust);
2367    want_send = (!s_exhaust && want_send) ||
2368                (!c_exhaust && nghttp2_session_want_write(ctx->h2)) ||
2369                !Curl_bufq_is_empty(&ctx->outbufq);
2370
2371    result = Curl_pollset_set(data, ps, sock, want_recv, want_send);
2372    CF_DATA_RESTORE(cf, save);
2373  }
2374  else if(ctx->sent_goaway && !cf->shutdown) {
2375    /* shutdown in progress */
2376    CF_DATA_SAVE(save, cf, data);
2377    want_send = nghttp2_session_want_write(ctx->h2) ||
2378                !Curl_bufq_is_empty(&ctx->outbufq);
2379    want_recv = nghttp2_session_want_read(ctx->h2);
2380    result = Curl_pollset_set(data, ps, sock, want_recv, want_send);
2381    CF_DATA_RESTORE(cf, save);
2382  }
2383  return result;
2384}
2385
2386static CURLcode cf_h2_ctx_open(struct Curl_cfilter *cf,
2387                               struct Curl_easy *data)
2388{
2389  struct cf_h2_ctx *ctx = cf->ctx;
2390  struct h2_stream_ctx *stream;
2391  CURLcode result = CURLE_OUT_OF_MEMORY;
2392  int rc;
2393  nghttp2_session_callbacks *cbs = NULL;
2394
2395  DEBUGASSERT(!ctx->h2);
2396  DEBUGASSERT(ctx->initialized);
2397
2398  rc = nghttp2_session_callbacks_new(&cbs);
2399  if(rc) {
2400    failf(data, "Could not initialize nghttp2 callbacks");
2401    goto out;
2402  }
2403
2404  nghttp2_session_callbacks_set_send_callback(cbs, send_callback);
2405  nghttp2_session_callbacks_set_on_frame_recv_callback(cbs, on_frame_recv);
2406  nghttp2_session_callbacks_set_on_invalid_frame_recv_callback(cbs,
2407    cf_h2_on_invalid_frame_recv);
2408#ifdef CURLVERBOSE
2409  nghttp2_session_callbacks_set_on_frame_send_callback(cbs, on_frame_send);
2410#endif
2411  nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
2412    cbs, on_data_chunk_recv);
2413  nghttp2_session_callbacks_set_on_stream_close_callback(cbs, on_stream_close);
2414  nghttp2_session_callbacks_set_on_begin_headers_callback(
2415    cbs, on_begin_headers);
2416  nghttp2_session_callbacks_set_on_header_callback(cbs, on_header);
2417#ifdef CURLVERBOSE
2418  nghttp2_session_callbacks_set_error_callback(cbs, error_callback);
2419#endif
2420
2421  /* The nghttp2 session is not yet setup, do it */
2422  rc = h2_client_new(cf, cbs);
2423  if(rc) {
2424    failf(data, "Could not initialize nghttp2");
2425    goto out;
2426  }
2427  ctx->max_concurrent_streams = DEFAULT_MAX_CONCURRENT_STREAMS;
2428
2429  if(ctx->via_h1_upgrade) {
2430    /* HTTP/1.1 Upgrade issued. H2 Settings have already been submitted
2431     * in the H1 request and we upgrade from there. This stream
2432     * is opened implicitly as #1. */
2433    uint8_t binsettings[H2_BINSETTINGS_LEN];
2434    ssize_t rclen;
2435    size_t binlen; /* length of the binsettings data */
2436
2437    rclen = populate_binsettings(binsettings, data);
2438
2439    if(!curlx_sztouz(rclen, &binlen) || !binlen) {
2440      failf(data, "nghttp2 unexpectedly failed on pack_settings_payload");
2441      result = CURLE_FAILED_INIT;
2442      goto out;
2443    }
2444
2445    result = http2_data_setup(cf, data, &stream);
2446    if(result)
2447      goto out;
2448    DEBUGASSERT(stream);
2449    stream->id = 1;
2450    /* queue SETTINGS frame (again) */
2451    rc = nghttp2_session_upgrade2(ctx->h2, binsettings, binlen,
2452                                  data->state.httpreq == HTTPREQ_HEAD,
2453                                  NULL);
2454    if(rc) {
2455      failf(data, "nghttp2_session_upgrade2() failed: %s(%d)",
2456            nghttp2_strerror(rc), rc);
2457      result = CURLE_HTTP2;
2458      goto out;
2459    }
2460
2461    rc = nghttp2_session_set_stream_user_data(ctx->h2, stream->id,
2462                                              data);
2463    if(rc) {
2464      infof(data, "http/2: failed to set user_data for stream %d",
2465            stream->id);
2466      DEBUGASSERT(0);
2467    }
2468    CURL_TRC_CF(data, cf, "created session via Upgrade");
2469  }
2470  else {
2471    nghttp2_settings_entry iv[H2_SETTINGS_IV_LEN];
2472    size_t ivlen;
2473
2474    ivlen = populate_settings(iv, data, ctx);
2475    rc = nghttp2_submit_settings(ctx->h2, NGHTTP2_FLAG_NONE,
2476                                 iv, ivlen);
2477    if(rc) {
2478      failf(data, "nghttp2_submit_settings() failed: %s(%d)",
2479            nghttp2_strerror(rc), rc);
2480      result = CURLE_HTTP2;
2481      goto out;
2482    }
2483  }
2484
2485  rc = nghttp2_session_set_local_window_size(ctx->h2, NGHTTP2_FLAG_NONE, 0,
2486                                             HTTP2_HUGE_WINDOW_SIZE);
2487  if(rc) {
2488    failf(data, "nghttp2_session_set_local_window_size() failed: %s(%d)",
2489          nghttp2_strerror(rc), rc);
2490    result = CURLE_HTTP2;
2491    goto out;
2492  }
2493
2494  /* all set, traffic will be send on connect */
2495  result = CURLE_OK;
2496  CURL_TRC_CF(data, cf, "[0] created h2 session%s",
2497              ctx->via_h1_upgrade ? " (via h1 upgrade)" : "");
2498
2499out:
2500  if(cbs)
2501    nghttp2_session_callbacks_del(cbs);
2502  return result;
2503}
2504
2505static CURLcode cf_h2_connect(struct Curl_cfilter *cf,
2506                              struct Curl_easy *data,
2507                              bool *done)
2508{
2509  struct cf_h2_ctx *ctx = cf->ctx;
2510  CURLcode result = CURLE_OK;
2511  struct cf_call_data save;
2512  bool first_time = FALSE;
2513
2514  if(cf->connected) {
2515    *done = TRUE;
2516    return CURLE_OK;
2517  }
2518
2519  /* Connect the lower filters first */
2520  if(!cf->next->connected) {
2521    result = Curl_conn_cf_connect(cf->next, data, done);
2522    if(result || !*done)
2523      return result;
2524  }
2525
2526  *done = FALSE;
2527
2528  CF_DATA_SAVE(save, cf, data);
2529  DEBUGASSERT(ctx->initialized);
2530  if(!ctx->h2) {
2531    result = cf_h2_ctx_open(cf, data);
2532    if(result)
2533      goto out;
2534    first_time = TRUE;
2535  }
2536
2537  if(!first_time) {
2538    result = h2_progress_ingress(cf, data, 0);
2539    if(result)
2540      goto out;
2541  }
2542
2543  /* Send out our SETTINGS and ACKs and such. If that blocks, we
2544   * have it buffered and can count this filter as being connected */
2545  result = h2_progress_egress(cf, data);
2546  if(result && (result != CURLE_AGAIN))
2547    goto out;
2548
2549  *done = TRUE;
2550  cf->connected = TRUE;
2551  result = CURLE_OK;
2552
2553out:
2554  CURL_TRC_CF(data, cf, "cf_connect() -> %d, %d, ", result, *done);
2555  CF_DATA_RESTORE(cf, save);
2556  return result;
2557}
2558
2559static void cf_h2_close(struct Curl_cfilter *cf, struct Curl_easy *data)
2560{
2561  struct cf_h2_ctx *ctx = cf->ctx;
2562
2563  if(ctx) {
2564    struct cf_call_data save;
2565
2566    CF_DATA_SAVE(save, cf, data);
2567    cf_h2_ctx_close(ctx);
2568    CF_DATA_RESTORE(cf, save);
2569    cf->connected = FALSE;
2570  }
2571  if(cf->next)
2572    cf->next->cft->do_close(cf->next, data);
2573}
2574
2575static void cf_h2_destroy(struct Curl_cfilter *cf, struct Curl_easy *data)
2576{
2577  struct cf_h2_ctx *ctx = cf->ctx;
2578
2579  (void)data;
2580  if(ctx) {
2581    cf_h2_ctx_free(ctx);
2582    cf->ctx = NULL;
2583  }
2584}
2585
2586static CURLcode cf_h2_shutdown(struct Curl_cfilter *cf,
2587                               struct Curl_easy *data, bool *done)
2588{
2589  struct cf_h2_ctx *ctx = cf->ctx;
2590  struct cf_call_data save;
2591  CURLcode result;
2592  int rv;
2593
2594  if(!cf->connected || !ctx->h2 || cf->shutdown || ctx->conn_closed) {
2595    *done = TRUE;
2596    return CURLE_OK;
2597  }
2598
2599  CF_DATA_SAVE(save, cf, data);
2600
2601  if(!ctx->sent_goaway) {
2602    ctx->sent_goaway = TRUE;
2603    rv = nghttp2_submit_goaway(ctx->h2, NGHTTP2_FLAG_NONE,
2604                               ctx->local_max_sid, 0,
2605                               (const uint8_t *)"shutdown",
2606                               sizeof("shutdown"));
2607    if(rv) {
2608      failf(data, "nghttp2_submit_goaway() failed: %s(%d)",
2609            nghttp2_strerror(rv), rv);
2610      result = CURLE_SEND_ERROR;
2611      goto out;
2612    }
2613  }
2614  /* GOAWAY submitted, process egress and ingress until nghttp2 is done. */
2615  result = CURLE_OK;
2616  if(nghttp2_session_want_write(ctx->h2) ||
2617     !Curl_bufq_is_empty(&ctx->outbufq))
2618    result = h2_progress_egress(cf, data);
2619  if(!result && nghttp2_session_want_read(ctx->h2))
2620    result = h2_progress_ingress(cf, data, 0);
2621
2622  if(result == CURLE_AGAIN)
2623    result = CURLE_OK;
2624
2625  *done = (ctx->conn_closed ||
2626           (!result && !nghttp2_session_want_write(ctx->h2) &&
2627            !nghttp2_session_want_read(ctx->h2) &&
2628            Curl_bufq_is_empty(&ctx->outbufq)));
2629
2630out:
2631  CF_DATA_RESTORE(cf, save);
2632  cf->shutdown = (result || *done);
2633  return result;
2634}
2635
2636static CURLcode http2_data_pause(struct Curl_cfilter *cf,
2637                                 struct Curl_easy *data,
2638                                 bool pause)
2639{
2640  struct cf_h2_ctx *ctx = cf->ctx;
2641  struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
2642
2643  DEBUGASSERT(data);
2644  if(ctx && ctx->h2 && stream) {
2645    CURLcode result;
2646
2647    stream->write_paused = pause;
2648    result = cf_h2_update_local_win(cf, data, stream);
2649    if(result)
2650      return result;
2651
2652    /* attempt to send the window update */
2653    (void)h2_progress_egress(cf, data);
2654
2655    if(!pause) {
2656      /* Unpausing a h2 transfer, requires it to be run again. The server
2657       * may send new DATA on us increasing the flow window, and it may
2658       * not. We may have already buffered and exhausted the new window
2659       * by operating on things in flight during the handling of other
2660       * transfers. */
2661      Curl_multi_mark_dirty(data);
2662    }
2663    CURL_TRC_CF(data, cf, "[%d] stream now %spaused", stream->id,
2664                pause ? "" : "un");
2665  }
2666  return CURLE_OK;
2667}
2668
2669static CURLcode cf_h2_cntrl(struct Curl_cfilter *cf,
2670                            struct Curl_easy *data,
2671                            int event, int arg1, void *arg2)
2672{
2673  CURLcode result = CURLE_OK;
2674  struct cf_call_data save;
2675
2676  (void)arg2;
2677
2678  CF_DATA_SAVE(save, cf, data);
2679  switch(event) {
2680  case CF_CTRL_DATA_SETUP:
2681    break;
2682  case CF_CTRL_DATA_PAUSE:
2683    result = http2_data_pause(cf, data, (arg1 != 0));
2684    break;
2685  case CF_CTRL_FLUSH:
2686    result = cf_h2_flush(cf, data);
2687    break;
2688  case CF_CTRL_DATA_DONE:
2689    http2_data_done(cf, data);
2690    break;
2691  case CF_CTRL_CONN_INFO_UPDATE:
2692    if(!cf->sockindex && cf->connected) {
2693      cf->conn->httpversion_seen = 20;
2694      Curl_conn_set_multiplex(cf->conn);
2695    }
2696    break;
2697  default:
2698    break;
2699  }
2700  CF_DATA_RESTORE(cf, save);
2701  return result;
2702}
2703
2704static bool cf_h2_data_pending(struct Curl_cfilter *cf,
2705                               const struct Curl_easy *data)
2706{
2707  struct cf_h2_ctx *ctx = cf->ctx;
2708
2709  if(ctx && !Curl_bufq_is_empty(&ctx->inbufq))
2710    return TRUE;
2711  return cf->next ? cf->next->cft->has_data_pending(cf->next, data) : FALSE;
2712}
2713
2714static bool cf_h2_is_alive(struct Curl_cfilter *cf,
2715                           struct Curl_easy *data,
2716                           bool *input_pending)
2717{
2718  struct cf_h2_ctx *ctx = cf->ctx;
2719  bool alive;
2720  struct cf_call_data save;
2721
2722  *input_pending = FALSE;
2723  CF_DATA_SAVE(save, cf, data);
2724  alive = (ctx && ctx->h2 && http2_connisalive(cf, data, input_pending));
2725  CURL_TRC_CF(data, cf, "conn alive -> %d, input_pending=%d",
2726              alive, *input_pending);
2727  CF_DATA_RESTORE(cf, save);
2728  return alive;
2729}
2730
2731static CURLcode cf_h2_keep_alive(struct Curl_cfilter *cf,
2732                                 struct Curl_easy *data)
2733{
2734  CURLcode result;
2735  struct cf_call_data save;
2736
2737  CF_DATA_SAVE(save, cf, data);
2738  result = http2_send_ping(cf, data);
2739  CF_DATA_RESTORE(cf, save);
2740  return result;
2741}
2742
2743static CURLcode cf_h2_query(struct Curl_cfilter *cf,
2744                            struct Curl_easy *data,
2745                            int query, int *pres1, void *pres2)
2746{
2747  struct cf_h2_ctx *ctx = cf->ctx;
2748  struct cf_call_data save;
2749  size_t effective_max;
2750
2751  switch(query) {
2752  case CF_QUERY_MAX_CONCURRENT:
2753    DEBUGASSERT(pres1);
2754
2755    CF_DATA_SAVE(save, cf, data);
2756    if(!ctx->h2 || !nghttp2_session_check_request_allowed(ctx->h2)) {
2757      /* the limit is what we have in use right now */
2758      effective_max = cf->conn->attached_xfers;
2759    }
2760    else {
2761      effective_max = ctx->max_concurrent_streams;
2762    }
2763    *pres1 = (effective_max > INT_MAX) ? INT_MAX : (int)effective_max;
2764    CF_DATA_RESTORE(cf, save);
2765    return CURLE_OK;
2766  case CF_QUERY_STREAM_ERROR: {
2767    struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
2768    *pres1 = stream ? (int)stream->error : 0;
2769    return CURLE_OK;
2770  }
2771  case CF_QUERY_NEED_FLUSH: {
2772    struct h2_stream_ctx *stream = H2_STREAM_CTX(ctx, data);
2773    if(!Curl_bufq_is_empty(&ctx->outbufq) ||
2774       (stream && !Curl_bufq_is_empty(&stream->sendbuf))) {
2775      *pres1 = TRUE;
2776      return CURLE_OK;
2777    }
2778    break;
2779  }
2780  case CF_QUERY_HTTP_VERSION:
2781    *pres1 = 20;
2782    return CURLE_OK;
2783  default:
2784    break;
2785  }
2786  return cf->next ?
2787    cf->next->cft->query(cf->next, data, query, pres1, pres2) :
2788    CURLE_UNKNOWN_OPTION;
2789}
2790
2791struct Curl_cftype Curl_cft_nghttp2 = {
2792  "HTTP/2",
2793  CF_TYPE_MULTIPLEX | CF_TYPE_HTTP,
2794  CURL_LOG_LVL_NONE,
2795  cf_h2_destroy,
2796  cf_h2_connect,
2797  cf_h2_close,
2798  cf_h2_shutdown,
2799  cf_h2_adjust_pollset,
2800  cf_h2_data_pending,
2801  cf_h2_send,
2802  cf_h2_recv,
2803  cf_h2_cntrl,
2804  cf_h2_is_alive,
2805  cf_h2_keep_alive,
2806  cf_h2_query,
2807};
2808
2809static CURLcode http2_cfilter_add(struct Curl_cfilter **pcf,
2810                                  struct Curl_easy *data,
2811                                  struct connectdata *conn,
2812                                  int sockindex,
2813                                  bool via_h1_upgrade)
2814{
2815  struct Curl_cfilter *cf = NULL;
2816  struct cf_h2_ctx *ctx;
2817  CURLcode result = CURLE_OUT_OF_MEMORY;
2818
2819  DEBUGASSERT(data->conn);
2820  ctx = curlx_calloc(1, sizeof(*ctx));
2821  if(!ctx)
2822    goto out;
2823  cf_h2_ctx_init(ctx, via_h1_upgrade);
2824
2825  result = Curl_cf_create(&cf, &Curl_cft_nghttp2, ctx);
2826  if(result)
2827    goto out;
2828
2829  ctx = NULL;
2830  Curl_conn_cf_add(data, conn, sockindex, cf);
2831
2832out:
2833  if(result)
2834    cf_h2_ctx_free(ctx);
2835  *pcf = result ? NULL : cf;
2836  return result;
2837}
2838
2839static CURLcode http2_cfilter_insert_after(struct Curl_cfilter *cf,
2840                                           struct Curl_easy *data,
2841                                           bool via_h1_upgrade)
2842{
2843  struct Curl_cfilter *cf_h2 = NULL;
2844  struct cf_h2_ctx *ctx;
2845  CURLcode result = CURLE_OUT_OF_MEMORY;
2846
2847  (void)data;
2848  ctx = curlx_calloc(1, sizeof(*ctx));
2849  if(!ctx)
2850    goto out;
2851  cf_h2_ctx_init(ctx, via_h1_upgrade);
2852
2853  result = Curl_cf_create(&cf_h2, &Curl_cft_nghttp2, ctx);
2854  if(result)
2855    goto out;
2856
2857  ctx = NULL;
2858  Curl_conn_cf_insert_after(cf, cf_h2);
2859
2860out:
2861  if(result)
2862    cf_h2_ctx_free(ctx);
2863  return result;
2864}
2865
2866bool Curl_http2_may_switch(struct Curl_easy *data)
2867{
2868  if(Curl_conn_http_version(data, data->conn) < 20 &&
2869     (data->state.http_neg.wanted & CURL_HTTP_V2x) &&
2870     data->state.http_neg.h2_prior_knowledge) {
2871#ifndef CURL_DISABLE_PROXY
2872    if(data->conn->bits.httpproxy && !data->conn->bits.tunnel_proxy) {
2873      /* We do not support HTTP/2 proxies yet. Also it is debatable
2874         whether or not this setting should apply to HTTP/2 proxies. */
2875      infof(data, "Ignoring HTTP/2 prior knowledge due to proxy");
2876      return FALSE;
2877    }
2878#endif
2879    return TRUE;
2880  }
2881  return FALSE;
2882}
2883
2884CURLcode Curl_http2_switch(struct Curl_easy *data)
2885{
2886  struct Curl_cfilter *cf;
2887  CURLcode result;
2888
2889  DEBUGASSERT(Curl_conn_http_version(data, data->conn) < 20);
2890
2891  result = http2_cfilter_add(&cf, data, data->conn, FIRSTSOCKET, FALSE);
2892  if(result)
2893    return result;
2894  CURL_TRC_CF(data, cf, "switching connection to HTTP/2");
2895
2896  if(cf->next) {
2897    bool done;
2898    return Curl_conn_cf_connect(cf, data, &done);
2899  }
2900  return CURLE_OK;
2901}
2902
2903CURLcode Curl_http2_switch_at(struct Curl_cfilter *cf, struct Curl_easy *data)
2904{
2905  struct Curl_cfilter *cf_h2;
2906  CURLcode result;
2907
2908  DEBUGASSERT(Curl_conn_http_version(data, data->conn) < 20);
2909
2910  result = http2_cfilter_insert_after(cf, data, FALSE);
2911  if(result)
2912    return result;
2913
2914  cf_h2 = cf->next;
2915
2916  if(cf_h2->next) {
2917    bool done;
2918    return Curl_conn_cf_connect(cf_h2, data, &done);
2919  }
2920  return CURLE_OK;
2921}
2922
2923CURLcode Curl_http2_upgrade(struct Curl_easy *data,
2924                            struct connectdata *conn, int sockindex,
2925                            const char *mem, size_t nread)
2926{
2927  struct Curl_cfilter *cf;
2928  struct cf_h2_ctx *ctx;
2929  CURLcode result;
2930
2931  DEBUGASSERT(Curl_conn_http_version(data, conn) < 20);
2932
2933  result = http2_cfilter_add(&cf, data, conn, sockindex, TRUE);
2934  if(result)
2935    return result;
2936  CURL_TRC_CF(data, cf, "upgrading connection to HTTP/2");
2937
2938  DEBUGASSERT(cf->cft == &Curl_cft_nghttp2);
2939  ctx = cf->ctx;
2940
2941  data->req.httpversion_sent = 20; /* it is an h2 request now */
2942  data->req.header = TRUE; /* we expect the real response to come in h2 */
2943  data->req.headerline = 0; /* restart the header line counter */
2944
2945  if(nread > 0) {
2946    /* Remaining data from the protocol switch reply is already using
2947     * the switched protocol, ie. HTTP/2. We add that to the network
2948     * inbufq. */
2949    size_t copied;
2950
2951    result = Curl_bufq_write(&ctx->inbufq,
2952                             (const unsigned char *)mem, nread, &copied);
2953    if(result) {
2954      failf(data, "error on copying HTTP Upgrade response: %d", result);
2955      return CURLE_RECV_ERROR;
2956    }
2957    if(copied < nread) {
2958      failf(data, "connection buffer size could not take all data "
2959            "from HTTP Upgrade response header: copied=%zu, datalen=%zu",
2960            copied, nread);
2961      return CURLE_HTTP2;
2962    }
2963    infof(data, "Copied HTTP/2 data in stream buffer to connection buffer"
2964          " after upgrade: len=%zu", nread);
2965  }
2966
2967  if(cf->next) {
2968    bool done;
2969    result = Curl_conn_cf_connect(cf, data, &done);
2970    if(!result)
2971      cf->cft->cntrl(cf, data, CF_CTRL_CONN_INFO_UPDATE, 0, NULL);
2972  }
2973  return result;
2974}
2975
2976/* Only call this function for a transfer that already got an HTTP/2
2977   CURLE_HTTP2_STREAM error! */
2978bool Curl_h2_http_1_1_error(struct Curl_easy *data)
2979{
2980  if(Curl_conn_http_version(data, data->conn) == 20) {
2981    int err = Curl_conn_get_stream_error(data, data->conn, FIRSTSOCKET);
2982    return err == NGHTTP2_HTTP_1_1_REQUIRED;
2983  }
2984  return FALSE;
2985}
2986
2987void *Curl_nghttp2_malloc(size_t size, void *user_data)
2988{
2989  (void)user_data;
2990  return Curl_cmalloc(size);
2991}
2992
2993void Curl_nghttp2_free(void *ptr, void *user_data)
2994{
2995  (void)user_data;
2996  Curl_cfree(ptr);
2997}
2998
2999void *Curl_nghttp2_calloc(size_t nmemb, size_t size, void *user_data)
3000{
3001  (void)user_data;
3002  return Curl_ccalloc(nmemb, size);
3003}
3004
3005void *Curl_nghttp2_realloc(void *ptr, size_t size, void *user_data)
3006{
3007  (void)user_data;
3008  return Curl_crealloc(ptr, size);
3009}
3010
3011#else /* CURL_DISABLE_HTTP || !USE_NGHTTP2 */
3012
3013/* Satisfy external references even if http2 is not compiled in. */
3014
3015char *curl_pushheader_bynum(struct curl_pushheaders *h, size_t num)
3016{
3017  (void)h;
3018  (void)num;
3019  return NULL;
3020}
3021
3022char *curl_pushheader_byname(struct curl_pushheaders *h, const char *name)
3023{
3024  (void)h;
3025  (void)name;
3026  return NULL;
3027}
3028
3029#endif /* !CURL_DISABLE_HTTP && USE_NGHTTP2 */