luna - curl/lib/multi.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#include "urldata.h"
  27#include "transfer.h"
  28#include "url.h"
  29#include "cfilters.h"
  30#include "connect.h"
  31#include "progress.h"
  32#include "curl_share.h"
  33#include "psl.h"
  34#include "multiif.h"
  35#include "multi_ev.h"
  36#include "sendf.h"
  37#include "curl_trc.h"
  38#include "http.h"
  39#include "select.h"
  40#include "curlx/wait.h"
  41#include "conncache.h"
  42#include "multihandle.h"
  43#include "sigpipe.h"
  44#include "vtls/vtls.h"
  45#include "vtls/vtls_scache.h"
  46#include "http_proxy.h"
  47#include "http2.h"
  48#include "socketpair.h"
  49#include "bufref.h"
  50
  51/* initial multi->xfers table size for a full multi */
  52#define CURL_XFER_TABLE_SIZE 512
  53
  54/*
  55  CURL_SOCKET_HASH_TABLE_SIZE should be a prime number. Increasing it from 97
  56  to 911 takes on a 32-bit machine 4 x 804 = 3211 more bytes. Still, every
  57  curl handle takes 6K memory, therefore this 3K are not significant.
  58*/
  59#ifndef CURL_SOCKET_HASH_TABLE_SIZE
  60#define CURL_SOCKET_HASH_TABLE_SIZE 911
  61#endif
  62
  63#ifndef CURL_CONNECTION_HASH_SIZE
  64#define CURL_CONNECTION_HASH_SIZE 97
  65#endif
  66
  67#ifndef CURL_DNS_HASH_SIZE
  68#define CURL_DNS_HASH_SIZE 71
  69#endif
  70
  71#ifndef CURL_TLS_SESSION_SIZE
  72#define CURL_TLS_SESSION_SIZE 25
  73#endif
  74
  75#define CURL_MULTI_HANDLE 0x000bab1e
  76
  77#ifdef DEBUGBUILD
  78/* On a debug build, we want to fail hard on multi handles that
  79 * are not NULL, but no longer have the MAGIC touch. This gives
  80 * us early warning on things only discovered by valgrind otherwise. */
  81#define GOOD_MULTI_HANDLE(x)                         \
  82  (((x) && (x)->magic == CURL_MULTI_HANDLE) ? TRUE : \
  83  (DEBUGASSERT(!(x)), FALSE))
  84#else
  85#define GOOD_MULTI_HANDLE(x) \
  86  ((x) && (x)->magic == CURL_MULTI_HANDLE)
  87#endif
  88
  89static void move_pending_to_connect(struct Curl_multi *multi,
  90                                    struct Curl_easy *data);
  91static CURLMcode add_next_timeout(const struct curltime *pnow,
  92                                  struct Curl_multi *multi,
  93                                  struct Curl_easy *d);
  94static void multi_timeout(struct Curl_multi *multi,
  95                          struct curltime *expire_time,
  96                          long *timeout_ms);
  97static void process_pending_handles(struct Curl_multi *multi);
  98static void multi_xfer_bufs_free(struct Curl_multi *multi);
  99#ifdef DEBUGBUILD
 100static void multi_xfer_tbl_dump(struct Curl_multi *multi);
 101#endif
 102
 103static const struct curltime *multi_now(struct Curl_multi *multi)
 104{
 105  curlx_pnow(&multi->now);
 106  return &multi->now;
 107}
 108
 109/* function pointer called once when switching TO a state */
 110typedef void (*init_multistate_func)(struct Curl_easy *data);
 111
 112/* called in DID state, before PERFORMING state */
 113static void before_perform(struct Curl_easy *data)
 114{
 115  data->req.chunk = FALSE;
 116  Curl_pgrsTime(data, TIMER_PRETRANSFER);
 117}
 118
 119static void init_completed(struct Curl_easy *data)
 120{
 121  /* this is a completed transfer */
 122
 123  /* Important: reset the conn pointer so that we do not point to memory
 124     that could be freed anytime */
 125  Curl_detach_connection(data);
 126  Curl_expire_clear(data); /* stop all timers */
 127}
 128
 129/* always use this function to change state, to make debugging easier */
 130static void mstate(struct Curl_easy *data, CURLMstate state
 131#ifdef DEBUGBUILD
 132                   , int lineno
 133#endif
 134)
 135{
 136  CURLMstate oldstate = data->mstate;
 137  static const init_multistate_func finit[MSTATE_LAST] = {
 138    NULL,              /* INIT */
 139    NULL,              /* PENDING */
 140    NULL,              /* SETUP */
 141    Curl_init_CONNECT, /* CONNECT */
 142    NULL,              /* CONNECTING */
 143    NULL,              /* PROTOCONNECT */
 144    NULL,              /* PROTOCONNECTING */
 145    NULL,              /* DO */
 146    NULL,              /* DOING */
 147    NULL,              /* DOING_MORE */
 148    before_perform,    /* DID */
 149    NULL,              /* PERFORMING */
 150    NULL,              /* RATELIMITING */
 151    NULL,              /* DONE */
 152    init_completed,    /* COMPLETED */
 153    NULL               /* MSGSENT */
 154  };
 155
 156  if(oldstate == state)
 157    /* do not bother when the new state is the same as the old state */
 158    return;
 159
 160#ifdef DEBUGBUILD
 161  NOVERBOSE((void)lineno);
 162  CURL_TRC_M(data, "-> [%s] (line %d)", CURL_MSTATE_NAME(state), lineno);
 163#else
 164  CURL_TRC_M(data, "-> [%s]", CURL_MSTATE_NAME(state));
 165#endif
 166
 167  /* really switching state */
 168  data->mstate = state;
 169  switch(state) {
 170  case MSTATE_DONE:
 171    CURLM_NTFY(data, CURLMNOTIFY_EASY_DONE);
 172    break;
 173  case MSTATE_COMPLETED:
 174    /* we sometimes directly jump to COMPLETED, trigger also a notification
 175     * in that case. */
 176    if(oldstate < MSTATE_DONE)
 177      CURLM_NTFY(data, CURLMNOTIFY_EASY_DONE);
 178    /* changing to COMPLETED means it is in process and needs to go */
 179    DEBUGASSERT(Curl_uint32_bset_contains(&data->multi->process, data->mid));
 180    Curl_uint32_bset_remove(&data->multi->process, data->mid);
 181    Curl_uint32_bset_remove(&data->multi->pending, data->mid); /* to be sure */
 182
 183    if(Curl_uint32_bset_empty(&data->multi->process)) {
 184      /* free the transfer buffer when we have no more active transfers */
 185      multi_xfer_bufs_free(data->multi);
 186    }
 187    break;
 188  default:
 189    break;
 190  }
 191
 192  /* if this state has an init-function, run it */
 193  if(finit[state])
 194    finit[state](data);
 195}
 196
 197#ifndef DEBUGBUILD
 198#define multistate(x, y) mstate(x, y)
 199#else
 200#define multistate(x, y) mstate(x, y, __LINE__)
 201#endif
 202
 203/* multi->proto_hash destructor. Should never be called as elements
 204 * MUST be added with their own destructor */
 205static void ph_freeentry(void *p)
 206{
 207  (void)p;
 208  /* Always FALSE. Cannot use a 0 assert here since compilers
 209   * are not in agreement if they then want a NORETURN attribute or
 210   * not. *sigh* */
 211  DEBUGASSERT(p == NULL);
 212}
 213
 214/*
 215 * multi_addmsg()
 216 *
 217 * Called when a transfer is completed. Adds the given msg pointer to
 218 * the list kept in the multi handle.
 219 */
 220static void multi_addmsg(struct Curl_multi *multi, struct Curl_message *msg)
 221{
 222  if(!Curl_llist_count(&multi->msglist))
 223    CURLM_NTFY(multi->admin, CURLMNOTIFY_INFO_READ);
 224  Curl_llist_append(&multi->msglist, msg, &msg->list);
 225}
 226
 227struct Curl_multi *Curl_multi_handle(uint32_t xfer_table_size,
 228                                     size_t ev_hashsize,  /* event hash */
 229                                     size_t chashsize, /* connection hash */
 230                                     size_t dnssize,   /* dns hash */
 231                                     size_t sesssize)  /* TLS session cache */
 232{
 233  struct Curl_multi *multi = curlx_calloc(1, sizeof(struct Curl_multi));
 234
 235  if(!multi)
 236    return NULL;
 237
 238  multi->magic = CURL_MULTI_HANDLE;
 239
 240  Curl_dnscache_init(&multi->dnscache, dnssize);
 241  Curl_mntfy_init(multi);
 242  Curl_multi_ev_init(multi, ev_hashsize);
 243  Curl_uint32_tbl_init(&multi->xfers, NULL);
 244  Curl_uint32_bset_init(&multi->process);
 245  Curl_uint32_bset_init(&multi->dirty);
 246  Curl_uint32_bset_init(&multi->pending);
 247  Curl_uint32_bset_init(&multi->msgsent);
 248  Curl_hash_init(&multi->proto_hash, 23,
 249                 Curl_hash_str, curlx_str_key_compare, ph_freeentry);
 250  Curl_llist_init(&multi->msglist, NULL);
 251
 252  multi->multiplexing = TRUE;
 253  multi->max_concurrent_streams = 100;
 254  multi->last_timeout_ms = -1;
 255#ifdef ENABLE_WAKEUP
 256  multi->wakeup_pair[0] = CURL_SOCKET_BAD;
 257  multi->wakeup_pair[1] = CURL_SOCKET_BAD;
 258#endif
 259
 260  if(Curl_mntfy_resize(multi) ||
 261     Curl_uint32_bset_resize(&multi->process, xfer_table_size) ||
 262     Curl_uint32_bset_resize(&multi->pending, xfer_table_size) ||
 263     Curl_uint32_bset_resize(&multi->dirty, xfer_table_size) ||
 264     Curl_uint32_bset_resize(&multi->msgsent, xfer_table_size) ||
 265     Curl_uint32_tbl_resize(&multi->xfers, xfer_table_size))
 266    goto error;
 267
 268  multi->admin = curl_easy_init();
 269  if(!multi->admin)
 270    goto error;
 271  /* Initialize admin handle to operate inside this multi */
 272  multi->admin->multi = multi;
 273  multi->admin->state.internal = TRUE;
 274  Curl_llist_init(&multi->admin->state.timeoutlist, NULL);
 275
 276#ifdef DEBUGBUILD
 277  if(getenv("CURL_DEBUG"))
 278    multi->admin->set.verbose = TRUE;
 279#endif
 280  Curl_uint32_tbl_add(&multi->xfers, multi->admin, &multi->admin->mid);
 281  Curl_uint32_bset_add(&multi->process, multi->admin->mid);
 282
 283  if(Curl_cshutdn_init(&multi->cshutdn, multi))
 284    goto error;
 285
 286  Curl_cpool_init(&multi->cpool, multi->admin, NULL, chashsize);
 287
 288#ifdef USE_SSL
 289  if(Curl_ssl_scache_create(sesssize, 2, &multi->ssl_scache))
 290    goto error;
 291#else
 292  (void)sesssize;
 293#endif
 294
 295#ifdef USE_WINSOCK
 296  multi->wsa_event = WSACreateEvent();
 297  if(multi->wsa_event == WSA_INVALID_EVENT)
 298    goto error;
 299#endif
 300#ifdef ENABLE_WAKEUP
 301  /* When enabled, rely on this to work. We ignore this in previous
 302   * versions, but that seems an unnecessary complication. */
 303  if(Curl_wakeup_init(multi->wakeup_pair, TRUE) < 0)
 304    goto error;
 305#endif
 306
 307  if(Curl_probeipv6(multi))
 308    goto error;
 309
 310#ifdef USE_RESOLV_THREADED
 311  if(xfer_table_size < CURL_XFER_TABLE_SIZE) { /* easy multi */
 312    if(Curl_async_thrdd_multi_init(multi, 0, 2, 10))
 313      goto error;
 314  }
 315  else { /* real multi handle */
 316    if(Curl_async_thrdd_multi_init(multi, 0, 20, 2000))
 317      goto error;
 318  }
 319#endif
 320
 321  return multi;
 322
 323error:
 324
 325#ifdef USE_RESOLV_THREADED
 326  Curl_async_thrdd_multi_destroy(multi, TRUE);
 327#endif
 328  Curl_multi_ev_cleanup(multi);
 329  Curl_hash_destroy(&multi->proto_hash);
 330  Curl_dnscache_destroy(&multi->dnscache);
 331  Curl_cpool_destroy(&multi->cpool);
 332  Curl_cshutdn_destroy(&multi->cshutdn, multi->admin);
 333#ifdef USE_SSL
 334  Curl_ssl_scache_destroy(multi->ssl_scache);
 335#endif
 336  if(multi->admin) {
 337    Curl_multi_ev_xfer_done(multi, multi->admin);
 338    multi->admin->multi = NULL;
 339    Curl_close(&multi->admin);
 340  }
 341  Curl_mntfy_cleanup(multi);
 342
 343  Curl_uint32_bset_destroy(&multi->process);
 344  Curl_uint32_bset_destroy(&multi->dirty);
 345  Curl_uint32_bset_destroy(&multi->pending);
 346  Curl_uint32_bset_destroy(&multi->msgsent);
 347  Curl_uint32_tbl_destroy(&multi->xfers);
 348#ifdef ENABLE_WAKEUP
 349  Curl_wakeup_destroy(multi->wakeup_pair);
 350#endif
 351
 352  curlx_free(multi);
 353  return NULL;
 354}
 355
 356CURLM *curl_multi_init(void)
 357{
 358  return Curl_multi_handle(CURL_XFER_TABLE_SIZE,
 359                           CURL_SOCKET_HASH_TABLE_SIZE,
 360                           CURL_CONNECTION_HASH_SIZE,
 361                           CURL_DNS_HASH_SIZE,
 362                           CURL_TLS_SESSION_SIZE);
 363}
 364
 365#if defined(DEBUGBUILD) && defined(CURLVERBOSE)
 366static void multi_warn_debug(struct Curl_multi *multi, struct Curl_easy *data)
 367{
 368  if(!multi->warned) {
 369    infof(data, "!!! WARNING !!!");
 370    infof(data, "This is a debug build of libcurl, "
 371                "do not use in production.");
 372    multi->warned = TRUE;
 373  }
 374}
 375#else
 376#define multi_warn_debug(x, y) Curl_nop_stmt
 377#endif
 378
 379bool Curl_is_connecting(struct Curl_easy *data)
 380{
 381  return data->mstate < MSTATE_DO;
 382}
 383
 384static CURLMcode multi_assess_wakeup(struct Curl_multi *multi)
 385{
 386#ifdef ENABLE_WAKEUP
 387  if(multi->socket_cb)
 388    return Curl_multi_ev_assess_xfer(multi, multi->admin);
 389#else
 390  (void)multi;
 391#endif
 392  return CURLM_OK;
 393}
 394
 395static CURLMcode multi_xfers_add(struct Curl_multi *multi,
 396                                 struct Curl_easy *data)
 397{
 398  uint32_t capacity = Curl_uint32_tbl_capacity(&multi->xfers);
 399  uint32_t new_size = 0;
 400  /* Prepare to make this into a CURLMOPT_MAX_TRANSFERS, because some
 401   * applications may want to prevent a run-away of their memory use. */
 402  /* UINT_MAX is our "invalid" id, do not let the table grow up to that. */
 403  const uint32_t max_capacity = UINT_MAX - 1;
 404
 405  if(capacity < max_capacity) {
 406    /* We want `multi->xfers` to have "sufficient" free rows, so that we do
 407     * not have to reuse the `mid` from a removed easy right away.
 408     * Since uint_tbl and uint_bset are memory efficient,
 409     * regard less than 25% free as insufficient.
 410     * (for low capacities, e.g. multi_easy, 4 or less). */
 411    uint32_t used = Curl_uint32_tbl_count(&multi->xfers);
 412    uint32_t unused = capacity - used;
 413    uint32_t min_unused = CURLMAX(capacity >> 2, 4);
 414    if(unused <= min_unused) {
 415      /* Make sure the uint arithmetic here works on the corner
 416       * cases where we are close to max_capacity or UINT_MAX */
 417      if((min_unused >= max_capacity) ||
 418         ((max_capacity - min_unused) <= capacity) ||
 419         ((UINT_MAX - min_unused - 63) <= capacity)) {
 420        new_size = max_capacity; /* can not be larger than this */
 421      }
 422      else {
 423        /* make it a 64 multiple, since our bitsets grow by that and
 424         * small (easy_multi) grows to at least 64 on first resize. */
 425        new_size = (((used + min_unused) + 63) / 64) * 64;
 426      }
 427    }
 428  }
 429
 430  if(new_size > capacity) {
 431    /* Grow the bitsets first. Should one fail, we do not need
 432     * to downsize the already resized ones. The sets continue
 433     * to work properly when larger than the table, but not
 434     * the other way around. */
 435    CURL_TRC_M(data, "increasing xfer table size to %u", new_size);
 436    if(Curl_uint32_bset_resize(&multi->process, new_size) ||
 437       Curl_uint32_bset_resize(&multi->dirty, new_size) ||
 438       Curl_uint32_bset_resize(&multi->pending, new_size) ||
 439       Curl_uint32_bset_resize(&multi->msgsent, new_size) ||
 440       Curl_uint32_tbl_resize(&multi->xfers, new_size))
 441      return CURLM_OUT_OF_MEMORY;
 442  }
 443
 444  /* Insert the easy into the table now */
 445  if(!Curl_uint32_tbl_add(&multi->xfers, data, &data->mid)) {
 446    /* MUST only happen when table is full */
 447    DEBUGASSERT(Curl_uint32_tbl_capacity(&multi->xfers) <=
 448                Curl_uint32_tbl_count(&multi->xfers));
 449    return CURLM_OUT_OF_MEMORY;
 450  }
 451  return CURLM_OK;
 452}
 453
 454CURLMcode curl_multi_add_handle(CURLM *m, CURL *curl)
 455{
 456  CURLMcode mresult;
 457  struct Curl_multi *multi = m;
 458  struct Curl_easy *data = curl;
 459
 460  /* First, make some basic checks that the CURLM handle is a good handle */
 461  if(!GOOD_MULTI_HANDLE(multi))
 462    return CURLM_BAD_HANDLE;
 463
 464  /* Verify that we got a somewhat good easy handle too */
 465  if(!GOOD_EASY_HANDLE(data))
 466    return CURLM_BAD_EASY_HANDLE;
 467
 468  /* Prevent users from adding same easy handle more than once and prevent
 469     adding to more than one multi stack */
 470  if(data->multi)
 471    return CURLM_ADDED_ALREADY;
 472
 473  if(multi->in_callback)
 474    return CURLM_RECURSIVE_API_CALL;
 475
 476  if(multi->dead) {
 477    /* a "dead" handle cannot get added transfers while any existing easy
 478       handles are still alive - but if there are none alive anymore, it is
 479       fine to start over and unmark the "deadness" of this handle.
 480       This means only the admin handle MUST be present. */
 481    if((Curl_uint32_tbl_count(&multi->xfers) != 1) ||
 482       !Curl_uint32_tbl_contains(&multi->xfers, 0))
 483      return CURLM_ABORTED_BY_CALLBACK;
 484    multi->dead = FALSE;
 485    Curl_uint32_bset_clear(&multi->process);
 486    Curl_uint32_bset_clear(&multi->dirty);
 487    Curl_uint32_bset_clear(&multi->pending);
 488    Curl_uint32_bset_clear(&multi->msgsent);
 489  }
 490
 491  if(data->multi_easy) {
 492    /* if this easy handle was previously used for curl_easy_perform(), there
 493       is a private multi handle here that we can kill */
 494    curl_multi_cleanup(data->multi_easy);
 495    data->multi_easy = NULL;
 496  }
 497
 498  /* Insert the easy into the multi->xfers table, assigning it a `mid`. */
 499  if(multi_xfers_add(multi, data))
 500    return CURLM_OUT_OF_MEMORY;
 501
 502  /* Initialize timeout list for this handle */
 503  Curl_llist_init(&data->state.timeoutlist, NULL);
 504
 505  /*
 506   * No failure allowed in this function beyond this point. No modification of
 507   * easy nor multi handle allowed before this except for potential multi's
 508   * connection pool growing which will not be undone in this function no
 509   * matter what.
 510   */
 511  if(data->set.errorbuffer)
 512    data->set.errorbuffer[0] = 0;
 513
 514  data->state.os_errno = 0;
 515
 516  /* make the Curl_easy refer back to this multi handle - before Curl_expire()
 517     is called. */
 518  data->multi = multi;
 519
 520  /* set the easy handle */
 521  multistate(data, MSTATE_INIT);
 522
 523#ifdef USE_LIBPSL
 524  /* Do the same for PSL. */
 525  if(data->share && (data->share->specifier & (1 << CURL_LOCK_DATA_PSL)))
 526    data->psl = &data->share->psl;
 527  else
 528    data->psl = &multi->psl;
 529#endif
 530
 531  /* add the easy handle to the process set */
 532  Curl_uint32_bset_add(&multi->process, data->mid);
 533  ++multi->xfers_alive;
 534  ++multi->xfers_total_ever;
 535
 536  Curl_cpool_xfer_init(data);
 537  multi_warn_debug(multi, data);
 538
 539  /* Make sure the new handle will run */
 540  Curl_multi_mark_dirty(data);
 541
 542  /* Necessary in event based processing, where dirty handles trigger
 543   * a timeout callback invocation. */
 544  mresult = Curl_update_timer(multi);
 545  if(mresult) {
 546    data->multi = NULL; /* not anymore */
 547    Curl_uint32_tbl_remove(&multi->xfers, data->mid);
 548    data->mid = UINT32_MAX;
 549    return mresult;
 550  }
 551
 552  /* The admin handle only ever has default timeouts set. To improve the
 553     state somewhat we clone the timeouts from each added handle so that the
 554     admin handle always has the same timeouts as the most recently added
 555     easy handle. */
 556  multi->admin->set.timeout = data->set.timeout;
 557  multi->admin->set.server_response_timeout =
 558    data->set.server_response_timeout;
 559  multi->admin->set.no_signal = data->set.no_signal;
 560
 561  mresult = multi_assess_wakeup(multi);
 562  if(mresult) {
 563    failf(data, "error enabling wakeup listening: %d", mresult);
 564    return mresult;
 565  }
 566
 567  CURL_TRC_M(data, "added to multi, mid=%u, running=%u, total=%u",
 568             data->mid, Curl_multi_xfers_running(multi),
 569             Curl_uint32_tbl_count(&multi->xfers));
 570  return CURLM_OK;
 571}
 572
 573#if 0
 574/* Debug-function, used like this:
 575 *
 576 * Curl_hash_print(&multi->sockhash, debug_print_sock_hash);
 577 *
 578 * Enable the hash print function first by editing hash.c
 579 */
 580static void debug_print_sock_hash(void *p)
 581{
 582  struct Curl_sh_entry *sh = (struct Curl_sh_entry *)p;
 583
 584  curl_mfprintf(stderr, " [readers %u][writers %u]",
 585                sh->readers, sh->writers);
 586}
 587#endif
 588
 589struct multi_done_ctx {
 590  BIT(premature);
 591};
 592
 593static bool multi_conn_should_close(struct connectdata *conn,
 594                                    struct Curl_easy *data,
 595                                    bool premature)
 596{
 597  /* if conn->bits.close is TRUE, it means that the connection should be
 598     closed in spite of everything else. */
 599  if(conn->bits.close)
 600    return TRUE;
 601
 602  /* if data->set.reuse_forbid is TRUE, it means the libcurl client has
 603     forced us to close this connection. This is ignored for requests taking
 604     place in a NTLM/NEGOTIATE authentication handshake. */
 605  if(data->set.reuse_forbid
 606#ifdef USE_NTLM
 607     && !(conn->http_ntlm_state == NTLMSTATE_TYPE2 ||
 608          conn->proxy_ntlm_state == NTLMSTATE_TYPE2)
 609#endif
 610#ifdef USE_SPNEGO
 611     && !(conn->http_negotiate_state == GSS_AUTHRECV ||
 612          conn->proxy_negotiate_state == GSS_AUTHRECV)
 613#endif
 614    )
 615    return TRUE;
 616
 617  /* Unless this connection is for a "connect-only" transfer, it
 618   * needs to be closed if the protocol handler does not support reuse. */
 619  if(!data->set.connect_only && conn->scheme &&
 620     !(conn->scheme->flags & PROTOPT_CONN_REUSE))
 621    return TRUE;
 622
 623  /* if premature is TRUE, it means this connection was said to be DONE before
 624     the entire request operation is complete and thus we cannot know in what
 625     state it is for reusing, so we are forced to close it. In a perfect world
 626     we can add code that keep track of if we really must close it here or not,
 627     but currently we have no such detail knowledge. */
 628  if(premature && !Curl_conn_is_multiplex(conn, FIRSTSOCKET))
 629    return TRUE;
 630
 631  return FALSE;
 632}
 633
 634static void multi_done_locked(struct connectdata *conn,
 635                              struct Curl_easy *data,
 636                              void *userdata)
 637{
 638  struct multi_done_ctx *mdctx = userdata;
 639
 640  Curl_detach_connection(data);
 641
 642  CURL_TRC_M(data, "multi_done_locked, in use=%u", conn->attached_xfers);
 643  if(CONN_INUSE(conn)) {
 644    /* Stop if still used. */
 645    CURL_TRC_M(data, "Connection still in use %u, no more multi_done now!",
 646               conn->attached_xfers);
 647    return;
 648  }
 649
 650  data->state.done = TRUE; /* called now! */
 651  data->state.recent_conn_id = conn->connection_id;
 652
 653  Curl_dnscache_prune(data);
 654
 655  if(multi_conn_should_close(conn, data, (bool)mdctx->premature)) {
 656    CURL_TRC_M(data, "multi_done, terminating conn #%" FMT_OFF_T " to %s, "
 657               "forbid=%d, close=%d, premature=%d, conn_multiplex=%d",
 658               conn->connection_id, conn->destination,
 659               data->set.reuse_forbid, conn->bits.close, mdctx->premature,
 660               Curl_conn_is_multiplex(conn, FIRSTSOCKET));
 661    connclose(conn, "disconnecting");
 662    Curl_conn_terminate(data, conn, (bool)mdctx->premature);
 663  }
 664  else if(!Curl_conn_get_max_concurrent(data, conn, FIRSTSOCKET)) {
 665    CURL_TRC_M(data, "multi_done, conn #%" FMT_OFF_T " to %s was shutdown"
 666               " by server, not reusing", conn->connection_id,
 667               conn->destination);
 668    connclose(conn, "server shutdown");
 669    Curl_conn_terminate(data, conn, (bool)mdctx->premature);
 670  }
 671  else {
 672    /* the connection is no longer in use by any transfer */
 673    if(Curl_cpool_conn_now_idle(data, conn)) {
 674      /* connection kept in the cpool */
 675      data->state.lastconnect_id = conn->connection_id;
 676      infof(data, "Connection #%" FMT_OFF_T " to host %s left intact",
 677            conn->connection_id, conn->destination);
 678    }
 679    else {
 680      /* connection was removed from the cpool and destroyed. */
 681      data->state.lastconnect_id = -1;
 682    }
 683  }
 684}
 685
 686static CURLcode multi_done(struct Curl_easy *data,
 687                           CURLcode status,  /* an error if this is called
 688                                                after an error was detected */
 689                           bool premature)
 690{
 691  CURLcode result;
 692  struct connectdata *conn = data->conn;
 693
 694  CURL_TRC_M(data, "multi_done: status: %d prem: %d done: %d",
 695             (int)status, (int)premature, data->state.done);
 696
 697  if(data->state.done)
 698    /* Stop if multi_done() has already been called */
 699    return CURLE_OK;
 700
 701  /* Shut down any ongoing async resolver operation. */
 702  Curl_resolv_shutdown_all(data);
 703
 704  /* Cleanup possible redirect junk */
 705  curlx_safefree(data->req.newurl);
 706  curlx_safefree(data->req.location);
 707
 708  switch(status) {
 709  case CURLE_ABORTED_BY_CALLBACK:
 710  case CURLE_READ_ERROR:
 711  case CURLE_WRITE_ERROR:
 712    /* When we are aborted due to a callback return code it has to be counted
 713       as premature as there is trouble ahead if we do not. We have many
 714       callbacks and protocols work differently, we could potentially do this
 715       more fine-grained in the future. */
 716    premature = TRUE;
 717    FALLTHROUGH();
 718  default:
 719    break;
 720  }
 721
 722  /* this calls the protocol-specific function pointer previously set */
 723  if(conn && conn->scheme->run->done && (data->mstate >= MSTATE_PROTOCONNECT))
 724    result = conn->scheme->run->done(data, status, premature);
 725  else
 726    result = status;
 727
 728  if(data->mstate > MSTATE_CONNECTING &&
 729     (result != CURLE_ABORTED_BY_CALLBACK)) {
 730    /* avoid this if
 731     * - the transfer has not connected
 732     * - we already aborted by callback to avoid this calling another callback
 733     */
 734    int rc = Curl_pgrsDone(data);
 735    if(!result && rc)
 736      result = CURLE_ABORTED_BY_CALLBACK;
 737  }
 738
 739  /* Make sure that transfer client writes are really done now. */
 740  result = Curl_1st_fatal(result, Curl_xfer_write_done(data, premature));
 741
 742  /* Inform connection filters that this transfer is done */
 743  if(conn)
 744    Curl_conn_ev_data_done(data, premature);
 745
 746  process_pending_handles(data->multi); /* connection / multiplex */
 747
 748  if(!result)
 749    result = Curl_req_done(&data->req, data, premature);
 750
 751  if(conn) {
 752    /* Under the potential connection pool's share lock, decide what to
 753     * do with the transfer's connection. */
 754    struct multi_done_ctx mdctx;
 755
 756    memset(&mdctx, 0, sizeof(mdctx));
 757    mdctx.premature = premature;
 758    Curl_cpool_do_locked(data, data->conn, multi_done_locked, &mdctx);
 759  }
 760
 761  /* flush the netrc cache */
 762  Curl_netrc_cleanup(&data->state.netrc);
 763  return result;
 764}
 765
 766static void close_connect_only(struct connectdata *conn,
 767                               struct Curl_easy *data,
 768                               void *userdata)
 769{
 770  (void)userdata;
 771  (void)data;
 772  if(conn->bits.connect_only)
 773    connclose(conn, "Removing connect-only easy handle");
 774}
 775
 776CURLMcode curl_multi_remove_handle(CURLM *m, CURL *curl)
 777{
 778  struct Curl_multi *multi = m;
 779  struct Curl_easy *data = curl;
 780  bool premature;
 781  struct Curl_llist_node *e;
 782  CURLMcode mresult;
 783  uint32_t mid;
 784
 785  /* First, make some basic checks that the CURLM handle is a good handle */
 786  if(!GOOD_MULTI_HANDLE(multi))
 787    return CURLM_BAD_HANDLE;
 788
 789  /* Verify that we got a somewhat good easy handle too */
 790  if(!GOOD_EASY_HANDLE(data))
 791    return CURLM_BAD_EASY_HANDLE;
 792
 793  /* Prevent users from trying to remove same easy handle more than once */
 794  if(!data->multi)
 795    return CURLM_OK; /* it is already removed so let's say it is fine! */
 796
 797  /* Prevent users from trying to remove an easy handle from the wrong multi */
 798  if(data->multi != multi)
 799    return CURLM_BAD_EASY_HANDLE;
 800
 801  if(data->mid == UINT32_MAX) {
 802    DEBUGASSERT(0);
 803    return CURLM_INTERNAL_ERROR;
 804  }
 805  if(Curl_uint32_tbl_get(&multi->xfers, data->mid) != data) {
 806    DEBUGASSERT(0);
 807    return CURLM_INTERNAL_ERROR;
 808  }
 809
 810  if(multi->in_callback)
 811    return CURLM_RECURSIVE_API_CALL;
 812
 813  premature = (data->mstate < MSTATE_COMPLETED);
 814
 815  /* If the 'state' is not INIT or COMPLETED, we might need to do something
 816     nice to put the easy_handle in a good known state when this returns. */
 817  if(data->conn &&
 818     data->mstate > MSTATE_DO &&
 819     data->mstate < MSTATE_COMPLETED) {
 820    /* Set connection owner so that the DONE function closes it. We can
 821       safely do this here since connection is killed. */
 822    streamclose(data->conn, "Removed with partial response");
 823  }
 824
 825  if(data->conn) {
 826    /* multi_done() clears the association between the easy handle and the
 827       connection.
 828
 829       Note that this ignores the return code because there is
 830       nothing really useful to do with it anyway! */
 831    (void)multi_done(data, data->result, premature);
 832  }
 833
 834  /* The timer must be shut down before data->multi is set to NULL, else the
 835     timenode will remain in the splay tree after curl_easy_cleanup is
 836     called. Do it after multi_done() in case that sets another time! */
 837  Curl_expire_clear(data);
 838
 839  /* If in `msgsent`, it was deducted from `multi->xfers_alive` already. */
 840  if(!Curl_uint32_bset_contains(&multi->msgsent, data->mid))
 841    --multi->xfers_alive;
 842
 843  Curl_wildcard_dtor(&data->wildcard);
 844
 845  data->mstate = MSTATE_COMPLETED;
 846
 847  /* Remove the association between the connection and the handle */
 848  Curl_detach_connection(data);
 849
 850  /* Tell event handling that this transfer is definitely going away */
 851  Curl_multi_ev_xfer_done(multi, data);
 852
 853  if(data->set.connect_only && !data->multi_easy) {
 854    /* This removes a handle that was part the multi interface that used
 855       CONNECT_ONLY, that connection is now left alive but since this handle
 856       has bits.close set nothing can use that transfer anymore and it is
 857       forbidden from reuse. This easy handle cannot find the connection
 858       anymore once removed from the multi handle
 859
 860       Better close the connection here, at once.
 861    */
 862    struct connectdata *c;
 863    curl_socket_t s;
 864    s = Curl_getconnectinfo(data, &c);
 865    if((s != CURL_SOCKET_BAD) && c) {
 866      Curl_conn_terminate(data, c, TRUE);
 867    }
 868  }
 869
 870  if(data->state.lastconnect_id != -1) {
 871    /* Mark any connect-only connection for closure */
 872    Curl_cpool_do_by_id(data, data->state.lastconnect_id,
 873                        close_connect_only, NULL);
 874  }
 875
 876#ifdef USE_LIBPSL
 877  /* Remove the PSL association. */
 878  if(data->psl == &multi->psl)
 879    data->psl = NULL;
 880#endif
 881
 882  /* make sure there is no pending message in the queue sent from this easy
 883     handle */
 884  for(e = Curl_llist_head(&multi->msglist); e; e = Curl_node_next(e)) {
 885    struct Curl_message *msg = Curl_node_elem(e);
 886
 887    if(msg->extmsg.easy_handle == data) {
 888      Curl_node_remove(e);
 889      /* there can only be one from this specific handle */
 890      break;
 891    }
 892  }
 893
 894  /* clear the association to this multi handle */
 895  mid = data->mid;
 896  DEBUGASSERT(Curl_uint32_tbl_contains(&multi->xfers, mid));
 897  Curl_uint32_tbl_remove(&multi->xfers, mid);
 898  Curl_uint32_bset_remove(&multi->process, mid);
 899  Curl_uint32_bset_remove(&multi->dirty, mid);
 900  Curl_uint32_bset_remove(&multi->pending, mid);
 901  Curl_uint32_bset_remove(&multi->msgsent, mid);
 902  data->multi = NULL;
 903  data->mid = UINT32_MAX;
 904  data->master_mid = UINT32_MAX;
 905
 906  /* NOTE NOTE NOTE
 907     We do not touch the easy handle here! */
 908  process_pending_handles(multi);
 909
 910  mresult = Curl_update_timer(multi);
 911  if(mresult)
 912    return mresult;
 913
 914  mresult = multi_assess_wakeup(multi);
 915  if(mresult) {
 916    failf(data, "error enabling wakeup listening: %d", mresult);
 917    return mresult;
 918  }
 919
 920  CURL_TRC_M(data, "removed from multi, mid=%u, running=%u, total=%u",
 921             mid, Curl_multi_xfers_running(multi),
 922             Curl_uint32_tbl_count(&multi->xfers));
 923  return CURLM_OK;
 924}
 925
 926/* Return TRUE if the application asked for multiplexing */
 927bool Curl_multiplex_wanted(const struct Curl_multi *multi)
 928{
 929  return multi && multi->multiplexing;
 930}
 931
 932/*
 933 * Curl_detach_connection() removes the given transfer from the connection.
 934 *
 935 * This is the only function that should clear data->conn. This will
 936 * occasionally be called with the data->conn pointer already cleared.
 937 */
 938void Curl_detach_connection(struct Curl_easy *data)
 939{
 940  struct connectdata *conn = data->conn;
 941  if(conn) {
 942    /* this should never happen, prevent underflow */
 943    DEBUGASSERT(conn->attached_xfers);
 944    if(conn->attached_xfers) {
 945      conn->attached_xfers--;
 946      if(!conn->attached_xfers)
 947        conn->attached_multi = NULL;
 948    }
 949  }
 950  data->conn = NULL;
 951}
 952
 953/*
 954 * Curl_attach_connection() attaches this transfer to this connection.
 955 *
 956 * This is the only function that should assign data->conn
 957 */
 958void Curl_attach_connection(struct Curl_easy *data,
 959                            struct connectdata *conn)
 960{
 961  DEBUGASSERT(data);
 962  DEBUGASSERT(!data->conn);
 963  DEBUGASSERT(conn);
 964  DEBUGASSERT(conn->attached_xfers < UINT32_MAX);
 965  data->conn = conn;
 966  conn->attached_xfers++;
 967  /* all attached transfers must be from the same multi */
 968  if(!conn->attached_multi)
 969    conn->attached_multi = data->multi;
 970  DEBUGASSERT(conn->attached_multi == data->multi);
 971
 972  if(conn->scheme && conn->scheme->run->attach)
 973    conn->scheme->run->attach(data, conn);
 974}
 975
 976/* adjust pollset for rate limits/pauses */
 977static CURLcode multi_adjust_pollset(struct Curl_easy *data,
 978                                     struct easy_pollset *ps)
 979{
 980  CURLcode result = CURLE_OK;
 981
 982  if(ps->n) {
 983    const struct curltime *pnow = Curl_pgrs_now(data);
 984    bool send_blocked, recv_blocked;
 985
 986    recv_blocked = (Curl_rlimit_avail(&data->progress.dl.rlimit, pnow) <= 0);
 987    send_blocked = (Curl_rlimit_avail(&data->progress.ul.rlimit, pnow) <= 0);
 988    if(send_blocked || recv_blocked) {
 989      int i;
 990      for(i = 0; i <= SECONDARYSOCKET; ++i) {
 991        curl_socket_t sock = data->conn->sock[i];
 992        if(sock == CURL_SOCKET_BAD)
 993          continue;
 994        if(recv_blocked && Curl_pollset_want_recv(data, ps, sock)) {
 995          result = Curl_pollset_remove_in(data, ps, sock);
 996          if(result)
 997            break;
 998        }
 999        if(send_blocked && Curl_pollset_want_send(data, ps, sock)) {
1000          result = Curl_pollset_remove_out(data, ps, sock);
1001          if(result)
1002            break;
1003        }
1004      }
1005    }
1006
1007    /* Not blocked and wanting to receive. If there is data pending
1008     * in the connection filters, make transfer run again. */
1009    if(!recv_blocked &&
1010       ((Curl_pollset_want_recv(data, ps, data->conn->sock[FIRSTSOCKET]) &&
1011         Curl_conn_data_pending(data, FIRSTSOCKET)) ||
1012        (Curl_pollset_want_recv(data, ps, data->conn->sock[SECONDARYSOCKET]) &&
1013         Curl_conn_data_pending(data, SECONDARYSOCKET)))) {
1014      CURL_TRC_M(data, "pollset[] has POLLIN, but there is still "
1015                 "buffered input -> mark as dirty");
1016      Curl_multi_mark_dirty(data);
1017    }
1018  }
1019  return result;
1020}
1021
1022static CURLcode mstate_connecting_pollset(struct Curl_easy *data,
1023                                          struct easy_pollset *ps)
1024{
1025  struct connectdata *conn = data->conn;
1026  curl_socket_t sockfd;
1027  CURLcode result = CURLE_OK;
1028
1029  if(Curl_xfer_recv_is_paused(data))
1030    return CURLE_OK;
1031  /* If a socket is set, receiving is default. If the socket
1032   * has not been determined yet (eyeballing), always ask the
1033   * connection filters for what to monitor. */
1034  sockfd = Curl_conn_get_first_socket(data);
1035  if(sockfd != CURL_SOCKET_BAD) {
1036    result = Curl_pollset_change(data, ps, sockfd, CURL_POLL_IN, 0);
1037    if(!result)
1038      result = multi_adjust_pollset(data, ps);
1039  }
1040  if(!result)
1041    result = Curl_conn_adjust_pollset(data, conn, ps);
1042  return result;
1043}
1044
1045static CURLcode mstate_protocol_pollset(struct Curl_easy *data,
1046                                        struct easy_pollset *ps)
1047{
1048  struct connectdata *conn = data->conn;
1049  CURLcode result = CURLE_OK;
1050
1051  if(conn->scheme->run->proto_pollset)
1052    result = conn->scheme->run->proto_pollset(data, ps);
1053  else {
1054    curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
1055    if(sockfd != CURL_SOCKET_BAD) {
1056      /* Default is to wait to something from the server */
1057      result = Curl_pollset_change(data, ps, sockfd, CURL_POLL_IN, 0);
1058    }
1059  }
1060  if(!result)
1061    result = multi_adjust_pollset(data, ps);
1062  if(!result)
1063    result = Curl_conn_adjust_pollset(data, conn, ps);
1064  return result;
1065}
1066
1067static CURLcode mstate_do_pollset(struct Curl_easy *data,
1068                                  struct easy_pollset *ps)
1069{
1070  struct connectdata *conn = data->conn;
1071  CURLcode result = CURLE_OK;
1072
1073  if(conn->scheme->run->doing_pollset)
1074    result = conn->scheme->run->doing_pollset(data, ps);
1075  else if(CONN_SOCK_IDX_VALID(conn->send_idx)) {
1076    /* Default is that we want to send something to the server */
1077    result = Curl_pollset_add_out(data, ps, conn->sock[conn->send_idx]);
1078  }
1079  if(!result)
1080    result = multi_adjust_pollset(data, ps);
1081  if(!result)
1082    result = Curl_conn_adjust_pollset(data, conn, ps);
1083  return result;
1084}
1085
1086static CURLcode mstate_domore_pollset(struct Curl_easy *data,
1087                                      struct easy_pollset *ps)
1088{
1089  struct connectdata *conn = data->conn;
1090  CURLcode result = CURLE_OK;
1091
1092  if(conn->scheme->run->domore_pollset)
1093    result = conn->scheme->run->domore_pollset(data, ps);
1094  else if(CONN_SOCK_IDX_VALID(conn->send_idx)) {
1095    /* Default is that we want to send something to the server */
1096    result = Curl_pollset_add_out(data, ps, conn->sock[conn->send_idx]);
1097  }
1098  if(!result)
1099    result = multi_adjust_pollset(data, ps);
1100  if(!result)
1101    result = Curl_conn_adjust_pollset(data, conn, ps);
1102  return result;
1103}
1104
1105static CURLcode mstate_perform_pollset(struct Curl_easy *data,
1106                                       struct easy_pollset *ps)
1107{
1108  struct connectdata *conn = data->conn;
1109  CURLcode result = CURLE_OK;
1110
1111  if(conn->scheme->run->perform_pollset)
1112    result = conn->scheme->run->perform_pollset(data, ps);
1113  else {
1114    /* Default is to obey the request flags for send/recv */
1115    if(Curl_req_want_recv(data) && CONN_SOCK_IDX_VALID(conn->recv_idx)) {
1116      result = Curl_pollset_add_in(data, ps, conn->sock[conn->recv_idx]);
1117    }
1118    if(!result && Curl_req_want_send(data) &&
1119       CONN_SOCK_IDX_VALID(conn->send_idx)) {
1120      result = Curl_pollset_add_out(data, ps, conn->sock[conn->send_idx]);
1121    }
1122  }
1123  if(!result)
1124    result = multi_adjust_pollset(data, ps);
1125  if(!result)
1126    result = Curl_conn_adjust_pollset(data, conn, ps);
1127  return result;
1128}
1129
1130/* Initializes `poll_set` with the current socket poll actions needed
1131 * for transfer `data`. */
1132CURLMcode Curl_multi_pollset(struct Curl_easy *data,
1133                             struct easy_pollset *ps)
1134{
1135  CURLcode result = CURLE_OK;
1136
1137  Curl_pollset_reset(ps);
1138#ifdef ENABLE_WAKEUP
1139  /* The admin handle always listens on the wakeup socket when there
1140   * are transfers alive. */
1141  if(data->multi && (data == data->multi->admin) &&
1142     data->multi->xfers_alive) {
1143    result = Curl_pollset_add_in(data, ps, data->multi->wakeup_pair[0]);
1144  }
1145#endif
1146  /* If the transfer has no connection, this is fine. Happens when
1147     called via curl_multi_remove_handle() => Curl_multi_ev_assess() =>
1148     Curl_multi_pollset(). */
1149  if(!result && data->conn) {
1150    switch(data->mstate) {
1151    case MSTATE_INIT:
1152    case MSTATE_PENDING:
1153    case MSTATE_SETUP:
1154    case MSTATE_CONNECT:
1155      /* nothing to poll for yet */
1156      break;
1157
1158    case MSTATE_CONNECTING:
1159      if(data->conn && !data->conn->bits.dns_resolved)
1160        result = Curl_resolv_pollset(data, ps);
1161      if(!result)
1162        result = mstate_connecting_pollset(data, ps);
1163      break;
1164
1165    case MSTATE_PROTOCONNECT:
1166    case MSTATE_PROTOCONNECTING:
1167      result = mstate_protocol_pollset(data, ps);
1168      break;
1169
1170    case MSTATE_DO:
1171    case MSTATE_DOING:
1172      result = mstate_do_pollset(data, ps);
1173      break;
1174
1175    case MSTATE_DOING_MORE:
1176      result = mstate_domore_pollset(data, ps);
1177      break;
1178
1179    case MSTATE_DID: /* same as PERFORMING in regard to polling */
1180    case MSTATE_PERFORMING:
1181      result = mstate_perform_pollset(data, ps);
1182      break;
1183
1184    case MSTATE_RATELIMITING:
1185      /* we need to let time pass, ignore socket(s) */
1186      break;
1187
1188    case MSTATE_DONE:
1189    case MSTATE_COMPLETED:
1190    case MSTATE_MSGSENT:
1191      /* nothing more to poll for */
1192      break;
1193
1194    default:
1195      failf(data, "multi_getsock: unexpected multi state %d", data->mstate);
1196      DEBUGASSERT(0);
1197      break;
1198    }
1199  }
1200
1201  if(result) {
1202    if(result == CURLE_OUT_OF_MEMORY)
1203      return CURLM_OUT_OF_MEMORY;
1204    failf(data, "error determining pollset: %d", result);
1205    return CURLM_INTERNAL_ERROR;
1206  }
1207
1208#ifdef CURLVERBOSE
1209  if(CURL_TRC_M_is_verbose(data)) {
1210    size_t timeout_count = Curl_llist_count(&data->state.timeoutlist);
1211    switch(ps->n) {
1212    case 0:
1213      CURL_TRC_M(data, "pollset[], timeouts=%zu, paused %d/%d (r/w)",
1214                 timeout_count,
1215                 Curl_xfer_send_is_paused(data),
1216                 Curl_xfer_recv_is_paused(data));
1217      break;
1218    case 1:
1219      CURL_TRC_M(data, "pollset[fd=%" FMT_SOCKET_T " %s%s], timeouts=%zu",
1220                 ps->sockets[0],
1221                 (ps->actions[0] & CURL_POLL_IN) ? "IN" : "",
1222                 (ps->actions[0] & CURL_POLL_OUT) ? "OUT" : "",
1223                 timeout_count);
1224      break;
1225    case 2:
1226      CURL_TRC_M(data, "pollset[fd=%" FMT_SOCKET_T " %s%s, "
1227                 "fd=%" FMT_SOCKET_T " %s%s], timeouts=%zu",
1228                 ps->sockets[0],
1229                 (ps->actions[0] & CURL_POLL_IN) ? "IN" : "",
1230                 (ps->actions[0] & CURL_POLL_OUT) ? "OUT" : "",
1231                 ps->sockets[1],
1232                 (ps->actions[1] & CURL_POLL_IN) ? "IN" : "",
1233                 (ps->actions[1] & CURL_POLL_OUT) ? "OUT" : "",
1234                 timeout_count);
1235      break;
1236    default:
1237      CURL_TRC_M(data, "pollset[fds=%u], timeouts=%zu", ps->n, timeout_count);
1238      break;
1239    }
1240    CURL_TRC_EASY_TIMERS(data);
1241  }
1242#endif
1243
1244  return CURLM_OK;
1245}
1246
1247CURLMcode curl_multi_fdset(CURLM *m,
1248                           fd_set *read_fd_set, fd_set *write_fd_set,
1249                           fd_set *exc_fd_set, int *max_fd)
1250{
1251  /* Scan through all the easy handles to get the file descriptors set.
1252     Some easy handles may not have connected to the remote host yet,
1253     and then we must make sure that is done. */
1254  int this_max_fd = -1;
1255  struct Curl_multi *multi = m;
1256  struct easy_pollset ps;
1257  unsigned int i;
1258  uint32_t mid;
1259  (void)exc_fd_set;
1260
1261  if(!GOOD_MULTI_HANDLE(multi))
1262    return CURLM_BAD_HANDLE;
1263
1264  if(multi->in_callback)
1265    return CURLM_RECURSIVE_API_CALL;
1266
1267  Curl_pollset_init(&ps);
1268  if(Curl_uint32_bset_first(&multi->process, &mid)) {
1269    do {
1270      struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
1271
1272      if(!data) {
1273        DEBUGASSERT(0);
1274        continue;
1275      }
1276
1277      Curl_multi_pollset(data, &ps);
1278      for(i = 0; i < ps.n; i++) {
1279        if(!FDSET_SOCK(ps.sockets[i]))
1280          /* pretend it does not exist */
1281          continue;
1282        if(ps.actions[i] & CURL_POLL_IN)
1283          FD_SET(ps.sockets[i], read_fd_set);
1284        if(ps.actions[i] & CURL_POLL_OUT)
1285          FD_SET(ps.sockets[i], write_fd_set);
1286        if((int)ps.sockets[i] > this_max_fd)
1287          this_max_fd = (int)ps.sockets[i];
1288      }
1289    } while(Curl_uint32_bset_next(&multi->process, mid, &mid));
1290  }
1291
1292  Curl_cshutdn_setfds(&multi->cshutdn, multi->admin,
1293                      read_fd_set, write_fd_set, &this_max_fd);
1294
1295  *max_fd = this_max_fd;
1296  Curl_pollset_cleanup(&ps);
1297
1298  return CURLM_OK;
1299}
1300
1301CURLMcode curl_multi_waitfds(CURLM *m,
1302                             struct curl_waitfd *ufds,
1303                             unsigned int size,
1304                             unsigned int *fd_count)
1305{
1306  struct Curl_waitfds cwfds;
1307  CURLMcode mresult = CURLM_OK;
1308  struct Curl_multi *multi = m;
1309  struct easy_pollset ps;
1310  unsigned int need = 0;
1311  uint32_t mid;
1312
1313  if(!ufds && (size || !fd_count))
1314    return CURLM_BAD_FUNCTION_ARGUMENT;
1315
1316  if(!GOOD_MULTI_HANDLE(multi))
1317    return CURLM_BAD_HANDLE;
1318
1319  if(multi->in_callback)
1320    return CURLM_RECURSIVE_API_CALL;
1321
1322  Curl_pollset_init(&ps);
1323  Curl_waitfds_init(&cwfds, ufds, size);
1324  if(Curl_uint32_bset_first(&multi->process, &mid)) {
1325    do {
1326      struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
1327      if(!data) {
1328        DEBUGASSERT(0);
1329        Curl_uint32_bset_remove(&multi->process, mid);
1330        Curl_uint32_bset_remove(&multi->dirty, mid);
1331        continue;
1332      }
1333      Curl_multi_pollset(data, &ps);
1334      need += Curl_waitfds_add_ps(&cwfds, &ps);
1335    } while(Curl_uint32_bset_next(&multi->process, mid, &mid));
1336  }
1337
1338  need += Curl_cshutdn_add_waitfds(&multi->cshutdn, multi->admin, &cwfds);
1339
1340  if(need != cwfds.n && ufds)
1341    mresult = CURLM_OUT_OF_MEMORY;
1342
1343  if(fd_count)
1344    *fd_count = need;
1345  Curl_pollset_cleanup(&ps);
1346  return mresult;
1347}
1348
1349#ifdef USE_WINSOCK
1350/* Reset FD_WRITE for TCP sockets. Nothing is actually sent. UDP sockets cannot
1351 * be reset this way because an empty datagram would be sent. #9203
1352 *
1353 * "On Windows the internal state of FD_WRITE as returned from
1354 * WSAEnumNetworkEvents is only reset after successful send()."
1355 */
1356static void reset_socket_fdwrite(curl_socket_t s)
1357{
1358  int t;
1359  int l = (int)sizeof(t);
1360  if(!getsockopt(s, SOL_SOCKET, SO_TYPE, (char *)&t, &l) && t == SOCK_STREAM)
1361    swrite(s, NULL, 0);
1362}
1363
1364static CURLMcode multi_winsock_select(struct Curl_multi *multi,
1365                                      struct curl_pollfds *cpfds,
1366                                      unsigned int curl_nfds,
1367                                      struct curl_waitfd extra_fds[],
1368                                      unsigned int extra_nfds,
1369                                      int timeout_ms,
1370                                      bool extrawait,
1371                                      int *pnevents)
1372{
1373  CURLMcode mresult = CURLM_OK;
1374  WSANETWORKEVENTS wsa_events;
1375  int nevents = 0;
1376  size_t i;
1377
1378  DEBUGASSERT(multi->wsa_event != WSA_INVALID_EVENT);
1379
1380  /* Set the WSA events based on the collected pollds */
1381  for(i = 0; i < cpfds->n; i++) {
1382    long mask = 0;
1383    if(cpfds->pfds[i].events & POLLIN)
1384      mask |= FD_READ | FD_ACCEPT | FD_CLOSE;
1385    if(cpfds->pfds[i].events & POLLPRI)
1386      mask |= FD_OOB;
1387    if(cpfds->pfds[i].events & POLLOUT) {
1388      mask |= FD_WRITE | FD_CONNECT | FD_CLOSE;
1389      reset_socket_fdwrite(cpfds->pfds[i].fd);
1390    }
1391    if(mask) {
1392      if(WSAEventSelect(cpfds->pfds[i].fd, multi->wsa_event, mask) != 0) {
1393        mresult = CURLM_OUT_OF_MEMORY;
1394        goto out;
1395      }
1396    }
1397  }
1398
1399  if(cpfds->n || extrawait) {
1400    int pollrc = 0;
1401
1402    if(cpfds->n) {         /* pre-check with Winsock */
1403      pollrc = Curl_poll(cpfds->pfds, cpfds->n, 0);
1404      if(pollrc < 0) {
1405        mresult = CURLM_UNRECOVERABLE_POLL;
1406        goto out;
1407      }
1408      nevents = pollrc;
1409    }
1410
1411    if(!nevents) {
1412      /* now wait... if not ready during the pre-check (pollrc == 0) */
1413      WSAWaitForMultipleEvents(1, &multi->wsa_event, FALSE, (DWORD)timeout_ms,
1414                               FALSE);
1415    }
1416
1417    /* With Winsock, we have to run the following section unconditionally
1418       to call WSAEventSelect(fd, event, 0) on all the sockets */
1419    /* copy revents results from the poll to the curl_multi_wait poll
1420       struct, the bit values of the actual underlying poll() implementation
1421       may not be the same as the ones in the public libcurl API! */
1422    for(i = 0; i < extra_nfds; i++) {
1423      unsigned short mask = 0;
1424      curl_socket_t s = extra_fds[i].fd;
1425
1426      wsa_events.lNetworkEvents = 0;
1427      if(WSAEnumNetworkEvents(s, NULL, &wsa_events) == 0) {
1428        if(wsa_events.lNetworkEvents & (FD_READ | FD_ACCEPT | FD_CLOSE))
1429          mask |= CURL_WAIT_POLLIN;
1430        if(wsa_events.lNetworkEvents & (FD_WRITE | FD_CONNECT | FD_CLOSE))
1431          mask |= CURL_WAIT_POLLOUT;
1432        if(wsa_events.lNetworkEvents & FD_OOB)
1433          mask |= CURL_WAIT_POLLPRI;
1434        if(!pollrc && wsa_events.lNetworkEvents)
1435          nevents++;
1436      }
1437      WSAEventSelect(s, multi->wsa_event, 0);
1438      if(!pollrc) {
1439        extra_fds[i].revents = (short)mask;
1440        continue;
1441      }
1442      else {
1443        unsigned r = (unsigned)cpfds->pfds[curl_nfds + i].revents;
1444        if(r & POLLIN)
1445          mask |= CURL_WAIT_POLLIN;
1446        if(r & POLLOUT)
1447          mask |= CURL_WAIT_POLLOUT;
1448        if(r & POLLPRI)
1449          mask |= CURL_WAIT_POLLPRI;
1450        extra_fds[i].revents = (short)mask;
1451      }
1452    }
1453
1454    /* Count up all our own sockets that had activity,
1455       and remove them from the event. */
1456    for(i = 0; i < curl_nfds; ++i) {
1457      wsa_events.lNetworkEvents = 0;
1458      if(WSAEnumNetworkEvents(cpfds->pfds[i].fd, NULL, &wsa_events) == 0) {
1459        if(!pollrc && wsa_events.lNetworkEvents)
1460          nevents++;
1461      }
1462      WSAEventSelect(cpfds->pfds[i].fd, multi->wsa_event, 0);
1463    }
1464    WSAResetEvent(multi->wsa_event);
1465  }
1466
1467out:
1468  *pnevents = nevents;
1469  return mresult;
1470}
1471
1472#else /* USE_WINSOCK */
1473
1474static CURLMcode multi_posix_poll(struct Curl_multi *multi,
1475                                  struct curl_pollfds *cpfds,
1476                                  unsigned int curl_nfds,
1477                                  struct curl_waitfd extra_fds[],
1478                                  unsigned int extra_nfds,
1479                                  int timeout_ms,
1480                                  bool extrawait,
1481                                  int *pnevents)
1482{
1483  CURLMcode mresult = CURLM_OK;
1484  int nevents = 0;
1485  size_t i;
1486
1487  (void)multi;
1488  if(cpfds->n) {
1489    int pollrc = Curl_poll(cpfds->pfds, cpfds->n, timeout_ms); /* wait... */
1490    if(pollrc < 0) {
1491      mresult = CURLM_UNRECOVERABLE_POLL;
1492      goto out;
1493    }
1494    nevents = pollrc;
1495
1496    /* copy revents results from the poll to the curl_multi_wait poll
1497       struct, the bit values of the actual underlying poll() implementation
1498       may not be the same as the ones in the public libcurl API! */
1499    for(i = 0; i < extra_nfds; i++) {
1500      unsigned r = (unsigned)cpfds->pfds[curl_nfds + i].revents;
1501      unsigned short mask = 0;
1502      if(r & POLLIN)
1503        mask |= CURL_WAIT_POLLIN;
1504      if(r & POLLOUT)
1505        mask |= CURL_WAIT_POLLOUT;
1506      if(r & POLLPRI)
1507        mask |= CURL_WAIT_POLLPRI;
1508      extra_fds[i].revents = (short)mask;
1509    }
1510  }
1511  else if(extrawait) {
1512    /* No fds to poll, but asked to obey timeout_ms anyway. We cannot
1513     * use Curl_poll() as it, on some platforms, returns immediately
1514     * without fds. */
1515    curlx_wait_ms(timeout_ms);
1516  }
1517
1518out:
1519  *pnevents = nevents;
1520  return mresult;
1521}
1522
1523#endif /* !USE_WINSOCK */
1524
1525#define NUM_POLLS_ON_STACK 10
1526
1527static CURLMcode multi_wait(struct Curl_multi *multi,
1528                            struct curl_waitfd extra_fds[],
1529                            unsigned int extra_nfds,
1530                            int timeout_ms,
1531                            int *ret,
1532                            bool extrawait)  /* when no socket, wait */
1533{
1534  size_t i;
1535  struct curltime expire_time;
1536  long timeout_internal;
1537  int nevents = 0;
1538  struct easy_pollset ps;
1539  struct pollfd a_few_on_stack[NUM_POLLS_ON_STACK];
1540  struct curl_pollfds cpfds;
1541  unsigned int curl_nfds = 0; /* how many pfds are for curl transfers */
1542  struct Curl_easy *data = NULL;
1543  CURLMcode mresult = CURLM_OK;
1544  uint32_t mid;
1545#ifdef ENABLE_WAKEUP
1546  int wakeup_idx = -1;
1547#endif
1548
1549  if(!GOOD_MULTI_HANDLE(multi))
1550    return CURLM_BAD_HANDLE;
1551
1552  if(multi->in_callback)
1553    return CURLM_RECURSIVE_API_CALL;
1554
1555  if(timeout_ms < 0)
1556    return CURLM_BAD_FUNCTION_ARGUMENT;
1557
1558  Curl_pollset_init(&ps);
1559  Curl_pollfds_init(&cpfds, a_few_on_stack, NUM_POLLS_ON_STACK);
1560
1561  /* Add the curl handles to our pollfds first */
1562  if(Curl_uint32_bset_first(&multi->process, &mid)) {
1563    do {
1564      data = Curl_multi_get_easy(multi, mid);
1565      if(!data) {
1566        DEBUGASSERT(0);
1567        Curl_uint32_bset_remove(&multi->process, mid);
1568        Curl_uint32_bset_remove(&multi->dirty, mid);
1569        continue;
1570      }
1571      Curl_multi_pollset(data, &ps);
1572      if(Curl_pollfds_add_ps(&cpfds, &ps)) {
1573        mresult = CURLM_OUT_OF_MEMORY;
1574        goto out;
1575      }
1576    } while(Curl_uint32_bset_next(&multi->process, mid, &mid));
1577  }
1578
1579  if(Curl_cshutdn_add_pollfds(&multi->cshutdn, multi->admin, &cpfds)) {
1580    mresult = CURLM_OUT_OF_MEMORY;
1581    goto out;
1582  }
1583
1584#ifdef ENABLE_WAKEUP
1585  /* If `extrawait` is TRUE *or* we have `extra_fds`to poll *or* we
1586   * have transfer sockets to poll, we obey `timeout_ms`.
1587   * Then we need to also monitor the multi's wakeup
1588   * socket to catch calls to `curl_multi_wakeup()` during the wait. */
1589  if(extrawait || cpfds.n || extra_nfds) {
1590    wakeup_idx = cpfds.n;
1591    if(Curl_pollfds_add_sock(&cpfds, multi->wakeup_pair[0], POLLIN)) {
1592      mresult = CURLM_OUT_OF_MEMORY;
1593      goto out;
1594    }
1595  }
1596#endif
1597
1598  curl_nfds = cpfds.n; /* what curl internally uses in cpfds */
1599  /* Add external file descriptions from poll-like struct curl_waitfd */
1600  for(i = 0; i < extra_nfds; i++) {
1601    unsigned short events = 0;
1602    if(extra_fds[i].events & CURL_WAIT_POLLIN)
1603      events |= POLLIN;
1604    if(extra_fds[i].events & CURL_WAIT_POLLPRI)
1605      events |= POLLPRI;
1606    if(extra_fds[i].events & CURL_WAIT_POLLOUT)
1607      events |= POLLOUT;
1608    if(Curl_pollfds_add_sock(&cpfds, extra_fds[i].fd, events)) {
1609      mresult = CURLM_OUT_OF_MEMORY;
1610      goto out;
1611    }
1612  }
1613
1614  /* We check the internal timeout *AFTER* we collected all sockets to
1615   * poll. Collecting the sockets may install new timers by protocols
1616   * and connection filters.
1617   * Use the shorter one of the internal and the caller requested timeout.
1618   * If we are called with `!extrawait` and multi_timeout() reports no
1619   * timeouts exist, do not wait. */
1620  multi_timeout(multi, &expire_time, &timeout_internal);
1621  if((timeout_internal >= 0) && (timeout_internal < (long)timeout_ms))
1622    timeout_ms = (int)timeout_internal;
1623
1624  if(data)
1625    CURL_TRC_M(data, "multi_wait(fds=%u, timeout=%d) tinternal=%ld",
1626               cpfds.n, timeout_ms, timeout_internal);
1627
1628#ifdef USE_WINSOCK
1629  mresult = multi_winsock_select(multi, &cpfds, curl_nfds,
1630                                 extra_fds, extra_nfds,
1631                                 timeout_ms, extrawait, &nevents);
1632#else
1633  mresult = multi_posix_poll(multi, &cpfds, curl_nfds,
1634                             extra_fds, extra_nfds,
1635                             timeout_ms, extrawait, &nevents);
1636#endif
1637
1638#ifdef ENABLE_WAKEUP
1639    if(nevents && (wakeup_idx >= 0)) {
1640      if(cpfds.pfds[wakeup_idx].revents & POLLIN) {
1641        (void)Curl_wakeup_consume(multi->wakeup_pair, TRUE);
1642        /* do not count the wakeup socket into the returned value */
1643        nevents--;
1644      }
1645    }
1646#endif
1647
1648out:
1649  Curl_pollset_cleanup(&ps);
1650  Curl_pollfds_cleanup(&cpfds);
1651  if(ret)
1652    *ret = nevents;
1653  return mresult;
1654}
1655
1656CURLMcode curl_multi_wait(CURLM *m,
1657                          struct curl_waitfd extra_fds[],
1658                          unsigned int extra_nfds,
1659                          int timeout_ms,
1660                          int *ret)
1661{
1662  return multi_wait(m, extra_fds, extra_nfds, timeout_ms, ret, FALSE);
1663}
1664
1665CURLMcode curl_multi_poll(CURLM *m,
1666                          struct curl_waitfd extra_fds[],
1667                          unsigned int extra_nfds,
1668                          int timeout_ms,
1669                          int *ret)
1670{
1671  return multi_wait(m, extra_fds, extra_nfds, timeout_ms, ret, TRUE);
1672}
1673
1674CURLMcode curl_multi_wakeup(CURLM *m)
1675{
1676  /* this function is usually called from another thread,
1677     it has to be careful only to access parts of the
1678     Curl_multi struct that are constant */
1679  struct Curl_multi *multi = m;
1680  CURLMcode mresult = CURLM_WAKEUP_FAILURE;
1681
1682  /* GOOD_MULTI_HANDLE can be safely called */
1683  if(!GOOD_MULTI_HANDLE(multi))
1684    return CURLM_BAD_HANDLE;
1685
1686#ifdef ENABLE_WAKEUP
1687  /* the wakeup_pair variable is only written during init and cleanup,
1688     making it safe to access from another thread after the init part
1689     and before cleanup */
1690  if(!Curl_wakeup_signal(multi->wakeup_pair))
1691    mresult = CURLM_OK;
1692#endif
1693#ifdef USE_WINSOCK
1694  if(WSASetEvent(multi->wsa_event))
1695    mresult = CURLM_OK;
1696#endif
1697  return mresult;
1698}
1699
1700/*
1701 * multi_ischanged() is called
1702 *
1703 * Returns TRUE/FALSE whether the state is changed to trigger a CONNECT_PEND
1704 * => CONNECT action.
1705 *
1706 * Set 'clear' to TRUE to have it also clear the state variable.
1707 */
1708static bool multi_ischanged(struct Curl_multi *multi, bool clear)
1709{
1710  bool retval = (bool)multi->recheckstate;
1711  if(clear)
1712    multi->recheckstate = FALSE;
1713  return retval;
1714}
1715
1716/*
1717 * Curl_multi_connchanged() is called to tell that there is a connection in
1718 * this multi handle that has changed state (multiplexing become possible, the
1719 * number of allowed streams changed or similar), and a subsequent use of this
1720 * multi handle should move CONNECT_PEND handles back to CONNECT to have them
1721 * retry.
1722 */
1723void Curl_multi_connchanged(struct Curl_multi *multi)
1724{
1725  multi->recheckstate = TRUE;
1726}
1727
1728CURLMcode Curl_multi_add_perform(struct Curl_multi *multi,
1729                                 struct Curl_easy *data,
1730                                 struct connectdata *conn)
1731{
1732  CURLMcode mresult;
1733
1734  if(multi->in_callback)
1735    return CURLM_RECURSIVE_API_CALL;
1736
1737  mresult = curl_multi_add_handle(multi, data);
1738  if(!mresult) {
1739    CURLcode result;
1740
1741    /* pass in NULL for 'conn' here since we do not want to init the
1742       connection, only this transfer */
1743    result = Curl_init_do(data, NULL);
1744    if(result) {
1745      curl_multi_remove_handle(multi, data);
1746      return CURLM_INTERNAL_ERROR;
1747    }
1748
1749    /* take this handle to the perform state right away */
1750    multistate(data, MSTATE_PERFORMING);
1751    Curl_attach_connection(data, conn);
1752    CURL_REQ_SET_RECV(data);
1753  }
1754  return mresult;
1755}
1756
1757static CURLcode multi_do(struct Curl_easy *data, bool *done)
1758{
1759  CURLcode result = CURLE_OK;
1760  struct connectdata *conn = data->conn;
1761
1762  DEBUGASSERT(conn);
1763  DEBUGASSERT(conn->scheme);
1764
1765  if(conn->scheme->run->do_it)
1766    result = conn->scheme->run->do_it(data, done);
1767
1768  return result;
1769}
1770
1771/*
1772 * multi_do_more() is called during the DO_MORE multi state. It is a second
1773 * stage DO state which (wrongly) was introduced to support FTP's second
1774 * connection.
1775 *
1776 * 'complete' can return DOMORE_INCOMPLETE, DOMORE_DONE or DOMORE_GOBACK
1777 * (to DOING state when there is more work to do)
1778 */
1779
1780static CURLcode multi_do_more(struct Curl_easy *data, domore *complete)
1781{
1782  CURLcode result = CURLE_OK;
1783  struct connectdata *conn = data->conn;
1784
1785  *complete = DOMORE_INCOMPLETE;
1786
1787  if(conn->scheme->run->do_more)
1788    result = conn->scheme->run->do_more(data, complete);
1789
1790  return result;
1791}
1792
1793/*
1794 * Check whether a timeout occurred, and handle it if it did
1795 */
1796static bool multi_handle_timeout(struct Curl_easy *data,
1797                                 bool *stream_error,
1798                                 CURLcode *result)
1799{
1800  timediff_t timeout_ms;
1801
1802  timeout_ms = Curl_timeleft_ms(data);
1803  if(timeout_ms < 0) {
1804    /* Handle timed out */
1805    struct curltime since;
1806    if(Curl_is_connecting(data))
1807      since = data->progress.t_startsingle;
1808    else
1809      since = data->progress.t_startop;
1810    if(data->mstate == MSTATE_CONNECTING)
1811      failf(data, "%s timed out after %" FMT_TIMEDIFF_T " milliseconds",
1812            data->conn->bits.dns_resolved ? "Connection" : "Resolving",
1813            curlx_ptimediff_ms(Curl_pgrs_now(data), &since));
1814    else {
1815      struct SingleRequest *k = &data->req;
1816      if(k->size != -1) {
1817        failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
1818              " milliseconds with %" FMT_OFF_T " out of %"
1819              FMT_OFF_T " bytes received",
1820              curlx_ptimediff_ms(Curl_pgrs_now(data), &since),
1821              k->bytecount, k->size);
1822      }
1823      else {
1824        failf(data, "Operation timed out after %" FMT_TIMEDIFF_T
1825              " milliseconds with %" FMT_OFF_T " bytes received",
1826              curlx_ptimediff_ms(Curl_pgrs_now(data), &since),
1827              k->bytecount);
1828      }
1829    }
1830    *result = CURLE_OPERATION_TIMEDOUT;
1831    if(data->conn) {
1832      /* Force connection closed if the connection has indeed been used */
1833      if(data->mstate > MSTATE_DO) {
1834        streamclose(data->conn, "Disconnect due to timeout");
1835        *stream_error = TRUE;
1836      }
1837      (void)multi_done(data, *result, TRUE);
1838    }
1839    return TRUE;
1840  }
1841
1842  return FALSE;
1843}
1844
1845/*
1846 * We are doing protocol-specific connecting and this is being called over and
1847 * over from the multi interface until the connection phase is done on
1848 * protocol layer.
1849 */
1850
1851static CURLcode protocol_connecting(struct Curl_easy *data, bool *done)
1852{
1853  CURLcode result = CURLE_OK;
1854  struct connectdata *conn = data->conn;
1855
1856  if(conn && conn->scheme->run->connecting) {
1857    *done = FALSE;
1858    result = conn->scheme->run->connecting(data, done);
1859  }
1860  else
1861    *done = TRUE;
1862
1863  return result;
1864}
1865
1866/*
1867 * We are DOING this is being called over and over from the multi interface
1868 * until the DOING phase is done on protocol layer.
1869 */
1870
1871static CURLcode protocol_doing(struct Curl_easy *data, bool *done)
1872{
1873  CURLcode result = CURLE_OK;
1874  struct connectdata *conn = data->conn;
1875
1876  if(conn && conn->scheme->run->doing) {
1877    *done = FALSE;
1878    result = conn->scheme->run->doing(data, done);
1879  }
1880  else
1881    *done = TRUE;
1882
1883  return result;
1884}
1885
1886/*
1887 * We have discovered that the TCP connection has been successful, we can now
1888 * proceed with some action.
1889 *
1890 */
1891static CURLcode protocol_connect(struct Curl_easy *data, bool *protocol_done)
1892{
1893  struct connectdata *conn = data->conn;
1894  CURLcode result = CURLE_OK;
1895
1896  DEBUGASSERT(conn);
1897  DEBUGASSERT(protocol_done);
1898  DEBUGASSERT(Curl_conn_is_connected(conn, FIRSTSOCKET));
1899
1900  *protocol_done = FALSE;
1901  if(!conn->bits.protoconnstart) {
1902    if(conn->scheme->run->connect_it) {
1903      /* Call the protocol-specific connect function */
1904      result = conn->scheme->run->connect_it(data, protocol_done);
1905      if(result)
1906        return result;
1907    }
1908    conn->bits.protoconnstart = TRUE;
1909  }
1910
1911  /* Unless this protocol does not have any protocol-connect callback, as
1912     then we know we are done. */
1913  if(!conn->scheme->run->connecting)
1914    *protocol_done = TRUE;
1915  return CURLE_OK;
1916}
1917
1918static void set_in_callback(struct Curl_multi *multi, bool value)
1919{
1920  multi->in_callback = value;
1921}
1922
1923/*
1924 * posttransfer() is called immediately after a transfer ends
1925 */
1926static void multi_posttransfer(struct Curl_easy *data)
1927{
1928#if defined(HAVE_SIGNAL) && defined(SIGPIPE) && !defined(MSG_NOSIGNAL)
1929  /* restore the signal handler for SIGPIPE before we get back */
1930  if(!data->set.no_signal)
1931    signal(SIGPIPE, data->state.prev_signal);
1932#else
1933  (void)data;
1934#endif
1935}
1936
1937/*
1938 * multi_follow() handles the URL redirect magic. Pass in the 'newurl' string
1939 * as given by the remote server and set up the new URL to request.
1940 *
1941 * This function DOES NOT FREE the given URL.
1942 */
1943static CURLcode multi_follow(struct Curl_easy *data,
1944                             const struct Curl_scheme *handler,
1945                             const char *newurl, /* the Location: string */
1946                             followtype type) /* see transfer.h */
1947{
1948  if(handler && handler->run->follow)
1949    return handler->run->follow(data, newurl, type);
1950
1951  if(type == FOLLOW_RETRY)
1952    /* Retries are generic and do not require protocol-specific redirect
1953       handling. */
1954    return CURLE_OK;
1955
1956  return CURLE_TOO_MANY_REDIRECTS;
1957}
1958
1959static CURLcode mspeed_check(struct Curl_easy *data)
1960{
1961  if(Curl_rlimit_active(&data->progress.dl.rlimit) ||
1962     Curl_rlimit_active(&data->progress.ul.rlimit)) {
1963    /* check if our send/recv limits require idle waits */
1964    const struct curltime *pnow = Curl_pgrs_now(data);
1965    timediff_t recv_ms, send_ms;
1966
1967    send_ms = Curl_rlimit_wait_ms(&data->progress.ul.rlimit, pnow);
1968    recv_ms = Curl_rlimit_wait_ms(&data->progress.dl.rlimit, pnow);
1969
1970    if(send_ms || recv_ms) {
1971      if(data->mstate != MSTATE_RATELIMITING) {
1972        multistate(data, MSTATE_RATELIMITING);
1973      }
1974      Curl_expire(data, CURLMAX(send_ms, recv_ms), EXPIRE_TOOFAST);
1975      Curl_multi_clear_dirty(data);
1976      CURL_TRC_M(data, "[RLIMIT] waiting %" FMT_TIMEDIFF_T "ms",
1977                 CURLMAX(send_ms, recv_ms));
1978      return CURLE_AGAIN;
1979    }
1980    else {
1981      /* when will the rate limits increase next? The transfer needs
1982       * to run again at that time or it may stall. */
1983      send_ms = Curl_rlimit_next_step_ms(&data->progress.ul.rlimit, pnow);
1984      recv_ms = Curl_rlimit_next_step_ms(&data->progress.dl.rlimit, pnow);
1985      if(send_ms || recv_ms) {
1986        timediff_t next_ms = CURLMIN(send_ms, recv_ms);
1987        if(!next_ms)
1988          next_ms = CURLMAX(send_ms, recv_ms);
1989        Curl_expire(data, next_ms, EXPIRE_TOOFAST);
1990        CURL_TRC_M(data, "[RLIMIT] next token update in %" FMT_TIMEDIFF_T "ms",
1991                   next_ms);
1992      }
1993    }
1994  }
1995
1996  if(data->mstate != MSTATE_PERFORMING) {
1997    CURL_TRC_M(data, "[RLIMIT] wait over, continue");
1998    multistate(data, MSTATE_PERFORMING);
1999  }
2000  return CURLE_OK;
2001}
2002
2003static CURLMcode multistate_performing(struct Curl_easy *data,
2004                                       bool *stream_errorp,
2005                                       CURLcode *resultp)
2006{
2007  char *newurl = NULL;
2008  bool retry = FALSE;
2009  CURLMcode mresult = CURLM_OK;
2010  CURLcode result = *resultp = CURLE_OK;
2011  *stream_errorp = FALSE;
2012
2013  if(mspeed_check(data) == CURLE_AGAIN)
2014    return CURLM_OK;
2015
2016  /* read/write data if it is ready to do so */
2017  result = Curl_sendrecv(data);
2018
2019  if(data->req.done || (result == CURLE_RECV_ERROR)) {
2020    /* If CURLE_RECV_ERROR happens early enough, we assume it was a race
2021     * condition and the server closed the reused connection exactly when we
2022     * wanted to use it, so figure out if that is indeed the case.
2023     */
2024    CURLcode ret = Curl_retry_request(data, &newurl);
2025    if(!ret)
2026      retry = !!newurl;
2027    else if(!result)
2028      result = ret;
2029
2030    if(retry) {
2031      /* if we are to retry, set the result to OK and consider the
2032         request as done */
2033      result = CURLE_OK;
2034      data->req.done = TRUE;
2035    }
2036  }
2037#ifndef CURL_DISABLE_HTTP
2038  else if((result == CURLE_HTTP2_STREAM) &&
2039          Curl_h2_http_1_1_error(data)) {
2040    CURLcode ret = Curl_retry_request(data, &newurl);
2041
2042    if(!ret) {
2043      infof(data, "Downgrades to HTTP/1.1");
2044      streamclose(data->conn, "Disconnect HTTP/2 for HTTP/1");
2045      data->state.http_neg.wanted = CURL_HTTP_V1x;
2046      data->state.http_neg.allowed = CURL_HTTP_V1x;
2047      /* clear the error message bit too as we ignore the one we got */
2048      data->state.errorbuf = FALSE;
2049      if(!newurl)
2050        /* typically for HTTP_1_1_REQUIRED error on first flight */
2051        newurl = Curl_bufref_dup(&data->state.url);
2052      if(!newurl) {
2053        result = CURLE_OUT_OF_MEMORY;
2054      }
2055      else {
2056        /* if we are to retry, set the result to OK and consider the request
2057          as done */
2058        retry = TRUE;
2059        result = CURLE_OK;
2060        data->req.done = TRUE;
2061      }
2062    }
2063    else
2064      result = ret;
2065  }
2066#endif
2067
2068  if(result) {
2069    /*
2070     * The transfer phase returned error, we mark the connection to get closed
2071     * to prevent being reused. This is because we cannot possibly know if the
2072     * connection is in a good shape or not now. Unless it is a protocol which
2073     * uses two "channels" like FTP, as then the error happened in the data
2074     * connection.
2075     */
2076
2077    if(!(data->conn->scheme->flags & PROTOPT_DUAL) &&
2078       result != CURLE_HTTP2_STREAM)
2079      streamclose(data->conn, "Transfer returned error");
2080
2081    multi_posttransfer(data);
2082    multi_done(data, result, TRUE);
2083  }
2084  else if(data->req.done && !Curl_cwriter_is_paused(data)) {
2085    const struct Curl_scheme *handler = data->conn->scheme;
2086
2087    /* call this even if the readwrite function returned error */
2088    multi_posttransfer(data);
2089
2090    /* When we follow redirects or is set to retry the connection, we must to
2091       go back to the CONNECT state */
2092    if(data->req.newurl || retry) {
2093      followtype follow = FOLLOW_NONE;
2094      if(!retry) {
2095        /* if the URL is a follow-location and not a retried request then
2096           figure out the URL here */
2097        curlx_free(newurl);
2098        newurl = data->req.newurl;
2099        data->req.newurl = NULL;
2100        follow = FOLLOW_REDIR;
2101      }
2102      else
2103        follow = FOLLOW_RETRY;
2104      (void)multi_done(data, CURLE_OK, FALSE);
2105      /* multi_done() might return CURLE_GOT_NOTHING */
2106      result = multi_follow(data, handler, newurl, follow);
2107      if(!result) {
2108        multistate(data, MSTATE_SETUP);
2109        mresult = CURLM_CALL_MULTI_PERFORM;
2110      }
2111    }
2112    else {
2113      /* after the transfer is done, go DONE */
2114
2115      /* but first check to see if we got a location info even though we are
2116         not following redirects */
2117      if(data->req.location) {
2118        curlx_free(newurl);
2119        newurl = data->req.location;
2120        data->req.location = NULL;
2121        result = multi_follow(data, handler, newurl, FOLLOW_FAKE);
2122        if(result) {
2123          *stream_errorp = TRUE;
2124          result = multi_done(data, result, TRUE);
2125        }
2126      }
2127
2128      if(!result) {
2129        multistate(data, MSTATE_DONE);
2130        mresult = CURLM_CALL_MULTI_PERFORM;
2131      }
2132    }
2133  }
2134  else { /* not errored, not done */
2135    mspeed_check(data);
2136  }
2137  curlx_free(newurl);
2138  *resultp = result;
2139  return mresult;
2140}
2141
2142static CURLMcode multistate_do(struct Curl_easy *data,
2143                               bool *stream_errorp,
2144                               CURLcode *resultp)
2145{
2146  CURLMcode mresult = CURLM_OK;
2147  CURLcode result = CURLE_OK;
2148  if(data->set.fprereq) {
2149    int prereq_rc;
2150
2151    /* call the prerequest callback function */
2152    Curl_set_in_callback(data, TRUE);
2153    prereq_rc = data->set.fprereq(data->set.prereq_userp,
2154                                  data->info.primary.remote_ip,
2155                                  data->info.primary.local_ip,
2156                                  data->info.primary.remote_port,
2157                                  data->info.primary.local_port);
2158    Curl_set_in_callback(data, FALSE);
2159    if(prereq_rc != CURL_PREREQFUNC_OK) {
2160      failf(data, "operation aborted by pre-request callback");
2161      /* failure in pre-request callback - do not do any other processing */
2162      result = CURLE_ABORTED_BY_CALLBACK;
2163      multi_posttransfer(data);
2164      multi_done(data, result, FALSE);
2165      *stream_errorp = TRUE;
2166      goto end;
2167    }
2168  }
2169
2170  if(data->set.connect_only && !data->set.connect_only_ws) {
2171    multistate(data, MSTATE_DONE);
2172    mresult = CURLM_CALL_MULTI_PERFORM;
2173  }
2174  else {
2175    bool dophase_done = FALSE;
2176    /* Perform the protocol's DO action */
2177    result = multi_do(data, &dophase_done);
2178
2179    /* When multi_do() returns failure, data->conn might be NULL! */
2180
2181    if(!result) {
2182      if(!dophase_done) {
2183#ifndef CURL_DISABLE_FTP
2184        /* some steps needed for wildcard matching */
2185        if(data->state.wildcardmatch) {
2186          struct WildcardData *wc = data->wildcard;
2187          if(wc->state == CURLWC_DONE || wc->state == CURLWC_SKIP) {
2188            /* skip some states if it is important */
2189            multi_done(data, CURLE_OK, FALSE);
2190
2191            /* if there is no connection left, skip the DONE state */
2192            multistate(data, data->conn ? MSTATE_DONE : MSTATE_COMPLETED);
2193            mresult = CURLM_CALL_MULTI_PERFORM;
2194            goto end;
2195          }
2196        }
2197#endif
2198        /* DO was not completed in one function call, we must continue
2199           DOING... */
2200        multistate(data, MSTATE_DOING);
2201        mresult = CURLM_CALL_MULTI_PERFORM;
2202      }
2203
2204      /* after DO, go DO_DONE... or DO_MORE */
2205      else if(data->conn->bits.do_more) {
2206        /* we are supposed to do more, but we need to sit down, relax and wait
2207           a little while first */
2208        multistate(data, MSTATE_DOING_MORE);
2209        mresult = CURLM_CALL_MULTI_PERFORM;
2210      }
2211      else {
2212        /* we are done with the DO, now DID */
2213        multistate(data, MSTATE_DID);
2214        mresult = CURLM_CALL_MULTI_PERFORM;
2215      }
2216    }
2217    else if((result == CURLE_SEND_ERROR) &&
2218            data->conn->bits.reuse) {
2219      /*
2220       * In this situation, a connection that we were trying to use may have
2221       * unexpectedly died. If possible, send the connection back to the
2222       * CONNECT phase so we can try again.
2223       */
2224      const struct Curl_scheme *handler = data->conn->scheme;
2225      char *newurl = NULL;
2226      followtype follow = FOLLOW_NONE;
2227      CURLcode drc;
2228
2229      drc = Curl_retry_request(data, &newurl);
2230      if(drc) {
2231        /* a failure here pretty much implies an out of memory */
2232        result = drc;
2233        *stream_errorp = TRUE;
2234      }
2235
2236      multi_posttransfer(data);
2237      drc = multi_done(data, result, FALSE);
2238
2239      /* When set to retry the connection, we must go back to the CONNECT
2240       * state */
2241      if(newurl) {
2242        if(!drc || (drc == CURLE_SEND_ERROR)) {
2243          follow = FOLLOW_RETRY;
2244          drc = multi_follow(data, handler, newurl, follow);
2245          if(!drc) {
2246            multistate(data, MSTATE_SETUP);
2247            mresult = CURLM_CALL_MULTI_PERFORM;
2248            result = CURLE_OK;
2249          }
2250          else {
2251            /* Follow failed */
2252            result = drc;
2253          }
2254        }
2255        else {
2256          /* done did not return OK or SEND_ERROR */
2257          result = drc;
2258        }
2259      }
2260      else {
2261        /* Have error handler disconnect conn if we cannot retry */
2262        *stream_errorp = TRUE;
2263      }
2264      curlx_free(newurl);
2265    }
2266    else {
2267      /* failure detected */
2268      multi_posttransfer(data);
2269      if(data->conn)
2270        multi_done(data, result, FALSE);
2271      *stream_errorp = TRUE;
2272    }
2273  }
2274end:
2275  *resultp = result;
2276  return mresult;
2277}
2278
2279static CURLMcode multistate_ratelimiting(struct Curl_easy *data,
2280                                         CURLcode *resultp)
2281{
2282  CURLcode result = CURLE_OK;
2283  CURLMcode mresult = CURLM_OK;
2284  DEBUGASSERT(data->conn);
2285  /* if both rates are within spec, resume transfer */
2286  result = Curl_pgrsCheck(data);
2287
2288  if(result) {
2289    if(!(data->conn->scheme->flags & PROTOPT_DUAL) &&
2290       result != CURLE_HTTP2_STREAM)
2291      streamclose(data->conn, "Transfer returned error");
2292
2293    multi_posttransfer(data);
2294    multi_done(data, result, TRUE);
2295  }
2296  else {
2297    if(!mspeed_check(data))
2298      mresult = CURLM_CALL_MULTI_PERFORM;
2299  }
2300  *resultp = result;
2301  return mresult;
2302}
2303
2304static CURLMcode multistate_connect(struct Curl_multi *multi,
2305                                    struct Curl_easy *data,
2306                                    CURLcode *resultp)
2307{
2308  /* Connect. We want to get a connection identifier filled in. This state can
2309     be entered from SETUP and from PENDING. */
2310  bool connected;
2311  CURLMcode mresult = CURLM_OK;
2312  CURLcode result = Curl_connect(data, &connected);
2313  if(result == CURLE_NO_CONNECTION_AVAILABLE) {
2314    /* There was no connection available. We will go to the pending state and
2315       wait for an available connection. */
2316    multistate(data, MSTATE_PENDING);
2317    /* move from process to pending set */
2318    Curl_uint32_bset_remove(&multi->process, data->mid);
2319    Curl_uint32_bset_remove(&multi->dirty, data->mid);
2320    Curl_uint32_bset_add(&multi->pending, data->mid);
2321    *resultp = CURLE_OK;
2322    return mresult;
2323  }
2324  else
2325    process_pending_handles(data->multi);
2326
2327  if(!result) {
2328    /* after the connect has been sent off, go WAITCONNECT unless the
2329       protocol connect is already done and we can go directly to WAITDO or
2330       DO! */
2331    mresult = CURLM_CALL_MULTI_PERFORM;
2332
2333    if(connected) {
2334      if(!data->conn->bits.reuse &&
2335         Curl_conn_is_multiplex(data->conn, FIRSTSOCKET)) {
2336        /* new connection, can multiplex, wake pending handles */
2337        process_pending_handles(data->multi);
2338      }
2339      multistate(data, MSTATE_PROTOCONNECT);
2340    }
2341    else {
2342      multistate(data, MSTATE_CONNECTING);
2343    }
2344  }
2345  *resultp = result;
2346  return mresult;
2347}
2348
2349/* returns the possibly updated result */
2350static CURLcode is_finished(struct Curl_multi *multi,
2351                            struct Curl_easy *data,
2352                            bool stream_error,
2353                            CURLcode result)
2354{
2355  if(data->mstate < MSTATE_COMPLETED) {
2356    if(result) {
2357      /*
2358       * If an error was returned, and we are not in completed state now,
2359       * then we go to completed and consider this transfer aborted.
2360       */
2361
2362      /* No attempt to disconnect connections must be made before this -
2363         connection detach and termination happens only here */
2364
2365      /* Check if we can move pending requests to send pipe */
2366      process_pending_handles(multi); /* connection */
2367
2368      if(data->conn) {
2369        if(stream_error) {
2370          /* Do not attempt to send data over a connection that timed out */
2371          bool dead_connection = result == CURLE_OPERATION_TIMEDOUT;
2372          struct connectdata *conn = data->conn;
2373
2374          /* This is where we make sure that the conn pointer is reset.
2375             We do not have to do this in every case block above where a
2376             failure is detected */
2377          Curl_detach_connection(data);
2378          Curl_conn_terminate(data, conn, dead_connection);
2379        }
2380      }
2381      else if(data->mstate == MSTATE_CONNECT) {
2382        /* Curl_connect() failed */
2383        multi_posttransfer(data);
2384        Curl_pgrsUpdate_nometer(data);
2385      }
2386
2387      multistate(data, MSTATE_COMPLETED);
2388      return result;
2389    }
2390    /* if there is still a connection to use, call the progress function */
2391    else if(data->conn && Curl_conn_is_connected(data->conn, FIRSTSOCKET)) {
2392      result = Curl_pgrsUpdate(data);
2393      if(result) {
2394        /* aborted due to progress callback return code must close the
2395           connection */
2396        streamclose(data->conn, "Aborted by callback");
2397
2398        /* if not yet in DONE state, go there, otherwise COMPLETED */
2399        multistate(data, (data->mstate < MSTATE_DONE) ?
2400                   MSTATE_DONE : MSTATE_COMPLETED);
2401        return result;
2402      }
2403    }
2404  }
2405  return result;
2406}
2407
2408static void handle_completed(struct Curl_multi *multi,
2409                             struct Curl_easy *data,
2410                             CURLcode result)
2411{
2412  if(data->master_mid != UINT32_MAX) {
2413    /* A sub transfer, not for msgsent to application */
2414    struct Curl_easy *mdata;
2415
2416    CURL_TRC_M(data, "sub xfer done for master %u", data->master_mid);
2417    mdata = Curl_multi_get_easy(multi, data->master_mid);
2418    if(mdata) {
2419      if(mdata->sub_xfer_done)
2420        mdata->sub_xfer_done(mdata, data, result);
2421      else
2422        CURL_TRC_M(data, "master easy %u without sub_xfer_done callback.",
2423                   data->master_mid);
2424    }
2425    else {
2426      CURL_TRC_M(data, "master easy %u already gone.", data->master_mid);
2427    }
2428  }
2429  else {
2430    /* now fill in the Curl_message with this info */
2431    struct Curl_message *msg = &data->msg;
2432
2433    msg->extmsg.msg = CURLMSG_DONE;
2434    msg->extmsg.easy_handle = data;
2435    msg->extmsg.data.result = result;
2436
2437    multi_addmsg(multi, msg);
2438    DEBUGASSERT(!data->conn);
2439  }
2440  multistate(data, MSTATE_MSGSENT);
2441
2442  /* remove from the other sets, add to msgsent */
2443  Curl_uint32_bset_remove(&multi->process, data->mid);
2444  Curl_uint32_bset_remove(&multi->dirty, data->mid);
2445  Curl_uint32_bset_remove(&multi->pending, data->mid);
2446  Curl_uint32_bset_add(&multi->msgsent, data->mid);
2447  --multi->xfers_alive;
2448  if(!multi->xfers_alive)
2449    multi_assess_wakeup(multi);
2450}
2451
2452static CURLMcode multistate_init(struct Curl_easy *data, CURLcode *result)
2453{
2454  *result = Curl_pretransfer(data);
2455  if(*result)
2456    return CURLM_OK;
2457
2458  /* after init, go SETUP */
2459  multistate(data, MSTATE_SETUP);
2460  Curl_pgrsTime(data, TIMER_STARTOP);
2461  return CURLM_CALL_MULTI_PERFORM;
2462}
2463
2464static CURLMcode multistate_setup(struct Curl_easy *data)
2465{
2466  Curl_pgrsTime(data, TIMER_STARTSINGLE);
2467  if(data->set.timeout)
2468    Curl_expire(data, data->set.timeout, EXPIRE_TIMEOUT);
2469  if(data->set.connecttimeout)
2470    /* Since a connection might go to pending and back to CONNECT several
2471       times before it actually takes off, we need to set the timeout once
2472       in SETUP before we enter CONNECT the first time. */
2473    Curl_expire(data, data->set.connecttimeout, EXPIRE_CONNECTTIMEOUT);
2474
2475  multistate(data, MSTATE_CONNECT);
2476  return CURLM_CALL_MULTI_PERFORM;
2477}
2478
2479static CURLMcode multistate_connecting(struct Curl_easy *data,
2480                                       bool *stream_error,
2481                                       CURLcode *result)
2482{
2483  bool connected;
2484
2485  if(!data->conn) {
2486    DEBUGASSERT(0);
2487    *result = CURLE_FAILED_INIT;
2488    return CURLM_OK;
2489  }
2490  if(!Curl_xfer_recv_is_paused(data)) {
2491    *result = Curl_conn_connect(data, FIRSTSOCKET, FALSE, &connected);
2492    if(connected && !(*result)) {
2493      if(!data->conn->bits.reuse &&
2494         Curl_conn_is_multiplex(data->conn, FIRSTSOCKET)) {
2495        /* new connection, can multiplex, wake pending handles */
2496        process_pending_handles(data->multi);
2497      }
2498      multistate(data, MSTATE_PROTOCONNECT);
2499      return CURLM_CALL_MULTI_PERFORM;
2500    }
2501    else if(*result) {
2502      /* failure detected */
2503      CURL_TRC_M(data, "connect failed -> %d", *result);
2504      multi_posttransfer(data);
2505      multi_done(data, *result, TRUE);
2506      *stream_error = TRUE;
2507      return CURLM_OK;
2508    }
2509  }
2510  return CURLM_OK;
2511}
2512
2513static CURLMcode multistate_protoconnect(struct Curl_easy *data,
2514                                         bool *stream_error,
2515                                         CURLcode *result)
2516{
2517  bool protocol_connected = FALSE;
2518
2519  if(!(*result) && data->conn->bits.reuse) {
2520    /* ftp seems to hang when protoconnect on reused connection since we
2521     * handle PROTOCONNECT in general inside the filters, it seems wrong to
2522     * restart this on a reused connection.
2523     */
2524    multistate(data, MSTATE_DO);
2525    return CURLM_CALL_MULTI_PERFORM;
2526  }
2527  if(!(*result))
2528    *result = protocol_connect(data, &protocol_connected);
2529  if(!(*result) && !protocol_connected) {
2530    /* switch to waiting state */
2531    multistate(data, MSTATE_PROTOCONNECTING);
2532    return CURLM_CALL_MULTI_PERFORM;
2533  }
2534  else if(!(*result)) {
2535    /* protocol connect has completed, go WAITDO or DO */
2536    multistate(data, MSTATE_DO);
2537    return CURLM_CALL_MULTI_PERFORM;
2538  }
2539
2540  /* failure detected */
2541  multi_posttransfer(data);
2542  multi_done(data, *result, TRUE);
2543  *stream_error = TRUE;
2544  return CURLM_OK;
2545}
2546
2547static CURLMcode multistate_protoconnecting(struct Curl_easy *data,
2548                                            bool *stream_error,
2549                                            CURLcode *result)
2550{
2551  bool protocol_connected = FALSE;
2552
2553  /* protocol-specific connect phase */
2554  *result = protocol_connecting(data, &protocol_connected);
2555  if(!(*result) && protocol_connected) {
2556    /* after the connect has completed, go WAITDO or DO */
2557    multistate(data, MSTATE_DO);
2558    return CURLM_CALL_MULTI_PERFORM;
2559  }
2560  else if(*result) {
2561    /* failure detected */
2562    multi_posttransfer(data);
2563    multi_done(data, *result, TRUE);
2564    *stream_error = TRUE;
2565  }
2566  return CURLM_OK;
2567}
2568
2569static CURLMcode multistate_doing(struct Curl_easy *data,
2570                                  bool *stream_error,
2571                                  CURLcode *result)
2572{
2573  bool dophase_done = FALSE;
2574
2575  /* we continue DOING until the DO phase is complete */
2576  DEBUGASSERT(data->conn);
2577  *result = protocol_doing(data, &dophase_done);
2578  if(!(*result)) {
2579    if(dophase_done) {
2580      /* after DO, go DO_DONE or DO_MORE */
2581      multistate(data, data->conn->bits.do_more ?
2582                 MSTATE_DOING_MORE : MSTATE_DID);
2583      return CURLM_CALL_MULTI_PERFORM;
2584    } /* dophase_done */
2585  }
2586  else {
2587    /* failure detected */
2588    multi_posttransfer(data);
2589    multi_done(data, *result, FALSE);
2590    *stream_error = TRUE;
2591  }
2592  return CURLM_OK;
2593}
2594
2595static CURLMcode multistate_doing_more(struct Curl_easy *data,
2596                                       bool *stream_error,
2597                                       CURLcode *result)
2598{
2599  domore control;
2600
2601  /*
2602   * When we are connected, DOING MORE and then go DID
2603   */
2604  DEBUGASSERT(data->conn);
2605  *result = multi_do_more(data, &control);
2606
2607  if(!(*result)) {
2608    if(control != DOMORE_INCOMPLETE) {
2609      /* if DONE, advance to DO_DONE
2610         if GOBACK, go back to DOING */
2611      multistate(data, control == DOMORE_DONE ? MSTATE_DID : MSTATE_DOING);
2612      return CURLM_CALL_MULTI_PERFORM;
2613    }
2614    /* else
2615       stay in DO_MORE */
2616  }
2617  else {
2618    /* failure detected */
2619    multi_posttransfer(data);
2620    multi_done(data, *result, FALSE);
2621    *stream_error = TRUE;
2622  }
2623  return CURLM_OK;
2624}
2625
2626static CURLMcode multistate_did(struct Curl_multi *multi,
2627                                struct Curl_easy *data)
2628{
2629  DEBUGASSERT(data->conn);
2630  if(data->conn->bits.multiplex)
2631    /* Check if we can move pending requests to send pipe */
2632    process_pending_handles(multi); /* multiplexed */
2633
2634  /* Only perform the transfer if there is a good socket to work with.
2635     Having both BAD is a signal to skip immediately to DONE */
2636  if(CONN_SOCK_IDX_VALID(data->conn->recv_idx) ||
2637     CONN_SOCK_IDX_VALID(data->conn->send_idx))
2638    multistate(data, MSTATE_PERFORMING);
2639  else {
2640#ifndef CURL_DISABLE_FTP
2641    if(data->state.wildcardmatch &&
2642       ((data->conn->scheme->flags & PROTOPT_WILDCARD) == 0)) {
2643      data->wildcard->state = CURLWC_DONE;
2644    }
2645#endif
2646    multistate(data, MSTATE_DONE);
2647  }
2648  return CURLM_CALL_MULTI_PERFORM;
2649}
2650
2651static CURLMcode multistate_done(struct Curl_easy *data, CURLcode *result)
2652{
2653  if(data->conn) {
2654    CURLcode res;
2655
2656    /* post-transfer command */
2657    res = multi_done(data, *result, FALSE);
2658
2659    /* allow a previously set error code take precedence */
2660    if(!(*result))
2661      *result = res;
2662  }
2663
2664#ifndef CURL_DISABLE_FTP
2665  if(data->state.wildcardmatch) {
2666    if(data->wildcard->state != CURLWC_DONE) {
2667      /* if a wildcard is set and we are not ending -> lets start again
2668         with MSTATE_INIT */
2669      multistate(data, MSTATE_INIT);
2670      return CURLM_CALL_MULTI_PERFORM;
2671    }
2672  }
2673#endif
2674  /* after we have DONE what we are supposed to do, go COMPLETED, and
2675     it does not matter what the multi_done() returned! */
2676  multistate(data, MSTATE_COMPLETED);
2677  return CURLM_CALL_MULTI_PERFORM;
2678}
2679
2680static CURLMcode multi_runsingle(struct Curl_multi *multi,
2681                                 struct Curl_easy *data,
2682                                 struct Curl_sigpipe_ctx *sigpipe_ctx)
2683{
2684  CURLMcode mresult;
2685  CURLcode result = CURLE_OK;
2686
2687  if(!GOOD_EASY_HANDLE(data))
2688    return CURLM_BAD_EASY_HANDLE;
2689
2690  if(multi->dead) {
2691    /* a multi-level callback returned error before, meaning every individual
2692     transfer now has failed */
2693    result = CURLE_ABORTED_BY_CALLBACK;
2694    multi_posttransfer(data);
2695    multi_done(data, result, FALSE);
2696    multistate(data, MSTATE_COMPLETED);
2697  }
2698
2699  multi_warn_debug(multi, data);
2700
2701  /* transfer runs now, clear the dirty bit. This may be set
2702   * again during processing, triggering a re-run later. */
2703  Curl_uint32_bset_remove(&multi->dirty, data->mid);
2704
2705  if(data == multi->admin) {
2706#ifdef ENABLE_WAKEUP
2707    /* Consume any pending wakeup signals before processing.
2708     * This is necessary for event based processing. See #21547 */
2709    (void)Curl_wakeup_consume(multi->wakeup_pair, TRUE);
2710#endif
2711#ifdef USE_RESOLV_THREADED
2712    Curl_async_thrdd_multi_process(multi);
2713#endif
2714    Curl_cshutdn_perform(&multi->cshutdn, multi->admin, sigpipe_ctx);
2715    return CURLM_OK;
2716  }
2717
2718  sigpipe_apply(data, sigpipe_ctx);
2719  do {
2720    /* A "stream" here is a logical stream if the protocol can handle that
2721       (HTTP/2), or the full connection for older protocols */
2722    bool stream_error = FALSE;
2723    mresult = CURLM_OK;
2724
2725    if(multi_ischanged(multi, TRUE)) {
2726      CURL_TRC_M(data, "multi changed, check CONNECT_PEND queue");
2727      process_pending_handles(multi); /* multiplexed */
2728    }
2729
2730    if(data->mstate > MSTATE_CONNECT &&
2731       data->mstate < MSTATE_COMPLETED) {
2732      /* Make sure we set the connection's current owner */
2733      DEBUGASSERT(data->conn);
2734      if(!data->conn)
2735        return CURLM_INTERNAL_ERROR;
2736    }
2737
2738    /* Wait for the connect state as only then is the start time stored, but
2739       we must not check already completed handles */
2740    if((data->mstate >= MSTATE_CONNECT) && (data->mstate < MSTATE_COMPLETED) &&
2741       multi_handle_timeout(data, &stream_error, &result))
2742      /* Skip the statemachine and go directly to error handling section. */
2743      goto statemachine_end;
2744
2745    switch(data->mstate) {
2746    case MSTATE_INIT:
2747      /* Transitional state. init this transfer. A handle never comes back to
2748         this state. */
2749      mresult = multistate_init(data, &result);
2750      break;
2751
2752    case MSTATE_SETUP:
2753      /* Transitional state. Setup things for a new transfer. The handle
2754         can come back to this state on a redirect. */
2755      mresult = multistate_setup(data);
2756      break;
2757
2758    case MSTATE_CONNECT:
2759      mresult = multistate_connect(multi, data, &result);
2760      break;
2761
2762    case MSTATE_CONNECTING:
2763      /* awaiting a completion of an asynch TCP connect */
2764      mresult = multistate_connecting(data, &stream_error, &result);
2765      break;
2766
2767    case MSTATE_PROTOCONNECT:
2768      mresult = multistate_protoconnect(data, &stream_error, &result);
2769      break;
2770
2771    case MSTATE_PROTOCONNECTING:
2772      /* protocol-specific connect phase */
2773      mresult = multistate_protoconnecting(data, &stream_error, &result);
2774      break;
2775
2776    case MSTATE_DO:
2777      mresult = multistate_do(data, &stream_error, &result);
2778      break;
2779
2780    case MSTATE_DOING:
2781      /* we continue DOING until the DO phase is complete */
2782      mresult = multistate_doing(data, &stream_error, &result);
2783      break;
2784
2785    case MSTATE_DOING_MORE:
2786      /*
2787       * When we are connected, DOING MORE and then go DID
2788       */
2789      mresult = multistate_doing_more(data, &stream_error, &result);
2790      break;
2791
2792    case MSTATE_DID:
2793      mresult = multistate_did(multi, data);
2794      break;
2795
2796    case MSTATE_RATELIMITING: /* limit-rate exceeded in either direction */
2797      mresult = multistate_ratelimiting(data, &result);
2798      break;
2799
2800    case MSTATE_PERFORMING:
2801      mresult = multistate_performing(data, &stream_error, &result);
2802      break;
2803
2804    case MSTATE_DONE:
2805      mresult = multistate_done(data, &result);
2806      break;
2807
2808    case MSTATE_COMPLETED:
2809      break;
2810
2811    case MSTATE_PENDING:
2812    case MSTATE_MSGSENT:
2813      /* handles in these states should NOT be in this list */
2814      break;
2815
2816    default:
2817      return CURLM_INTERNAL_ERROR;
2818    }
2819
2820    if(data->mstate >= MSTATE_CONNECT &&
2821       data->mstate < MSTATE_DO &&
2822       mresult != CURLM_CALL_MULTI_PERFORM &&
2823       !multi_ischanged(multi, FALSE)) {
2824      /* We now handle stream timeouts if and only if this will be the last
2825       * loop iteration. We only check this on the last iteration to ensure
2826       * that if we know we have additional work to do immediately
2827       * (i.e. CURLM_CALL_MULTI_PERFORM == TRUE) then we should do that before
2828       * declaring the connection timed out as we may almost have a completed
2829       * connection. */
2830      multi_handle_timeout(data, &stream_error, &result);
2831    }
2832
2833statemachine_end:
2834
2835    result = is_finished(multi, data, stream_error, result);
2836    if(result)
2837      mresult = CURLM_CALL_MULTI_PERFORM;
2838
2839    if(MSTATE_COMPLETED == data->mstate) {
2840      handle_completed(multi, data, result);
2841      return CURLM_OK;
2842    }
2843  } while((mresult == CURLM_CALL_MULTI_PERFORM) ||
2844          multi_ischanged(multi, FALSE));
2845
2846  data->result = result;
2847  return mresult;
2848}
2849
2850static CURLMcode multi_perform(struct Curl_multi *multi,
2851                               int *running_handles)
2852{
2853  CURLMcode returncode = CURLM_OK;
2854  struct curltime start = *multi_now(multi);
2855  uint32_t mid;
2856  struct Curl_sigpipe_ctx sigpipe_ctx;
2857
2858  if(multi->in_callback)
2859    return CURLM_RECURSIVE_API_CALL;
2860
2861  if(multi->in_ntfy_callback)
2862    return CURLM_RECURSIVE_API_CALL;
2863
2864  sigpipe_init(&sigpipe_ctx);
2865
2866  if(Curl_uint32_bset_first(&multi->process, &mid)) {
2867    CURL_TRC_M(multi->admin, "multi_perform(running=%u)",
2868               Curl_multi_xfers_running(multi));
2869    do {
2870      struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
2871      CURLMcode mresult;
2872      if(!data) {
2873        DEBUGASSERT(0);
2874        Curl_uint32_bset_remove(&multi->process, mid);
2875        Curl_uint32_bset_remove(&multi->dirty, mid);
2876        continue;
2877      }
2878      mresult = multi_runsingle(multi, data, &sigpipe_ctx);
2879      if(mresult)
2880        returncode = mresult;
2881    } while(Curl_uint32_bset_next(&multi->process, mid, &mid));
2882  }
2883  sigpipe_restore(&sigpipe_ctx);
2884
2885  if(multi_ischanged(multi, TRUE))
2886    process_pending_handles(multi);
2887
2888  if(!returncode && CURL_MNTFY_HAS_ENTRIES(multi))
2889    returncode = Curl_mntfy_dispatch_all(multi);
2890
2891  /*
2892   * Remove all expired timers from the splay since handles are dealt
2893   * with unconditionally by this function and curl_multi_timeout() requires
2894   * that already passed/handled expire times are removed from the splay.
2895   *
2896   * It is important that the 'now' value is set at the entry of this function
2897   * and not for the current time as it may have ticked a little while since
2898   * then and then we risk this loop to remove timers that actually have not
2899   * been handled!
2900   */
2901  if(multi->timetree) {
2902    struct Curl_tree *t = NULL;
2903    do {
2904      multi->timetree = Curl_splaygetbest(&start, multi->timetree, &t);
2905      if(t) {
2906        /* the removed may have another timeout in queue */
2907        struct Curl_easy *data = Curl_splayget(t);
2908        (void)add_next_timeout(&start, multi, data);
2909        if(data->mstate == MSTATE_PENDING) {
2910          bool stream_unused;
2911          CURLcode result_unused;
2912          if(multi_handle_timeout(data, &stream_unused, &result_unused)) {
2913            infof(data, "PENDING handle timeout");
2914            move_pending_to_connect(multi, data);
2915          }
2916        }
2917      }
2918    } while(t);
2919  }
2920
2921  if(running_handles) {
2922    unsigned int running = Curl_multi_xfers_running(multi);
2923    *running_handles = (running < INT_MAX) ? (int)running : INT_MAX;
2924  }
2925
2926  if(CURLM_OK >= returncode)
2927    returncode = Curl_update_timer(multi);
2928
2929  return returncode;
2930}
2931
2932CURLMcode curl_multi_perform(CURLM *m, int *running_handles)
2933{
2934  struct Curl_multi *multi = m;
2935
2936  if(!GOOD_MULTI_HANDLE(multi))
2937    return CURLM_BAD_HANDLE;
2938
2939  return multi_perform(multi, running_handles);
2940}
2941
2942CURLMcode curl_multi_cleanup(CURLM *m)
2943{
2944  struct Curl_multi *multi = m;
2945  if(GOOD_MULTI_HANDLE(multi)) {
2946    void *entry;
2947    uint32_t mid;
2948    if(multi->in_callback)
2949      return CURLM_RECURSIVE_API_CALL;
2950    if(multi->in_ntfy_callback)
2951      return CURLM_RECURSIVE_API_CALL;
2952
2953    /* First remove all remaining easy handles,
2954     * close internal ones. admin handle is special */
2955    if(Curl_uint32_tbl_first(&multi->xfers, &mid, &entry)) {
2956      do {
2957        struct Curl_easy *data = entry;
2958        if(!GOOD_EASY_HANDLE(data))
2959          return CURLM_BAD_HANDLE;
2960
2961#ifdef DEBUGBUILD
2962        if(mid != data->mid) {
2963          CURL_TRC_M(data, "multi_cleanup: still present with mid=%u, "
2964                     "but unexpected data->mid=%u\n", mid, data->mid);
2965          DEBUGASSERT(0);
2966        }
2967#endif
2968
2969        if(data == multi->admin)
2970          continue;
2971
2972        if(!data->state.done && data->conn)
2973          /* if DONE was never called for this handle */
2974          (void)multi_done(data, CURLE_OK, TRUE);
2975
2976        data->multi = NULL; /* clear the association */
2977        Curl_uint32_tbl_remove(&multi->xfers, mid);
2978        data->mid = UINT32_MAX;
2979
2980#ifdef USE_LIBPSL
2981        if(data->psl == &multi->psl)
2982          data->psl = NULL;
2983#endif
2984        if(data->state.internal)
2985          Curl_close(&data);
2986      } while(Curl_uint32_tbl_next(&multi->xfers, mid, &mid, &entry));
2987    }
2988
2989#ifdef USE_RESOLV_THREADED
2990    Curl_async_thrdd_multi_destroy(multi, !multi->quick_exit);
2991#endif
2992    Curl_cpool_destroy(&multi->cpool);
2993    Curl_cshutdn_destroy(&multi->cshutdn, multi->admin);
2994    if(multi->admin) {
2995      CURL_TRC_M(multi->admin, "multi_cleanup, closing admin handle, done");
2996      multi->admin->multi = NULL;
2997      Curl_uint32_tbl_remove(&multi->xfers, multi->admin->mid);
2998      Curl_close(&multi->admin);
2999    }
3000
3001    multi->magic = 0; /* not good anymore */
3002
3003    Curl_multi_ev_cleanup(multi);
3004    Curl_hash_destroy(&multi->proto_hash);
3005    Curl_dnscache_destroy(&multi->dnscache);
3006    Curl_psl_destroy(&multi->psl);
3007#ifdef USE_SSL
3008    Curl_ssl_scache_destroy(multi->ssl_scache);
3009#endif
3010
3011#ifdef USE_WINSOCK
3012    WSACloseEvent(multi->wsa_event);
3013#endif
3014#ifdef ENABLE_WAKEUP
3015  Curl_wakeup_destroy(multi->wakeup_pair);
3016#endif
3017
3018    multi_xfer_bufs_free(multi);
3019    Curl_mntfy_cleanup(multi);
3020#ifdef DEBUGBUILD
3021    if(Curl_uint32_tbl_count(&multi->xfers)) {
3022      multi_xfer_tbl_dump(multi);
3023      DEBUGASSERT(0);
3024    }
3025#endif
3026    Curl_uint32_bset_destroy(&multi->process);
3027    Curl_uint32_bset_destroy(&multi->dirty);
3028    Curl_uint32_bset_destroy(&multi->pending);
3029    Curl_uint32_bset_destroy(&multi->msgsent);
3030    Curl_uint32_tbl_destroy(&multi->xfers);
3031    curlx_free(multi);
3032
3033    return CURLM_OK;
3034  }
3035  return CURLM_BAD_HANDLE;
3036}
3037
3038/*
3039 * curl_multi_info_read()
3040 *
3041 * This function is the primary way for a multi/multi_socket application to
3042 * figure out if a transfer has ended. We MUST make this function as fast as
3043 * possible as it will be polled frequently and we MUST NOT scan any lists in
3044 * here to figure out things. We must scale fine to thousands of handles and
3045 * beyond. The current design is fully O(1).
3046 */
3047
3048CURLMsg *curl_multi_info_read(CURLM *m, int *msgs_in_queue)
3049{
3050  struct Curl_message *msg;
3051  struct Curl_multi *multi = m;
3052
3053  *msgs_in_queue = 0; /* default to none */
3054
3055  if(GOOD_MULTI_HANDLE(multi) &&
3056     !multi->in_callback &&
3057     Curl_llist_count(&multi->msglist)) {
3058    /* there is one or more messages in the list */
3059    struct Curl_llist_node *e;
3060
3061    /* extract the head of the list to return */
3062    e = Curl_llist_head(&multi->msglist);
3063
3064    msg = Curl_node_elem(e);
3065
3066    /* remove the extracted entry */
3067    Curl_node_remove(e);
3068
3069    *msgs_in_queue = curlx_uztosi(Curl_llist_count(&multi->msglist));
3070
3071    return &msg->extmsg;
3072  }
3073  return NULL;
3074}
3075
3076void Curl_multi_will_close(struct Curl_easy *data, curl_socket_t s)
3077{
3078  if(data) {
3079    struct Curl_multi *multi = data->multi;
3080    if(multi) {
3081      CURL_TRC_M(data, "Curl_multi_will_close fd=%" FMT_SOCKET_T, s);
3082      Curl_multi_ev_socket_done(multi, data, s);
3083    }
3084  }
3085}
3086
3087/*
3088 * add_next_timeout()
3089 *
3090 * Each Curl_easy has a list of timeouts. The add_next_timeout() is called
3091 * when it has been removed from the splay tree because the timeout has
3092 * expired. This function is then to advance in the list to pick the next
3093 * timeout to use (skip the already expired ones) and add this node back to
3094 * the splay tree again.
3095 *
3096 * The splay tree only has each sessionhandle as a single node and the nearest
3097 * timeout is used to sort it on.
3098 */
3099static CURLMcode add_next_timeout(const struct curltime *pnow,
3100                                  struct Curl_multi *multi,
3101                                  struct Curl_easy *d)
3102{
3103  struct curltime *tv = &d->state.expiretime;
3104  struct Curl_llist *list = &d->state.timeoutlist;
3105  struct Curl_llist_node *e;
3106
3107  /* move over the timeout list for this specific handle and remove all
3108     timeouts that are now passed tense and store the next pending
3109     timeout in *tv */
3110  for(e = Curl_llist_head(list); e;) {
3111    struct Curl_llist_node *n = Curl_node_next(e);
3112    struct time_node *node = Curl_node_elem(e);
3113    timediff_t diff = curlx_ptimediff_us(&node->time, pnow);
3114    if(diff <= 0)
3115      /* remove outdated entry */
3116      Curl_node_remove(e);
3117    else
3118      /* the list is sorted so get out on the first mismatch */
3119      break;
3120    e = n;
3121  }
3122  e = Curl_llist_head(list);
3123  if(!e) {
3124    /* clear the expire times within the handles that we remove from the
3125       splay tree */
3126    tv->tv_sec = 0;
3127    tv->tv_usec = 0;
3128  }
3129  else {
3130    struct time_node *node = Curl_node_elem(e);
3131    /* copy the first entry to 'tv' */
3132    memcpy(tv, &node->time, sizeof(*tv));
3133
3134    /* Insert this node again into the splay. Keep the timer in the list in
3135       case we need to recompute future timers. */
3136    multi->timetree = Curl_splayinsert(tv, multi->timetree,
3137                                       &d->state.timenode);
3138  }
3139  return CURLM_OK;
3140}
3141
3142static void multi_mark_expired_as_dirty(struct Curl_multi *multi,
3143                                        const struct curltime *ts)
3144{
3145  struct Curl_easy *data = NULL;
3146  struct Curl_tree *t = NULL;
3147
3148  /*
3149   * The loop following here will go on as long as there are expire-times left
3150   * to process (compared to `ts`) in the splay and 'data' will be
3151   * re-assigned for every expired handle we deal with.
3152   */
3153  while(1) {
3154    /* Check if there is one (more) expired timer to deal with! This function
3155       extracts a matching node if there is one */
3156    multi->timetree = Curl_splaygetbest(ts, multi->timetree, &t);
3157    if(!t)
3158      return;
3159
3160    data = Curl_splayget(t); /* assign this for next loop */
3161    if(!data)
3162      continue;
3163#ifdef CURLVERBOSE
3164    if(CURL_TRC_TIMER_is_verbose(data)) {
3165      struct Curl_llist_node *e = Curl_llist_head(&data->state.timeoutlist);
3166      if(e) {
3167        struct time_node *n = Curl_node_elem(e);
3168        CURL_TRC_TIMER(data, n->eid, "has expired");
3169      }
3170    }
3171#endif
3172    (void)add_next_timeout(ts, multi, data);
3173    Curl_multi_mark_dirty(data);
3174  }
3175}
3176
3177static CURLMcode multi_run_dirty(struct Curl_multi *multi,
3178                                 struct Curl_sigpipe_ctx *sigpipe_ctx,
3179                                 uint32_t *pnum)
3180{
3181  CURLMcode mresult = CURLM_OK;
3182  uint32_t mid;
3183
3184  *pnum = 0;
3185  if(Curl_uint32_bset_first(&multi->dirty, &mid)) {
3186    do {
3187      struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
3188      if(data) {
3189        CURL_TRC_M(data, "multi_run_dirty");
3190
3191        if(!Curl_uint32_bset_contains(&multi->process, mid)) {
3192          /* We are no longer processing this transfer */
3193          Curl_uint32_bset_remove(&multi->dirty, mid);
3194          continue;
3195        }
3196
3197        (*pnum)++;
3198        /* runsingle() clears the dirty mid */
3199        mresult = multi_runsingle(multi, data, sigpipe_ctx);
3200
3201        if(CURLM_OK >= mresult) {
3202          /* reassess event handling of data */
3203          mresult = Curl_multi_ev_assess_xfer(multi, data);
3204          if(mresult)
3205            goto out;
3206        }
3207      }
3208      else {
3209        CURL_TRC_M(multi->admin, "multi_run_dirty, %u no longer found", mid);
3210        Curl_uint32_bset_remove(&multi->dirty, mid);
3211      }
3212    } while(Curl_uint32_bset_next(&multi->dirty, mid, &mid));
3213  }
3214
3215out:
3216  return mresult;
3217}
3218
3219static CURLMcode multi_socket(struct Curl_multi *multi,
3220                              bool checkall,
3221                              curl_socket_t s,
3222                              int ev_bitmask,
3223                              int *running_handles)
3224{
3225  CURLMcode mresult = CURLM_OK;
3226  struct Curl_sigpipe_ctx pipe_ctx;
3227  uint32_t run_xfers;
3228
3229  (void)ev_bitmask;
3230  sigpipe_init(&pipe_ctx);
3231
3232  if(checkall) {
3233    /* *perform() deals with running_handles on its own */
3234    mresult = multi_perform(multi, running_handles);
3235
3236    if(mresult != CURLM_BAD_HANDLE) {
3237      /* Reassess event status of all active transfers */
3238      mresult = Curl_multi_ev_assess_xfer_bset(multi, &multi->process);
3239    }
3240    goto out;
3241  }
3242
3243  if(s != CURL_SOCKET_TIMEOUT) {
3244    /* Mark all transfers of that socket as dirty */
3245    Curl_multi_ev_dirty_xfers(multi, s);
3246  }
3247  else {
3248    /* Asked to run due to time-out. Clear the 'last_expire_ts' variable to
3249       force Curl_update_timer() to trigger a callback to the app again even
3250       if the same timeout is still the one to run after this call. That
3251       handles the case when the application asks libcurl to run the timeout
3252       prematurely. */
3253    memset(&multi->last_expire_ts, 0, sizeof(multi->last_expire_ts));
3254
3255    /* Applications may set `socket_cb` *after* having added transfers
3256     * first. *Then* kick off processing with a
3257     * curl_multi_socket_action(TIMEOUT) afterwards. Make sure our
3258     * admin handle registers its pollset with the callbacks present. */
3259    mresult = multi_assess_wakeup(multi);
3260    if(mresult)
3261      goto out;
3262  }
3263
3264  multi_mark_expired_as_dirty(multi, multi_now(multi));
3265  mresult = multi_run_dirty(multi, &pipe_ctx, &run_xfers);
3266  if(mresult)
3267    goto out;
3268
3269  if(run_xfers) {
3270    /* Running transfers takes time. With a new timestamp, we might catch
3271     * other expires which are due now. Instead of telling the application
3272     * to set a 0 timeout and call us again, we run them here.
3273     * Do that only once or it might be unfair to transfers on other
3274     * sockets. */
3275    multi_mark_expired_as_dirty(multi, &multi->now);
3276    mresult = multi_run_dirty(multi, &pipe_ctx, &run_xfers);
3277  }
3278
3279out:
3280  sigpipe_restore(&pipe_ctx);
3281
3282  if(multi_ischanged(multi, TRUE))
3283    process_pending_handles(multi);
3284
3285  if(!mresult && CURL_MNTFY_HAS_ENTRIES(multi))
3286    mresult = Curl_mntfy_dispatch_all(multi);
3287
3288  if(running_handles) {
3289    unsigned int running = Curl_multi_xfers_running(multi);
3290    *running_handles = (running < INT_MAX) ? (int)running : INT_MAX;
3291  }
3292
3293  if(CURLM_OK >= mresult)
3294    mresult = Curl_update_timer(multi);
3295  return mresult;
3296}
3297
3298#undef curl_multi_setopt
3299CURLMcode curl_multi_setopt(CURLM *m, CURLMoption option, ...)
3300{
3301  CURLMcode mresult = CURLM_OK;
3302  va_list param;
3303  unsigned long uarg;
3304  struct Curl_multi *multi = m;
3305
3306  if(!GOOD_MULTI_HANDLE(multi))
3307    return CURLM_BAD_HANDLE;
3308
3309  if(multi->in_callback)
3310    return CURLM_RECURSIVE_API_CALL;
3311
3312  va_start(param, option);
3313
3314  switch(option) {
3315  case CURLMOPT_SOCKETFUNCTION:
3316    multi->socket_cb = va_arg(param, curl_socket_callback);
3317    break;
3318  case CURLMOPT_SOCKETDATA:
3319    multi->socket_userp = va_arg(param, void *);
3320    break;
3321  case CURLMOPT_PUSHFUNCTION:
3322    multi->push_cb = va_arg(param, curl_push_callback);
3323    break;
3324  case CURLMOPT_PUSHDATA:
3325    multi->push_userp = va_arg(param, void *);
3326    break;
3327  case CURLMOPT_PIPELINING:
3328    multi->multiplexing = va_arg(param, long) & CURLPIPE_MULTIPLEX ? 1 : 0;
3329    break;
3330  case CURLMOPT_TIMERFUNCTION:
3331    multi->timer_cb = va_arg(param, curl_multi_timer_callback);
3332    break;
3333  case CURLMOPT_TIMERDATA:
3334    multi->timer_userp = va_arg(param, void *);
3335    break;
3336  case CURLMOPT_MAXCONNECTS:
3337    uarg = va_arg(param, unsigned long);
3338    if(uarg <= UINT_MAX)
3339      multi->maxconnects = (unsigned int)uarg;
3340    break;
3341  case CURLMOPT_MAX_HOST_CONNECTIONS:
3342    if(!curlx_sltouz(va_arg(param, long), &multi->max_host_connections))
3343      mresult = CURLM_BAD_FUNCTION_ARGUMENT;
3344    break;
3345  case CURLMOPT_MAX_TOTAL_CONNECTIONS:
3346    if(!curlx_sltouz(va_arg(param, long), &multi->max_total_connections))
3347      mresult = CURLM_BAD_FUNCTION_ARGUMENT;
3348    break;
3349    /* options formerly used for pipelining */
3350  case CURLMOPT_MAX_PIPELINE_LENGTH:
3351    break;
3352  case CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE:
3353    break;
3354  case CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE:
3355    break;
3356  case CURLMOPT_PIPELINING_SITE_BL:
3357    break;
3358  case CURLMOPT_PIPELINING_SERVER_BL:
3359    break;
3360  case CURLMOPT_MAX_CONCURRENT_STREAMS: {
3361    long streams = va_arg(param, long);
3362    if((streams < 1) || (streams > INT_MAX))
3363      streams = 100;
3364    multi->max_concurrent_streams = (unsigned int)streams;
3365    break;
3366  }
3367  case CURLMOPT_NETWORK_CHANGED: {
3368    long val = va_arg(param, long);
3369    if(val & CURLMNWC_CLEAR_ALL)
3370      /* In the beginning, all values available to set were 1 by mistake. We
3371         converted this to mean "all", thus setting all the bits
3372         automatically */
3373      val = CURLMNWC_CLEAR_DNS | CURLMNWC_CLEAR_CONNS;
3374    if(val & CURLMNWC_CLEAR_DNS) {
3375      Curl_dnscache_clear(multi->admin);
3376    }
3377    if(val & CURLMNWC_CLEAR_CONNS) {
3378      Curl_cpool_nw_changed(multi->admin);
3379    }
3380    break;
3381  }
3382  case CURLMOPT_NOTIFYFUNCTION:
3383    multi->ntfy.ntfy_cb = va_arg(param, curl_notify_callback);
3384    break;
3385  case CURLMOPT_NOTIFYDATA:
3386    multi->ntfy.ntfy_cb_data = va_arg(param, void *);
3387    break;
3388  case CURLMOPT_RESOLVE_THREADS_MAX:
3389#ifdef USE_RESOLV_THREADED
3390    uarg = va_arg(param, long);
3391    if((uarg <= 0) || (uarg > UINT32_MAX))
3392      mresult = CURLM_BAD_FUNCTION_ARGUMENT;
3393    else {
3394      CURLcode result = Curl_async_thrdd_multi_set_props(
3395        multi, 0, (uint32_t)uarg, 2000);
3396      switch(result) {
3397      case CURLE_OK:
3398        mresult = CURLM_OK;
3399        break;
3400      case CURLE_BAD_FUNCTION_ARGUMENT:
3401        mresult = CURLM_BAD_FUNCTION_ARGUMENT;
3402        break;
3403      case CURLE_OUT_OF_MEMORY:
3404        mresult = CURLM_OUT_OF_MEMORY;
3405        break;
3406      default:
3407        mresult = CURLM_INTERNAL_ERROR;
3408        break;
3409      }
3410    }
3411#endif
3412    break;
3413  case CURLMOPT_QUICK_EXIT:
3414    multi->quick_exit = va_arg(param, long) ? 1 : 0;
3415    break;
3416  default:
3417    mresult = CURLM_UNKNOWN_OPTION;
3418    break;
3419  }
3420  va_end(param);
3421  return mresult;
3422}
3423
3424/* we define curl_multi_socket() in the public multi.h header */
3425#undef curl_multi_socket
3426
3427CURLMcode curl_multi_socket(CURLM *m, curl_socket_t s, int *running_handles)
3428{
3429  struct Curl_multi *multi = m;
3430  if(multi->in_callback)
3431    return CURLM_RECURSIVE_API_CALL;
3432  if(multi->in_ntfy_callback)
3433    return CURLM_RECURSIVE_API_CALL;
3434  return multi_socket(multi, FALSE, s, 0, running_handles);
3435}
3436
3437CURLMcode curl_multi_socket_action(CURLM *m, curl_socket_t s,
3438                                   int ev_bitmask, int *running_handles)
3439{
3440  struct Curl_multi *multi = m;
3441  if(multi->in_callback)
3442    return CURLM_RECURSIVE_API_CALL;
3443  if(multi->in_ntfy_callback)
3444    return CURLM_RECURSIVE_API_CALL;
3445  return multi_socket(multi, FALSE, s, ev_bitmask, running_handles);
3446}
3447
3448CURLMcode curl_multi_socket_all(CURLM *m, int *running_handles)
3449{
3450  struct Curl_multi *multi = m;
3451  if(multi->in_callback)
3452    return CURLM_RECURSIVE_API_CALL;
3453  if(multi->in_ntfy_callback)
3454    return CURLM_RECURSIVE_API_CALL;
3455  return multi_socket(multi, TRUE, CURL_SOCKET_BAD, 0, running_handles);
3456}
3457
3458static bool multi_has_dirties(struct Curl_multi *multi)
3459{
3460  uint32_t mid;
3461  if(Curl_uint32_bset_first(&multi->dirty, &mid)) {
3462    do {
3463      struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
3464      if(data) {
3465        if(Curl_uint32_bset_contains(&multi->process, mid))
3466          return TRUE;
3467        /* We are no longer processing this transfer */
3468        Curl_uint32_bset_remove(&multi->dirty, mid);
3469      }
3470      else {
3471        CURL_TRC_M(multi->admin, "dirty transfer %u no longer found", mid);
3472        Curl_uint32_bset_remove(&multi->dirty, mid);
3473      }
3474    } while(Curl_uint32_bset_next(&multi->dirty, mid, &mid));
3475  }
3476  return FALSE;
3477}
3478
3479static void multi_timeout(struct Curl_multi *multi,
3480                          struct curltime *expire_time,
3481                          long *timeout_ms)
3482{
3483  static const struct curltime tv_zero = { 0, 0 };
3484  VERBOSE(struct Curl_easy *data = NULL);
3485
3486  if(multi->dead) {
3487    *timeout_ms = 0;
3488    return;
3489  }
3490
3491  if(multi_has_dirties(multi)) {
3492    *expire_time = *multi_now(multi);
3493    *timeout_ms = 0;
3494    return;
3495  }
3496  else if(multi->timetree) {
3497    const struct curltime *pnow = multi_now(multi);
3498    /* splay the lowest to the bottom */
3499    multi->timetree = Curl_splay(&tv_zero, multi->timetree);
3500    /* this will not return NULL from a non-empty tree, but some compilers
3501     * are not convinced of that. Analyzers are hard. */
3502    *expire_time = multi->timetree ? multi->timetree->key : tv_zero;
3503
3504    /* 'multi->timetree' will be non-NULL here but the compilers sometimes
3505       yell at us if we assume so */
3506    if(multi->timetree &&
3507       curlx_ptimediff_us(&multi->timetree->key, pnow) > 0) {
3508      /* some time left before expiration */
3509      timediff_t diff_ms =
3510        curlx_timediff_ceil_ms(multi->timetree->key, *pnow);
3511      VERBOSE(data = Curl_splayget(multi->timetree));
3512      /* this should be safe even on 32-bit archs, as we do not use that
3513         overly long timeouts */
3514      *timeout_ms = (long)diff_ms;
3515    }
3516    else {
3517      if(multi->timetree)
3518        VERBOSE(data = Curl_splayget(multi->timetree));
3519      /* 0 means immediately */
3520      *timeout_ms = 0;
3521    }
3522  }
3523  else {
3524    *expire_time = tv_zero;
3525    *timeout_ms = -1;
3526  }
3527
3528#ifdef CURLVERBOSE
3529  if(CURL_TRC_TIMER_is_verbose(data)) {
3530    struct Curl_llist_node *e = Curl_llist_head(&data->state.timeoutlist);
3531    if(e) {
3532      struct time_node *n = Curl_node_elem(e);
3533      CURL_TRC_TIMER(data, n->eid, "gives multi timeout in %ldms",
3534                     *timeout_ms);
3535    }
3536  }
3537#endif
3538}
3539
3540CURLMcode curl_multi_timeout(CURLM *m,
3541                             long *timeout_ms)
3542{
3543  struct curltime expire_time;
3544  struct Curl_multi *multi = m;
3545
3546  /* First, make some basic checks that the CURLM handle is a good handle */
3547  if(!GOOD_MULTI_HANDLE(multi))
3548    return CURLM_BAD_HANDLE;
3549
3550  if(multi->in_callback)
3551    return CURLM_RECURSIVE_API_CALL;
3552
3553  multi_timeout(multi, &expire_time, timeout_ms);
3554  return CURLM_OK;
3555}
3556
3557/*
3558 * Tell the application it should update its timers, if it subscribes to the
3559 * update timer callback.
3560 */
3561CURLMcode Curl_update_timer(struct Curl_multi *multi)
3562{
3563  struct curltime expire_ts;
3564  long timeout_ms;
3565  int rc;
3566  bool set_value = FALSE;
3567
3568  if(!multi->timer_cb || multi->dead)
3569    return CURLM_OK;
3570  multi_timeout(multi, &expire_ts, &timeout_ms);
3571
3572  if(timeout_ms < 0 && multi->last_timeout_ms < 0) {
3573    /* nothing to do */
3574  }
3575  else if(timeout_ms < 0) {
3576    /* there is no timeout now but there was one previously */
3577    CURL_TRC_M(multi->admin, "[TIMER] clear");
3578    timeout_ms = -1; /* normalize */
3579    set_value = TRUE;
3580  }
3581  else if(multi->last_timeout_ms < 0) {
3582    CURL_TRC_M(multi->admin, "[TIMER] set %ldms, none before", timeout_ms);
3583    set_value = TRUE;
3584  }
3585  else if(curlx_ptimediff_us(&multi->last_expire_ts, &expire_ts)) {
3586    /* We had a timeout before and have one now, the absolute timestamp
3587     * differs. The relative timeout_ms may be the same, but the starting
3588     * point differs. Let the application restart its timer. */
3589    CURL_TRC_M(multi->admin, "[TIMER] set %ldms, replace previous",
3590               timeout_ms);
3591    set_value = TRUE;
3592  }
3593  else {
3594    /* We have same expire time as previously. Our relative 'timeout_ms'
3595     * may be different now, but the application has the timer running
3596     * and we do not to tell it to start this again. */
3597  }
3598
3599  if(set_value) {
3600    multi->last_expire_ts = expire_ts;
3601    multi->last_timeout_ms = timeout_ms;
3602    set_in_callback(multi, TRUE);
3603    rc = multi->timer_cb(multi, timeout_ms, multi->timer_userp);
3604    set_in_callback(multi, FALSE);
3605    if(rc == -1) {
3606      multi->dead = TRUE;
3607      return CURLM_ABORTED_BY_CALLBACK;
3608    }
3609  }
3610  return CURLM_OK;
3611}
3612
3613/*
3614 * multi_deltimeout()
3615 *
3616 * Remove a given timestamp from the list of timeouts.
3617 */
3618static void multi_deltimeout(struct Curl_easy *data, expire_id eid)
3619{
3620  struct Curl_llist_node *e;
3621  struct Curl_llist *timeoutlist = &data->state.timeoutlist;
3622  /* find and remove the specific node from the list */
3623  for(e = Curl_llist_head(timeoutlist); e; e = Curl_node_next(e)) {
3624    struct time_node *n = Curl_node_elem(e);
3625    if(n->eid == eid) {
3626      Curl_node_remove(e);
3627      return;
3628    }
3629  }
3630}
3631
3632/*
3633 * multi_addtimeout()
3634 *
3635 * Add a timestamp to the list of timeouts. Keep the list sorted so that head
3636 * of list is always the timeout nearest in time.
3637 *
3638 */
3639static CURLMcode multi_addtimeout(struct Curl_easy *data,
3640                                  struct curltime *stamp,
3641                                  expire_id eid)
3642{
3643  struct Curl_llist_node *e;
3644  struct time_node *node;
3645  struct Curl_llist_node *prev = NULL;
3646  size_t n;
3647  struct Curl_llist *timeoutlist = &data->state.timeoutlist;
3648
3649  node = &data->state.expires[eid];
3650
3651  /* copy the timestamp and id */
3652  memcpy(&node->time, stamp, sizeof(*stamp));
3653  node->eid = eid; /* also marks it as in use */
3654
3655  n = Curl_llist_count(timeoutlist);
3656  if(n) {
3657    /* find the correct spot in the list */
3658    for(e = Curl_llist_head(timeoutlist); e; e = Curl_node_next(e)) {
3659      struct time_node *check = Curl_node_elem(e);
3660      timediff_t diff = curlx_ptimediff_ms(&check->time, &node->time);
3661      if(diff > 0)
3662        break;
3663      prev = e;
3664    }
3665  }
3666  /* else
3667     this is the first timeout on the list */
3668
3669  Curl_llist_insert_next(timeoutlist, prev, node, &node->list);
3670  CURL_TRC_TIMER(data, eid, "set for %" FMT_TIMEDIFF_T "ns",
3671                 curlx_ptimediff_us(&node->time, Curl_pgrs_now(data)));
3672  return CURLM_OK;
3673}
3674
3675void Curl_expire_ex(struct Curl_easy *data,
3676                    timediff_t milli, expire_id id)
3677{
3678  struct Curl_multi *multi = data->multi;
3679  struct curltime *curr_expire = &data->state.expiretime;
3680  struct curltime set;
3681
3682  /* this is only interesting while there is still an associated multi struct
3683     remaining! */
3684  if(!multi)
3685    return;
3686
3687  DEBUGASSERT(id < EXPIRE_LAST);
3688
3689  set = *Curl_pgrs_now(data);
3690  set.tv_sec += (time_t)(milli / 1000); /* may be a 64 to 32-bit conversion */
3691  set.tv_usec += (int)(milli % 1000) * 1000;
3692
3693  if(set.tv_usec >= 1000000) {
3694    set.tv_sec++;
3695    set.tv_usec -= 1000000;
3696  }
3697
3698  /* Remove any timer with the same id */
3699  multi_deltimeout(data, id);
3700
3701  /* Add it to the timer list. It must stay in the list until it has expired
3702     in case we need to recompute the minimum timer later. */
3703  multi_addtimeout(data, &set, id);
3704
3705  if(curr_expire->tv_sec || curr_expire->tv_usec) {
3706    /* This means that the struct is added as a node in the splay tree.
3707       Compare if the new time is earlier, and only remove-old/add-new if it
3708       is. */
3709    timediff_t diff = curlx_ptimediff_ms(&set, curr_expire);
3710    int rc;
3711
3712    if(diff > 0) {
3713      /* The current splay tree entry is sooner than this new expiry time.
3714         We do not need to update our splay tree entry. */
3715      return;
3716    }
3717
3718    /* Since this is an updated time, we must remove the previous entry from
3719       the splay tree first and then re-add the new value */
3720    rc = Curl_splayremove(multi->timetree, &data->state.timenode,
3721                          &multi->timetree);
3722    if(rc)
3723      infof(data, "Internal error removing splay node = %d", rc);
3724  }
3725
3726  /* Indicate that we are in the splay tree and insert the new timer expiry
3727     value since it is our local minimum. */
3728  *curr_expire = set;
3729  Curl_splayset(&data->state.timenode, data);
3730  multi->timetree = Curl_splayinsert(curr_expire, multi->timetree,
3731                                     &data->state.timenode);
3732}
3733
3734/*
3735 * Curl_expire()
3736 *
3737 * given a number of milliseconds from now to use to set the 'act before
3738 * this'-time for the transfer, to be extracted by curl_multi_timeout()
3739 *
3740 * The timeout will be added to a queue of timeouts if it defines a moment in
3741 * time that is later than the current head of queue.
3742 *
3743 * Expire replaces a former timeout using the same id if already set.
3744 */
3745void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
3746{
3747  Curl_expire_ex(data, milli, id);
3748}
3749
3750/*
3751 * Curl_expire_done()
3752 *
3753 * Removes the expire timer. Marks it as done.
3754 *
3755 */
3756void Curl_expire_done(struct Curl_easy *data, expire_id id)
3757{
3758  /* remove the timer, if there */
3759  multi_deltimeout(data, id);
3760  CURL_TRC_TIMER(data, id, "cleared");
3761}
3762
3763/*
3764 * Curl_expire_clear()
3765 *
3766 * Clear ALL timeout values for this handle.
3767 */
3768void Curl_expire_clear(struct Curl_easy *data)
3769{
3770  struct Curl_multi *multi = data->multi;
3771  struct curltime *nowp = &data->state.expiretime;
3772
3773  /* this is only interesting while there is still an associated multi struct
3774     remaining! */
3775  if(!multi)
3776    return;
3777
3778  if(nowp->tv_sec || nowp->tv_usec) {
3779    /* Since this is an cleared time, we must remove the previous entry from
3780       the splay tree */
3781    struct Curl_llist *list = &data->state.timeoutlist;
3782    int rc;
3783
3784    rc = Curl_splayremove(multi->timetree, &data->state.timenode,
3785                          &multi->timetree);
3786    if(rc)
3787      infof(data, "Internal error clearing splay node = %d", rc);
3788
3789    /* clear the timeout list too */
3790    Curl_llist_destroy(list, NULL);
3791
3792    if(data->id >= 0)
3793      CURL_TRC_M(data, "[TIMEOUT] all cleared");
3794    nowp->tv_sec = 0;
3795    nowp->tv_usec = 0;
3796  }
3797}
3798
3799CURLMcode curl_multi_assign(CURLM *m, curl_socket_t sockfd,
3800                            void *sockp)
3801{
3802  struct Curl_multi *multi = m;
3803  if(!GOOD_MULTI_HANDLE(multi))
3804    return CURLM_BAD_HANDLE;
3805
3806  return Curl_multi_ev_assign(multi, sockfd, sockp);
3807}
3808
3809static void move_pending_to_connect(struct Curl_multi *multi,
3810                                    struct Curl_easy *data)
3811{
3812  DEBUGASSERT(data->mstate == MSTATE_PENDING);
3813
3814  /* Remove this node from the pending set, add into process set */
3815  Curl_uint32_bset_remove(&multi->pending, data->mid);
3816  Curl_uint32_bset_add(&multi->process, data->mid);
3817
3818  multistate(data, MSTATE_CONNECT);
3819  Curl_multi_mark_dirty(data); /* make it run */
3820}
3821
3822/* process_pending_handles() moves a handle from PENDING back into the process
3823   list and change state to CONNECT.
3824
3825   We do not move all transfers because that can be a significant amount.
3826   Since this is tried every now and then doing too many too often becomes a
3827   performance problem.
3828
3829   When there is a change for connection limits like max host connections etc,
3830   this likely only allows one new transfer. When there is a pipewait change,
3831   it can potentially allow hundreds of new transfers.
3832
3833   We could consider an improvement where we store the queue reason and allow
3834   more pipewait rechecks than others.
3835*/
3836static void process_pending_handles(struct Curl_multi *multi)
3837{
3838  uint32_t mid = multi->last_pending_mid;
3839
3840  if(mid) {
3841    while(Curl_uint32_bset_next(&multi->pending, mid, &mid)) {
3842      struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
3843      if(data) {
3844        move_pending_to_connect(multi, data);
3845        multi->last_pending_mid = mid;
3846        return;
3847      }
3848      /* transfer no longer known, should not happen */
3849      Curl_uint32_bset_remove(&multi->pending, mid);
3850      DEBUGASSERT(0);
3851    }
3852    /* found no pending transfers with `mid` larger than `last_pending_mid`.
3853     * Start at the beginning of the pending set again. */
3854    multi->last_pending_mid = 0;
3855  }
3856
3857  if(Curl_uint32_bset_first(&multi->pending, &mid)) {
3858    do {
3859      struct Curl_easy *data = Curl_multi_get_easy(multi, mid);
3860      if(data) {
3861        move_pending_to_connect(multi, data);
3862        multi->last_pending_mid = mid;
3863        return;
3864      }
3865      /* transfer no longer known, should not happen */
3866      Curl_uint32_bset_remove(&multi->pending, mid);
3867      DEBUGASSERT(0);
3868    } while(Curl_uint32_bset_next(&multi->pending, mid, &mid));
3869  }
3870}
3871
3872void Curl_set_in_callback(struct Curl_easy *data, bool value)
3873{
3874  if(data && data->multi)
3875    data->multi->in_callback = value;
3876}
3877
3878bool Curl_is_in_callback(struct Curl_easy *data)
3879{
3880  return data && data->multi && data->multi->in_callback;
3881}
3882
3883unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi)
3884{
3885  DEBUGASSERT(multi);
3886  return multi->max_concurrent_streams;
3887}
3888
3889CURL **curl_multi_get_handles(CURLM *m)
3890{
3891  struct Curl_multi *multi = m;
3892  void *entry;
3893  size_t count = Curl_uint32_tbl_count(&multi->xfers);
3894  CURL **a = curlx_malloc(sizeof(struct Curl_easy *) * (count + 1));
3895  if(a) {
3896    unsigned int i = 0;
3897    uint32_t mid;
3898
3899    if(Curl_uint32_tbl_first(&multi->xfers, &mid, &entry)) {
3900      do {
3901        struct Curl_easy *data = entry;
3902        DEBUGASSERT(i < count);
3903        if(!data->state.internal)
3904          a[i++] = data;
3905      } while(Curl_uint32_tbl_next(&multi->xfers, mid, &mid, &entry));
3906    }
3907    a[i] = NULL; /* last entry is a NULL */
3908  }
3909  return a;
3910}
3911
3912CURLMcode curl_multi_get_offt(CURLM *m,
3913                              CURLMinfo_offt info,
3914                              curl_off_t *pvalue)
3915{
3916  struct Curl_multi *multi = m;
3917  uint32_t n;
3918
3919  if(!GOOD_MULTI_HANDLE(multi))
3920    return CURLM_BAD_HANDLE;
3921  if(!pvalue)
3922    return CURLM_BAD_FUNCTION_ARGUMENT;
3923
3924  switch(info) {
3925  case CURLMINFO_XFERS_CURRENT:
3926    n = Curl_uint32_tbl_count(&multi->xfers);
3927    if(n && multi->admin)
3928      --n;
3929    *pvalue = (curl_off_t)n;
3930    return CURLM_OK;
3931  case CURLMINFO_XFERS_RUNNING:
3932    n = Curl_uint32_bset_count(&multi->process);
3933    if(n && Curl_uint32_bset_contains(&multi->process, multi->admin->mid))
3934      --n;
3935    *pvalue = (curl_off_t)n;
3936    return CURLM_OK;
3937  case CURLMINFO_XFERS_PENDING:
3938    *pvalue = (curl_off_t)Curl_uint32_bset_count(&multi->pending);
3939    return CURLM_OK;
3940  case CURLMINFO_XFERS_DONE:
3941    *pvalue = (curl_off_t)Curl_uint32_bset_count(&multi->msgsent);
3942    return CURLM_OK;
3943  case CURLMINFO_XFERS_ADDED:
3944    *pvalue = multi->xfers_total_ever;
3945    return CURLM_OK;
3946  default:
3947    *pvalue = -1;
3948    return CURLM_UNKNOWN_OPTION;
3949  }
3950}
3951
3952CURLcode Curl_multi_xfer_buf_borrow(struct Curl_easy *data,
3953                                    char **pbuf, size_t *pbuflen)
3954{
3955  DEBUGASSERT(data);
3956  DEBUGASSERT(data->multi);
3957  *pbuf = NULL;
3958  *pbuflen = 0;
3959  if(!data->multi) {
3960    failf(data, "transfer has no multi handle");
3961    return CURLE_FAILED_INIT;
3962  }
3963  if(!data->set.buffer_size) {
3964    failf(data, "transfer buffer size is 0");
3965    return CURLE_FAILED_INIT;
3966  }
3967  if(data->multi->xfer_buf_borrowed) {
3968    failf(data, "attempt to borrow xfer_buf when already borrowed");
3969    return CURLE_AGAIN;
3970  }
3971
3972  if(data->multi->xfer_buf &&
3973     data->set.buffer_size > data->multi->xfer_buf_len) {
3974    /* not large enough, get a new one */
3975    curlx_free(data->multi->xfer_buf);
3976    data->multi->xfer_buf = NULL;
3977    data->multi->xfer_buf_len = 0;
3978  }
3979
3980  if(!data->multi->xfer_buf) {
3981    data->multi->xfer_buf = curlx_malloc(curlx_uitouz(data->set.buffer_size));
3982    if(!data->multi->xfer_buf) {
3983      failf(data, "could not allocate xfer_buf of %u bytes",
3984            data->set.buffer_size);
3985      return CURLE_OUT_OF_MEMORY;
3986    }
3987    data->multi->xfer_buf_len = data->set.buffer_size;
3988  }
3989
3990  data->multi->xfer_buf_borrowed = TRUE;
3991  *pbuf = data->multi->xfer_buf;
3992  *pbuflen = data->multi->xfer_buf_len;
3993  return CURLE_OK;
3994}
3995
3996void Curl_multi_xfer_buf_release(struct Curl_easy *data, char *buf)
3997{
3998  (void)buf;
3999  DEBUGASSERT(data);
4000  DEBUGASSERT(data->multi);
4001  DEBUGASSERT(!buf || data->multi->xfer_buf == buf);
4002  data->multi->xfer_buf_borrowed = FALSE;
4003}
4004
4005CURLcode Curl_multi_xfer_ulbuf_borrow(struct Curl_easy *data,
4006                                      char **pbuf, size_t *pbuflen)
4007{
4008  DEBUGASSERT(data);
4009  DEBUGASSERT(data->multi);
4010  *pbuf = NULL;
4011  *pbuflen = 0;
4012  if(!data->multi) {
4013    failf(data, "transfer has no multi handle");
4014    return CURLE_FAILED_INIT;
4015  }
4016  if(!data->set.upload_buffer_size) {
4017    failf(data, "transfer upload buffer size is 0");
4018    return CURLE_FAILED_INIT;
4019  }
4020  if(data->multi->xfer_ulbuf_borrowed) {
4021    failf(data, "attempt to borrow xfer_ulbuf when already borrowed");
4022    return CURLE_AGAIN;
4023  }
4024
4025  if(data->multi->xfer_ulbuf &&
4026     data->set.upload_buffer_size > data->multi->xfer_ulbuf_len) {
4027    /* not large enough, get a new one */
4028    curlx_free(data->multi->xfer_ulbuf);
4029    data->multi->xfer_ulbuf = NULL;
4030    data->multi->xfer_ulbuf_len = 0;
4031  }
4032
4033  if(!data->multi->xfer_ulbuf) {
4034    data->multi->xfer_ulbuf =
4035      curlx_malloc(curlx_uitouz(data->set.upload_buffer_size));
4036    if(!data->multi->xfer_ulbuf) {
4037      failf(data, "could not allocate xfer_ulbuf of %u bytes",
4038            data->set.upload_buffer_size);
4039      return CURLE_OUT_OF_MEMORY;
4040    }
4041    data->multi->xfer_ulbuf_len = data->set.upload_buffer_size;
4042  }
4043
4044  data->multi->xfer_ulbuf_borrowed = TRUE;
4045  *pbuf = data->multi->xfer_ulbuf;
4046  *pbuflen = data->multi->xfer_ulbuf_len;
4047  return CURLE_OK;
4048}
4049
4050void Curl_multi_xfer_ulbuf_release(struct Curl_easy *data, char *buf)
4051{
4052  (void)buf;
4053  DEBUGASSERT(data);
4054  DEBUGASSERT(data->multi);
4055  DEBUGASSERT(!buf || data->multi->xfer_ulbuf == buf);
4056  data->multi->xfer_ulbuf_borrowed = FALSE;
4057}
4058
4059CURLcode Curl_multi_xfer_sockbuf_borrow(struct Curl_easy *data,
4060                                        size_t blen, char **pbuf)
4061{
4062  DEBUGASSERT(data);
4063  DEBUGASSERT(data->multi);
4064  *pbuf = NULL;
4065  if(!data->multi) {
4066    failf(data, "transfer has no multi handle");
4067    return CURLE_FAILED_INIT;
4068  }
4069  if(data->multi->xfer_sockbuf_borrowed) {
4070    failf(data, "attempt to borrow xfer_sockbuf when already borrowed");
4071    return CURLE_AGAIN;
4072  }
4073
4074  if(data->multi->xfer_sockbuf && blen > data->multi->xfer_sockbuf_len) {
4075    /* not large enough, get a new one */
4076    curlx_free(data->multi->xfer_sockbuf);
4077    data->multi->xfer_sockbuf = NULL;
4078    data->multi->xfer_sockbuf_len = 0;
4079  }
4080
4081  if(!data->multi->xfer_sockbuf) {
4082    data->multi->xfer_sockbuf = curlx_malloc(blen);
4083    if(!data->multi->xfer_sockbuf) {
4084      failf(data, "could not allocate xfer_sockbuf of %zu bytes", blen);
4085      return CURLE_OUT_OF_MEMORY;
4086    }
4087    data->multi->xfer_sockbuf_len = blen;
4088  }
4089
4090  data->multi->xfer_sockbuf_borrowed = TRUE;
4091  *pbuf = data->multi->xfer_sockbuf;
4092  return CURLE_OK;
4093}
4094
4095void Curl_multi_xfer_sockbuf_release(struct Curl_easy *data, char *buf)
4096{
4097  (void)buf;
4098  DEBUGASSERT(data);
4099  DEBUGASSERT(data->multi);
4100  DEBUGASSERT(!buf || data->multi->xfer_sockbuf == buf);
4101  data->multi->xfer_sockbuf_borrowed = FALSE;
4102}
4103
4104static void multi_xfer_bufs_free(struct Curl_multi *multi)
4105{
4106  DEBUGASSERT(multi);
4107  curlx_safefree(multi->xfer_buf);
4108  multi->xfer_buf_len = 0;
4109  multi->xfer_buf_borrowed = FALSE;
4110  curlx_safefree(multi->xfer_ulbuf);
4111  multi->xfer_ulbuf_len = 0;
4112  multi->xfer_ulbuf_borrowed = FALSE;
4113  curlx_safefree(multi->xfer_sockbuf);
4114  multi->xfer_sockbuf_len = 0;
4115  multi->xfer_sockbuf_borrowed = FALSE;
4116}
4117
4118struct Curl_easy *Curl_multi_get_easy(struct Curl_multi *multi,
4119                                      uint32_t mid)
4120{
4121  struct Curl_easy *data = Curl_uint32_tbl_get(&multi->xfers, mid);
4122  if(GOOD_EASY_HANDLE(data))
4123    return data;
4124  CURL_TRC_M(multi->admin, "invalid easy handle in xfer table for mid=%u",
4125             mid);
4126  Curl_uint32_tbl_remove(&multi->xfers, mid);
4127  return NULL;
4128}
4129
4130unsigned int Curl_multi_xfers_running(struct Curl_multi *multi)
4131{
4132  return multi->xfers_alive;
4133}
4134
4135void Curl_multi_mark_dirty(struct Curl_easy *data)
4136{
4137  if(data->multi && data->mid != UINT32_MAX)
4138    Curl_uint32_bset_add(&data->multi->dirty, data->mid);
4139}
4140
4141void Curl_multi_clear_dirty(struct Curl_easy *data)
4142{
4143  if(data->multi && data->mid != UINT32_MAX)
4144    Curl_uint32_bset_remove(&data->multi->dirty, data->mid);
4145}
4146
4147CURLMcode curl_multi_notify_enable(CURLM *m, unsigned int notification)
4148{
4149  struct Curl_multi *multi = m;
4150
4151  if(!GOOD_MULTI_HANDLE(multi))
4152    return CURLM_BAD_HANDLE;
4153  return Curl_mntfy_enable(multi, notification);
4154}
4155
4156CURLMcode curl_multi_notify_disable(CURLM *m, unsigned int notification)
4157{
4158  struct Curl_multi *multi = m;
4159
4160  if(!GOOD_MULTI_HANDLE(multi))
4161    return CURLM_BAD_HANDLE;
4162  return Curl_mntfy_disable(multi, notification);
4163}
4164
4165#ifdef DEBUGBUILD
4166static void multi_xfer_dump(struct Curl_multi *multi, uint32_t mid,
4167                            void *entry)
4168{
4169  struct Curl_easy *data = entry;
4170
4171  (void)multi;
4172  if(!data) {
4173    curl_mfprintf(stderr, "mid=%u, entry=NULL, bug in xfer table?\n", mid);
4174  }
4175  else {
4176    curl_mfprintf(stderr, "mid=%u, magic=%s, p=%p, id=%" FMT_OFF_T
4177                  ", url=%s\n",
4178                  mid,
4179                  (data->magic == CURLEASY_MAGIC_NUMBER) ? "GOOD" : "BAD!",
4180                  (void *)data, data->id, Curl_bufref_ptr(&data->state.url));
4181  }
4182}
4183
4184static void multi_xfer_tbl_dump(struct Curl_multi *multi)
4185{
4186  uint32_t mid;
4187  void *entry;
4188  curl_mfprintf(stderr, "=== multi xfer table (count=%u, capacity=%u\n",
4189                Curl_uint32_tbl_count(&multi->xfers),
4190                Curl_uint32_tbl_capacity(&multi->xfers));
4191  if(Curl_uint32_tbl_first(&multi->xfers, &mid, &entry)) {
4192    multi_xfer_dump(multi, mid, entry);
4193    while(Curl_uint32_tbl_next(&multi->xfers, mid, &mid, &entry))
4194      multi_xfer_dump(multi, mid, entry);
4195  }
4196  curl_mfprintf(stderr, "===\n");
4197  fflush(stderr);
4198}
4199#endif /* DEBUGBUILD */