lib/conncache.c

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