| 1 |
/*************************************************************************** |
| 2 |
* _ _ ____ _ |
| 3 |
* Project ___| | | | _ \| | |
| 4 |
* / __| | | | |_) | | |
| 5 |
* | (__| |_| | _ <| |___ |
| 6 |
* \___|\___/|_| \_\_____| |
| 7 |
* |
| 8 |
* Copyright (C) 2012 - 2016, Linus Nielsen Feltzing, <[email protected]> |
| 9 |
* Copyright (C) 2012 - 2020, Daniel Stenberg, <[email protected]>, 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 |