Annotation of embedaddon/curl/lib/multi.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22:
! 23: #include "curl_setup.h"
! 24:
! 25: #include <curl/curl.h>
! 26:
! 27: #include "urldata.h"
! 28: #include "transfer.h"
! 29: #include "url.h"
! 30: #include "connect.h"
! 31: #include "progress.h"
! 32: #include "easyif.h"
! 33: #include "share.h"
! 34: #include "psl.h"
! 35: #include "multiif.h"
! 36: #include "sendf.h"
! 37: #include "timeval.h"
! 38: #include "http.h"
! 39: #include "select.h"
! 40: #include "warnless.h"
! 41: #include "speedcheck.h"
! 42: #include "conncache.h"
! 43: #include "multihandle.h"
! 44: #include "sigpipe.h"
! 45: #include "vtls/vtls.h"
! 46: #include "connect.h"
! 47: #include "http_proxy.h"
! 48: #include "http2.h"
! 49: #include "socketpair.h"
! 50: #include "socks.h"
! 51: /* The last 3 #include files should be in this order */
! 52: #include "curl_printf.h"
! 53: #include "curl_memory.h"
! 54: #include "memdebug.h"
! 55:
! 56: /*
! 57: CURL_SOCKET_HASH_TABLE_SIZE should be a prime number. Increasing it from 97
! 58: to 911 takes on a 32-bit machine 4 x 804 = 3211 more bytes. Still, every
! 59: CURL handle takes 45-50 K memory, therefore this 3K are not significant.
! 60: */
! 61: #ifndef CURL_SOCKET_HASH_TABLE_SIZE
! 62: #define CURL_SOCKET_HASH_TABLE_SIZE 911
! 63: #endif
! 64:
! 65: #ifndef CURL_CONNECTION_HASH_SIZE
! 66: #define CURL_CONNECTION_HASH_SIZE 97
! 67: #endif
! 68:
! 69: #define CURL_MULTI_HANDLE 0x000bab1e
! 70:
! 71: #define GOOD_MULTI_HANDLE(x) \
! 72: ((x) && (x)->type == CURL_MULTI_HANDLE)
! 73:
! 74: static CURLMcode singlesocket(struct Curl_multi *multi,
! 75: struct Curl_easy *data);
! 76: static CURLMcode add_next_timeout(struct curltime now,
! 77: struct Curl_multi *multi,
! 78: struct Curl_easy *d);
! 79: static CURLMcode multi_timeout(struct Curl_multi *multi,
! 80: long *timeout_ms);
! 81: static void process_pending_handles(struct Curl_multi *multi);
! 82: static void detach_connnection(struct Curl_easy *data);
! 83:
! 84: #ifdef DEBUGBUILD
! 85: static const char * const statename[]={
! 86: "INIT",
! 87: "CONNECT_PEND",
! 88: "CONNECT",
! 89: "WAITRESOLVE",
! 90: "WAITCONNECT",
! 91: "WAITPROXYCONNECT",
! 92: "SENDPROTOCONNECT",
! 93: "PROTOCONNECT",
! 94: "DO",
! 95: "DOING",
! 96: "DO_MORE",
! 97: "DO_DONE",
! 98: "PERFORM",
! 99: "TOOFAST",
! 100: "DONE",
! 101: "COMPLETED",
! 102: "MSGSENT",
! 103: };
! 104: #endif
! 105:
! 106: /* function pointer called once when switching TO a state */
! 107: typedef void (*init_multistate_func)(struct Curl_easy *data);
! 108:
! 109: static void Curl_init_completed(struct Curl_easy *data)
! 110: {
! 111: /* this is a completed transfer */
! 112:
! 113: /* Important: reset the conn pointer so that we don't point to memory
! 114: that could be freed anytime */
! 115: detach_connnection(data);
! 116: Curl_expire_clear(data); /* stop all timers */
! 117: }
! 118:
! 119: /* always use this function to change state, to make debugging easier */
! 120: static void mstate(struct Curl_easy *data, CURLMstate state
! 121: #ifdef DEBUGBUILD
! 122: , int lineno
! 123: #endif
! 124: )
! 125: {
! 126: CURLMstate oldstate = data->mstate;
! 127: static const init_multistate_func finit[CURLM_STATE_LAST] = {
! 128: NULL, /* INIT */
! 129: NULL, /* CONNECT_PEND */
! 130: Curl_init_CONNECT, /* CONNECT */
! 131: NULL, /* WAITRESOLVE */
! 132: NULL, /* WAITCONNECT */
! 133: NULL, /* WAITPROXYCONNECT */
! 134: NULL, /* SENDPROTOCONNECT */
! 135: NULL, /* PROTOCONNECT */
! 136: Curl_connect_free, /* DO */
! 137: NULL, /* DOING */
! 138: NULL, /* DO_MORE */
! 139: NULL, /* DO_DONE */
! 140: NULL, /* PERFORM */
! 141: NULL, /* TOOFAST */
! 142: NULL, /* DONE */
! 143: Curl_init_completed, /* COMPLETED */
! 144: NULL /* MSGSENT */
! 145: };
! 146:
! 147: #if defined(DEBUGBUILD) && defined(CURL_DISABLE_VERBOSE_STRINGS)
! 148: (void) lineno;
! 149: #endif
! 150:
! 151: if(oldstate == state)
! 152: /* don't bother when the new state is the same as the old state */
! 153: return;
! 154:
! 155: data->mstate = state;
! 156:
! 157: #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
! 158: if(data->mstate >= CURLM_STATE_CONNECT_PEND &&
! 159: data->mstate < CURLM_STATE_COMPLETED) {
! 160: long connection_id = -5000;
! 161:
! 162: if(data->conn)
! 163: connection_id = data->conn->connection_id;
! 164:
! 165: infof(data,
! 166: "STATE: %s => %s handle %p; line %d (connection #%ld)\n",
! 167: statename[oldstate], statename[data->mstate],
! 168: (void *)data, lineno, connection_id);
! 169: }
! 170: #endif
! 171:
! 172: if(state == CURLM_STATE_COMPLETED)
! 173: /* changing to COMPLETED means there's one less easy handle 'alive' */
! 174: data->multi->num_alive--;
! 175:
! 176: /* if this state has an init-function, run it */
! 177: if(finit[state])
! 178: finit[state](data);
! 179: }
! 180:
! 181: #ifndef DEBUGBUILD
! 182: #define multistate(x,y) mstate(x,y)
! 183: #else
! 184: #define multistate(x,y) mstate(x,y, __LINE__)
! 185: #endif
! 186:
! 187: /*
! 188: * We add one of these structs to the sockhash for each socket
! 189: */
! 190:
! 191: struct Curl_sh_entry {
! 192: struct curl_hash transfers; /* hash of transfers using this socket */
! 193: unsigned int action; /* what combined action READ/WRITE this socket waits
! 194: for */
! 195: void *socketp; /* settable by users with curl_multi_assign() */
! 196: unsigned int users; /* number of transfers using this */
! 197: unsigned int readers; /* this many transfers want to read */
! 198: unsigned int writers; /* this many transfers want to write */
! 199: };
! 200: /* bits for 'action' having no bits means this socket is not expecting any
! 201: action */
! 202: #define SH_READ 1
! 203: #define SH_WRITE 2
! 204:
! 205: /* look up a given socket in the socket hash, skip invalid sockets */
! 206: static struct Curl_sh_entry *sh_getentry(struct curl_hash *sh,
! 207: curl_socket_t s)
! 208: {
! 209: if(s != CURL_SOCKET_BAD) {
! 210: /* only look for proper sockets */
! 211: return Curl_hash_pick(sh, (char *)&s, sizeof(curl_socket_t));
! 212: }
! 213: return NULL;
! 214: }
! 215:
! 216: #define TRHASH_SIZE 13
! 217: static size_t trhash(void *key, size_t key_length, size_t slots_num)
! 218: {
! 219: size_t keyval = (size_t)*(struct Curl_easy **)key;
! 220: (void) key_length;
! 221:
! 222: return (keyval % slots_num);
! 223: }
! 224:
! 225: static size_t trhash_compare(void *k1, size_t k1_len, void *k2, size_t k2_len)
! 226: {
! 227: (void)k1_len;
! 228: (void)k2_len;
! 229:
! 230: return *(struct Curl_easy **)k1 == *(struct Curl_easy **)k2;
! 231: }
! 232:
! 233: static void trhash_dtor(void *nada)
! 234: {
! 235: (void)nada;
! 236: }
! 237:
! 238:
! 239: /* make sure this socket is present in the hash for this handle */
! 240: static struct Curl_sh_entry *sh_addentry(struct curl_hash *sh,
! 241: curl_socket_t s)
! 242: {
! 243: struct Curl_sh_entry *there = sh_getentry(sh, s);
! 244: struct Curl_sh_entry *check;
! 245:
! 246: if(there) {
! 247: /* it is present, return fine */
! 248: return there;
! 249: }
! 250:
! 251: /* not present, add it */
! 252: check = calloc(1, sizeof(struct Curl_sh_entry));
! 253: if(!check)
! 254: return NULL; /* major failure */
! 255:
! 256: if(Curl_hash_init(&check->transfers, TRHASH_SIZE, trhash,
! 257: trhash_compare, trhash_dtor)) {
! 258: free(check);
! 259: return NULL;
! 260: }
! 261:
! 262: /* make/add new hash entry */
! 263: if(!Curl_hash_add(sh, (char *)&s, sizeof(curl_socket_t), check)) {
! 264: Curl_hash_destroy(&check->transfers);
! 265: free(check);
! 266: return NULL; /* major failure */
! 267: }
! 268:
! 269: return check; /* things are good in sockhash land */
! 270: }
! 271:
! 272:
! 273: /* delete the given socket + handle from the hash */
! 274: static void sh_delentry(struct Curl_sh_entry *entry,
! 275: struct curl_hash *sh, curl_socket_t s)
! 276: {
! 277: Curl_hash_destroy(&entry->transfers);
! 278:
! 279: /* We remove the hash entry. This will end up in a call to
! 280: sh_freeentry(). */
! 281: Curl_hash_delete(sh, (char *)&s, sizeof(curl_socket_t));
! 282: }
! 283:
! 284: /*
! 285: * free a sockhash entry
! 286: */
! 287: static void sh_freeentry(void *freethis)
! 288: {
! 289: struct Curl_sh_entry *p = (struct Curl_sh_entry *) freethis;
! 290:
! 291: free(p);
! 292: }
! 293:
! 294: static size_t fd_key_compare(void *k1, size_t k1_len, void *k2, size_t k2_len)
! 295: {
! 296: (void) k1_len; (void) k2_len;
! 297:
! 298: return (*((curl_socket_t *) k1)) == (*((curl_socket_t *) k2));
! 299: }
! 300:
! 301: static size_t hash_fd(void *key, size_t key_length, size_t slots_num)
! 302: {
! 303: curl_socket_t fd = *((curl_socket_t *) key);
! 304: (void) key_length;
! 305:
! 306: return (fd % slots_num);
! 307: }
! 308:
! 309: /*
! 310: * sh_init() creates a new socket hash and returns the handle for it.
! 311: *
! 312: * Quote from README.multi_socket:
! 313: *
! 314: * "Some tests at 7000 and 9000 connections showed that the socket hash lookup
! 315: * is somewhat of a bottle neck. Its current implementation may be a bit too
! 316: * limiting. It simply has a fixed-size array, and on each entry in the array
! 317: * it has a linked list with entries. So the hash only checks which list to
! 318: * scan through. The code I had used so for used a list with merely 7 slots
! 319: * (as that is what the DNS hash uses) but with 7000 connections that would
! 320: * make an average of 1000 nodes in each list to run through. I upped that to
! 321: * 97 slots (I believe a prime is suitable) and noticed a significant speed
! 322: * increase. I need to reconsider the hash implementation or use a rather
! 323: * large default value like this. At 9000 connections I was still below 10us
! 324: * per call."
! 325: *
! 326: */
! 327: static int sh_init(struct curl_hash *hash, int hashsize)
! 328: {
! 329: return Curl_hash_init(hash, hashsize, hash_fd, fd_key_compare,
! 330: sh_freeentry);
! 331: }
! 332:
! 333: /*
! 334: * multi_addmsg()
! 335: *
! 336: * Called when a transfer is completed. Adds the given msg pointer to
! 337: * the list kept in the multi handle.
! 338: */
! 339: static CURLMcode multi_addmsg(struct Curl_multi *multi,
! 340: struct Curl_message *msg)
! 341: {
! 342: Curl_llist_insert_next(&multi->msglist, multi->msglist.tail, msg,
! 343: &msg->list);
! 344: return CURLM_OK;
! 345: }
! 346:
! 347: struct Curl_multi *Curl_multi_handle(int hashsize, /* socket hash */
! 348: int chashsize) /* connection hash */
! 349: {
! 350: struct Curl_multi *multi = calloc(1, sizeof(struct Curl_multi));
! 351:
! 352: if(!multi)
! 353: return NULL;
! 354:
! 355: multi->type = CURL_MULTI_HANDLE;
! 356:
! 357: if(Curl_mk_dnscache(&multi->hostcache))
! 358: goto error;
! 359:
! 360: if(sh_init(&multi->sockhash, hashsize))
! 361: goto error;
! 362:
! 363: if(Curl_conncache_init(&multi->conn_cache, chashsize))
! 364: goto error;
! 365:
! 366: Curl_llist_init(&multi->msglist, NULL);
! 367: Curl_llist_init(&multi->pending, NULL);
! 368:
! 369: multi->multiplexing = TRUE;
! 370:
! 371: /* -1 means it not set by user, use the default value */
! 372: multi->maxconnects = -1;
! 373: multi->max_concurrent_streams = 100;
! 374: multi->ipv6_works = Curl_ipv6works(NULL);
! 375:
! 376: #ifdef ENABLE_WAKEUP
! 377: if(Curl_socketpair(AF_UNIX, SOCK_STREAM, 0, multi->wakeup_pair) < 0) {
! 378: multi->wakeup_pair[0] = CURL_SOCKET_BAD;
! 379: multi->wakeup_pair[1] = CURL_SOCKET_BAD;
! 380: }
! 381: else if(curlx_nonblock(multi->wakeup_pair[0], TRUE) < 0 ||
! 382: curlx_nonblock(multi->wakeup_pair[1], TRUE) < 0) {
! 383: sclose(multi->wakeup_pair[0]);
! 384: sclose(multi->wakeup_pair[1]);
! 385: multi->wakeup_pair[0] = CURL_SOCKET_BAD;
! 386: multi->wakeup_pair[1] = CURL_SOCKET_BAD;
! 387: }
! 388: #endif
! 389:
! 390: return multi;
! 391:
! 392: error:
! 393:
! 394: Curl_hash_destroy(&multi->sockhash);
! 395: Curl_hash_destroy(&multi->hostcache);
! 396: Curl_conncache_destroy(&multi->conn_cache);
! 397: Curl_llist_destroy(&multi->msglist, NULL);
! 398: Curl_llist_destroy(&multi->pending, NULL);
! 399:
! 400: free(multi);
! 401: return NULL;
! 402: }
! 403:
! 404: struct Curl_multi *curl_multi_init(void)
! 405: {
! 406: return Curl_multi_handle(CURL_SOCKET_HASH_TABLE_SIZE,
! 407: CURL_CONNECTION_HASH_SIZE);
! 408: }
! 409:
! 410: CURLMcode curl_multi_add_handle(struct Curl_multi *multi,
! 411: struct Curl_easy *data)
! 412: {
! 413: /* First, make some basic checks that the CURLM handle is a good handle */
! 414: if(!GOOD_MULTI_HANDLE(multi))
! 415: return CURLM_BAD_HANDLE;
! 416:
! 417: /* Verify that we got a somewhat good easy handle too */
! 418: if(!GOOD_EASY_HANDLE(data))
! 419: return CURLM_BAD_EASY_HANDLE;
! 420:
! 421: /* Prevent users from adding same easy handle more than once and prevent
! 422: adding to more than one multi stack */
! 423: if(data->multi)
! 424: return CURLM_ADDED_ALREADY;
! 425:
! 426: if(multi->in_callback)
! 427: return CURLM_RECURSIVE_API_CALL;
! 428:
! 429: /* Initialize timeout list for this handle */
! 430: Curl_llist_init(&data->state.timeoutlist, NULL);
! 431:
! 432: /*
! 433: * No failure allowed in this function beyond this point. And no
! 434: * modification of easy nor multi handle allowed before this except for
! 435: * potential multi's connection cache growing which won't be undone in this
! 436: * function no matter what.
! 437: */
! 438: if(data->set.errorbuffer)
! 439: data->set.errorbuffer[0] = 0;
! 440:
! 441: /* set the easy handle */
! 442: multistate(data, CURLM_STATE_INIT);
! 443:
! 444: /* for multi interface connections, we share DNS cache automatically if the
! 445: easy handle's one is currently not set. */
! 446: if(!data->dns.hostcache ||
! 447: (data->dns.hostcachetype == HCACHE_NONE)) {
! 448: data->dns.hostcache = &multi->hostcache;
! 449: data->dns.hostcachetype = HCACHE_MULTI;
! 450: }
! 451:
! 452: /* Point to the shared or multi handle connection cache */
! 453: if(data->share && (data->share->specifier & (1<< CURL_LOCK_DATA_CONNECT)))
! 454: data->state.conn_cache = &data->share->conn_cache;
! 455: else
! 456: data->state.conn_cache = &multi->conn_cache;
! 457:
! 458: #ifdef USE_LIBPSL
! 459: /* Do the same for PSL. */
! 460: if(data->share && (data->share->specifier & (1 << CURL_LOCK_DATA_PSL)))
! 461: data->psl = &data->share->psl;
! 462: else
! 463: data->psl = &multi->psl;
! 464: #endif
! 465:
! 466: /* We add the new entry last in the list. */
! 467: data->next = NULL; /* end of the line */
! 468: if(multi->easyp) {
! 469: struct Curl_easy *last = multi->easylp;
! 470: last->next = data;
! 471: data->prev = last;
! 472: multi->easylp = data; /* the new last node */
! 473: }
! 474: else {
! 475: /* first node, make prev NULL! */
! 476: data->prev = NULL;
! 477: multi->easylp = multi->easyp = data; /* both first and last */
! 478: }
! 479:
! 480: /* make the Curl_easy refer back to this multi handle */
! 481: data->multi = multi;
! 482:
! 483: /* Set the timeout for this handle to expire really soon so that it will
! 484: be taken care of even when this handle is added in the midst of operation
! 485: when only the curl_multi_socket() API is used. During that flow, only
! 486: sockets that time-out or have actions will be dealt with. Since this
! 487: handle has no action yet, we make sure it times out to get things to
! 488: happen. */
! 489: Curl_expire(data, 0, EXPIRE_RUN_NOW);
! 490:
! 491: /* increase the node-counter */
! 492: multi->num_easy++;
! 493:
! 494: /* increase the alive-counter */
! 495: multi->num_alive++;
! 496:
! 497: /* A somewhat crude work-around for a little glitch in Curl_update_timer()
! 498: that happens if the lastcall time is set to the same time when the handle
! 499: is removed as when the next handle is added, as then the check in
! 500: Curl_update_timer() that prevents calling the application multiple times
! 501: with the same timer info will not trigger and then the new handle's
! 502: timeout will not be notified to the app.
! 503:
! 504: The work-around is thus simply to clear the 'lastcall' variable to force
! 505: Curl_update_timer() to always trigger a callback to the app when a new
! 506: easy handle is added */
! 507: memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall));
! 508:
! 509: /* The closure handle only ever has default timeouts set. To improve the
! 510: state somewhat we clone the timeouts from each added handle so that the
! 511: closure handle always has the same timeouts as the most recently added
! 512: easy handle. */
! 513: data->state.conn_cache->closure_handle->set.timeout = data->set.timeout;
! 514: data->state.conn_cache->closure_handle->set.server_response_timeout =
! 515: data->set.server_response_timeout;
! 516: data->state.conn_cache->closure_handle->set.no_signal =
! 517: data->set.no_signal;
! 518:
! 519: Curl_update_timer(multi);
! 520: return CURLM_OK;
! 521: }
! 522:
! 523: #if 0
! 524: /* Debug-function, used like this:
! 525: *
! 526: * Curl_hash_print(multi->sockhash, debug_print_sock_hash);
! 527: *
! 528: * Enable the hash print function first by editing hash.c
! 529: */
! 530: static void debug_print_sock_hash(void *p)
! 531: {
! 532: struct Curl_sh_entry *sh = (struct Curl_sh_entry *)p;
! 533:
! 534: fprintf(stderr, " [easy %p/magic %x/socket %d]",
! 535: (void *)sh->data, sh->data->magic, (int)sh->socket);
! 536: }
! 537: #endif
! 538:
! 539: static CURLcode multi_done(struct Curl_easy *data,
! 540: CURLcode status, /* an error if this is called
! 541: after an error was detected */
! 542: bool premature)
! 543: {
! 544: CURLcode result;
! 545: struct connectdata *conn = data->conn;
! 546: unsigned int i;
! 547:
! 548: DEBUGF(infof(data, "multi_done\n"));
! 549:
! 550: if(data->state.done)
! 551: /* Stop if multi_done() has already been called */
! 552: return CURLE_OK;
! 553:
! 554: conn->data = data; /* ensure the connection uses this transfer now */
! 555:
! 556: /* Stop the resolver and free its own resources (but not dns_entry yet). */
! 557: Curl_resolver_kill(conn);
! 558:
! 559: /* Cleanup possible redirect junk */
! 560: Curl_safefree(data->req.newurl);
! 561: Curl_safefree(data->req.location);
! 562:
! 563: switch(status) {
! 564: case CURLE_ABORTED_BY_CALLBACK:
! 565: case CURLE_READ_ERROR:
! 566: case CURLE_WRITE_ERROR:
! 567: /* When we're aborted due to a callback return code it basically have to
! 568: be counted as premature as there is trouble ahead if we don't. We have
! 569: many callbacks and protocols work differently, we could potentially do
! 570: this more fine-grained in the future. */
! 571: premature = TRUE;
! 572: default:
! 573: break;
! 574: }
! 575:
! 576: /* this calls the protocol-specific function pointer previously set */
! 577: if(conn->handler->done)
! 578: result = conn->handler->done(conn, status, premature);
! 579: else
! 580: result = status;
! 581:
! 582: if(CURLE_ABORTED_BY_CALLBACK != result) {
! 583: /* avoid this if we already aborted by callback to avoid this calling
! 584: another callback */
! 585: CURLcode rc = Curl_pgrsDone(conn);
! 586: if(!result && rc)
! 587: result = CURLE_ABORTED_BY_CALLBACK;
! 588: }
! 589:
! 590: process_pending_handles(data->multi); /* connection / multiplex */
! 591:
! 592: CONN_LOCK(data);
! 593: detach_connnection(data);
! 594: if(CONN_INUSE(conn)) {
! 595: /* Stop if still used. */
! 596: /* conn->data must not remain pointing to this transfer since it is going
! 597: away! Find another to own it! */
! 598: conn->data = conn->easyq.head->ptr;
! 599: CONN_UNLOCK(data);
! 600: DEBUGF(infof(data, "Connection still in use %zu, "
! 601: "no more multi_done now!\n",
! 602: conn->easyq.size));
! 603: return CURLE_OK;
! 604: }
! 605: conn->data = NULL; /* the connection now has no owner */
! 606: data->state.done = TRUE; /* called just now! */
! 607:
! 608: if(conn->dns_entry) {
! 609: Curl_resolv_unlock(data, conn->dns_entry); /* done with this */
! 610: conn->dns_entry = NULL;
! 611: }
! 612: Curl_hostcache_prune(data);
! 613: Curl_safefree(data->state.ulbuf);
! 614:
! 615: /* if the transfer was completed in a paused state there can be buffered
! 616: data left to free */
! 617: for(i = 0; i < data->state.tempcount; i++) {
! 618: free(data->state.tempwrite[i].buf);
! 619: }
! 620: data->state.tempcount = 0;
! 621:
! 622: /* if data->set.reuse_forbid is TRUE, it means the libcurl client has
! 623: forced us to close this connection. This is ignored for requests taking
! 624: place in a NTLM/NEGOTIATE authentication handshake
! 625:
! 626: if conn->bits.close is TRUE, it means that the connection should be
! 627: closed in spite of all our efforts to be nice, due to protocol
! 628: restrictions in our or the server's end
! 629:
! 630: if premature is TRUE, it means this connection was said to be DONE before
! 631: the entire request operation is complete and thus we can't know in what
! 632: state it is for re-using, so we're forced to close it. In a perfect world
! 633: we can add code that keep track of if we really must close it here or not,
! 634: but currently we have no such detail knowledge.
! 635: */
! 636:
! 637: if((data->set.reuse_forbid
! 638: #if defined(USE_NTLM)
! 639: && !(conn->http_ntlm_state == NTLMSTATE_TYPE2 ||
! 640: conn->proxy_ntlm_state == NTLMSTATE_TYPE2)
! 641: #endif
! 642: #if defined(USE_SPNEGO)
! 643: && !(conn->http_negotiate_state == GSS_AUTHRECV ||
! 644: conn->proxy_negotiate_state == GSS_AUTHRECV)
! 645: #endif
! 646: ) || conn->bits.close
! 647: || (premature && !(conn->handler->flags & PROTOPT_STREAM))) {
! 648: CURLcode res2;
! 649: connclose(conn, "disconnecting");
! 650: CONN_UNLOCK(data);
! 651: res2 = Curl_disconnect(data, conn, premature);
! 652:
! 653: /* If we had an error already, make sure we return that one. But
! 654: if we got a new error, return that. */
! 655: if(!result && res2)
! 656: result = res2;
! 657: }
! 658: else {
! 659: char buffer[256];
! 660: /* create string before returning the connection */
! 661: msnprintf(buffer, sizeof(buffer),
! 662: "Connection #%ld to host %s left intact",
! 663: conn->connection_id,
! 664: conn->bits.socksproxy ? conn->socks_proxy.host.dispname :
! 665: conn->bits.httpproxy ? conn->http_proxy.host.dispname :
! 666: conn->bits.conn_to_host ? conn->conn_to_host.dispname :
! 667: conn->host.dispname);
! 668: /* the connection is no longer in use by this transfer */
! 669: CONN_UNLOCK(data);
! 670: if(Curl_conncache_return_conn(data, conn)) {
! 671: /* remember the most recently used connection */
! 672: data->state.lastconnect = conn;
! 673: infof(data, "%s\n", buffer);
! 674: }
! 675: else
! 676: data->state.lastconnect = NULL;
! 677: }
! 678:
! 679: Curl_free_request_state(data);
! 680: return result;
! 681: }
! 682:
! 683: CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
! 684: struct Curl_easy *data)
! 685: {
! 686: struct Curl_easy *easy = data;
! 687: bool premature;
! 688: bool easy_owns_conn;
! 689: struct curl_llist_element *e;
! 690:
! 691: /* First, make some basic checks that the CURLM handle is a good handle */
! 692: if(!GOOD_MULTI_HANDLE(multi))
! 693: return CURLM_BAD_HANDLE;
! 694:
! 695: /* Verify that we got a somewhat good easy handle too */
! 696: if(!GOOD_EASY_HANDLE(data))
! 697: return CURLM_BAD_EASY_HANDLE;
! 698:
! 699: /* Prevent users from trying to remove same easy handle more than once */
! 700: if(!data->multi)
! 701: return CURLM_OK; /* it is already removed so let's say it is fine! */
! 702:
! 703: /* Prevent users from trying to remove an easy handle from the wrong multi */
! 704: if(data->multi != multi)
! 705: return CURLM_BAD_EASY_HANDLE;
! 706:
! 707: if(multi->in_callback)
! 708: return CURLM_RECURSIVE_API_CALL;
! 709:
! 710: premature = (data->mstate < CURLM_STATE_COMPLETED) ? TRUE : FALSE;
! 711: easy_owns_conn = (data->conn && (data->conn->data == easy)) ?
! 712: TRUE : FALSE;
! 713:
! 714: /* If the 'state' is not INIT or COMPLETED, we might need to do something
! 715: nice to put the easy_handle in a good known state when this returns. */
! 716: if(premature) {
! 717: /* this handle is "alive" so we need to count down the total number of
! 718: alive connections when this is removed */
! 719: multi->num_alive--;
! 720: }
! 721:
! 722: if(data->conn &&
! 723: data->mstate > CURLM_STATE_DO &&
! 724: data->mstate < CURLM_STATE_COMPLETED) {
! 725: /* Set connection owner so that the DONE function closes it. We can
! 726: safely do this here since connection is killed. */
! 727: data->conn->data = easy;
! 728: streamclose(data->conn, "Removed with partial response");
! 729: easy_owns_conn = TRUE;
! 730: }
! 731:
! 732: if(data->conn) {
! 733:
! 734: /* we must call multi_done() here (if we still own the connection) so that
! 735: we don't leave a half-baked one around */
! 736: if(easy_owns_conn) {
! 737:
! 738: /* multi_done() clears the association between the easy handle and the
! 739: connection.
! 740:
! 741: Note that this ignores the return code simply because there's
! 742: nothing really useful to do with it anyway! */
! 743: (void)multi_done(data, data->result, premature);
! 744: }
! 745: }
! 746:
! 747: /* The timer must be shut down before data->multi is set to NULL, else the
! 748: timenode will remain in the splay tree after curl_easy_cleanup is
! 749: called. Do it after multi_done() in case that sets another time! */
! 750: Curl_expire_clear(data);
! 751:
! 752: if(data->connect_queue.ptr)
! 753: /* the handle was in the pending list waiting for an available connection,
! 754: so go ahead and remove it */
! 755: Curl_llist_remove(&multi->pending, &data->connect_queue, NULL);
! 756:
! 757: if(data->dns.hostcachetype == HCACHE_MULTI) {
! 758: /* stop using the multi handle's DNS cache, *after* the possible
! 759: multi_done() call above */
! 760: data->dns.hostcache = NULL;
! 761: data->dns.hostcachetype = HCACHE_NONE;
! 762: }
! 763:
! 764: Curl_wildcard_dtor(&data->wildcard);
! 765:
! 766: /* destroy the timeout list that is held in the easy handle, do this *after*
! 767: multi_done() as that may actually call Curl_expire that uses this */
! 768: Curl_llist_destroy(&data->state.timeoutlist, NULL);
! 769:
! 770: /* as this was using a shared connection cache we clear the pointer to that
! 771: since we're not part of that multi handle anymore */
! 772: data->state.conn_cache = NULL;
! 773:
! 774: /* change state without using multistate(), only to make singlesocket() do
! 775: what we want */
! 776: data->mstate = CURLM_STATE_COMPLETED;
! 777: singlesocket(multi, easy); /* to let the application know what sockets that
! 778: vanish with this handle */
! 779:
! 780: /* Remove the association between the connection and the handle */
! 781: if(data->conn)
! 782: detach_connnection(data);
! 783:
! 784: #ifdef USE_LIBPSL
! 785: /* Remove the PSL association. */
! 786: if(data->psl == &multi->psl)
! 787: data->psl = NULL;
! 788: #endif
! 789:
! 790: data->multi = NULL; /* clear the association to this multi handle */
! 791:
! 792: /* make sure there's no pending message in the queue sent from this easy
! 793: handle */
! 794:
! 795: for(e = multi->msglist.head; e; e = e->next) {
! 796: struct Curl_message *msg = e->ptr;
! 797:
! 798: if(msg->extmsg.easy_handle == easy) {
! 799: Curl_llist_remove(&multi->msglist, e, NULL);
! 800: /* there can only be one from this specific handle */
! 801: break;
! 802: }
! 803: }
! 804:
! 805: /* make the previous node point to our next */
! 806: if(data->prev)
! 807: data->prev->next = data->next;
! 808: else
! 809: multi->easyp = data->next; /* point to first node */
! 810:
! 811: /* make our next point to our previous node */
! 812: if(data->next)
! 813: data->next->prev = data->prev;
! 814: else
! 815: multi->easylp = data->prev; /* point to last node */
! 816:
! 817: /* NOTE NOTE NOTE
! 818: We do not touch the easy handle here! */
! 819: multi->num_easy--; /* one less to care about now */
! 820:
! 821: Curl_update_timer(multi);
! 822: return CURLM_OK;
! 823: }
! 824:
! 825: /* Return TRUE if the application asked for multiplexing */
! 826: bool Curl_multiplex_wanted(const struct Curl_multi *multi)
! 827: {
! 828: return (multi && (multi->multiplexing));
! 829: }
! 830:
! 831: /* This is the only function that should clear data->conn. This will
! 832: occasionally be called with the pointer already cleared. */
! 833: static void detach_connnection(struct Curl_easy *data)
! 834: {
! 835: struct connectdata *conn = data->conn;
! 836: if(conn)
! 837: Curl_llist_remove(&conn->easyq, &data->conn_queue, NULL);
! 838: data->conn = NULL;
! 839: }
! 840:
! 841: /* This is the only function that should assign data->conn */
! 842: void Curl_attach_connnection(struct Curl_easy *data,
! 843: struct connectdata *conn)
! 844: {
! 845: DEBUGASSERT(!data->conn);
! 846: DEBUGASSERT(conn);
! 847: data->conn = conn;
! 848: Curl_llist_insert_next(&conn->easyq, conn->easyq.tail, data,
! 849: &data->conn_queue);
! 850: }
! 851:
! 852: static int waitconnect_getsock(struct connectdata *conn,
! 853: curl_socket_t *sock)
! 854: {
! 855: int i;
! 856: int s = 0;
! 857: int rc = 0;
! 858:
! 859: #ifdef USE_SSL
! 860: if(CONNECT_FIRSTSOCKET_PROXY_SSL())
! 861: return Curl_ssl_getsock(conn, sock);
! 862: #endif
! 863:
! 864: if(SOCKS_STATE(conn->cnnct.state))
! 865: return Curl_SOCKS_getsock(conn, sock, FIRSTSOCKET);
! 866:
! 867: for(i = 0; i<2; i++) {
! 868: if(conn->tempsock[i] != CURL_SOCKET_BAD) {
! 869: sock[s] = conn->tempsock[i];
! 870: rc |= GETSOCK_WRITESOCK(s);
! 871: #ifdef ENABLE_QUIC
! 872: if(conn->transport == TRNSPRT_QUIC)
! 873: /* when connecting QUIC, we want to read the socket too */
! 874: rc |= GETSOCK_READSOCK(s);
! 875: #endif
! 876: s++;
! 877: }
! 878: }
! 879:
! 880: return rc;
! 881: }
! 882:
! 883: static int waitproxyconnect_getsock(struct connectdata *conn,
! 884: curl_socket_t *sock)
! 885: {
! 886: sock[0] = conn->sock[FIRSTSOCKET];
! 887:
! 888: /* when we've sent a CONNECT to a proxy, we should rather wait for the
! 889: socket to become readable to be able to get the response headers */
! 890: if(conn->connect_state)
! 891: return GETSOCK_READSOCK(0);
! 892:
! 893: return GETSOCK_WRITESOCK(0);
! 894: }
! 895:
! 896: static int domore_getsock(struct connectdata *conn,
! 897: curl_socket_t *socks)
! 898: {
! 899: if(conn && conn->handler->domore_getsock)
! 900: return conn->handler->domore_getsock(conn, socks);
! 901: return GETSOCK_BLANK;
! 902: }
! 903:
! 904: static int doing_getsock(struct connectdata *conn,
! 905: curl_socket_t *socks)
! 906: {
! 907: if(conn && conn->handler->doing_getsock)
! 908: return conn->handler->doing_getsock(conn, socks);
! 909: return GETSOCK_BLANK;
! 910: }
! 911:
! 912: static int protocol_getsock(struct connectdata *conn,
! 913: curl_socket_t *socks)
! 914: {
! 915: if(conn->handler->proto_getsock)
! 916: return conn->handler->proto_getsock(conn, socks);
! 917: /* Backup getsock logic. Since there is a live socket in use, we must wait
! 918: for it or it will be removed from watching when the multi_socket API is
! 919: used. */
! 920: socks[0] = conn->sock[FIRSTSOCKET];
! 921: return GETSOCK_READSOCK(0) | GETSOCK_WRITESOCK(0);
! 922: }
! 923:
! 924: /* returns bitmapped flags for this handle and its sockets. The 'socks[]'
! 925: array contains MAX_SOCKSPEREASYHANDLE entries. */
! 926: static int multi_getsock(struct Curl_easy *data,
! 927: curl_socket_t *socks)
! 928: {
! 929: /* The no connection case can happen when this is called from
! 930: curl_multi_remove_handle() => singlesocket() => multi_getsock().
! 931: */
! 932: if(!data->conn)
! 933: return 0;
! 934:
! 935: if(data->mstate > CURLM_STATE_CONNECT &&
! 936: data->mstate < CURLM_STATE_COMPLETED) {
! 937: /* Set up ownership correctly */
! 938: data->conn->data = data;
! 939: }
! 940:
! 941: switch(data->mstate) {
! 942: default:
! 943: #if 0 /* switch back on these cases to get the compiler to check for all enums
! 944: to be present */
! 945: case CURLM_STATE_TOOFAST: /* returns 0, so will not select. */
! 946: case CURLM_STATE_COMPLETED:
! 947: case CURLM_STATE_MSGSENT:
! 948: case CURLM_STATE_INIT:
! 949: case CURLM_STATE_CONNECT:
! 950: case CURLM_STATE_WAITDO:
! 951: case CURLM_STATE_DONE:
! 952: case CURLM_STATE_LAST:
! 953: /* this will get called with CURLM_STATE_COMPLETED when a handle is
! 954: removed */
! 955: #endif
! 956: return 0;
! 957:
! 958: case CURLM_STATE_WAITRESOLVE:
! 959: return Curl_resolv_getsock(data->conn, socks);
! 960:
! 961: case CURLM_STATE_PROTOCONNECT:
! 962: case CURLM_STATE_SENDPROTOCONNECT:
! 963: return protocol_getsock(data->conn, socks);
! 964:
! 965: case CURLM_STATE_DO:
! 966: case CURLM_STATE_DOING:
! 967: return doing_getsock(data->conn, socks);
! 968:
! 969: case CURLM_STATE_WAITPROXYCONNECT:
! 970: return waitproxyconnect_getsock(data->conn, socks);
! 971:
! 972: case CURLM_STATE_WAITCONNECT:
! 973: return waitconnect_getsock(data->conn, socks);
! 974:
! 975: case CURLM_STATE_DO_MORE:
! 976: return domore_getsock(data->conn, socks);
! 977:
! 978: case CURLM_STATE_DO_DONE: /* since is set after DO is completed, we switch
! 979: to waiting for the same as the *PERFORM
! 980: states */
! 981: case CURLM_STATE_PERFORM:
! 982: return Curl_single_getsock(data->conn, socks);
! 983: }
! 984:
! 985: }
! 986:
! 987: CURLMcode curl_multi_fdset(struct Curl_multi *multi,
! 988: fd_set *read_fd_set, fd_set *write_fd_set,
! 989: fd_set *exc_fd_set, int *max_fd)
! 990: {
! 991: /* Scan through all the easy handles to get the file descriptors set.
! 992: Some easy handles may not have connected to the remote host yet,
! 993: and then we must make sure that is done. */
! 994: struct Curl_easy *data;
! 995: int this_max_fd = -1;
! 996: curl_socket_t sockbunch[MAX_SOCKSPEREASYHANDLE];
! 997: int i;
! 998: (void)exc_fd_set; /* not used */
! 999:
! 1000: if(!GOOD_MULTI_HANDLE(multi))
! 1001: return CURLM_BAD_HANDLE;
! 1002:
! 1003: if(multi->in_callback)
! 1004: return CURLM_RECURSIVE_API_CALL;
! 1005:
! 1006: data = multi->easyp;
! 1007: while(data) {
! 1008: int bitmap = multi_getsock(data, sockbunch);
! 1009:
! 1010: for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++) {
! 1011: curl_socket_t s = CURL_SOCKET_BAD;
! 1012:
! 1013: if((bitmap & GETSOCK_READSOCK(i)) && VALID_SOCK((sockbunch[i]))) {
! 1014: FD_SET(sockbunch[i], read_fd_set);
! 1015: s = sockbunch[i];
! 1016: }
! 1017: if((bitmap & GETSOCK_WRITESOCK(i)) && VALID_SOCK((sockbunch[i]))) {
! 1018: FD_SET(sockbunch[i], write_fd_set);
! 1019: s = sockbunch[i];
! 1020: }
! 1021: if(s == CURL_SOCKET_BAD)
! 1022: /* this socket is unused, break out of loop */
! 1023: break;
! 1024: if((int)s > this_max_fd)
! 1025: this_max_fd = (int)s;
! 1026: }
! 1027:
! 1028: data = data->next; /* check next handle */
! 1029: }
! 1030:
! 1031: *max_fd = this_max_fd;
! 1032:
! 1033: return CURLM_OK;
! 1034: }
! 1035:
! 1036: #define NUM_POLLS_ON_STACK 10
! 1037:
! 1038: static CURLMcode Curl_multi_wait(struct Curl_multi *multi,
! 1039: struct curl_waitfd extra_fds[],
! 1040: unsigned int extra_nfds,
! 1041: int timeout_ms,
! 1042: int *ret,
! 1043: bool extrawait, /* when no socket, wait */
! 1044: bool use_wakeup)
! 1045: {
! 1046: struct Curl_easy *data;
! 1047: curl_socket_t sockbunch[MAX_SOCKSPEREASYHANDLE];
! 1048: int bitmap;
! 1049: unsigned int i;
! 1050: unsigned int nfds = 0;
! 1051: unsigned int curlfds;
! 1052: bool ufds_malloc = FALSE;
! 1053: long timeout_internal;
! 1054: int retcode = 0;
! 1055: struct pollfd a_few_on_stack[NUM_POLLS_ON_STACK];
! 1056: struct pollfd *ufds = &a_few_on_stack[0];
! 1057:
! 1058: if(!GOOD_MULTI_HANDLE(multi))
! 1059: return CURLM_BAD_HANDLE;
! 1060:
! 1061: if(multi->in_callback)
! 1062: return CURLM_RECURSIVE_API_CALL;
! 1063:
! 1064: if(timeout_ms < 0)
! 1065: return CURLM_BAD_FUNCTION_ARGUMENT;
! 1066:
! 1067: /* Count up how many fds we have from the multi handle */
! 1068: data = multi->easyp;
! 1069: while(data) {
! 1070: bitmap = multi_getsock(data, sockbunch);
! 1071:
! 1072: for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++) {
! 1073: curl_socket_t s = CURL_SOCKET_BAD;
! 1074:
! 1075: if(bitmap & GETSOCK_READSOCK(i)) {
! 1076: ++nfds;
! 1077: s = sockbunch[i];
! 1078: }
! 1079: if(bitmap & GETSOCK_WRITESOCK(i)) {
! 1080: ++nfds;
! 1081: s = sockbunch[i];
! 1082: }
! 1083: if(s == CURL_SOCKET_BAD) {
! 1084: break;
! 1085: }
! 1086: }
! 1087:
! 1088: data = data->next; /* check next handle */
! 1089: }
! 1090:
! 1091: /* If the internally desired timeout is actually shorter than requested from
! 1092: the outside, then use the shorter time! But only if the internal timer
! 1093: is actually larger than -1! */
! 1094: (void)multi_timeout(multi, &timeout_internal);
! 1095: if((timeout_internal >= 0) && (timeout_internal < (long)timeout_ms))
! 1096: timeout_ms = (int)timeout_internal;
! 1097:
! 1098: curlfds = nfds; /* number of internal file descriptors */
! 1099: nfds += extra_nfds; /* add the externally provided ones */
! 1100:
! 1101: #ifdef ENABLE_WAKEUP
! 1102: if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
! 1103: ++nfds;
! 1104: }
! 1105: #endif
! 1106:
! 1107: if(nfds > NUM_POLLS_ON_STACK) {
! 1108: /* 'nfds' is a 32 bit value and 'struct pollfd' is typically 8 bytes
! 1109: big, so at 2^29 sockets this value might wrap. When a process gets
! 1110: the capability to actually handle over 500 million sockets this
! 1111: calculation needs a integer overflow check. */
! 1112: ufds = malloc(nfds * sizeof(struct pollfd));
! 1113: if(!ufds)
! 1114: return CURLM_OUT_OF_MEMORY;
! 1115: ufds_malloc = TRUE;
! 1116: }
! 1117: nfds = 0;
! 1118:
! 1119: /* only do the second loop if we found descriptors in the first stage run
! 1120: above */
! 1121:
! 1122: if(curlfds) {
! 1123: /* Add the curl handles to our pollfds first */
! 1124: data = multi->easyp;
! 1125: while(data) {
! 1126: bitmap = multi_getsock(data, sockbunch);
! 1127:
! 1128: for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++) {
! 1129: curl_socket_t s = CURL_SOCKET_BAD;
! 1130:
! 1131: if(bitmap & GETSOCK_READSOCK(i)) {
! 1132: ufds[nfds].fd = sockbunch[i];
! 1133: ufds[nfds].events = POLLIN;
! 1134: ++nfds;
! 1135: s = sockbunch[i];
! 1136: }
! 1137: if(bitmap & GETSOCK_WRITESOCK(i)) {
! 1138: ufds[nfds].fd = sockbunch[i];
! 1139: ufds[nfds].events = POLLOUT;
! 1140: ++nfds;
! 1141: s = sockbunch[i];
! 1142: }
! 1143: if(s == CURL_SOCKET_BAD) {
! 1144: break;
! 1145: }
! 1146: }
! 1147:
! 1148: data = data->next; /* check next handle */
! 1149: }
! 1150: }
! 1151:
! 1152: /* Add external file descriptions from poll-like struct curl_waitfd */
! 1153: for(i = 0; i < extra_nfds; i++) {
! 1154: ufds[nfds].fd = extra_fds[i].fd;
! 1155: ufds[nfds].events = 0;
! 1156: if(extra_fds[i].events & CURL_WAIT_POLLIN)
! 1157: ufds[nfds].events |= POLLIN;
! 1158: if(extra_fds[i].events & CURL_WAIT_POLLPRI)
! 1159: ufds[nfds].events |= POLLPRI;
! 1160: if(extra_fds[i].events & CURL_WAIT_POLLOUT)
! 1161: ufds[nfds].events |= POLLOUT;
! 1162: ++nfds;
! 1163: }
! 1164:
! 1165: #ifdef ENABLE_WAKEUP
! 1166: if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
! 1167: ufds[nfds].fd = multi->wakeup_pair[0];
! 1168: ufds[nfds].events = POLLIN;
! 1169: ++nfds;
! 1170: }
! 1171: #endif
! 1172:
! 1173: if(nfds) {
! 1174: int pollrc;
! 1175: /* wait... */
! 1176: pollrc = Curl_poll(ufds, nfds, timeout_ms);
! 1177:
! 1178: if(pollrc > 0) {
! 1179: retcode = pollrc;
! 1180: /* copy revents results from the poll to the curl_multi_wait poll
! 1181: struct, the bit values of the actual underlying poll() implementation
! 1182: may not be the same as the ones in the public libcurl API! */
! 1183: for(i = 0; i < extra_nfds; i++) {
! 1184: unsigned short mask = 0;
! 1185: unsigned r = ufds[curlfds + i].revents;
! 1186:
! 1187: if(r & POLLIN)
! 1188: mask |= CURL_WAIT_POLLIN;
! 1189: if(r & POLLOUT)
! 1190: mask |= CURL_WAIT_POLLOUT;
! 1191: if(r & POLLPRI)
! 1192: mask |= CURL_WAIT_POLLPRI;
! 1193:
! 1194: extra_fds[i].revents = mask;
! 1195: }
! 1196:
! 1197: #ifdef ENABLE_WAKEUP
! 1198: if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
! 1199: if(ufds[curlfds + extra_nfds].revents & POLLIN) {
! 1200: char buf[64];
! 1201: ssize_t nread;
! 1202: while(1) {
! 1203: /* the reading socket is non-blocking, try to read
! 1204: data from it until it receives an error (except EINTR).
! 1205: In normal cases it will get EAGAIN or EWOULDBLOCK
! 1206: when there is no more data, breaking the loop. */
! 1207: nread = sread(multi->wakeup_pair[0], buf, sizeof(buf));
! 1208: if(nread <= 0) {
! 1209: #ifndef USE_WINSOCK
! 1210: if(nread < 0 && EINTR == SOCKERRNO)
! 1211: continue;
! 1212: #endif
! 1213: break;
! 1214: }
! 1215: }
! 1216: /* do not count the wakeup socket into the returned value */
! 1217: retcode--;
! 1218: }
! 1219: }
! 1220: #endif
! 1221: }
! 1222: }
! 1223:
! 1224: if(ufds_malloc)
! 1225: free(ufds);
! 1226: if(ret)
! 1227: *ret = retcode;
! 1228: if(!extrawait || nfds)
! 1229: /* if any socket was checked */
! 1230: ;
! 1231: else {
! 1232: long sleep_ms = 0;
! 1233:
! 1234: /* Avoid busy-looping when there's nothing particular to wait for */
! 1235: if(!curl_multi_timeout(multi, &sleep_ms) && sleep_ms) {
! 1236: if(sleep_ms > timeout_ms)
! 1237: sleep_ms = timeout_ms;
! 1238: /* when there are no easy handles in the multi, this holds a -1
! 1239: timeout */
! 1240: else if((sleep_ms < 0) && extrawait)
! 1241: sleep_ms = timeout_ms;
! 1242: Curl_wait_ms((int)sleep_ms);
! 1243: }
! 1244: }
! 1245:
! 1246: return CURLM_OK;
! 1247: }
! 1248:
! 1249: CURLMcode curl_multi_wait(struct Curl_multi *multi,
! 1250: struct curl_waitfd extra_fds[],
! 1251: unsigned int extra_nfds,
! 1252: int timeout_ms,
! 1253: int *ret)
! 1254: {
! 1255: return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, FALSE,
! 1256: FALSE);
! 1257: }
! 1258:
! 1259: CURLMcode curl_multi_poll(struct Curl_multi *multi,
! 1260: struct curl_waitfd extra_fds[],
! 1261: unsigned int extra_nfds,
! 1262: int timeout_ms,
! 1263: int *ret)
! 1264: {
! 1265: return Curl_multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, TRUE,
! 1266: TRUE);
! 1267: }
! 1268:
! 1269: CURLMcode curl_multi_wakeup(struct Curl_multi *multi)
! 1270: {
! 1271: /* this function is usually called from another thread,
! 1272: it has to be careful only to access parts of the
! 1273: Curl_multi struct that are constant */
! 1274:
! 1275: /* GOOD_MULTI_HANDLE can be safely called */
! 1276: if(!GOOD_MULTI_HANDLE(multi))
! 1277: return CURLM_BAD_HANDLE;
! 1278:
! 1279: #ifdef ENABLE_WAKEUP
! 1280: /* the wakeup_pair variable is only written during init and cleanup,
! 1281: making it safe to access from another thread after the init part
! 1282: and before cleanup */
! 1283: if(multi->wakeup_pair[1] != CURL_SOCKET_BAD) {
! 1284: char buf[1];
! 1285: buf[0] = 1;
! 1286: while(1) {
! 1287: /* swrite() is not thread-safe in general, because concurrent calls
! 1288: can have their messages interleaved, but in this case the content
! 1289: of the messages does not matter, which makes it ok to call.
! 1290:
! 1291: The write socket is set to non-blocking, this way this function
! 1292: cannot block, making it safe to call even from the same thread
! 1293: that will call Curl_multi_wait(). If swrite() returns that it
! 1294: would block, it's considered successful because it means that
! 1295: previous calls to this function will wake up the poll(). */
! 1296: if(swrite(multi->wakeup_pair[1], buf, sizeof(buf)) < 0) {
! 1297: int err = SOCKERRNO;
! 1298: int return_success;
! 1299: #ifdef USE_WINSOCK
! 1300: return_success = WSAEWOULDBLOCK == err;
! 1301: #else
! 1302: if(EINTR == err)
! 1303: continue;
! 1304: return_success = EWOULDBLOCK == err || EAGAIN == err;
! 1305: #endif
! 1306: if(!return_success)
! 1307: return CURLM_WAKEUP_FAILURE;
! 1308: }
! 1309: return CURLM_OK;
! 1310: }
! 1311: }
! 1312: #endif
! 1313: return CURLM_WAKEUP_FAILURE;
! 1314: }
! 1315:
! 1316: /*
! 1317: * multi_ischanged() is called
! 1318: *
! 1319: * Returns TRUE/FALSE whether the state is changed to trigger a CONNECT_PEND
! 1320: * => CONNECT action.
! 1321: *
! 1322: * Set 'clear' to TRUE to have it also clear the state variable.
! 1323: */
! 1324: static bool multi_ischanged(struct Curl_multi *multi, bool clear)
! 1325: {
! 1326: bool retval = multi->recheckstate;
! 1327: if(clear)
! 1328: multi->recheckstate = FALSE;
! 1329: return retval;
! 1330: }
! 1331:
! 1332: CURLMcode Curl_multi_add_perform(struct Curl_multi *multi,
! 1333: struct Curl_easy *data,
! 1334: struct connectdata *conn)
! 1335: {
! 1336: CURLMcode rc;
! 1337:
! 1338: if(multi->in_callback)
! 1339: return CURLM_RECURSIVE_API_CALL;
! 1340:
! 1341: rc = curl_multi_add_handle(multi, data);
! 1342: if(!rc) {
! 1343: struct SingleRequest *k = &data->req;
! 1344:
! 1345: /* pass in NULL for 'conn' here since we don't want to init the
! 1346: connection, only this transfer */
! 1347: Curl_init_do(data, NULL);
! 1348:
! 1349: /* take this handle to the perform state right away */
! 1350: multistate(data, CURLM_STATE_PERFORM);
! 1351: Curl_attach_connnection(data, conn);
! 1352: k->keepon |= KEEP_RECV; /* setup to receive! */
! 1353: }
! 1354: return rc;
! 1355: }
! 1356:
! 1357: /*
! 1358: * do_complete is called when the DO actions are complete.
! 1359: *
! 1360: * We init chunking and trailer bits to their default values here immediately
! 1361: * before receiving any header data for the current request.
! 1362: */
! 1363: static void do_complete(struct connectdata *conn)
! 1364: {
! 1365: conn->data->req.chunk = FALSE;
! 1366: Curl_pgrsTime(conn->data, TIMER_PRETRANSFER);
! 1367: }
! 1368:
! 1369: static CURLcode multi_do(struct Curl_easy *data, bool *done)
! 1370: {
! 1371: CURLcode result = CURLE_OK;
! 1372: struct connectdata *conn = data->conn;
! 1373:
! 1374: DEBUGASSERT(conn);
! 1375: DEBUGASSERT(conn->handler);
! 1376: DEBUGASSERT(conn->data == data);
! 1377:
! 1378: if(conn->handler->do_it) {
! 1379: /* generic protocol-specific function pointer set in curl_connect() */
! 1380: result = conn->handler->do_it(conn, done);
! 1381:
! 1382: if(!result && *done)
! 1383: /* do_complete must be called after the protocol-specific DO function */
! 1384: do_complete(conn);
! 1385: }
! 1386: return result;
! 1387: }
! 1388:
! 1389: /*
! 1390: * multi_do_more() is called during the DO_MORE multi state. It is basically a
! 1391: * second stage DO state which (wrongly) was introduced to support FTP's
! 1392: * second connection.
! 1393: *
! 1394: * 'complete' can return 0 for incomplete, 1 for done and -1 for go back to
! 1395: * DOING state there's more work to do!
! 1396: */
! 1397:
! 1398: static CURLcode multi_do_more(struct connectdata *conn, int *complete)
! 1399: {
! 1400: CURLcode result = CURLE_OK;
! 1401:
! 1402: *complete = 0;
! 1403:
! 1404: if(conn->handler->do_more)
! 1405: result = conn->handler->do_more(conn, complete);
! 1406:
! 1407: if(!result && (*complete == 1))
! 1408: /* do_complete must be called after the protocol-specific DO function */
! 1409: do_complete(conn);
! 1410:
! 1411: return result;
! 1412: }
! 1413:
! 1414: /*
! 1415: * We are doing protocol-specific connecting and this is being called over and
! 1416: * over from the multi interface until the connection phase is done on
! 1417: * protocol layer.
! 1418: */
! 1419:
! 1420: static CURLcode protocol_connecting(struct connectdata *conn,
! 1421: bool *done)
! 1422: {
! 1423: CURLcode result = CURLE_OK;
! 1424:
! 1425: if(conn && conn->handler->connecting) {
! 1426: *done = FALSE;
! 1427: result = conn->handler->connecting(conn, done);
! 1428: }
! 1429: else
! 1430: *done = TRUE;
! 1431:
! 1432: return result;
! 1433: }
! 1434:
! 1435: /*
! 1436: * We are DOING this is being called over and over from the multi interface
! 1437: * until the DOING phase is done on protocol layer.
! 1438: */
! 1439:
! 1440: static CURLcode protocol_doing(struct connectdata *conn, bool *done)
! 1441: {
! 1442: CURLcode result = CURLE_OK;
! 1443:
! 1444: if(conn && conn->handler->doing) {
! 1445: *done = FALSE;
! 1446: result = conn->handler->doing(conn, done);
! 1447: }
! 1448: else
! 1449: *done = TRUE;
! 1450:
! 1451: return result;
! 1452: }
! 1453:
! 1454: /*
! 1455: * We have discovered that the TCP connection has been successful, we can now
! 1456: * proceed with some action.
! 1457: *
! 1458: */
! 1459: static CURLcode protocol_connect(struct connectdata *conn,
! 1460: bool *protocol_done)
! 1461: {
! 1462: CURLcode result = CURLE_OK;
! 1463:
! 1464: DEBUGASSERT(conn);
! 1465: DEBUGASSERT(protocol_done);
! 1466:
! 1467: *protocol_done = FALSE;
! 1468:
! 1469: if(conn->bits.tcpconnect[FIRSTSOCKET] && conn->bits.protoconnstart) {
! 1470: /* We already are connected, get back. This may happen when the connect
! 1471: worked fine in the first call, like when we connect to a local server
! 1472: or proxy. Note that we don't know if the protocol is actually done.
! 1473:
! 1474: Unless this protocol doesn't have any protocol-connect callback, as
! 1475: then we know we're done. */
! 1476: if(!conn->handler->connecting)
! 1477: *protocol_done = TRUE;
! 1478:
! 1479: return CURLE_OK;
! 1480: }
! 1481:
! 1482: if(!conn->bits.protoconnstart) {
! 1483:
! 1484: result = Curl_proxy_connect(conn, FIRSTSOCKET);
! 1485: if(result)
! 1486: return result;
! 1487:
! 1488: if(CONNECT_FIRSTSOCKET_PROXY_SSL())
! 1489: /* wait for HTTPS proxy SSL initialization to complete */
! 1490: return CURLE_OK;
! 1491:
! 1492: if(conn->bits.tunnel_proxy && conn->bits.httpproxy &&
! 1493: Curl_connect_ongoing(conn))
! 1494: /* when using an HTTP tunnel proxy, await complete tunnel establishment
! 1495: before proceeding further. Return CURLE_OK so we'll be called again */
! 1496: return CURLE_OK;
! 1497:
! 1498: if(conn->handler->connect_it) {
! 1499: /* is there a protocol-specific connect() procedure? */
! 1500:
! 1501: /* Call the protocol-specific connect function */
! 1502: result = conn->handler->connect_it(conn, protocol_done);
! 1503: }
! 1504: else
! 1505: *protocol_done = TRUE;
! 1506:
! 1507: /* it has started, possibly even completed but that knowledge isn't stored
! 1508: in this bit! */
! 1509: if(!result)
! 1510: conn->bits.protoconnstart = TRUE;
! 1511: }
! 1512:
! 1513: return result; /* pass back status */
! 1514: }
! 1515:
! 1516:
! 1517: static CURLMcode multi_runsingle(struct Curl_multi *multi,
! 1518: struct curltime now,
! 1519: struct Curl_easy *data)
! 1520: {
! 1521: struct Curl_message *msg = NULL;
! 1522: bool connected;
! 1523: bool async;
! 1524: bool protocol_connected = FALSE;
! 1525: bool dophase_done = FALSE;
! 1526: bool done = FALSE;
! 1527: CURLMcode rc;
! 1528: CURLcode result = CURLE_OK;
! 1529: timediff_t timeout_ms;
! 1530: timediff_t recv_timeout_ms;
! 1531: timediff_t send_timeout_ms;
! 1532: int control;
! 1533:
! 1534: if(!GOOD_EASY_HANDLE(data))
! 1535: return CURLM_BAD_EASY_HANDLE;
! 1536:
! 1537: do {
! 1538: /* A "stream" here is a logical stream if the protocol can handle that
! 1539: (HTTP/2), or the full connection for older protocols */
! 1540: bool stream_error = FALSE;
! 1541: rc = CURLM_OK;
! 1542:
! 1543: DEBUGASSERT((data->mstate <= CURLM_STATE_CONNECT) ||
! 1544: (data->mstate >= CURLM_STATE_DONE) ||
! 1545: data->conn);
! 1546: if(!data->conn &&
! 1547: data->mstate > CURLM_STATE_CONNECT &&
! 1548: data->mstate < CURLM_STATE_DONE) {
! 1549: /* In all these states, the code will blindly access 'data->conn'
! 1550: so this is precaution that it isn't NULL. And it silences static
! 1551: analyzers. */
! 1552: failf(data, "In state %d with no conn, bail out!\n", data->mstate);
! 1553: return CURLM_INTERNAL_ERROR;
! 1554: }
! 1555:
! 1556: if(multi_ischanged(multi, TRUE)) {
! 1557: DEBUGF(infof(data, "multi changed, check CONNECT_PEND queue!\n"));
! 1558: process_pending_handles(multi); /* multiplexed */
! 1559: }
! 1560:
! 1561: if(data->conn && data->mstate > CURLM_STATE_CONNECT &&
! 1562: data->mstate < CURLM_STATE_COMPLETED) {
! 1563: /* Make sure we set the connection's current owner */
! 1564: data->conn->data = data;
! 1565: }
! 1566:
! 1567: if(data->conn &&
! 1568: (data->mstate >= CURLM_STATE_CONNECT) &&
! 1569: (data->mstate < CURLM_STATE_COMPLETED)) {
! 1570: /* we need to wait for the connect state as only then is the start time
! 1571: stored, but we must not check already completed handles */
! 1572: timeout_ms = Curl_timeleft(data, &now,
! 1573: (data->mstate <= CURLM_STATE_DO)?
! 1574: TRUE:FALSE);
! 1575:
! 1576: if(timeout_ms < 0) {
! 1577: /* Handle timed out */
! 1578: if(data->mstate == CURLM_STATE_WAITRESOLVE)
! 1579: failf(data, "Resolving timed out after %" CURL_FORMAT_TIMEDIFF_T
! 1580: " milliseconds",
! 1581: Curl_timediff(now, data->progress.t_startsingle));
! 1582: else if(data->mstate == CURLM_STATE_WAITCONNECT)
! 1583: failf(data, "Connection timed out after %" CURL_FORMAT_TIMEDIFF_T
! 1584: " milliseconds",
! 1585: Curl_timediff(now, data->progress.t_startsingle));
! 1586: else {
! 1587: struct SingleRequest *k = &data->req;
! 1588: if(k->size != -1) {
! 1589: failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T
! 1590: " milliseconds with %" CURL_FORMAT_CURL_OFF_T " out of %"
! 1591: CURL_FORMAT_CURL_OFF_T " bytes received",
! 1592: Curl_timediff(now, data->progress.t_startsingle),
! 1593: k->bytecount, k->size);
! 1594: }
! 1595: else {
! 1596: failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T
! 1597: " milliseconds with %" CURL_FORMAT_CURL_OFF_T
! 1598: " bytes received",
! 1599: Curl_timediff(now, data->progress.t_startsingle),
! 1600: k->bytecount);
! 1601: }
! 1602: }
! 1603:
! 1604: /* Force connection closed if the connection has indeed been used */
! 1605: if(data->mstate > CURLM_STATE_DO) {
! 1606: streamclose(data->conn, "Disconnected with pending data");
! 1607: stream_error = TRUE;
! 1608: }
! 1609: result = CURLE_OPERATION_TIMEDOUT;
! 1610: (void)multi_done(data, result, TRUE);
! 1611: /* Skip the statemachine and go directly to error handling section. */
! 1612: goto statemachine_end;
! 1613: }
! 1614: }
! 1615:
! 1616: switch(data->mstate) {
! 1617: case CURLM_STATE_INIT:
! 1618: /* init this transfer. */
! 1619: result = Curl_pretransfer(data);
! 1620:
! 1621: if(!result) {
! 1622: /* after init, go CONNECT */
! 1623: multistate(data, CURLM_STATE_CONNECT);
! 1624: Curl_pgrsTime(data, TIMER_STARTOP);
! 1625: rc = CURLM_CALL_MULTI_PERFORM;
! 1626: }
! 1627: break;
! 1628:
! 1629: case CURLM_STATE_CONNECT_PEND:
! 1630: /* We will stay here until there is a connection available. Then
! 1631: we try again in the CURLM_STATE_CONNECT state. */
! 1632: break;
! 1633:
! 1634: case CURLM_STATE_CONNECT:
! 1635: /* Connect. We want to get a connection identifier filled in. */
! 1636: Curl_pgrsTime(data, TIMER_STARTSINGLE);
! 1637: if(data->set.timeout)
! 1638: Curl_expire(data, data->set.timeout, EXPIRE_TIMEOUT);
! 1639:
! 1640: if(data->set.connecttimeout)
! 1641: Curl_expire(data, data->set.connecttimeout, EXPIRE_CONNECTTIMEOUT);
! 1642:
! 1643: result = Curl_connect(data, &async, &protocol_connected);
! 1644: if(CURLE_NO_CONNECTION_AVAILABLE == result) {
! 1645: /* There was no connection available. We will go to the pending
! 1646: state and wait for an available connection. */
! 1647: multistate(data, CURLM_STATE_CONNECT_PEND);
! 1648:
! 1649: /* add this handle to the list of connect-pending handles */
! 1650: Curl_llist_insert_next(&multi->pending, multi->pending.tail, data,
! 1651: &data->connect_queue);
! 1652: result = CURLE_OK;
! 1653: break;
! 1654: }
! 1655: else if(data->state.previouslypending) {
! 1656: /* this transfer comes from the pending queue so try move another */
! 1657: infof(data, "Transfer was pending, now try another\n");
! 1658: process_pending_handles(data->multi);
! 1659: }
! 1660:
! 1661: if(!result) {
! 1662: if(async)
! 1663: /* We're now waiting for an asynchronous name lookup */
! 1664: multistate(data, CURLM_STATE_WAITRESOLVE);
! 1665: else {
! 1666: /* after the connect has been sent off, go WAITCONNECT unless the
! 1667: protocol connect is already done and we can go directly to
! 1668: WAITDO or DO! */
! 1669: rc = CURLM_CALL_MULTI_PERFORM;
! 1670:
! 1671: if(protocol_connected)
! 1672: multistate(data, CURLM_STATE_DO);
! 1673: else {
! 1674: #ifndef CURL_DISABLE_HTTP
! 1675: if(Curl_connect_ongoing(data->conn))
! 1676: multistate(data, CURLM_STATE_WAITPROXYCONNECT);
! 1677: else
! 1678: #endif
! 1679: multistate(data, CURLM_STATE_WAITCONNECT);
! 1680: }
! 1681: }
! 1682: }
! 1683: break;
! 1684:
! 1685: case CURLM_STATE_WAITRESOLVE:
! 1686: /* awaiting an asynch name resolve to complete */
! 1687: {
! 1688: struct Curl_dns_entry *dns = NULL;
! 1689: struct connectdata *conn = data->conn;
! 1690: const char *hostname;
! 1691:
! 1692: DEBUGASSERT(conn);
! 1693: if(conn->bits.httpproxy)
! 1694: hostname = conn->http_proxy.host.name;
! 1695: else if(conn->bits.conn_to_host)
! 1696: hostname = conn->conn_to_host.name;
! 1697: else
! 1698: hostname = conn->host.name;
! 1699:
! 1700: /* check if we have the name resolved by now */
! 1701: dns = Curl_fetch_addr(conn, hostname, (int)conn->port);
! 1702:
! 1703: if(dns) {
! 1704: #ifdef CURLRES_ASYNCH
! 1705: conn->async.dns = dns;
! 1706: conn->async.done = TRUE;
! 1707: #endif
! 1708: result = CURLE_OK;
! 1709: infof(data, "Hostname '%s' was found in DNS cache\n", hostname);
! 1710: }
! 1711:
! 1712: if(!dns)
! 1713: result = Curl_resolv_check(data->conn, &dns);
! 1714:
! 1715: /* Update sockets here, because the socket(s) may have been
! 1716: closed and the application thus needs to be told, even if it
! 1717: is likely that the same socket(s) will again be used further
! 1718: down. If the name has not yet been resolved, it is likely
! 1719: that new sockets have been opened in an attempt to contact
! 1720: another resolver. */
! 1721: singlesocket(multi, data);
! 1722:
! 1723: if(dns) {
! 1724: /* Perform the next step in the connection phase, and then move on
! 1725: to the WAITCONNECT state */
! 1726: result = Curl_once_resolved(data->conn, &protocol_connected);
! 1727:
! 1728: if(result)
! 1729: /* if Curl_once_resolved() returns failure, the connection struct
! 1730: is already freed and gone */
! 1731: data->conn = NULL; /* no more connection */
! 1732: else {
! 1733: /* call again please so that we get the next socket setup */
! 1734: rc = CURLM_CALL_MULTI_PERFORM;
! 1735: if(protocol_connected)
! 1736: multistate(data, CURLM_STATE_DO);
! 1737: else {
! 1738: #ifndef CURL_DISABLE_HTTP
! 1739: if(Curl_connect_ongoing(data->conn))
! 1740: multistate(data, CURLM_STATE_WAITPROXYCONNECT);
! 1741: else
! 1742: #endif
! 1743: multistate(data, CURLM_STATE_WAITCONNECT);
! 1744: }
! 1745: }
! 1746: }
! 1747:
! 1748: if(result) {
! 1749: /* failure detected */
! 1750: stream_error = TRUE;
! 1751: break;
! 1752: }
! 1753: }
! 1754: break;
! 1755:
! 1756: #ifndef CURL_DISABLE_HTTP
! 1757: case CURLM_STATE_WAITPROXYCONNECT:
! 1758: /* this is HTTP-specific, but sending CONNECT to a proxy is HTTP... */
! 1759: DEBUGASSERT(data->conn);
! 1760: result = Curl_http_connect(data->conn, &protocol_connected);
! 1761:
! 1762: if(data->conn->bits.proxy_connect_closed) {
! 1763: rc = CURLM_CALL_MULTI_PERFORM;
! 1764: /* connect back to proxy again */
! 1765: result = CURLE_OK;
! 1766: multi_done(data, CURLE_OK, FALSE);
! 1767: multistate(data, CURLM_STATE_CONNECT);
! 1768: }
! 1769: else if(!result) {
! 1770: if((data->conn->http_proxy.proxytype != CURLPROXY_HTTPS ||
! 1771: data->conn->bits.proxy_ssl_connected[FIRSTSOCKET]) &&
! 1772: Curl_connect_complete(data->conn)) {
! 1773: rc = CURLM_CALL_MULTI_PERFORM;
! 1774: /* initiate protocol connect phase */
! 1775: multistate(data, CURLM_STATE_SENDPROTOCONNECT);
! 1776: }
! 1777: }
! 1778: else if(result)
! 1779: stream_error = TRUE;
! 1780: break;
! 1781: #endif
! 1782:
! 1783: case CURLM_STATE_WAITCONNECT:
! 1784: /* awaiting a completion of an asynch TCP connect */
! 1785: DEBUGASSERT(data->conn);
! 1786: result = Curl_is_connected(data->conn, FIRSTSOCKET, &connected);
! 1787: if(connected && !result) {
! 1788: #ifndef CURL_DISABLE_HTTP
! 1789: if((data->conn->http_proxy.proxytype == CURLPROXY_HTTPS &&
! 1790: !data->conn->bits.proxy_ssl_connected[FIRSTSOCKET]) ||
! 1791: Curl_connect_ongoing(data->conn)) {
! 1792: multistate(data, CURLM_STATE_WAITPROXYCONNECT);
! 1793: break;
! 1794: }
! 1795: #endif
! 1796: rc = CURLM_CALL_MULTI_PERFORM;
! 1797: multistate(data, data->conn->bits.tunnel_proxy?
! 1798: CURLM_STATE_WAITPROXYCONNECT:
! 1799: CURLM_STATE_SENDPROTOCONNECT);
! 1800: }
! 1801: else if(result) {
! 1802: /* failure detected */
! 1803: Curl_posttransfer(data);
! 1804: multi_done(data, result, TRUE);
! 1805: stream_error = TRUE;
! 1806: break;
! 1807: }
! 1808: break;
! 1809:
! 1810: case CURLM_STATE_SENDPROTOCONNECT:
! 1811: result = protocol_connect(data->conn, &protocol_connected);
! 1812: if(!result && !protocol_connected)
! 1813: /* switch to waiting state */
! 1814: multistate(data, CURLM_STATE_PROTOCONNECT);
! 1815: else if(!result) {
! 1816: /* protocol connect has completed, go WAITDO or DO */
! 1817: multistate(data, CURLM_STATE_DO);
! 1818: rc = CURLM_CALL_MULTI_PERFORM;
! 1819: }
! 1820: else if(result) {
! 1821: /* failure detected */
! 1822: Curl_posttransfer(data);
! 1823: multi_done(data, result, TRUE);
! 1824: stream_error = TRUE;
! 1825: }
! 1826: break;
! 1827:
! 1828: case CURLM_STATE_PROTOCONNECT:
! 1829: /* protocol-specific connect phase */
! 1830: result = protocol_connecting(data->conn, &protocol_connected);
! 1831: if(!result && protocol_connected) {
! 1832: /* after the connect has completed, go WAITDO or DO */
! 1833: multistate(data, CURLM_STATE_DO);
! 1834: rc = CURLM_CALL_MULTI_PERFORM;
! 1835: }
! 1836: else if(result) {
! 1837: /* failure detected */
! 1838: Curl_posttransfer(data);
! 1839: multi_done(data, result, TRUE);
! 1840: stream_error = TRUE;
! 1841: }
! 1842: break;
! 1843:
! 1844: case CURLM_STATE_DO:
! 1845: if(data->set.connect_only) {
! 1846: /* keep connection open for application to use the socket */
! 1847: connkeep(data->conn, "CONNECT_ONLY");
! 1848: multistate(data, CURLM_STATE_DONE);
! 1849: result = CURLE_OK;
! 1850: rc = CURLM_CALL_MULTI_PERFORM;
! 1851: }
! 1852: else {
! 1853: /* Perform the protocol's DO action */
! 1854: result = multi_do(data, &dophase_done);
! 1855:
! 1856: /* When multi_do() returns failure, data->conn might be NULL! */
! 1857:
! 1858: if(!result) {
! 1859: if(!dophase_done) {
! 1860: #ifndef CURL_DISABLE_FTP
! 1861: /* some steps needed for wildcard matching */
! 1862: if(data->state.wildcardmatch) {
! 1863: struct WildcardData *wc = &data->wildcard;
! 1864: if(wc->state == CURLWC_DONE || wc->state == CURLWC_SKIP) {
! 1865: /* skip some states if it is important */
! 1866: multi_done(data, CURLE_OK, FALSE);
! 1867: multistate(data, CURLM_STATE_DONE);
! 1868: rc = CURLM_CALL_MULTI_PERFORM;
! 1869: break;
! 1870: }
! 1871: }
! 1872: #endif
! 1873: /* DO was not completed in one function call, we must continue
! 1874: DOING... */
! 1875: multistate(data, CURLM_STATE_DOING);
! 1876: rc = CURLM_OK;
! 1877: }
! 1878:
! 1879: /* after DO, go DO_DONE... or DO_MORE */
! 1880: else if(data->conn->bits.do_more) {
! 1881: /* we're supposed to do more, but we need to sit down, relax
! 1882: and wait a little while first */
! 1883: multistate(data, CURLM_STATE_DO_MORE);
! 1884: rc = CURLM_OK;
! 1885: }
! 1886: else {
! 1887: /* we're done with the DO, now DO_DONE */
! 1888: multistate(data, CURLM_STATE_DO_DONE);
! 1889: rc = CURLM_CALL_MULTI_PERFORM;
! 1890: }
! 1891: }
! 1892: else if((CURLE_SEND_ERROR == result) &&
! 1893: data->conn->bits.reuse) {
! 1894: /*
! 1895: * In this situation, a connection that we were trying to use
! 1896: * may have unexpectedly died. If possible, send the connection
! 1897: * back to the CONNECT phase so we can try again.
! 1898: */
! 1899: char *newurl = NULL;
! 1900: followtype follow = FOLLOW_NONE;
! 1901: CURLcode drc;
! 1902:
! 1903: drc = Curl_retry_request(data->conn, &newurl);
! 1904: if(drc) {
! 1905: /* a failure here pretty much implies an out of memory */
! 1906: result = drc;
! 1907: stream_error = TRUE;
! 1908: }
! 1909:
! 1910: Curl_posttransfer(data);
! 1911: drc = multi_done(data, result, FALSE);
! 1912:
! 1913: /* When set to retry the connection, we must to go back to
! 1914: * the CONNECT state */
! 1915: if(newurl) {
! 1916: if(!drc || (drc == CURLE_SEND_ERROR)) {
! 1917: follow = FOLLOW_RETRY;
! 1918: drc = Curl_follow(data, newurl, follow);
! 1919: if(!drc) {
! 1920: multistate(data, CURLM_STATE_CONNECT);
! 1921: rc = CURLM_CALL_MULTI_PERFORM;
! 1922: result = CURLE_OK;
! 1923: }
! 1924: else {
! 1925: /* Follow failed */
! 1926: result = drc;
! 1927: }
! 1928: }
! 1929: else {
! 1930: /* done didn't return OK or SEND_ERROR */
! 1931: result = drc;
! 1932: }
! 1933: }
! 1934: else {
! 1935: /* Have error handler disconnect conn if we can't retry */
! 1936: stream_error = TRUE;
! 1937: }
! 1938: free(newurl);
! 1939: }
! 1940: else {
! 1941: /* failure detected */
! 1942: Curl_posttransfer(data);
! 1943: if(data->conn)
! 1944: multi_done(data, result, FALSE);
! 1945: stream_error = TRUE;
! 1946: }
! 1947: }
! 1948: break;
! 1949:
! 1950: case CURLM_STATE_DOING:
! 1951: /* we continue DOING until the DO phase is complete */
! 1952: DEBUGASSERT(data->conn);
! 1953: result = protocol_doing(data->conn, &dophase_done);
! 1954: if(!result) {
! 1955: if(dophase_done) {
! 1956: /* after DO, go DO_DONE or DO_MORE */
! 1957: multistate(data, data->conn->bits.do_more?
! 1958: CURLM_STATE_DO_MORE:
! 1959: CURLM_STATE_DO_DONE);
! 1960: rc = CURLM_CALL_MULTI_PERFORM;
! 1961: } /* dophase_done */
! 1962: }
! 1963: else {
! 1964: /* failure detected */
! 1965: Curl_posttransfer(data);
! 1966: multi_done(data, result, FALSE);
! 1967: stream_error = TRUE;
! 1968: }
! 1969: break;
! 1970:
! 1971: case CURLM_STATE_DO_MORE:
! 1972: /*
! 1973: * When we are connected, DO MORE and then go DO_DONE
! 1974: */
! 1975: DEBUGASSERT(data->conn);
! 1976: result = multi_do_more(data->conn, &control);
! 1977:
! 1978: if(!result) {
! 1979: if(control) {
! 1980: /* if positive, advance to DO_DONE
! 1981: if negative, go back to DOING */
! 1982: multistate(data, control == 1?
! 1983: CURLM_STATE_DO_DONE:
! 1984: CURLM_STATE_DOING);
! 1985: rc = CURLM_CALL_MULTI_PERFORM;
! 1986: }
! 1987: else
! 1988: /* stay in DO_MORE */
! 1989: rc = CURLM_OK;
! 1990: }
! 1991: else {
! 1992: /* failure detected */
! 1993: Curl_posttransfer(data);
! 1994: multi_done(data, result, FALSE);
! 1995: stream_error = TRUE;
! 1996: }
! 1997: break;
! 1998:
! 1999: case CURLM_STATE_DO_DONE:
! 2000: DEBUGASSERT(data->conn);
! 2001: if(data->conn->bits.multiplex)
! 2002: /* Check if we can move pending requests to send pipe */
! 2003: process_pending_handles(multi); /* multiplexed */
! 2004:
! 2005: /* Only perform the transfer if there's a good socket to work with.
! 2006: Having both BAD is a signal to skip immediately to DONE */
! 2007: if((data->conn->sockfd != CURL_SOCKET_BAD) ||
! 2008: (data->conn->writesockfd != CURL_SOCKET_BAD))
! 2009: multistate(data, CURLM_STATE_PERFORM);
! 2010: else {
! 2011: #ifndef CURL_DISABLE_FTP
! 2012: if(data->state.wildcardmatch &&
! 2013: ((data->conn->handler->flags & PROTOPT_WILDCARD) == 0)) {
! 2014: data->wildcard.state = CURLWC_DONE;
! 2015: }
! 2016: #endif
! 2017: multistate(data, CURLM_STATE_DONE);
! 2018: }
! 2019: rc = CURLM_CALL_MULTI_PERFORM;
! 2020: break;
! 2021:
! 2022: case CURLM_STATE_TOOFAST: /* limit-rate exceeded in either direction */
! 2023: DEBUGASSERT(data->conn);
! 2024: /* if both rates are within spec, resume transfer */
! 2025: if(Curl_pgrsUpdate(data->conn))
! 2026: result = CURLE_ABORTED_BY_CALLBACK;
! 2027: else
! 2028: result = Curl_speedcheck(data, now);
! 2029:
! 2030: if(!result) {
! 2031: send_timeout_ms = 0;
! 2032: if(data->set.max_send_speed > 0)
! 2033: send_timeout_ms =
! 2034: Curl_pgrsLimitWaitTime(data->progress.uploaded,
! 2035: data->progress.ul_limit_size,
! 2036: data->set.max_send_speed,
! 2037: data->progress.ul_limit_start,
! 2038: now);
! 2039:
! 2040: recv_timeout_ms = 0;
! 2041: if(data->set.max_recv_speed > 0)
! 2042: recv_timeout_ms =
! 2043: Curl_pgrsLimitWaitTime(data->progress.downloaded,
! 2044: data->progress.dl_limit_size,
! 2045: data->set.max_recv_speed,
! 2046: data->progress.dl_limit_start,
! 2047: now);
! 2048:
! 2049: if(!send_timeout_ms && !recv_timeout_ms) {
! 2050: multistate(data, CURLM_STATE_PERFORM);
! 2051: Curl_ratelimit(data, now);
! 2052: }
! 2053: else if(send_timeout_ms >= recv_timeout_ms)
! 2054: Curl_expire(data, send_timeout_ms, EXPIRE_TOOFAST);
! 2055: else
! 2056: Curl_expire(data, recv_timeout_ms, EXPIRE_TOOFAST);
! 2057: }
! 2058: break;
! 2059:
! 2060: case CURLM_STATE_PERFORM:
! 2061: {
! 2062: char *newurl = NULL;
! 2063: bool retry = FALSE;
! 2064: bool comeback = FALSE;
! 2065:
! 2066: /* check if over send speed */
! 2067: send_timeout_ms = 0;
! 2068: if(data->set.max_send_speed > 0)
! 2069: send_timeout_ms = Curl_pgrsLimitWaitTime(data->progress.uploaded,
! 2070: data->progress.ul_limit_size,
! 2071: data->set.max_send_speed,
! 2072: data->progress.ul_limit_start,
! 2073: now);
! 2074:
! 2075: /* check if over recv speed */
! 2076: recv_timeout_ms = 0;
! 2077: if(data->set.max_recv_speed > 0)
! 2078: recv_timeout_ms = Curl_pgrsLimitWaitTime(data->progress.downloaded,
! 2079: data->progress.dl_limit_size,
! 2080: data->set.max_recv_speed,
! 2081: data->progress.dl_limit_start,
! 2082: now);
! 2083:
! 2084: if(send_timeout_ms || recv_timeout_ms) {
! 2085: Curl_ratelimit(data, now);
! 2086: multistate(data, CURLM_STATE_TOOFAST);
! 2087: if(send_timeout_ms >= recv_timeout_ms)
! 2088: Curl_expire(data, send_timeout_ms, EXPIRE_TOOFAST);
! 2089: else
! 2090: Curl_expire(data, recv_timeout_ms, EXPIRE_TOOFAST);
! 2091: break;
! 2092: }
! 2093:
! 2094: /* read/write data if it is ready to do so */
! 2095: result = Curl_readwrite(data->conn, data, &done, &comeback);
! 2096:
! 2097: if(done || (result == CURLE_RECV_ERROR)) {
! 2098: /* If CURLE_RECV_ERROR happens early enough, we assume it was a race
! 2099: * condition and the server closed the re-used connection exactly when
! 2100: * we wanted to use it, so figure out if that is indeed the case.
! 2101: */
! 2102: CURLcode ret = Curl_retry_request(data->conn, &newurl);
! 2103: if(!ret)
! 2104: retry = (newurl)?TRUE:FALSE;
! 2105: else if(!result)
! 2106: result = ret;
! 2107:
! 2108: if(retry) {
! 2109: /* if we are to retry, set the result to OK and consider the
! 2110: request as done */
! 2111: result = CURLE_OK;
! 2112: done = TRUE;
! 2113: }
! 2114: }
! 2115: else if((CURLE_HTTP2_STREAM == result) &&
! 2116: Curl_h2_http_1_1_error(data->conn)) {
! 2117: CURLcode ret = Curl_retry_request(data->conn, &newurl);
! 2118:
! 2119: if(!ret) {
! 2120: infof(data, "Downgrades to HTTP/1.1!\n");
! 2121: data->set.httpversion = CURL_HTTP_VERSION_1_1;
! 2122: /* clear the error message bit too as we ignore the one we got */
! 2123: data->state.errorbuf = FALSE;
! 2124: if(!newurl)
! 2125: /* typically for HTTP_1_1_REQUIRED error on first flight */
! 2126: newurl = strdup(data->change.url);
! 2127: /* if we are to retry, set the result to OK and consider the request
! 2128: as done */
! 2129: retry = TRUE;
! 2130: result = CURLE_OK;
! 2131: done = TRUE;
! 2132: }
! 2133: else
! 2134: result = ret;
! 2135: }
! 2136:
! 2137: if(result) {
! 2138: /*
! 2139: * The transfer phase returned error, we mark the connection to get
! 2140: * closed to prevent being re-used. This is because we can't possibly
! 2141: * know if the connection is in a good shape or not now. Unless it is
! 2142: * a protocol which uses two "channels" like FTP, as then the error
! 2143: * happened in the data connection.
! 2144: */
! 2145:
! 2146: if(!(data->conn->handler->flags & PROTOPT_DUAL) &&
! 2147: result != CURLE_HTTP2_STREAM)
! 2148: streamclose(data->conn, "Transfer returned error");
! 2149:
! 2150: Curl_posttransfer(data);
! 2151: multi_done(data, result, TRUE);
! 2152: }
! 2153: else if(done) {
! 2154: followtype follow = FOLLOW_NONE;
! 2155:
! 2156: /* call this even if the readwrite function returned error */
! 2157: Curl_posttransfer(data);
! 2158:
! 2159: /* When we follow redirects or is set to retry the connection, we must
! 2160: to go back to the CONNECT state */
! 2161: if(data->req.newurl || retry) {
! 2162: if(!retry) {
! 2163: /* if the URL is a follow-location and not just a retried request
! 2164: then figure out the URL here */
! 2165: free(newurl);
! 2166: newurl = data->req.newurl;
! 2167: data->req.newurl = NULL;
! 2168: follow = FOLLOW_REDIR;
! 2169: }
! 2170: else
! 2171: follow = FOLLOW_RETRY;
! 2172: (void)multi_done(data, CURLE_OK, FALSE);
! 2173: /* multi_done() might return CURLE_GOT_NOTHING */
! 2174: result = Curl_follow(data, newurl, follow);
! 2175: if(!result) {
! 2176: multistate(data, CURLM_STATE_CONNECT);
! 2177: rc = CURLM_CALL_MULTI_PERFORM;
! 2178: }
! 2179: free(newurl);
! 2180: }
! 2181: else {
! 2182: /* after the transfer is done, go DONE */
! 2183:
! 2184: /* but first check to see if we got a location info even though we're
! 2185: not following redirects */
! 2186: if(data->req.location) {
! 2187: free(newurl);
! 2188: newurl = data->req.location;
! 2189: data->req.location = NULL;
! 2190: result = Curl_follow(data, newurl, FOLLOW_FAKE);
! 2191: free(newurl);
! 2192: if(result) {
! 2193: stream_error = TRUE;
! 2194: result = multi_done(data, result, TRUE);
! 2195: }
! 2196: }
! 2197:
! 2198: if(!result) {
! 2199: multistate(data, CURLM_STATE_DONE);
! 2200: rc = CURLM_CALL_MULTI_PERFORM;
! 2201: }
! 2202: }
! 2203: }
! 2204: else if(comeback) {
! 2205: /* This avoids CURLM_CALL_MULTI_PERFORM so that a very fast transfer
! 2206: won't get stuck on this transfer at the expense of other concurrent
! 2207: transfers */
! 2208: Curl_expire(data, 0, EXPIRE_RUN_NOW);
! 2209: rc = CURLM_OK;
! 2210: }
! 2211: break;
! 2212: }
! 2213:
! 2214: case CURLM_STATE_DONE:
! 2215: /* this state is highly transient, so run another loop after this */
! 2216: rc = CURLM_CALL_MULTI_PERFORM;
! 2217:
! 2218: if(data->conn) {
! 2219: CURLcode res;
! 2220:
! 2221: if(data->conn->bits.multiplex)
! 2222: /* Check if we can move pending requests to connection */
! 2223: process_pending_handles(multi); /* multiplexing */
! 2224:
! 2225: /* post-transfer command */
! 2226: res = multi_done(data, result, FALSE);
! 2227:
! 2228: /* allow a previously set error code take precedence */
! 2229: if(!result)
! 2230: result = res;
! 2231:
! 2232: /*
! 2233: * If there are other handles on the connection, multi_done won't set
! 2234: * conn to NULL. In such a case, curl_multi_remove_handle() can
! 2235: * access free'd data, if the connection is free'd and the handle
! 2236: * removed before we perform the processing in CURLM_STATE_COMPLETED
! 2237: */
! 2238: if(data->conn)
! 2239: detach_connnection(data);
! 2240: }
! 2241:
! 2242: #ifndef CURL_DISABLE_FTP
! 2243: if(data->state.wildcardmatch) {
! 2244: if(data->wildcard.state != CURLWC_DONE) {
! 2245: /* if a wildcard is set and we are not ending -> lets start again
! 2246: with CURLM_STATE_INIT */
! 2247: multistate(data, CURLM_STATE_INIT);
! 2248: break;
! 2249: }
! 2250: }
! 2251: #endif
! 2252: /* after we have DONE what we're supposed to do, go COMPLETED, and
! 2253: it doesn't matter what the multi_done() returned! */
! 2254: multistate(data, CURLM_STATE_COMPLETED);
! 2255: break;
! 2256:
! 2257: case CURLM_STATE_COMPLETED:
! 2258: break;
! 2259:
! 2260: case CURLM_STATE_MSGSENT:
! 2261: data->result = result;
! 2262: return CURLM_OK; /* do nothing */
! 2263:
! 2264: default:
! 2265: return CURLM_INTERNAL_ERROR;
! 2266: }
! 2267: statemachine_end:
! 2268:
! 2269: if(data->mstate < CURLM_STATE_COMPLETED) {
! 2270: if(result) {
! 2271: /*
! 2272: * If an error was returned, and we aren't in completed state now,
! 2273: * then we go to completed and consider this transfer aborted.
! 2274: */
! 2275:
! 2276: /* NOTE: no attempt to disconnect connections must be made
! 2277: in the case blocks above - cleanup happens only here */
! 2278:
! 2279: /* Check if we can move pending requests to send pipe */
! 2280: process_pending_handles(multi); /* connection */
! 2281:
! 2282: if(data->conn) {
! 2283: if(stream_error) {
! 2284: /* Don't attempt to send data over a connection that timed out */
! 2285: bool dead_connection = result == CURLE_OPERATION_TIMEDOUT;
! 2286: struct connectdata *conn = data->conn;
! 2287:
! 2288: /* This is where we make sure that the conn pointer is reset.
! 2289: We don't have to do this in every case block above where a
! 2290: failure is detected */
! 2291: detach_connnection(data);
! 2292:
! 2293: /* disconnect properly */
! 2294: Curl_disconnect(data, conn, dead_connection);
! 2295: }
! 2296: }
! 2297: else if(data->mstate == CURLM_STATE_CONNECT) {
! 2298: /* Curl_connect() failed */
! 2299: (void)Curl_posttransfer(data);
! 2300: }
! 2301:
! 2302: multistate(data, CURLM_STATE_COMPLETED);
! 2303: rc = CURLM_CALL_MULTI_PERFORM;
! 2304: }
! 2305: /* if there's still a connection to use, call the progress function */
! 2306: else if(data->conn && Curl_pgrsUpdate(data->conn)) {
! 2307: /* aborted due to progress callback return code must close the
! 2308: connection */
! 2309: result = CURLE_ABORTED_BY_CALLBACK;
! 2310: streamclose(data->conn, "Aborted by callback");
! 2311:
! 2312: /* if not yet in DONE state, go there, otherwise COMPLETED */
! 2313: multistate(data, (data->mstate < CURLM_STATE_DONE)?
! 2314: CURLM_STATE_DONE: CURLM_STATE_COMPLETED);
! 2315: rc = CURLM_CALL_MULTI_PERFORM;
! 2316: }
! 2317: }
! 2318:
! 2319: if(CURLM_STATE_COMPLETED == data->mstate) {
! 2320: if(data->set.fmultidone) {
! 2321: /* signal via callback instead */
! 2322: data->set.fmultidone(data, result);
! 2323: }
! 2324: else {
! 2325: /* now fill in the Curl_message with this info */
! 2326: msg = &data->msg;
! 2327:
! 2328: msg->extmsg.msg = CURLMSG_DONE;
! 2329: msg->extmsg.easy_handle = data;
! 2330: msg->extmsg.data.result = result;
! 2331:
! 2332: rc = multi_addmsg(multi, msg);
! 2333: DEBUGASSERT(!data->conn);
! 2334: }
! 2335: multistate(data, CURLM_STATE_MSGSENT);
! 2336: }
! 2337: } while((rc == CURLM_CALL_MULTI_PERFORM) || multi_ischanged(multi, FALSE));
! 2338:
! 2339: data->result = result;
! 2340: return rc;
! 2341: }
! 2342:
! 2343:
! 2344: CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles)
! 2345: {
! 2346: struct Curl_easy *data;
! 2347: CURLMcode returncode = CURLM_OK;
! 2348: struct Curl_tree *t;
! 2349: struct curltime now = Curl_now();
! 2350:
! 2351: if(!GOOD_MULTI_HANDLE(multi))
! 2352: return CURLM_BAD_HANDLE;
! 2353:
! 2354: if(multi->in_callback)
! 2355: return CURLM_RECURSIVE_API_CALL;
! 2356:
! 2357: data = multi->easyp;
! 2358: while(data) {
! 2359: CURLMcode result;
! 2360: SIGPIPE_VARIABLE(pipe_st);
! 2361:
! 2362: sigpipe_ignore(data, &pipe_st);
! 2363: result = multi_runsingle(multi, now, data);
! 2364: sigpipe_restore(&pipe_st);
! 2365:
! 2366: if(result)
! 2367: returncode = result;
! 2368:
! 2369: data = data->next; /* operate on next handle */
! 2370: }
! 2371:
! 2372: /*
! 2373: * Simply remove all expired timers from the splay since handles are dealt
! 2374: * with unconditionally by this function and curl_multi_timeout() requires
! 2375: * that already passed/handled expire times are removed from the splay.
! 2376: *
! 2377: * It is important that the 'now' value is set at the entry of this function
! 2378: * and not for the current time as it may have ticked a little while since
! 2379: * then and then we risk this loop to remove timers that actually have not
! 2380: * been handled!
! 2381: */
! 2382: do {
! 2383: multi->timetree = Curl_splaygetbest(now, multi->timetree, &t);
! 2384: if(t)
! 2385: /* the removed may have another timeout in queue */
! 2386: (void)add_next_timeout(now, multi, t->payload);
! 2387:
! 2388: } while(t);
! 2389:
! 2390: *running_handles = multi->num_alive;
! 2391:
! 2392: if(CURLM_OK >= returncode)
! 2393: Curl_update_timer(multi);
! 2394:
! 2395: return returncode;
! 2396: }
! 2397:
! 2398: CURLMcode curl_multi_cleanup(struct Curl_multi *multi)
! 2399: {
! 2400: struct Curl_easy *data;
! 2401: struct Curl_easy *nextdata;
! 2402:
! 2403: if(GOOD_MULTI_HANDLE(multi)) {
! 2404: if(multi->in_callback)
! 2405: return CURLM_RECURSIVE_API_CALL;
! 2406:
! 2407: multi->type = 0; /* not good anymore */
! 2408:
! 2409: /* Firsrt remove all remaining easy handles */
! 2410: data = multi->easyp;
! 2411: while(data) {
! 2412: nextdata = data->next;
! 2413: if(!data->state.done && data->conn)
! 2414: /* if DONE was never called for this handle */
! 2415: (void)multi_done(data, CURLE_OK, TRUE);
! 2416: if(data->dns.hostcachetype == HCACHE_MULTI) {
! 2417: /* clear out the usage of the shared DNS cache */
! 2418: Curl_hostcache_clean(data, data->dns.hostcache);
! 2419: data->dns.hostcache = NULL;
! 2420: data->dns.hostcachetype = HCACHE_NONE;
! 2421: }
! 2422:
! 2423: /* Clear the pointer to the connection cache */
! 2424: data->state.conn_cache = NULL;
! 2425: data->multi = NULL; /* clear the association */
! 2426:
! 2427: #ifdef USE_LIBPSL
! 2428: if(data->psl == &multi->psl)
! 2429: data->psl = NULL;
! 2430: #endif
! 2431:
! 2432: data = nextdata;
! 2433: }
! 2434:
! 2435: /* Close all the connections in the connection cache */
! 2436: Curl_conncache_close_all_connections(&multi->conn_cache);
! 2437:
! 2438: Curl_hash_destroy(&multi->sockhash);
! 2439: Curl_conncache_destroy(&multi->conn_cache);
! 2440: Curl_llist_destroy(&multi->msglist, NULL);
! 2441: Curl_llist_destroy(&multi->pending, NULL);
! 2442:
! 2443: Curl_hash_destroy(&multi->hostcache);
! 2444: Curl_psl_destroy(&multi->psl);
! 2445:
! 2446: #ifdef ENABLE_WAKEUP
! 2447: sclose(multi->wakeup_pair[0]);
! 2448: sclose(multi->wakeup_pair[1]);
! 2449: #endif
! 2450: free(multi);
! 2451:
! 2452: return CURLM_OK;
! 2453: }
! 2454: return CURLM_BAD_HANDLE;
! 2455: }
! 2456:
! 2457: /*
! 2458: * curl_multi_info_read()
! 2459: *
! 2460: * This function is the primary way for a multi/multi_socket application to
! 2461: * figure out if a transfer has ended. We MUST make this function as fast as
! 2462: * possible as it will be polled frequently and we MUST NOT scan any lists in
! 2463: * here to figure out things. We must scale fine to thousands of handles and
! 2464: * beyond. The current design is fully O(1).
! 2465: */
! 2466:
! 2467: CURLMsg *curl_multi_info_read(struct Curl_multi *multi, int *msgs_in_queue)
! 2468: {
! 2469: struct Curl_message *msg;
! 2470:
! 2471: *msgs_in_queue = 0; /* default to none */
! 2472:
! 2473: if(GOOD_MULTI_HANDLE(multi) &&
! 2474: !multi->in_callback &&
! 2475: Curl_llist_count(&multi->msglist)) {
! 2476: /* there is one or more messages in the list */
! 2477: struct curl_llist_element *e;
! 2478:
! 2479: /* extract the head of the list to return */
! 2480: e = multi->msglist.head;
! 2481:
! 2482: msg = e->ptr;
! 2483:
! 2484: /* remove the extracted entry */
! 2485: Curl_llist_remove(&multi->msglist, e, NULL);
! 2486:
! 2487: *msgs_in_queue = curlx_uztosi(Curl_llist_count(&multi->msglist));
! 2488:
! 2489: return &msg->extmsg;
! 2490: }
! 2491: return NULL;
! 2492: }
! 2493:
! 2494: /*
! 2495: * singlesocket() checks what sockets we deal with and their "action state"
! 2496: * and if we have a different state in any of those sockets from last time we
! 2497: * call the callback accordingly.
! 2498: */
! 2499: static CURLMcode singlesocket(struct Curl_multi *multi,
! 2500: struct Curl_easy *data)
! 2501: {
! 2502: curl_socket_t socks[MAX_SOCKSPEREASYHANDLE];
! 2503: int i;
! 2504: struct Curl_sh_entry *entry;
! 2505: curl_socket_t s;
! 2506: int num;
! 2507: unsigned int curraction;
! 2508: int actions[MAX_SOCKSPEREASYHANDLE];
! 2509:
! 2510: for(i = 0; i< MAX_SOCKSPEREASYHANDLE; i++)
! 2511: socks[i] = CURL_SOCKET_BAD;
! 2512:
! 2513: /* Fill in the 'current' struct with the state as it is now: what sockets to
! 2514: supervise and for what actions */
! 2515: curraction = multi_getsock(data, socks);
! 2516:
! 2517: /* We have 0 .. N sockets already and we get to know about the 0 .. M
! 2518: sockets we should have from now on. Detect the differences, remove no
! 2519: longer supervised ones and add new ones */
! 2520:
! 2521: /* walk over the sockets we got right now */
! 2522: for(i = 0; (i< MAX_SOCKSPEREASYHANDLE) &&
! 2523: (curraction & (GETSOCK_READSOCK(i) | GETSOCK_WRITESOCK(i)));
! 2524: i++) {
! 2525: unsigned int action = CURL_POLL_NONE;
! 2526: unsigned int prevaction = 0;
! 2527: unsigned int comboaction;
! 2528: bool sincebefore = FALSE;
! 2529:
! 2530: s = socks[i];
! 2531:
! 2532: /* get it from the hash */
! 2533: entry = sh_getentry(&multi->sockhash, s);
! 2534:
! 2535: if(curraction & GETSOCK_READSOCK(i))
! 2536: action |= CURL_POLL_IN;
! 2537: if(curraction & GETSOCK_WRITESOCK(i))
! 2538: action |= CURL_POLL_OUT;
! 2539:
! 2540: actions[i] = action;
! 2541: if(entry) {
! 2542: /* check if new for this transfer */
! 2543: int j;
! 2544: for(j = 0; j< data->numsocks; j++) {
! 2545: if(s == data->sockets[j]) {
! 2546: prevaction = data->actions[j];
! 2547: sincebefore = TRUE;
! 2548: break;
! 2549: }
! 2550: }
! 2551: }
! 2552: else {
! 2553: /* this is a socket we didn't have before, add it to the hash! */
! 2554: entry = sh_addentry(&multi->sockhash, s);
! 2555: if(!entry)
! 2556: /* fatal */
! 2557: return CURLM_OUT_OF_MEMORY;
! 2558: }
! 2559: if(sincebefore && (prevaction != action)) {
! 2560: /* Socket was used already, but different action now */
! 2561: if(prevaction & CURL_POLL_IN)
! 2562: entry->readers--;
! 2563: if(prevaction & CURL_POLL_OUT)
! 2564: entry->writers--;
! 2565: if(action & CURL_POLL_IN)
! 2566: entry->readers++;
! 2567: if(action & CURL_POLL_OUT)
! 2568: entry->writers++;
! 2569: }
! 2570: else if(!sincebefore) {
! 2571: /* a new user */
! 2572: entry->users++;
! 2573: if(action & CURL_POLL_IN)
! 2574: entry->readers++;
! 2575: if(action & CURL_POLL_OUT)
! 2576: entry->writers++;
! 2577:
! 2578: /* add 'data' to the transfer hash on this socket! */
! 2579: if(!Curl_hash_add(&entry->transfers, (char *)&data, /* hash key */
! 2580: sizeof(struct Curl_easy *), data))
! 2581: return CURLM_OUT_OF_MEMORY;
! 2582: }
! 2583:
! 2584: comboaction = (entry->writers? CURL_POLL_OUT : 0) |
! 2585: (entry->readers ? CURL_POLL_IN : 0);
! 2586:
! 2587: /* socket existed before and has the same action set as before */
! 2588: if(sincebefore && (entry->action == comboaction))
! 2589: /* same, continue */
! 2590: continue;
! 2591:
! 2592: if(multi->socket_cb)
! 2593: multi->socket_cb(data, s, comboaction, multi->socket_userp,
! 2594: entry->socketp);
! 2595:
! 2596: entry->action = comboaction; /* store the current action state */
! 2597: }
! 2598:
! 2599: num = i; /* number of sockets */
! 2600:
! 2601: /* when we've walked over all the sockets we should have right now, we must
! 2602: make sure to detect sockets that are removed */
! 2603: for(i = 0; i< data->numsocks; i++) {
! 2604: int j;
! 2605: bool stillused = FALSE;
! 2606: s = data->sockets[i];
! 2607: for(j = 0; j < num; j++) {
! 2608: if(s == socks[j]) {
! 2609: /* this is still supervised */
! 2610: stillused = TRUE;
! 2611: break;
! 2612: }
! 2613: }
! 2614: if(stillused)
! 2615: continue;
! 2616:
! 2617: entry = sh_getentry(&multi->sockhash, s);
! 2618: /* if this is NULL here, the socket has been closed and notified so
! 2619: already by Curl_multi_closed() */
! 2620: if(entry) {
! 2621: int oldactions = data->actions[i];
! 2622: /* this socket has been removed. Decrease user count */
! 2623: entry->users--;
! 2624: if(oldactions & CURL_POLL_OUT)
! 2625: entry->writers--;
! 2626: if(oldactions & CURL_POLL_IN)
! 2627: entry->readers--;
! 2628: if(!entry->users) {
! 2629: if(multi->socket_cb)
! 2630: multi->socket_cb(data, s, CURL_POLL_REMOVE,
! 2631: multi->socket_userp,
! 2632: entry->socketp);
! 2633: sh_delentry(entry, &multi->sockhash, s);
! 2634: }
! 2635: else {
! 2636: /* still users, but remove this handle as a user of this socket */
! 2637: if(Curl_hash_delete(&entry->transfers, (char *)&data,
! 2638: sizeof(struct Curl_easy *))) {
! 2639: DEBUGASSERT(NULL);
! 2640: }
! 2641: }
! 2642: }
! 2643: } /* for loop over numsocks */
! 2644:
! 2645: memcpy(data->sockets, socks, num*sizeof(curl_socket_t));
! 2646: memcpy(data->actions, actions, num*sizeof(int));
! 2647: data->numsocks = num;
! 2648: return CURLM_OK;
! 2649: }
! 2650:
! 2651: void Curl_updatesocket(struct Curl_easy *data)
! 2652: {
! 2653: singlesocket(data->multi, data);
! 2654: }
! 2655:
! 2656:
! 2657: /*
! 2658: * Curl_multi_closed()
! 2659: *
! 2660: * Used by the connect code to tell the multi_socket code that one of the
! 2661: * sockets we were using is about to be closed. This function will then
! 2662: * remove it from the sockethash for this handle to make the multi_socket API
! 2663: * behave properly, especially for the case when libcurl will create another
! 2664: * socket again and it gets the same file descriptor number.
! 2665: */
! 2666:
! 2667: void Curl_multi_closed(struct Curl_easy *data, curl_socket_t s)
! 2668: {
! 2669: if(data) {
! 2670: /* if there's still an easy handle associated with this connection */
! 2671: struct Curl_multi *multi = data->multi;
! 2672: if(multi) {
! 2673: /* this is set if this connection is part of a handle that is added to
! 2674: a multi handle, and only then this is necessary */
! 2675: struct Curl_sh_entry *entry = sh_getentry(&multi->sockhash, s);
! 2676:
! 2677: if(entry) {
! 2678: if(multi->socket_cb)
! 2679: multi->socket_cb(data, s, CURL_POLL_REMOVE,
! 2680: multi->socket_userp,
! 2681: entry->socketp);
! 2682:
! 2683: /* now remove it from the socket hash */
! 2684: sh_delentry(entry, &multi->sockhash, s);
! 2685: }
! 2686: }
! 2687: }
! 2688: }
! 2689:
! 2690: /*
! 2691: * add_next_timeout()
! 2692: *
! 2693: * Each Curl_easy has a list of timeouts. The add_next_timeout() is called
! 2694: * when it has just been removed from the splay tree because the timeout has
! 2695: * expired. This function is then to advance in the list to pick the next
! 2696: * timeout to use (skip the already expired ones) and add this node back to
! 2697: * the splay tree again.
! 2698: *
! 2699: * The splay tree only has each sessionhandle as a single node and the nearest
! 2700: * timeout is used to sort it on.
! 2701: */
! 2702: static CURLMcode add_next_timeout(struct curltime now,
! 2703: struct Curl_multi *multi,
! 2704: struct Curl_easy *d)
! 2705: {
! 2706: struct curltime *tv = &d->state.expiretime;
! 2707: struct curl_llist *list = &d->state.timeoutlist;
! 2708: struct curl_llist_element *e;
! 2709: struct time_node *node = NULL;
! 2710:
! 2711: /* move over the timeout list for this specific handle and remove all
! 2712: timeouts that are now passed tense and store the next pending
! 2713: timeout in *tv */
! 2714: for(e = list->head; e;) {
! 2715: struct curl_llist_element *n = e->next;
! 2716: timediff_t diff;
! 2717: node = (struct time_node *)e->ptr;
! 2718: diff = Curl_timediff(node->time, now);
! 2719: if(diff <= 0)
! 2720: /* remove outdated entry */
! 2721: Curl_llist_remove(list, e, NULL);
! 2722: else
! 2723: /* the list is sorted so get out on the first mismatch */
! 2724: break;
! 2725: e = n;
! 2726: }
! 2727: e = list->head;
! 2728: if(!e) {
! 2729: /* clear the expire times within the handles that we remove from the
! 2730: splay tree */
! 2731: tv->tv_sec = 0;
! 2732: tv->tv_usec = 0;
! 2733: }
! 2734: else {
! 2735: /* copy the first entry to 'tv' */
! 2736: memcpy(tv, &node->time, sizeof(*tv));
! 2737:
! 2738: /* Insert this node again into the splay. Keep the timer in the list in
! 2739: case we need to recompute future timers. */
! 2740: multi->timetree = Curl_splayinsert(*tv, multi->timetree,
! 2741: &d->state.timenode);
! 2742: }
! 2743: return CURLM_OK;
! 2744: }
! 2745:
! 2746: static CURLMcode multi_socket(struct Curl_multi *multi,
! 2747: bool checkall,
! 2748: curl_socket_t s,
! 2749: int ev_bitmask,
! 2750: int *running_handles)
! 2751: {
! 2752: CURLMcode result = CURLM_OK;
! 2753: struct Curl_easy *data = NULL;
! 2754: struct Curl_tree *t;
! 2755: struct curltime now = Curl_now();
! 2756:
! 2757: if(checkall) {
! 2758: /* *perform() deals with running_handles on its own */
! 2759: result = curl_multi_perform(multi, running_handles);
! 2760:
! 2761: /* walk through each easy handle and do the socket state change magic
! 2762: and callbacks */
! 2763: if(result != CURLM_BAD_HANDLE) {
! 2764: data = multi->easyp;
! 2765: while(data && !result) {
! 2766: result = singlesocket(multi, data);
! 2767: data = data->next;
! 2768: }
! 2769: }
! 2770:
! 2771: /* or should we fall-through and do the timer-based stuff? */
! 2772: return result;
! 2773: }
! 2774: if(s != CURL_SOCKET_TIMEOUT) {
! 2775: struct Curl_sh_entry *entry = sh_getentry(&multi->sockhash, s);
! 2776:
! 2777: if(!entry)
! 2778: /* Unmatched socket, we can't act on it but we ignore this fact. In
! 2779: real-world tests it has been proved that libevent can in fact give
! 2780: the application actions even though the socket was just previously
! 2781: asked to get removed, so thus we better survive stray socket actions
! 2782: and just move on. */
! 2783: ;
! 2784: else {
! 2785: struct curl_hash_iterator iter;
! 2786: struct curl_hash_element *he;
! 2787:
! 2788: /* the socket can be shared by many transfers, iterate */
! 2789: Curl_hash_start_iterate(&entry->transfers, &iter);
! 2790: for(he = Curl_hash_next_element(&iter); he;
! 2791: he = Curl_hash_next_element(&iter)) {
! 2792: data = (struct Curl_easy *)he->ptr;
! 2793: DEBUGASSERT(data);
! 2794: DEBUGASSERT(data->magic == CURLEASY_MAGIC_NUMBER);
! 2795:
! 2796: if(data->conn && !(data->conn->handler->flags & PROTOPT_DIRLOCK))
! 2797: /* set socket event bitmask if they're not locked */
! 2798: data->conn->cselect_bits = ev_bitmask;
! 2799:
! 2800: Curl_expire(data, 0, EXPIRE_RUN_NOW);
! 2801: }
! 2802:
! 2803: /* Now we fall-through and do the timer-based stuff, since we don't want
! 2804: to force the user to have to deal with timeouts as long as at least
! 2805: one connection in fact has traffic. */
! 2806:
! 2807: data = NULL; /* set data to NULL again to avoid calling
! 2808: multi_runsingle() in case there's no need to */
! 2809: now = Curl_now(); /* get a newer time since the multi_runsingle() loop
! 2810: may have taken some time */
! 2811: }
! 2812: }
! 2813: else {
! 2814: /* Asked to run due to time-out. Clear the 'lastcall' variable to force
! 2815: Curl_update_timer() to trigger a callback to the app again even if the
! 2816: same timeout is still the one to run after this call. That handles the
! 2817: case when the application asks libcurl to run the timeout
! 2818: prematurely. */
! 2819: memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall));
! 2820: }
! 2821:
! 2822: /*
! 2823: * The loop following here will go on as long as there are expire-times left
! 2824: * to process in the splay and 'data' will be re-assigned for every expired
! 2825: * handle we deal with.
! 2826: */
! 2827: do {
! 2828: /* the first loop lap 'data' can be NULL */
! 2829: if(data) {
! 2830: SIGPIPE_VARIABLE(pipe_st);
! 2831:
! 2832: sigpipe_ignore(data, &pipe_st);
! 2833: result = multi_runsingle(multi, now, data);
! 2834: sigpipe_restore(&pipe_st);
! 2835:
! 2836: if(CURLM_OK >= result) {
! 2837: /* get the socket(s) and check if the state has been changed since
! 2838: last */
! 2839: result = singlesocket(multi, data);
! 2840: if(result)
! 2841: return result;
! 2842: }
! 2843: }
! 2844:
! 2845: /* Check if there's one (more) expired timer to deal with! This function
! 2846: extracts a matching node if there is one */
! 2847:
! 2848: multi->timetree = Curl_splaygetbest(now, multi->timetree, &t);
! 2849: if(t) {
! 2850: data = t->payload; /* assign this for next loop */
! 2851: (void)add_next_timeout(now, multi, t->payload);
! 2852: }
! 2853:
! 2854: } while(t);
! 2855:
! 2856: *running_handles = multi->num_alive;
! 2857: return result;
! 2858: }
! 2859:
! 2860: #undef curl_multi_setopt
! 2861: CURLMcode curl_multi_setopt(struct Curl_multi *multi,
! 2862: CURLMoption option, ...)
! 2863: {
! 2864: CURLMcode res = CURLM_OK;
! 2865: va_list param;
! 2866:
! 2867: if(!GOOD_MULTI_HANDLE(multi))
! 2868: return CURLM_BAD_HANDLE;
! 2869:
! 2870: if(multi->in_callback)
! 2871: return CURLM_RECURSIVE_API_CALL;
! 2872:
! 2873: va_start(param, option);
! 2874:
! 2875: switch(option) {
! 2876: case CURLMOPT_SOCKETFUNCTION:
! 2877: multi->socket_cb = va_arg(param, curl_socket_callback);
! 2878: break;
! 2879: case CURLMOPT_SOCKETDATA:
! 2880: multi->socket_userp = va_arg(param, void *);
! 2881: break;
! 2882: case CURLMOPT_PUSHFUNCTION:
! 2883: multi->push_cb = va_arg(param, curl_push_callback);
! 2884: break;
! 2885: case CURLMOPT_PUSHDATA:
! 2886: multi->push_userp = va_arg(param, void *);
! 2887: break;
! 2888: case CURLMOPT_PIPELINING:
! 2889: multi->multiplexing = va_arg(param, long) & CURLPIPE_MULTIPLEX;
! 2890: break;
! 2891: case CURLMOPT_TIMERFUNCTION:
! 2892: multi->timer_cb = va_arg(param, curl_multi_timer_callback);
! 2893: break;
! 2894: case CURLMOPT_TIMERDATA:
! 2895: multi->timer_userp = va_arg(param, void *);
! 2896: break;
! 2897: case CURLMOPT_MAXCONNECTS:
! 2898: multi->maxconnects = va_arg(param, long);
! 2899: break;
! 2900: case CURLMOPT_MAX_HOST_CONNECTIONS:
! 2901: multi->max_host_connections = va_arg(param, long);
! 2902: break;
! 2903: case CURLMOPT_MAX_TOTAL_CONNECTIONS:
! 2904: multi->max_total_connections = va_arg(param, long);
! 2905: break;
! 2906: /* options formerly used for pipelining */
! 2907: case CURLMOPT_MAX_PIPELINE_LENGTH:
! 2908: break;
! 2909: case CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE:
! 2910: break;
! 2911: case CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE:
! 2912: break;
! 2913: case CURLMOPT_PIPELINING_SITE_BL:
! 2914: break;
! 2915: case CURLMOPT_PIPELINING_SERVER_BL:
! 2916: break;
! 2917: case CURLMOPT_MAX_CONCURRENT_STREAMS:
! 2918: {
! 2919: long streams = va_arg(param, long);
! 2920: if(streams < 1)
! 2921: streams = 100;
! 2922: multi->max_concurrent_streams =
! 2923: (streams > (long)INITIAL_MAX_CONCURRENT_STREAMS)?
! 2924: INITIAL_MAX_CONCURRENT_STREAMS : (unsigned int)streams;
! 2925: }
! 2926: break;
! 2927: default:
! 2928: res = CURLM_UNKNOWN_OPTION;
! 2929: break;
! 2930: }
! 2931: va_end(param);
! 2932: return res;
! 2933: }
! 2934:
! 2935: /* we define curl_multi_socket() in the public multi.h header */
! 2936: #undef curl_multi_socket
! 2937:
! 2938: CURLMcode curl_multi_socket(struct Curl_multi *multi, curl_socket_t s,
! 2939: int *running_handles)
! 2940: {
! 2941: CURLMcode result;
! 2942: if(multi->in_callback)
! 2943: return CURLM_RECURSIVE_API_CALL;
! 2944: result = multi_socket(multi, FALSE, s, 0, running_handles);
! 2945: if(CURLM_OK >= result)
! 2946: Curl_update_timer(multi);
! 2947: return result;
! 2948: }
! 2949:
! 2950: CURLMcode curl_multi_socket_action(struct Curl_multi *multi, curl_socket_t s,
! 2951: int ev_bitmask, int *running_handles)
! 2952: {
! 2953: CURLMcode result;
! 2954: if(multi->in_callback)
! 2955: return CURLM_RECURSIVE_API_CALL;
! 2956: result = multi_socket(multi, FALSE, s, ev_bitmask, running_handles);
! 2957: if(CURLM_OK >= result)
! 2958: Curl_update_timer(multi);
! 2959: return result;
! 2960: }
! 2961:
! 2962: CURLMcode curl_multi_socket_all(struct Curl_multi *multi, int *running_handles)
! 2963:
! 2964: {
! 2965: CURLMcode result;
! 2966: if(multi->in_callback)
! 2967: return CURLM_RECURSIVE_API_CALL;
! 2968: result = multi_socket(multi, TRUE, CURL_SOCKET_BAD, 0, running_handles);
! 2969: if(CURLM_OK >= result)
! 2970: Curl_update_timer(multi);
! 2971: return result;
! 2972: }
! 2973:
! 2974: static CURLMcode multi_timeout(struct Curl_multi *multi,
! 2975: long *timeout_ms)
! 2976: {
! 2977: static struct curltime tv_zero = {0, 0};
! 2978:
! 2979: if(multi->timetree) {
! 2980: /* we have a tree of expire times */
! 2981: struct curltime now = Curl_now();
! 2982:
! 2983: /* splay the lowest to the bottom */
! 2984: multi->timetree = Curl_splay(tv_zero, multi->timetree);
! 2985:
! 2986: if(Curl_splaycomparekeys(multi->timetree->key, now) > 0) {
! 2987: /* some time left before expiration */
! 2988: timediff_t diff = Curl_timediff(multi->timetree->key, now);
! 2989: if(diff <= 0)
! 2990: /*
! 2991: * Since we only provide millisecond resolution on the returned value
! 2992: * and the diff might be less than one millisecond here, we don't
! 2993: * return zero as that may cause short bursts of busyloops on fast
! 2994: * processors while the diff is still present but less than one
! 2995: * millisecond! instead we return 1 until the time is ripe.
! 2996: */
! 2997: *timeout_ms = 1;
! 2998: else
! 2999: /* this should be safe even on 64 bit archs, as we don't use that
! 3000: overly long timeouts */
! 3001: *timeout_ms = (long)diff;
! 3002: }
! 3003: else
! 3004: /* 0 means immediately */
! 3005: *timeout_ms = 0;
! 3006: }
! 3007: else
! 3008: *timeout_ms = -1;
! 3009:
! 3010: return CURLM_OK;
! 3011: }
! 3012:
! 3013: CURLMcode curl_multi_timeout(struct Curl_multi *multi,
! 3014: long *timeout_ms)
! 3015: {
! 3016: /* First, make some basic checks that the CURLM handle is a good handle */
! 3017: if(!GOOD_MULTI_HANDLE(multi))
! 3018: return CURLM_BAD_HANDLE;
! 3019:
! 3020: if(multi->in_callback)
! 3021: return CURLM_RECURSIVE_API_CALL;
! 3022:
! 3023: return multi_timeout(multi, timeout_ms);
! 3024: }
! 3025:
! 3026: /*
! 3027: * Tell the application it should update its timers, if it subscribes to the
! 3028: * update timer callback.
! 3029: */
! 3030: void Curl_update_timer(struct Curl_multi *multi)
! 3031: {
! 3032: long timeout_ms;
! 3033:
! 3034: if(!multi->timer_cb)
! 3035: return;
! 3036: if(multi_timeout(multi, &timeout_ms)) {
! 3037: return;
! 3038: }
! 3039: if(timeout_ms < 0) {
! 3040: static const struct curltime none = {0, 0};
! 3041: if(Curl_splaycomparekeys(none, multi->timer_lastcall)) {
! 3042: multi->timer_lastcall = none;
! 3043: /* there's no timeout now but there was one previously, tell the app to
! 3044: disable it */
! 3045: multi->timer_cb(multi, -1, multi->timer_userp);
! 3046: return;
! 3047: }
! 3048: return;
! 3049: }
! 3050:
! 3051: /* When multi_timeout() is done, multi->timetree points to the node with the
! 3052: * timeout we got the (relative) time-out time for. We can thus easily check
! 3053: * if this is the same (fixed) time as we got in a previous call and then
! 3054: * avoid calling the callback again. */
! 3055: if(Curl_splaycomparekeys(multi->timetree->key, multi->timer_lastcall) == 0)
! 3056: return;
! 3057:
! 3058: multi->timer_lastcall = multi->timetree->key;
! 3059:
! 3060: multi->timer_cb(multi, timeout_ms, multi->timer_userp);
! 3061: }
! 3062:
! 3063: /*
! 3064: * multi_deltimeout()
! 3065: *
! 3066: * Remove a given timestamp from the list of timeouts.
! 3067: */
! 3068: static void
! 3069: multi_deltimeout(struct Curl_easy *data, expire_id eid)
! 3070: {
! 3071: struct curl_llist_element *e;
! 3072: struct curl_llist *timeoutlist = &data->state.timeoutlist;
! 3073: /* find and remove the specific node from the list */
! 3074: for(e = timeoutlist->head; e; e = e->next) {
! 3075: struct time_node *n = (struct time_node *)e->ptr;
! 3076: if(n->eid == eid) {
! 3077: Curl_llist_remove(timeoutlist, e, NULL);
! 3078: return;
! 3079: }
! 3080: }
! 3081: }
! 3082:
! 3083: /*
! 3084: * multi_addtimeout()
! 3085: *
! 3086: * Add a timestamp to the list of timeouts. Keep the list sorted so that head
! 3087: * of list is always the timeout nearest in time.
! 3088: *
! 3089: */
! 3090: static CURLMcode
! 3091: multi_addtimeout(struct Curl_easy *data,
! 3092: struct curltime *stamp,
! 3093: expire_id eid)
! 3094: {
! 3095: struct curl_llist_element *e;
! 3096: struct time_node *node;
! 3097: struct curl_llist_element *prev = NULL;
! 3098: size_t n;
! 3099: struct curl_llist *timeoutlist = &data->state.timeoutlist;
! 3100:
! 3101: node = &data->state.expires[eid];
! 3102:
! 3103: /* copy the timestamp and id */
! 3104: memcpy(&node->time, stamp, sizeof(*stamp));
! 3105: node->eid = eid; /* also marks it as in use */
! 3106:
! 3107: n = Curl_llist_count(timeoutlist);
! 3108: if(n) {
! 3109: /* find the correct spot in the list */
! 3110: for(e = timeoutlist->head; e; e = e->next) {
! 3111: struct time_node *check = (struct time_node *)e->ptr;
! 3112: timediff_t diff = Curl_timediff(check->time, node->time);
! 3113: if(diff > 0)
! 3114: break;
! 3115: prev = e;
! 3116: }
! 3117:
! 3118: }
! 3119: /* else
! 3120: this is the first timeout on the list */
! 3121:
! 3122: Curl_llist_insert_next(timeoutlist, prev, node, &node->list);
! 3123: return CURLM_OK;
! 3124: }
! 3125:
! 3126: /*
! 3127: * Curl_expire()
! 3128: *
! 3129: * given a number of milliseconds from now to use to set the 'act before
! 3130: * this'-time for the transfer, to be extracted by curl_multi_timeout()
! 3131: *
! 3132: * The timeout will be added to a queue of timeouts if it defines a moment in
! 3133: * time that is later than the current head of queue.
! 3134: *
! 3135: * Expire replaces a former timeout using the same id if already set.
! 3136: */
! 3137: void Curl_expire(struct Curl_easy *data, timediff_t milli, expire_id id)
! 3138: {
! 3139: struct Curl_multi *multi = data->multi;
! 3140: struct curltime *nowp = &data->state.expiretime;
! 3141: struct curltime set;
! 3142:
! 3143: /* this is only interesting while there is still an associated multi struct
! 3144: remaining! */
! 3145: if(!multi)
! 3146: return;
! 3147:
! 3148: DEBUGASSERT(id < EXPIRE_LAST);
! 3149:
! 3150: set = Curl_now();
! 3151: set.tv_sec += (time_t)(milli/1000); /* might be a 64 to 32 bit conversion */
! 3152: set.tv_usec += (unsigned int)(milli%1000)*1000;
! 3153:
! 3154: if(set.tv_usec >= 1000000) {
! 3155: set.tv_sec++;
! 3156: set.tv_usec -= 1000000;
! 3157: }
! 3158:
! 3159: /* Remove any timer with the same id just in case. */
! 3160: multi_deltimeout(data, id);
! 3161:
! 3162: /* Add it to the timer list. It must stay in the list until it has expired
! 3163: in case we need to recompute the minimum timer later. */
! 3164: multi_addtimeout(data, &set, id);
! 3165:
! 3166: if(nowp->tv_sec || nowp->tv_usec) {
! 3167: /* This means that the struct is added as a node in the splay tree.
! 3168: Compare if the new time is earlier, and only remove-old/add-new if it
! 3169: is. */
! 3170: timediff_t diff = Curl_timediff(set, *nowp);
! 3171: int rc;
! 3172:
! 3173: if(diff > 0) {
! 3174: /* The current splay tree entry is sooner than this new expiry time.
! 3175: We don't need to update our splay tree entry. */
! 3176: return;
! 3177: }
! 3178:
! 3179: /* Since this is an updated time, we must remove the previous entry from
! 3180: the splay tree first and then re-add the new value */
! 3181: rc = Curl_splayremovebyaddr(multi->timetree,
! 3182: &data->state.timenode,
! 3183: &multi->timetree);
! 3184: if(rc)
! 3185: infof(data, "Internal error removing splay node = %d\n", rc);
! 3186: }
! 3187:
! 3188: /* Indicate that we are in the splay tree and insert the new timer expiry
! 3189: value since it is our local minimum. */
! 3190: *nowp = set;
! 3191: data->state.timenode.payload = data;
! 3192: multi->timetree = Curl_splayinsert(*nowp, multi->timetree,
! 3193: &data->state.timenode);
! 3194: }
! 3195:
! 3196: /*
! 3197: * Curl_expire_done()
! 3198: *
! 3199: * Removes the expire timer. Marks it as done.
! 3200: *
! 3201: */
! 3202: void Curl_expire_done(struct Curl_easy *data, expire_id id)
! 3203: {
! 3204: /* remove the timer, if there */
! 3205: multi_deltimeout(data, id);
! 3206: }
! 3207:
! 3208: /*
! 3209: * Curl_expire_clear()
! 3210: *
! 3211: * Clear ALL timeout values for this handle.
! 3212: */
! 3213: void Curl_expire_clear(struct Curl_easy *data)
! 3214: {
! 3215: struct Curl_multi *multi = data->multi;
! 3216: struct curltime *nowp = &data->state.expiretime;
! 3217:
! 3218: /* this is only interesting while there is still an associated multi struct
! 3219: remaining! */
! 3220: if(!multi)
! 3221: return;
! 3222:
! 3223: if(nowp->tv_sec || nowp->tv_usec) {
! 3224: /* Since this is an cleared time, we must remove the previous entry from
! 3225: the splay tree */
! 3226: struct curl_llist *list = &data->state.timeoutlist;
! 3227: int rc;
! 3228:
! 3229: rc = Curl_splayremovebyaddr(multi->timetree,
! 3230: &data->state.timenode,
! 3231: &multi->timetree);
! 3232: if(rc)
! 3233: infof(data, "Internal error clearing splay node = %d\n", rc);
! 3234:
! 3235: /* flush the timeout list too */
! 3236: while(list->size > 0) {
! 3237: Curl_llist_remove(list, list->tail, NULL);
! 3238: }
! 3239:
! 3240: #ifdef DEBUGBUILD
! 3241: infof(data, "Expire cleared (transfer %p)\n", data);
! 3242: #endif
! 3243: nowp->tv_sec = 0;
! 3244: nowp->tv_usec = 0;
! 3245: }
! 3246: }
! 3247:
! 3248:
! 3249:
! 3250:
! 3251: CURLMcode curl_multi_assign(struct Curl_multi *multi, curl_socket_t s,
! 3252: void *hashp)
! 3253: {
! 3254: struct Curl_sh_entry *there = NULL;
! 3255:
! 3256: if(multi->in_callback)
! 3257: return CURLM_RECURSIVE_API_CALL;
! 3258:
! 3259: there = sh_getentry(&multi->sockhash, s);
! 3260:
! 3261: if(!there)
! 3262: return CURLM_BAD_SOCKET;
! 3263:
! 3264: there->socketp = hashp;
! 3265:
! 3266: return CURLM_OK;
! 3267: }
! 3268:
! 3269: size_t Curl_multi_max_host_connections(struct Curl_multi *multi)
! 3270: {
! 3271: return multi ? multi->max_host_connections : 0;
! 3272: }
! 3273:
! 3274: size_t Curl_multi_max_total_connections(struct Curl_multi *multi)
! 3275: {
! 3276: return multi ? multi->max_total_connections : 0;
! 3277: }
! 3278:
! 3279: /*
! 3280: * When information about a connection has appeared, call this!
! 3281: */
! 3282:
! 3283: void Curl_multiuse_state(struct connectdata *conn,
! 3284: int bundlestate) /* use BUNDLE_* defines */
! 3285: {
! 3286: DEBUGASSERT(conn);
! 3287: DEBUGASSERT(conn->bundle);
! 3288: DEBUGASSERT(conn->data);
! 3289: DEBUGASSERT(conn->data->multi);
! 3290:
! 3291: conn->bundle->multiuse = bundlestate;
! 3292: process_pending_handles(conn->data->multi);
! 3293: }
! 3294:
! 3295: static void process_pending_handles(struct Curl_multi *multi)
! 3296: {
! 3297: struct curl_llist_element *e = multi->pending.head;
! 3298: if(e) {
! 3299: struct Curl_easy *data = e->ptr;
! 3300:
! 3301: DEBUGASSERT(data->mstate == CURLM_STATE_CONNECT_PEND);
! 3302:
! 3303: multistate(data, CURLM_STATE_CONNECT);
! 3304:
! 3305: /* Remove this node from the list */
! 3306: Curl_llist_remove(&multi->pending, e, NULL);
! 3307:
! 3308: /* Make sure that the handle will be processed soonish. */
! 3309: Curl_expire(data, 0, EXPIRE_RUN_NOW);
! 3310:
! 3311: /* mark this as having been in the pending queue */
! 3312: data->state.previouslypending = TRUE;
! 3313: }
! 3314: }
! 3315:
! 3316: void Curl_set_in_callback(struct Curl_easy *data, bool value)
! 3317: {
! 3318: /* might get called when there is no data pointer! */
! 3319: if(data) {
! 3320: if(data->multi_easy)
! 3321: data->multi_easy->in_callback = value;
! 3322: else if(data->multi)
! 3323: data->multi->in_callback = value;
! 3324: }
! 3325: }
! 3326:
! 3327: bool Curl_is_in_callback(struct Curl_easy *easy)
! 3328: {
! 3329: return ((easy->multi && easy->multi->in_callback) ||
! 3330: (easy->multi_easy && easy->multi_easy->in_callback));
! 3331: }
! 3332:
! 3333: #ifdef DEBUGBUILD
! 3334: void Curl_multi_dump(struct Curl_multi *multi)
! 3335: {
! 3336: struct Curl_easy *data;
! 3337: int i;
! 3338: fprintf(stderr, "* Multi status: %d handles, %d alive\n",
! 3339: multi->num_easy, multi->num_alive);
! 3340: for(data = multi->easyp; data; data = data->next) {
! 3341: if(data->mstate < CURLM_STATE_COMPLETED) {
! 3342: /* only display handles that are not completed */
! 3343: fprintf(stderr, "handle %p, state %s, %d sockets\n",
! 3344: (void *)data,
! 3345: statename[data->mstate], data->numsocks);
! 3346: for(i = 0; i < data->numsocks; i++) {
! 3347: curl_socket_t s = data->sockets[i];
! 3348: struct Curl_sh_entry *entry = sh_getentry(&multi->sockhash, s);
! 3349:
! 3350: fprintf(stderr, "%d ", (int)s);
! 3351: if(!entry) {
! 3352: fprintf(stderr, "INTERNAL CONFUSION\n");
! 3353: continue;
! 3354: }
! 3355: fprintf(stderr, "[%s %s] ",
! 3356: (entry->action&CURL_POLL_IN)?"RECVING":"",
! 3357: (entry->action&CURL_POLL_OUT)?"SENDING":"");
! 3358: }
! 3359: if(data->numsocks)
! 3360: fprintf(stderr, "\n");
! 3361: }
! 3362: }
! 3363: }
! 3364: #endif
! 3365:
! 3366: unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi)
! 3367: {
! 3368: DEBUGASSERT(multi);
! 3369: return multi->max_concurrent_streams;
! 3370: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to multi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib