Annotation of embedaddon/curl/lib/conncache.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 2012 - 2016, Linus Nielsen Feltzing, <linus@haxx.se>
! 9: * Copyright (C) 2012 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 10: *
! 11: * This software is licensed as described in the file COPYING, which
! 12: * you should have received as part of this distribution. The terms
! 13: * are also available at https://curl.haxx.se/docs/copyright.html.
! 14: *
! 15: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 16: * copies of the Software, and permit persons to whom the Software is
! 17: * furnished to do so, under the terms of the COPYING file.
! 18: *
! 19: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 20: * KIND, either express or implied.
! 21: *
! 22: ***************************************************************************/
! 23:
! 24: #include "curl_setup.h"
! 25:
! 26: #include <curl/curl.h>
! 27:
! 28: #include "urldata.h"
! 29: #include "url.h"
! 30: #include "progress.h"
! 31: #include "multiif.h"
! 32: #include "sendf.h"
! 33: #include "conncache.h"
! 34: #include "share.h"
! 35: #include "sigpipe.h"
! 36: #include "connect.h"
! 37:
! 38: /* The last 3 #include files should be in this order */
! 39: #include "curl_printf.h"
! 40: #include "curl_memory.h"
! 41: #include "memdebug.h"
! 42:
! 43: #define HASHKEY_SIZE 128
! 44:
! 45: static void conn_llist_dtor(void *user, void *element)
! 46: {
! 47: struct connectdata *conn = element;
! 48: (void)user;
! 49: conn->bundle = NULL;
! 50: }
! 51:
! 52: static CURLcode bundle_create(struct Curl_easy *data,
! 53: struct connectbundle **cb_ptr)
! 54: {
! 55: (void)data;
! 56: DEBUGASSERT(*cb_ptr == NULL);
! 57: *cb_ptr = malloc(sizeof(struct connectbundle));
! 58: if(!*cb_ptr)
! 59: return CURLE_OUT_OF_MEMORY;
! 60:
! 61: (*cb_ptr)->num_connections = 0;
! 62: (*cb_ptr)->multiuse = BUNDLE_UNKNOWN;
! 63:
! 64: Curl_llist_init(&(*cb_ptr)->conn_list, (curl_llist_dtor) conn_llist_dtor);
! 65: return CURLE_OK;
! 66: }
! 67:
! 68: static void bundle_destroy(struct connectbundle *cb_ptr)
! 69: {
! 70: if(!cb_ptr)
! 71: return;
! 72:
! 73: Curl_llist_destroy(&cb_ptr->conn_list, NULL);
! 74:
! 75: free(cb_ptr);
! 76: }
! 77:
! 78: /* Add a connection to a bundle */
! 79: static void bundle_add_conn(struct connectbundle *cb_ptr,
! 80: struct connectdata *conn)
! 81: {
! 82: Curl_llist_insert_next(&cb_ptr->conn_list, cb_ptr->conn_list.tail, conn,
! 83: &conn->bundle_node);
! 84: conn->bundle = cb_ptr;
! 85: cb_ptr->num_connections++;
! 86: }
! 87:
! 88: /* Remove a connection from a bundle */
! 89: static int bundle_remove_conn(struct connectbundle *cb_ptr,
! 90: struct connectdata *conn)
! 91: {
! 92: struct curl_llist_element *curr;
! 93:
! 94: curr = cb_ptr->conn_list.head;
! 95: while(curr) {
! 96: if(curr->ptr == conn) {
! 97: Curl_llist_remove(&cb_ptr->conn_list, curr, NULL);
! 98: cb_ptr->num_connections--;
! 99: conn->bundle = NULL;
! 100: return 1; /* we removed a handle */
! 101: }
! 102: curr = curr->next;
! 103: }
! 104: DEBUGASSERT(0);
! 105: return 0;
! 106: }
! 107:
! 108: static void free_bundle_hash_entry(void *freethis)
! 109: {
! 110: struct connectbundle *b = (struct connectbundle *) freethis;
! 111:
! 112: bundle_destroy(b);
! 113: }
! 114:
! 115: int Curl_conncache_init(struct conncache *connc, int size)
! 116: {
! 117: int rc;
! 118:
! 119: /* allocate a new easy handle to use when closing cached connections */
! 120: connc->closure_handle = curl_easy_init();
! 121: if(!connc->closure_handle)
! 122: return 1; /* bad */
! 123:
! 124: rc = Curl_hash_init(&connc->hash, size, Curl_hash_str,
! 125: Curl_str_key_compare, free_bundle_hash_entry);
! 126: if(rc)
! 127: Curl_close(&connc->closure_handle);
! 128: else
! 129: connc->closure_handle->state.conn_cache = connc;
! 130:
! 131: return rc;
! 132: }
! 133:
! 134: void Curl_conncache_destroy(struct conncache *connc)
! 135: {
! 136: if(connc)
! 137: Curl_hash_destroy(&connc->hash);
! 138: }
! 139:
! 140: /* creates a key to find a bundle for this connection */
! 141: static void hashkey(struct connectdata *conn, char *buf,
! 142: size_t len, /* something like 128 is fine */
! 143: const char **hostp)
! 144: {
! 145: const char *hostname;
! 146: long port = conn->remote_port;
! 147:
! 148: if(conn->bits.httpproxy && !conn->bits.tunnel_proxy) {
! 149: hostname = conn->http_proxy.host.name;
! 150: port = conn->port;
! 151: }
! 152: else if(conn->bits.conn_to_host)
! 153: hostname = conn->conn_to_host.name;
! 154: else
! 155: hostname = conn->host.name;
! 156:
! 157: if(hostp)
! 158: /* report back which name we used */
! 159: *hostp = hostname;
! 160:
! 161: /* put the number first so that the hostname gets cut off if too long */
! 162: msnprintf(buf, len, "%ld%s", port, hostname);
! 163: }
! 164:
! 165: void Curl_conncache_unlock(struct Curl_easy *data)
! 166: {
! 167: CONN_UNLOCK(data);
! 168: }
! 169:
! 170: /* Returns number of connections currently held in the connection cache.
! 171: Locks/unlocks the cache itself!
! 172: */
! 173: size_t Curl_conncache_size(struct Curl_easy *data)
! 174: {
! 175: size_t num;
! 176: CONN_LOCK(data);
! 177: num = data->state.conn_cache->num_conn;
! 178: CONN_UNLOCK(data);
! 179: return num;
! 180: }
! 181:
! 182: /* Look up the bundle with all the connections to the same host this
! 183: connectdata struct is setup to use.
! 184:
! 185: **NOTE**: When it returns, it holds the connection cache lock! */
! 186: struct connectbundle *Curl_conncache_find_bundle(struct connectdata *conn,
! 187: struct conncache *connc,
! 188: const char **hostp)
! 189: {
! 190: struct connectbundle *bundle = NULL;
! 191: CONN_LOCK(conn->data);
! 192: if(connc) {
! 193: char key[HASHKEY_SIZE];
! 194: hashkey(conn, key, sizeof(key), hostp);
! 195: bundle = Curl_hash_pick(&connc->hash, key, strlen(key));
! 196: }
! 197:
! 198: return bundle;
! 199: }
! 200:
! 201: static bool conncache_add_bundle(struct conncache *connc,
! 202: char *key,
! 203: struct connectbundle *bundle)
! 204: {
! 205: void *p = Curl_hash_add(&connc->hash, key, strlen(key), bundle);
! 206:
! 207: return p?TRUE:FALSE;
! 208: }
! 209:
! 210: static void conncache_remove_bundle(struct conncache *connc,
! 211: struct connectbundle *bundle)
! 212: {
! 213: struct curl_hash_iterator iter;
! 214: struct curl_hash_element *he;
! 215:
! 216: if(!connc)
! 217: return;
! 218:
! 219: Curl_hash_start_iterate(&connc->hash, &iter);
! 220:
! 221: he = Curl_hash_next_element(&iter);
! 222: while(he) {
! 223: if(he->ptr == bundle) {
! 224: /* The bundle is destroyed by the hash destructor function,
! 225: free_bundle_hash_entry() */
! 226: Curl_hash_delete(&connc->hash, he->key, he->key_len);
! 227: return;
! 228: }
! 229:
! 230: he = Curl_hash_next_element(&iter);
! 231: }
! 232: }
! 233:
! 234: CURLcode Curl_conncache_add_conn(struct conncache *connc,
! 235: struct connectdata *conn)
! 236: {
! 237: CURLcode result = CURLE_OK;
! 238: struct connectbundle *bundle;
! 239: struct connectbundle *new_bundle = NULL;
! 240: struct Curl_easy *data = conn->data;
! 241:
! 242: /* *find_bundle() locks the connection cache */
! 243: bundle = Curl_conncache_find_bundle(conn, data->state.conn_cache, NULL);
! 244: if(!bundle) {
! 245: int rc;
! 246: char key[HASHKEY_SIZE];
! 247:
! 248: result = bundle_create(data, &new_bundle);
! 249: if(result) {
! 250: goto unlock;
! 251: }
! 252:
! 253: hashkey(conn, key, sizeof(key), NULL);
! 254: rc = conncache_add_bundle(data->state.conn_cache, key, new_bundle);
! 255:
! 256: if(!rc) {
! 257: bundle_destroy(new_bundle);
! 258: result = CURLE_OUT_OF_MEMORY;
! 259: goto unlock;
! 260: }
! 261: bundle = new_bundle;
! 262: }
! 263:
! 264: bundle_add_conn(bundle, conn);
! 265: conn->connection_id = connc->next_connection_id++;
! 266: connc->num_conn++;
! 267:
! 268: DEBUGF(infof(conn->data, "Added connection %ld. "
! 269: "The cache now contains %zu members\n",
! 270: conn->connection_id, connc->num_conn));
! 271:
! 272: unlock:
! 273: CONN_UNLOCK(data);
! 274:
! 275: return result;
! 276: }
! 277:
! 278: /*
! 279: * Removes the connectdata object from the connection cache *and* clears the
! 280: * ->data pointer association. Pass TRUE/FALSE in the 'lock' argument
! 281: * depending on if the parent function already holds the lock or not.
! 282: */
! 283: void Curl_conncache_remove_conn(struct Curl_easy *data,
! 284: struct connectdata *conn, bool lock)
! 285: {
! 286: struct connectbundle *bundle = conn->bundle;
! 287: struct conncache *connc = data->state.conn_cache;
! 288:
! 289: /* The bundle pointer can be NULL, since this function can be called
! 290: due to a failed connection attempt, before being added to a bundle */
! 291: if(bundle) {
! 292: if(lock) {
! 293: CONN_LOCK(data);
! 294: }
! 295: bundle_remove_conn(bundle, conn);
! 296: if(bundle->num_connections == 0)
! 297: conncache_remove_bundle(connc, bundle);
! 298: conn->bundle = NULL; /* removed from it */
! 299: if(connc) {
! 300: connc->num_conn--;
! 301: DEBUGF(infof(data, "The cache now contains %zu members\n",
! 302: connc->num_conn));
! 303: }
! 304: conn->data = NULL; /* clear the association */
! 305: if(lock) {
! 306: CONN_UNLOCK(data);
! 307: }
! 308: }
! 309: }
! 310:
! 311: /* This function iterates the entire connection cache and calls the function
! 312: func() with the connection pointer as the first argument and the supplied
! 313: 'param' argument as the other.
! 314:
! 315: The conncache lock is still held when the callback is called. It needs it,
! 316: so that it can safely continue traversing the lists once the callback
! 317: returns.
! 318:
! 319: Returns 1 if the loop was aborted due to the callback's return code.
! 320:
! 321: Return 0 from func() to continue the loop, return 1 to abort it.
! 322: */
! 323: bool Curl_conncache_foreach(struct Curl_easy *data,
! 324: struct conncache *connc,
! 325: void *param,
! 326: int (*func)(struct connectdata *conn, void *param))
! 327: {
! 328: struct curl_hash_iterator iter;
! 329: struct curl_llist_element *curr;
! 330: struct curl_hash_element *he;
! 331:
! 332: if(!connc)
! 333: return FALSE;
! 334:
! 335: CONN_LOCK(data);
! 336: Curl_hash_start_iterate(&connc->hash, &iter);
! 337:
! 338: he = Curl_hash_next_element(&iter);
! 339: while(he) {
! 340: struct connectbundle *bundle;
! 341:
! 342: bundle = he->ptr;
! 343: he = Curl_hash_next_element(&iter);
! 344:
! 345: curr = bundle->conn_list.head;
! 346: while(curr) {
! 347: /* Yes, we need to update curr before calling func(), because func()
! 348: might decide to remove the connection */
! 349: struct connectdata *conn = curr->ptr;
! 350: curr = curr->next;
! 351:
! 352: if(1 == func(conn, param)) {
! 353: CONN_UNLOCK(data);
! 354: return TRUE;
! 355: }
! 356: }
! 357: }
! 358: CONN_UNLOCK(data);
! 359: return FALSE;
! 360: }
! 361:
! 362: /* Return the first connection found in the cache. Used when closing all
! 363: connections.
! 364:
! 365: NOTE: no locking is done here as this is presumably only done when cleaning
! 366: up a cache!
! 367: */
! 368: static struct connectdata *
! 369: conncache_find_first_connection(struct conncache *connc)
! 370: {
! 371: struct curl_hash_iterator iter;
! 372: struct curl_hash_element *he;
! 373: struct connectbundle *bundle;
! 374:
! 375: Curl_hash_start_iterate(&connc->hash, &iter);
! 376:
! 377: he = Curl_hash_next_element(&iter);
! 378: while(he) {
! 379: struct curl_llist_element *curr;
! 380: bundle = he->ptr;
! 381:
! 382: curr = bundle->conn_list.head;
! 383: if(curr) {
! 384: return curr->ptr;
! 385: }
! 386:
! 387: he = Curl_hash_next_element(&iter);
! 388: }
! 389:
! 390: return NULL;
! 391: }
! 392:
! 393: /*
! 394: * Give ownership of a connection back to the connection cache. Might
! 395: * disconnect the oldest existing in there to make space.
! 396: *
! 397: * Return TRUE if stored, FALSE if closed.
! 398: */
! 399: bool Curl_conncache_return_conn(struct Curl_easy *data,
! 400: struct connectdata *conn)
! 401: {
! 402: /* data->multi->maxconnects can be negative, deal with it. */
! 403: size_t maxconnects =
! 404: (data->multi->maxconnects < 0) ? data->multi->num_easy * 4:
! 405: data->multi->maxconnects;
! 406: struct connectdata *conn_candidate = NULL;
! 407:
! 408: conn->lastused = Curl_now(); /* it was used up until now */
! 409: if(maxconnects > 0 &&
! 410: Curl_conncache_size(data) > maxconnects) {
! 411: infof(data, "Connection cache is full, closing the oldest one.\n");
! 412:
! 413: conn_candidate = Curl_conncache_extract_oldest(data);
! 414: if(conn_candidate) {
! 415: /* the winner gets the honour of being disconnected */
! 416: (void)Curl_disconnect(data, conn_candidate, /* dead_connection */ FALSE);
! 417: }
! 418: }
! 419:
! 420: return (conn_candidate == conn) ? FALSE : TRUE;
! 421:
! 422: }
! 423:
! 424: /*
! 425: * This function finds the connection in the connection bundle that has been
! 426: * unused for the longest time.
! 427: *
! 428: * Does not lock the connection cache!
! 429: *
! 430: * Returns the pointer to the oldest idle connection, or NULL if none was
! 431: * found.
! 432: */
! 433: struct connectdata *
! 434: Curl_conncache_extract_bundle(struct Curl_easy *data,
! 435: struct connectbundle *bundle)
! 436: {
! 437: struct curl_llist_element *curr;
! 438: timediff_t highscore = -1;
! 439: timediff_t score;
! 440: struct curltime now;
! 441: struct connectdata *conn_candidate = NULL;
! 442: struct connectdata *conn;
! 443:
! 444: (void)data;
! 445:
! 446: now = Curl_now();
! 447:
! 448: curr = bundle->conn_list.head;
! 449: while(curr) {
! 450: conn = curr->ptr;
! 451:
! 452: if(!CONN_INUSE(conn) && !conn->data) {
! 453: /* Set higher score for the age passed since the connection was used */
! 454: score = Curl_timediff(now, conn->lastused);
! 455:
! 456: if(score > highscore) {
! 457: highscore = score;
! 458: conn_candidate = conn;
! 459: }
! 460: }
! 461: curr = curr->next;
! 462: }
! 463: if(conn_candidate) {
! 464: /* remove it to prevent another thread from nicking it */
! 465: bundle_remove_conn(bundle, conn_candidate);
! 466: data->state.conn_cache->num_conn--;
! 467: DEBUGF(infof(data, "The cache now contains %zu members\n",
! 468: data->state.conn_cache->num_conn));
! 469: conn_candidate->data = data; /* associate! */
! 470: }
! 471:
! 472: return conn_candidate;
! 473: }
! 474:
! 475: /*
! 476: * This function finds the connection in the connection cache that has been
! 477: * unused for the longest time and extracts that from the bundle.
! 478: *
! 479: * Returns the pointer to the connection, or NULL if none was found.
! 480: */
! 481: struct connectdata *
! 482: Curl_conncache_extract_oldest(struct Curl_easy *data)
! 483: {
! 484: struct conncache *connc = data->state.conn_cache;
! 485: struct curl_hash_iterator iter;
! 486: struct curl_llist_element *curr;
! 487: struct curl_hash_element *he;
! 488: timediff_t highscore =- 1;
! 489: timediff_t score;
! 490: struct curltime now;
! 491: struct connectdata *conn_candidate = NULL;
! 492: struct connectbundle *bundle;
! 493: struct connectbundle *bundle_candidate = NULL;
! 494:
! 495: now = Curl_now();
! 496:
! 497: CONN_LOCK(data);
! 498: Curl_hash_start_iterate(&connc->hash, &iter);
! 499:
! 500: he = Curl_hash_next_element(&iter);
! 501: while(he) {
! 502: struct connectdata *conn;
! 503:
! 504: bundle = he->ptr;
! 505:
! 506: curr = bundle->conn_list.head;
! 507: while(curr) {
! 508: conn = curr->ptr;
! 509:
! 510: if(!CONN_INUSE(conn) && !conn->data && !conn->bits.close &&
! 511: !conn->bits.connect_only) {
! 512: /* Set higher score for the age passed since the connection was used */
! 513: score = Curl_timediff(now, conn->lastused);
! 514:
! 515: if(score > highscore) {
! 516: highscore = score;
! 517: conn_candidate = conn;
! 518: bundle_candidate = bundle;
! 519: }
! 520: }
! 521: curr = curr->next;
! 522: }
! 523:
! 524: he = Curl_hash_next_element(&iter);
! 525: }
! 526: if(conn_candidate) {
! 527: /* remove it to prevent another thread from nicking it */
! 528: bundle_remove_conn(bundle_candidate, conn_candidate);
! 529: connc->num_conn--;
! 530: DEBUGF(infof(data, "The cache now contains %zu members\n",
! 531: connc->num_conn));
! 532: conn_candidate->data = data; /* associate! */
! 533: }
! 534: CONN_UNLOCK(data);
! 535:
! 536: return conn_candidate;
! 537: }
! 538:
! 539: void Curl_conncache_close_all_connections(struct conncache *connc)
! 540: {
! 541: struct connectdata *conn;
! 542:
! 543: conn = conncache_find_first_connection(connc);
! 544: while(conn) {
! 545: SIGPIPE_VARIABLE(pipe_st);
! 546: conn->data = connc->closure_handle;
! 547:
! 548: sigpipe_ignore(conn->data, &pipe_st);
! 549: /* This will remove the connection from the cache */
! 550: connclose(conn, "kill all");
! 551: (void)Curl_disconnect(connc->closure_handle, conn, FALSE);
! 552: sigpipe_restore(&pipe_st);
! 553:
! 554: conn = conncache_find_first_connection(connc);
! 555: }
! 556:
! 557: if(connc->closure_handle) {
! 558: SIGPIPE_VARIABLE(pipe_st);
! 559: sigpipe_ignore(connc->closure_handle, &pipe_st);
! 560:
! 561: Curl_hostcache_clean(connc->closure_handle,
! 562: connc->closure_handle->dns.hostcache);
! 563: Curl_close(&connc->closure_handle);
! 564: sigpipe_restore(&pipe_st);
! 565: }
! 566: }
! 567:
! 568: #if 0
! 569: /* Useful for debugging the connection cache */
! 570: void Curl_conncache_print(struct conncache *connc)
! 571: {
! 572: struct curl_hash_iterator iter;
! 573: struct curl_llist_element *curr;
! 574: struct curl_hash_element *he;
! 575:
! 576: if(!connc)
! 577: return;
! 578:
! 579: fprintf(stderr, "=Bundle cache=\n");
! 580:
! 581: Curl_hash_start_iterate(connc->hash, &iter);
! 582:
! 583: he = Curl_hash_next_element(&iter);
! 584: while(he) {
! 585: struct connectbundle *bundle;
! 586: struct connectdata *conn;
! 587:
! 588: bundle = he->ptr;
! 589:
! 590: fprintf(stderr, "%s -", he->key);
! 591: curr = bundle->conn_list->head;
! 592: while(curr) {
! 593: conn = curr->ptr;
! 594:
! 595: fprintf(stderr, " [%p %d]", (void *)conn, conn->inuse);
! 596: curr = curr->next;
! 597: }
! 598: fprintf(stderr, "\n");
! 599:
! 600: he = Curl_hash_next_element(&iter);
! 601: }
! 602: }
! 603: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to conncache.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