Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 1 | /*************************************************************************** |
| 2 | * _ _ ____ _ |
| 3 | * Project ___| | | | _ \| | |
| 4 | * / __| | | | |_) | | |
| 5 | * | (__| |_| | _ <| |___ |
| 6 | * \___|\___/|_| \_\_____| |
| 7 | * |
| 8 | * Copyright (C) 2012, Linus Nielsen Feltzing, <linus@haxx.se> |
| 9 | * Copyright (C) 2012 - 2015, 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 http://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 "rawstr.h" |
| 34 | #include "conncache.h" |
| 35 | #include "curl_printf.h" |
| 36 | |
| 37 | #include "curl_memory.h" |
| 38 | /* The last #include file should be: */ |
| 39 | #include "memdebug.h" |
| 40 | |
| 41 | static void conn_llist_dtor(void *user, void *element) |
| 42 | { |
| 43 | struct connectdata *data = element; |
| 44 | (void)user; |
| 45 | |
| 46 | data->bundle = NULL; |
| 47 | } |
| 48 | |
| 49 | static CURLcode bundle_create(struct SessionHandle *data, |
| 50 | struct connectbundle **cb_ptr) |
| 51 | { |
| 52 | (void)data; |
| 53 | DEBUGASSERT(*cb_ptr == NULL); |
| 54 | *cb_ptr = malloc(sizeof(struct connectbundle)); |
| 55 | if(!*cb_ptr) |
| 56 | return CURLE_OUT_OF_MEMORY; |
| 57 | |
| 58 | (*cb_ptr)->num_connections = 0; |
| 59 | (*cb_ptr)->multiuse = BUNDLE_UNKNOWN; |
| 60 | |
| 61 | (*cb_ptr)->conn_list = Curl_llist_alloc((curl_llist_dtor) conn_llist_dtor); |
| 62 | if(!(*cb_ptr)->conn_list) { |
| 63 | Curl_safefree(*cb_ptr); |
| 64 | return CURLE_OUT_OF_MEMORY; |
| 65 | } |
| 66 | return CURLE_OK; |
| 67 | } |
| 68 | |
| 69 | static void bundle_destroy(struct connectbundle *cb_ptr) |
| 70 | { |
| 71 | if(!cb_ptr) |
| 72 | return; |
| 73 | |
| 74 | if(cb_ptr->conn_list) { |
| 75 | Curl_llist_destroy(cb_ptr->conn_list, NULL); |
| 76 | cb_ptr->conn_list = NULL; |
| 77 | } |
| 78 | free(cb_ptr); |
| 79 | } |
| 80 | |
| 81 | /* Add a connection to a bundle */ |
| 82 | static CURLcode bundle_add_conn(struct connectbundle *cb_ptr, |
| 83 | struct connectdata *conn) |
| 84 | { |
| 85 | if(!Curl_llist_insert_next(cb_ptr->conn_list, cb_ptr->conn_list->tail, conn)) |
| 86 | return CURLE_OUT_OF_MEMORY; |
| 87 | |
| 88 | conn->bundle = cb_ptr; |
| 89 | |
| 90 | cb_ptr->num_connections++; |
| 91 | return CURLE_OK; |
| 92 | } |
| 93 | |
| 94 | /* Remove a connection from a bundle */ |
| 95 | static int bundle_remove_conn(struct connectbundle *cb_ptr, |
| 96 | struct connectdata *conn) |
| 97 | { |
| 98 | struct curl_llist_element *curr; |
| 99 | |
| 100 | curr = cb_ptr->conn_list->head; |
| 101 | while(curr) { |
| 102 | if(curr->ptr == conn) { |
| 103 | Curl_llist_remove(cb_ptr->conn_list, curr, NULL); |
| 104 | cb_ptr->num_connections--; |
| 105 | conn->bundle = NULL; |
| 106 | return 1; /* we removed a handle */ |
| 107 | } |
| 108 | curr = curr->next; |
| 109 | } |
| 110 | return 0; |
| 111 | } |
| 112 | |
| 113 | static void free_bundle_hash_entry(void *freethis) |
| 114 | { |
| 115 | struct connectbundle *b = (struct connectbundle *) freethis; |
| 116 | |
| 117 | bundle_destroy(b); |
| 118 | } |
| 119 | |
| 120 | int Curl_conncache_init(struct conncache *connc, int size) |
| 121 | { |
| 122 | return Curl_hash_init(&connc->hash, size, Curl_hash_str, |
| 123 | Curl_str_key_compare, free_bundle_hash_entry); |
| 124 | } |
| 125 | |
| 126 | void Curl_conncache_destroy(struct conncache *connc) |
| 127 | { |
| 128 | if(connc) |
| 129 | Curl_hash_destroy(&connc->hash); |
| 130 | } |
| 131 | |
| 132 | /* returns an allocated key to find a bundle for this connection */ |
| 133 | static char *hashkey(struct connectdata *conn) |
| 134 | { |
| 135 | return aprintf("%s:%d", |
| 136 | conn->bits.proxy?conn->proxy.name:conn->host.name, |
| 137 | conn->localport); |
| 138 | } |
| 139 | |
| 140 | /* Look up the bundle with all the connections to the same host this |
| 141 | connectdata struct is setup to use. */ |
| 142 | struct connectbundle *Curl_conncache_find_bundle(struct connectdata *conn, |
| 143 | struct conncache *connc) |
| 144 | { |
| 145 | struct connectbundle *bundle = NULL; |
| 146 | if(connc) { |
| 147 | char *key = hashkey(conn); |
| 148 | if(key) { |
| 149 | bundle = Curl_hash_pick(&connc->hash, key, strlen(key)); |
| 150 | free(key); |
| 151 | } |
| 152 | } |
| 153 | |
| 154 | return bundle; |
| 155 | } |
| 156 | |
| 157 | static bool conncache_add_bundle(struct conncache *connc, |
| 158 | char *key, |
| 159 | struct connectbundle *bundle) |
| 160 | { |
| 161 | void *p = Curl_hash_add(&connc->hash, key, strlen(key), bundle); |
| 162 | |
| 163 | return p?TRUE:FALSE; |
| 164 | } |
| 165 | |
| 166 | static void conncache_remove_bundle(struct conncache *connc, |
| 167 | struct connectbundle *bundle) |
| 168 | { |
| 169 | struct curl_hash_iterator iter; |
| 170 | struct curl_hash_element *he; |
| 171 | |
| 172 | if(!connc) |
| 173 | return; |
| 174 | |
| 175 | Curl_hash_start_iterate(&connc->hash, &iter); |
| 176 | |
| 177 | he = Curl_hash_next_element(&iter); |
| 178 | while(he) { |
| 179 | if(he->ptr == bundle) { |
| 180 | /* The bundle is destroyed by the hash destructor function, |
| 181 | free_bundle_hash_entry() */ |
| 182 | Curl_hash_delete(&connc->hash, he->key, he->key_len); |
| 183 | return; |
| 184 | } |
| 185 | |
| 186 | he = Curl_hash_next_element(&iter); |
| 187 | } |
| 188 | } |
| 189 | |
| 190 | CURLcode Curl_conncache_add_conn(struct conncache *connc, |
| 191 | struct connectdata *conn) |
| 192 | { |
| 193 | CURLcode result; |
| 194 | struct connectbundle *bundle; |
| 195 | struct connectbundle *new_bundle = NULL; |
| 196 | struct SessionHandle *data = conn->data; |
| 197 | |
| 198 | bundle = Curl_conncache_find_bundle(conn, data->state.conn_cache); |
| 199 | if(!bundle) { |
| 200 | char *key; |
| 201 | int rc; |
| 202 | |
| 203 | result = bundle_create(data, &new_bundle); |
| 204 | if(result) |
| 205 | return result; |
| 206 | |
| 207 | key = hashkey(conn); |
| 208 | if(!key) { |
| 209 | bundle_destroy(new_bundle); |
| 210 | return CURLE_OUT_OF_MEMORY; |
| 211 | } |
| 212 | |
| 213 | rc = conncache_add_bundle(data->state.conn_cache, key, new_bundle); |
| 214 | free(key); |
| 215 | if(!rc) { |
| 216 | bundle_destroy(new_bundle); |
| 217 | return CURLE_OUT_OF_MEMORY; |
| 218 | } |
| 219 | bundle = new_bundle; |
| 220 | } |
| 221 | |
| 222 | result = bundle_add_conn(bundle, conn); |
| 223 | if(result) { |
| 224 | if(new_bundle) |
| 225 | conncache_remove_bundle(data->state.conn_cache, new_bundle); |
| 226 | return result; |
| 227 | } |
| 228 | |
| 229 | conn->connection_id = connc->next_connection_id++; |
| 230 | connc->num_connections++; |
| 231 | |
| 232 | DEBUGF(infof(conn->data, "Added connection %ld. " |
| 233 | "The cache now contains %" CURL_FORMAT_CURL_OFF_TU " members\n", |
| 234 | conn->connection_id, (curl_off_t) connc->num_connections)); |
| 235 | |
| 236 | return CURLE_OK; |
| 237 | } |
| 238 | |
| 239 | void Curl_conncache_remove_conn(struct conncache *connc, |
| 240 | struct connectdata *conn) |
| 241 | { |
| 242 | struct connectbundle *bundle = conn->bundle; |
| 243 | |
| 244 | /* The bundle pointer can be NULL, since this function can be called |
| 245 | due to a failed connection attempt, before being added to a bundle */ |
| 246 | if(bundle) { |
| 247 | bundle_remove_conn(bundle, conn); |
| 248 | if(bundle->num_connections == 0) { |
| 249 | conncache_remove_bundle(connc, bundle); |
| 250 | } |
| 251 | |
| 252 | if(connc) { |
| 253 | connc->num_connections--; |
| 254 | |
| 255 | DEBUGF(infof(conn->data, "The cache now contains %" |
| 256 | CURL_FORMAT_CURL_OFF_TU " members\n", |
| 257 | (curl_off_t) connc->num_connections)); |
| 258 | } |
| 259 | } |
| 260 | } |
| 261 | |
| 262 | /* This function iterates the entire connection cache and calls the |
| 263 | function func() with the connection pointer as the first argument |
| 264 | and the supplied 'param' argument as the other, |
| 265 | |
| 266 | Return 0 from func() to continue the loop, return 1 to abort it. |
| 267 | */ |
| 268 | void Curl_conncache_foreach(struct conncache *connc, |
| 269 | void *param, |
| 270 | int (*func)(struct connectdata *conn, void *param)) |
| 271 | { |
| 272 | struct curl_hash_iterator iter; |
| 273 | struct curl_llist_element *curr; |
| 274 | struct curl_hash_element *he; |
| 275 | |
| 276 | if(!connc) |
| 277 | return; |
| 278 | |
| 279 | Curl_hash_start_iterate(&connc->hash, &iter); |
| 280 | |
| 281 | he = Curl_hash_next_element(&iter); |
| 282 | while(he) { |
| 283 | struct connectbundle *bundle; |
| 284 | |
| 285 | bundle = he->ptr; |
| 286 | he = Curl_hash_next_element(&iter); |
| 287 | |
| 288 | curr = bundle->conn_list->head; |
| 289 | while(curr) { |
| 290 | /* Yes, we need to update curr before calling func(), because func() |
| 291 | might decide to remove the connection */ |
| 292 | struct connectdata *conn = curr->ptr; |
| 293 | curr = curr->next; |
| 294 | |
| 295 | if(1 == func(conn, param)) |
| 296 | return; |
| 297 | } |
| 298 | } |
| 299 | } |
| 300 | |
| 301 | /* Return the first connection found in the cache. Used when closing all |
| 302 | connections */ |
| 303 | struct connectdata * |
| 304 | Curl_conncache_find_first_connection(struct conncache *connc) |
| 305 | { |
| 306 | struct curl_hash_iterator iter; |
| 307 | struct curl_hash_element *he; |
| 308 | struct connectbundle *bundle; |
| 309 | |
| 310 | Curl_hash_start_iterate(&connc->hash, &iter); |
| 311 | |
| 312 | he = Curl_hash_next_element(&iter); |
| 313 | while(he) { |
| 314 | struct curl_llist_element *curr; |
| 315 | bundle = he->ptr; |
| 316 | |
| 317 | curr = bundle->conn_list->head; |
| 318 | if(curr) { |
| 319 | return curr->ptr; |
| 320 | } |
| 321 | |
| 322 | he = Curl_hash_next_element(&iter); |
| 323 | } |
| 324 | |
| 325 | return NULL; |
| 326 | } |
| 327 | |
| 328 | |
| 329 | #if 0 |
| 330 | /* Useful for debugging the connection cache */ |
| 331 | void Curl_conncache_print(struct conncache *connc) |
| 332 | { |
| 333 | struct curl_hash_iterator iter; |
| 334 | struct curl_llist_element *curr; |
| 335 | struct curl_hash_element *he; |
| 336 | |
| 337 | if(!connc) |
| 338 | return; |
| 339 | |
| 340 | fprintf(stderr, "=Bundle cache=\n"); |
| 341 | |
| 342 | Curl_hash_start_iterate(connc->hash, &iter); |
| 343 | |
| 344 | he = Curl_hash_next_element(&iter); |
| 345 | while(he) { |
| 346 | struct connectbundle *bundle; |
| 347 | struct connectdata *conn; |
| 348 | |
| 349 | bundle = he->ptr; |
| 350 | |
| 351 | fprintf(stderr, "%s -", he->key); |
| 352 | curr = bundle->conn_list->head; |
| 353 | while(curr) { |
| 354 | conn = curr->ptr; |
| 355 | |
| 356 | fprintf(stderr, " [%p %d]", (void *)conn, conn->inuse); |
| 357 | curr = curr->next; |
| 358 | } |
| 359 | fprintf(stderr, "\n"); |
| 360 | |
| 361 | he = Curl_hash_next_element(&iter); |
| 362 | } |
| 363 | } |
| 364 | #endif |