Sterling Hughes' provided initial DNS cache source code.

11 files changed, 648 insertions, 29 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index 817cecf49..63bf02cec 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -56,7 +56,8 @@ escape.c       mprintf.c      telnet.c       \
 escape.h       getpass.c      netrc.c        telnet.h       \
 getinfo.c getinfo.h transfer.c strequal.c strequal.h easy.c \
 security.h security.c krb4.c krb4.h memdebug.c memdebug.h inet_ntoa_r.h \
-http_chunks.c http_chunks.h strtok.c strtok.h connect.c connect.h
+http_chunks.c http_chunks.h strtok.c strtok.h connect.c connect.h \
+llist.c llist.h hash.c hash.h
 
 noinst_HEADERS = setup.h transfer.h
 
diff --git a/lib/connect.c b/lib/connect.c
index 06d2464ae..d7add1067 100644
--- a/lib/connect.c
+++ b/lib/connect.c
@@ -210,11 +210,11 @@ static CURLcode bindlocal(struct connectdata *conn,
     in_addr_t in;
 
     if(Curl_if2ip(data->set.device, myhost, sizeof(myhost))) {
-      h = Curl_getaddrinfo(data, myhost, 0, &hostdataptr);
+      h = Curl_resolv(data, myhost, 0, &hostdataptr);
     }
     else {
       if(strlen(data->set.device)>1) {
-        h = Curl_getaddrinfo(data, data->set.device, 0, &hostdataptr);
+        h = Curl_resolv(data, data->set.device, 0, &hostdataptr);
       }
       if(h) {
         /* we know data->set.device is shorter than the myhost array */
@@ -229,8 +229,6 @@ static CURLcode bindlocal(struct connectdata *conn,
          hostent_buf,
          sizeof(hostent_buf));
       */
-      if(hostdataptr)
-        free(hostdataptr); /* allocated by Curl_getaddrinfo() */
       return CURLE_HTTP_PORT_FAILED;
     }
 
@@ -304,9 +302,6 @@ static CURLcode bindlocal(struct connectdata *conn,
       return CURLE_HTTP_PORT_FAILED;
     }
 
-    if(hostdataptr)
-      free(hostdataptr); /* allocated by Curl_getaddrinfo() */
-
     return CURLE_OK;
 
   } /* end of device selection support */
diff --git a/lib/easy.c b/lib/easy.c
index 245bbf955..c24eb9018 100644
--- a/lib/easy.c
+++ b/lib/easy.c
@@ -76,6 +76,7 @@
 #include "ssluse.h"
 #include "url.h"
 #include "getinfo.h"
+#include "hostip.h"
 
 #define _MPRINTF_REPLACE /* use our functions only */
 #include <curl/mprintf.h>
@@ -139,7 +140,9 @@ CURLcode curl_global_init(long flags)
 {
   if (initialized)
     return CURLE_OK;
- 
+
+  Curl_host_cache_init();
+  
   if (flags & CURL_GLOBAL_SSL)
     Curl_SSL_init();
 
@@ -162,6 +165,8 @@ void curl_global_cleanup(void)
   if (!initialized)
     return;
 
+  Curl_host_cache_dtor();
+  
   if (init_flags & CURL_GLOBAL_SSL)
     Curl_SSL_cleanup();
 
diff --git a/lib/ftp.c b/lib/ftp.c
index 16441bdd8..cdaef884a 100644
--- a/lib/ftp.c
+++ b/lib/ftp.c
@@ -1174,19 +1174,19 @@ CURLcode ftp_use_port(struct connectdata *conn)
 
   if(data->set.ftpport) {
     if(Curl_if2ip(data->set.ftpport, myhost, sizeof(myhost))) {
-      h = Curl_getaddrinfo(data, myhost, 0, &hostdataptr);
+      h = Curl_resolv(data, myhost, 0, &hostdataptr);
     }
     else {
-      if(strlen(data->set.ftpport)>1)
-        h = Curl_getaddrinfo(data, data->set.ftpport, 0, &hostdataptr);
+      int len = strlen(data->set.ftpport);
+      if(len>1)
+        h = Curl_resolv(data, data->set.ftpport, 0, &hostdataptr);
       if(h)
         strcpy(myhost, data->set.ftpport); /* buffer overflow risk */
     }
   }
   if(! *myhost) {
-    h=Curl_getaddrinfo(data,
-                       getmyhost(myhost, sizeof(myhost)),
-                       0, &hostdataptr);
+    char *tmp_host = getmyhost(myhost, sizeof(myhost));
+    h=Curl_resolv(data, tmp_host, 0, &hostdataptr);
   }
   infof(data, "We connect from %s\n", myhost);
   
@@ -1237,9 +1237,6 @@ CURLcode ftp_use_port(struct connectdata *conn)
       free(hostdataptr);
       return CURLE_FTP_PORT_FAILED;
     }
-    if(hostdataptr)
-      /* free the memory used for name lookup */
-      Curl_freeaddrinfo(hostdataptr);
   }
   else {
     failf(data, "could't find my own IP address (%s)", myhost);
@@ -1431,7 +1428,7 @@ CURLcode ftp_use_pasv(struct connectdata *conn)
   }
   else {
     /* normal, direct, ftp connection */
-    addr = Curl_getaddrinfo(data, newhostp, newport, &hostdataptr);
+    addr = Curl_resolv(data, newhostp, newport, &hostdataptr);
     if(!addr) {
       failf(data, "Can't resolve new host %s", newhost);
       return CURLE_FTP_CANT_GET_HOST;
@@ -1450,9 +1447,6 @@ CURLcode ftp_use_pasv(struct connectdata *conn)
     /* this just dumps information about this second connection */
     ftp_pasv_verbose(conn, conninfo, newhost, connectport);
   
-  if(hostdataptr)
-    Curl_freeaddrinfo(hostdataptr);
-  
   if(CURLE_OK != result)
     return result;
 
diff --git a/lib/hash.c b/lib/hash.c
new file mode 100644
index 000000000..c0680e488
--- /dev/null
+++ b/lib/hash.c
@@ -0,0 +1,271 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+#include "setup.h"
+
+#include <string.h>
+
+#include "hash.h"
+#include "llist.h"
+
+#ifdef MALLOCDEBUG
+/* this must be the last include file */
+#include "memdebug.h"
+#endif
+
+
+static unsigned long 
+curl_hash_str(const char *key, unsigned int key_length)
+{
+  register unsigned long h = 0;
+  register unsigned long g;
+  register char *p = (char *) key;
+  register char *end = (char *) key + key_length;
+
+  while (p < end) {
+    h = (h << 4) + *p++;
+    if ((g = (h & 0xF0000000))) {
+      h = h ^ (g >> 24);
+      h = h ^ g;
+    }
+  }
+
+  return h;
+}
+
+static unsigned long 
+curl_hash_num(unsigned long key)
+{
+  key += ~(key << 15);
+  key ^= (key >> 10);
+  key += (key << 3);
+  key ^= (key >> 6);
+  key += (key << 11);
+  key ^= (key >> 16);
+
+  return key;
+}
+
+static void 
+hash_element_dtor(void *u, void *ele)
+{
+  curl_hash_element *e = (curl_hash_element *) ele; 
+  curl_hash         *h = (curl_hash *) u; 
+	
+  if (e->key.type == CURL_HASH_KEY_IS_STRING) {
+    free(e->key.value.str.val);
+  }
+  h->dtor(e->ptr);
+
+  free(e);
+  e = NULL;
+}
+
+void 
+curl_hash_init(curl_hash *h, int slots, curl_hash_dtor dtor)
+{
+  int i;
+
+  h->dtor = dtor;
+  h->size = 0;
+  h->slots = slots;  
+
+  h->table = (curl_llist **) malloc(slots * sizeof(curl_llist *));
+  for (i = 0; i < h->slots; ++i) {
+    h->table[i] = curl_llist_alloc((curl_llist_dtor) hash_element_dtor);
+  }
+}
+
+curl_hash *
+curl_hash_alloc(int slots, curl_hash_dtor dtor)
+{
+  curl_hash *h;
+
+  h = malloc(sizeof(curl_hash));
+  curl_hash_init(h, slots, dtor);
+
+  return h;
+}
+
+#define FIND_SLOT(__h, __s_key, __s_key_len, __n_key) \
+  ((__s_key ? curl_hash_str(__s_key, __s_key_len) : curl_hash_num(__n_key)) % (__h)->slots)
+
+#define KEY_CREATE(__k, __s_key, __s_key_len, __n_key, __dup) \
+  if (__s_key) { \
+    if (__dup) { \
+      (__k)->value.str.val = (char *) malloc(__s_key_len); \
+      memcpy((__k)->value.str.val, __s_key, __s_key_len); \
+    } else { \
+      (__k)->value.str.val = __s_key; \
+    } \
+    (__k)->value.str.len = __s_key_len; \
+    (__k)->type = CURL_HASH_KEY_IS_STRING; \
+  } else { \
+    (__k)->value.num = __n_key; \
+    (__k)->type = CURL_HASH_KEY_IS_NUM; \
+  }
+
+#define MIN(a, b) (a > b ? b : a)
+
+static int 
+curl_hash_key_compare(curl_hash_key *key1, curl_hash_key *key2)
+{
+  if (key1->type == CURL_HASH_KEY_IS_NUM) {
+    if (key2->type == CURL_HASH_KEY_IS_STRING)
+      return 0;
+
+    if (key1->value.num == key2->value.num)
+      return 1;
+  } else {
+    if (key2->type == CURL_HASH_KEY_IS_NUM)
+      return 0;
+
+    if (memcmp(key1->value.str.val, key2->value.str.val, 
+               MIN(key1->value.str.len, key2->value.str.len)) == 0)
+      return 1;
+  }
+
+  return 0;
+}
+
+int 
+curl_hash_add_or_update(curl_hash *h, char *str_key, unsigned int str_key_len, 
+                        unsigned long num_key, const void *p)
+{
+  curl_hash_element  *e;
+  curl_hash_key       tmp;
+  curl_llist         *l; 
+  curl_llist_element *le;
+  int                slot;
+
+  slot = FIND_SLOT(h, str_key, str_key_len, num_key);
+  l = h->table[slot];
+  KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0);
+  for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) {
+    if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) {
+      curl_hash_element *to_update = CURL_LLIST_VALP(le);
+      h->dtor(to_update->ptr);
+      to_update->ptr = (void *) p;
+      return 1;
+    }
+  }
+
+  e = (curl_hash_element *) malloc(sizeof(curl_hash_element));
+  KEY_CREATE(&e->key, str_key, str_key_len, num_key, 1);
+  e->ptr = (void *) p;
+
+  if (curl_llist_insert_next(l, CURL_LLIST_TAIL(l), e)) {
+    ++h->size;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int 
+curl_hash_extended_delete(curl_hash *h, char *str_key, unsigned int str_key_len, 
+                          unsigned long num_key)
+{
+  curl_llist         *l;
+  curl_llist_element *le;
+  curl_hash_key       tmp;
+  int                slot;
+
+  slot = FIND_SLOT(h, str_key, str_key_len, num_key);
+  l = h->table[slot];
+
+  KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0);
+  for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) {
+    if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) {
+      curl_llist_remove(l, le, (void *) h);
+      --h->size;
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+int 
+curl_hash_extended_find(curl_hash *h, char *str_key, unsigned int str_key_len, 
+                        unsigned long num_key, void **p)
+{
+  curl_llist         *l;
+  curl_llist_element *le;
+  curl_hash_key       tmp;
+  int                slot;
+
+  slot = FIND_SLOT(h, str_key, str_key_len, num_key);
+  l = h->table[slot];
+
+  KEY_CREATE(&tmp, str_key, str_key_len, num_key, 0);
+  for (le = CURL_LLIST_HEAD(l); le != NULL; le = CURL_LLIST_NEXT(le)) {
+    if (curl_hash_key_compare(&tmp, &((curl_hash_element *) CURL_LLIST_VALP(le))->key)) {
+      *p = ((curl_hash_element *) CURL_LLIST_VALP(le))->ptr;
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+void 
+curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *))
+{
+  curl_llist_element  *le;
+  int                  i;
+
+  for (i = 0; i < h->slots; ++i) {
+    for (le = CURL_LLIST_HEAD(h->table[i]); le != NULL; le = CURL_LLIST_NEXT(le)) {
+      cb(user, (curl_hash_element *) CURL_LLIST_VALP(le));
+    }
+  }
+}
+
+void
+curl_hash_clean(curl_hash *h)
+{
+  int i;
+
+  for (i = 0; i < h->slots; ++i) {
+    curl_llist_destroy(h->table[i], (void *) h);
+  }
+
+  free(h->table);
+  h->table = NULL;
+}
+
+void 
+curl_hash_destroy(curl_hash *h)
+{
+  curl_hash_clean(h);
+  free(h);
+}
+
+/*
+ * local variables:
+ * eval: (load-file "../curl-mode.el")
+ * end:
+ * vim600: fdm=marker
+ * vim: et sw=2 ts=2 sts=2 tw=78
+ */
diff --git a/lib/hash.h b/lib/hash.h
new file mode 100644
index 000000000..420bb899f
--- /dev/null
+++ b/lib/hash.h
@@ -0,0 +1,86 @@
+#ifndef __HASH_H
+#define __HASH_H
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+#include "setup.h"
+
+#include "setup.h"
+
+#include <stddef.h>
+
+#include "llist.h"
+
+#define CURL_HASH_KEY_IS_STRING 0
+#define CURL_HASH_KEY_IS_NUM    1
+
+typedef void (*curl_hash_dtor)(void *);
+
+typedef struct _curl_hash {
+  curl_llist     **table;
+  curl_hash_dtor   dtor;
+  int              slots;
+  size_t           size;
+} curl_hash;
+
+typedef struct _curl_hash_key {
+  union {
+    struct {
+      char *val;
+      unsigned int len;
+    } str;
+
+    unsigned long num;
+  } value;
+
+  int type;
+} curl_hash_key;
+
+typedef struct _curl_hash_element {
+  curl_hash_key  key;
+  void          *ptr;
+} curl_hash_element;
+
+
+void curl_hash_init(curl_hash *h, int slots, curl_hash_dtor dtor);
+curl_hash *curl_hash_alloc(int slots, curl_hash_dtor dtor);
+int curl_hash_add_or_update(curl_hash *h, char *str_key, unsigned int str_key_len, 
+			     unsigned long num_key, const void *p);
+int curl_hash_extended_delete(curl_hash *h, char *str_key, unsigned int str_key_len, 
+			       unsigned long num_key);
+int curl_hash_extended_find(curl_hash *h, char *str_key, unsigned int str_key_len, 
+			     unsigned long num_key, void **p);
+void curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *));
+void curl_hash_clean(curl_hash *h);
+void curl_hash_destroy(curl_hash *h);
+
+#define curl_hash_find(h, key, key_len, p) curl_hash_extended_find(h, key, key_len, 0, p)
+#define curl_hash_delete(h, key, key_len) curl_hash_extended_delete(h, key, key_len, 0)
+#define curl_hash_add(h, key, key_len, p) curl_hash_add_or_update(h, key, key_len, 0, p)
+#define curl_hash_update curl_hash_add
+#define curl_hash_index_find(h, key, p) curl_hash_extended_find(h, NULL, 0, key, p)
+#define curl_hash_index_delete(h, key) curl_hash_extended_delete(h, NULL, 0, key)
+#define curl_hash_index_add(h, key, p) curl_hash_add_or_update(h, NULL, 0, key, p)
+#define curl_hash_index_update curl_hash_index_add
+
+#endif
diff --git a/lib/hostip.c b/lib/hostip.c
index 86faa117a..db02b8681 100644
--- a/lib/hostip.c
+++ b/lib/hostip.c
@@ -58,6 +58,7 @@
 #include "urldata.h"
 #include "sendf.h"
 #include "hostip.h"
+#include "hash.h"
 
 #if defined(HAVE_INET_NTOA_R) && !defined(HAVE_INET_NTOA_R_DECL)
 #include "inet_ntoa_r.h"
@@ -68,6 +69,38 @@
 #include "memdebug.h"
 #endif
 
+static curl_hash hostname_cache;
+
+void Curl_host_cache_init(void)
+{
+  curl_hash_init(&hostname_cache, 7, Curl_freeaddrinfo);
+}
+
+void Curl_host_cache_dtor(void)
+{
+  curl_hash_clean(&hostname_cache);
+}
+
+
+Curl_addrinfo *Curl_resolv(struct SessionHandle *data,
+                           char *hostname,
+                           int port,
+                           char **bufp)
+{
+  Curl_addrinfo *addr = NULL;
+  size_t hostname_len = strlen(hostname)+1;
+
+  if (curl_hash_find(&hostname_cache, hostname, hostname_len, (void **) &addr))
+    return addr;
+
+  addr = Curl_getaddrinfo(data, hostname, port, bufp);
+  if (!addr)
+    return NULL;
+
+  curl_hash_add(&hostname_cache, hostname, hostname_len, (const void *) addr);
+  return addr;
+}
+
 /*
  * This is a wrapper function for freeing name information in a protocol
  * independent way. This takes care of using the appropriate underlaying
diff --git a/lib/hostip.h b/lib/hostip.h
index 291b9cc71..97b50ae9d 100644
--- a/lib/hostip.h
+++ b/lib/hostip.h
@@ -27,6 +27,14 @@ struct addrinfo;
 struct hostent;
 struct SessionHandle;
 
+void Curl_host_cache_init(void);
+void Curl_host_cache_dtor(void);
+
+Curl_addrinfo *Curl_resolv(struct SessionHandle *data,
+			   char *hostname,
+			   int port,
+			   char **bufp);
+
 /* Get name info */
 Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
                                 char *hostname,
diff --git a/lib/llist.c b/lib/llist.c
new file mode 100644
index 000000000..b031cf6ac
--- /dev/null
+++ b/lib/llist.c
@@ -0,0 +1,165 @@
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+#include "setup.h"
+
+
+#include <string.h>
+
+#include "llist.h"
+
+#ifdef MALLOCDEBUG
+/* this must be the last include file */
+#include "memdebug.h"
+#endif
+void 
+curl_llist_init(curl_llist *l, curl_llist_dtor dtor)
+{
+  l->size = 0;
+  l->dtor = dtor;
+  l->head = NULL;
+  l->tail = NULL;
+}
+
+curl_llist *
+curl_llist_alloc(curl_llist_dtor dtor)
+{
+  curl_llist *list;
+
+  list = malloc(sizeof(curl_llist));
+  curl_llist_init(list, dtor);
+
+  return list;
+}
+
+int
+curl_llist_insert_next(curl_llist *list, curl_llist_element *e, const void *p)
+{
+  curl_llist_element  *ne;
+
+  ne = (curl_llist_element *) malloc(sizeof(curl_llist_element));
+  ne->ptr = (void *) p;
+  if (list->size == 0) {
+    list->head = ne;
+    list->head->prev = NULL;
+    list->head->next = NULL;
+    list->tail = ne;
+  } else {
+    ne->next = e->next;
+    ne->prev = e;
+    if (e->next) {
+      e->next->prev = ne;
+    } else {
+      list->tail = ne;
+    }
+    e->next = ne;
+  }
+
+  ++list->size;
+
+  return 1;
+}
+
+int 
+curl_llist_insert_prev(curl_llist *list, curl_llist_element *e, const void *p)
+{
+  curl_llist_element *ne;
+
+  ne = (curl_llist_element *) malloc(sizeof(curl_llist_element));
+  ne->ptr = (void *) p;
+  if (list->size == 0) {
+    list->head = ne;
+    list->head->prev = NULL;
+    list->head->next = NULL;
+    list->tail = ne;
+  } else {
+    ne->next = e;
+    ne->prev = e->prev;
+    if (e->prev)
+      e->prev->next = ne;
+    else
+      list->head = ne;
+    e->prev = ne;
+  }
+
+  ++list->size;
+
+  return 1;
+}
+
+int 
+curl_llist_remove(curl_llist *list, curl_llist_element *e, void *user)
+{
+  if (e == NULL || list->size == 0)
+    return 1;
+
+  if (e == list->head) {
+    list->head = e->next;
+
+    if (list->head == NULL)
+      list->tail = NULL;
+    else
+      e->next->prev = NULL;
+  } else {
+    e->prev->next = e->next;
+    if (!e->next)
+      list->tail = e->prev;
+    else
+      e->next->prev = e->prev;
+  }
+
+  list->dtor(user, e->ptr);
+  free(e);
+  --list->size;
+
+  return 1;
+}
+
+int 
+curl_llist_remove_next(curl_llist *list, curl_llist_element *e, void *user)
+{
+  return curl_llist_remove(list, e->next, user);
+}
+
+int 
+curl_llist_remove_prev(curl_llist *list, curl_llist_element *e, void *user)
+{
+  return curl_llist_remove(list, e->prev, user);
+}
+
+size_t 
+curl_llist_count(curl_llist *list)
+{
+  return list->size;
+}
+
+void 
+curl_llist_destroy(curl_llist *list, void *user)
+{
+  while (list->size > 0) {
+    curl_llist_remove(list, CURL_LLIST_TAIL(list), user);
+  }
+
+  free(list);
+  list = NULL;
+}
diff --git a/lib/llist.h b/lib/llist.h
new file mode 100644
index 000000000..f598a1cad
--- /dev/null
+++ b/lib/llist.h
@@ -0,0 +1,64 @@
+#ifndef __LLIST_H
+#define __LLIST_H
+/*****************************************************************************
+ *                                  _   _ ____  _     
+ *  Project                     ___| | | |  _ \| |    
+ *                             / __| | | | |_) | |    
+ *                            | (__| |_| |  _ <| |___ 
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al
+ *
+ * In order to be useful for every potential user, curl and libcurl are
+ * dual-licensed under the MPL and the MIT/X-derivate licenses.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the MPL or the MIT/X-derivate
+ * licenses. You may pick one of these licenses.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id$
+ *****************************************************************************/
+
+#include "setup.h"
+#include <stddef.h>
+
+typedef void (*curl_llist_dtor)(void *, void *);
+
+typedef struct _curl_llist_element {
+  void *ptr;
+
+  struct _curl_llist_element *prev;
+  struct _curl_llist_element *next;
+} curl_llist_element;
+
+typedef struct _curl_llist {
+  curl_llist_element *head;
+  curl_llist_element *tail;
+
+  curl_llist_dtor dtor;
+
+  size_t size;
+} curl_llist;
+
+void curl_llist_init(curl_llist *, curl_llist_dtor);
+curl_llist *curl_llist_alloc(curl_llist_dtor);
+int curl_llist_insert_next(curl_llist *, curl_llist_element *, const void *);
+int curl_llist_insert_prev(curl_llist *, curl_llist_element *, const void *);
+int curl_llist_remove(curl_llist *, curl_llist_element *, void *);
+int curl_llist_remove_next(curl_llist *, curl_llist_element *, void *);
+size_t curl_llist_count(curl_llist *);
+void curl_llist_destroy(curl_llist *, void *);
+
+#define CURL_LLIST_HEAD(__l) ((__l)->head)
+#define CURL_LLIST_TAIL(__l) ((__l)->tail)
+#define CURL_LLIST_NEXT(__e) ((__e)->next)
+#define CURL_LLIST_PREV(__e) ((__e)->prev)
+#define CURL_LLIST_VALP(__e) ((__e)->ptr)
+#define CURL_LLIST_IS_TAIL(__e) ((__e)->next ? 0 : 1)
+#define CURL_LLIST_IS_HEAD(__e) ((__e)->prev ? 0 : 1)
+
+#endif
diff --git a/lib/url.c b/lib/url.c
index 79e6ced7b..5a477a26d 100644
--- a/lib/url.c
+++ b/lib/url.c
@@ -940,9 +940,6 @@ CURLcode Curl_disconnect(struct connectdata *conn)
   if(conn->proto.generic)
     free(conn->proto.generic);
 
-  if(conn->hostent_buf) /* host name info */
-    Curl_freeaddrinfo(conn->hostent_buf);
-
   if(conn->newurl)
     free(conn->newurl);
 
@@ -2060,8 +2057,8 @@ static CURLcode CreateConnection(struct SessionHandle *data,
     /* Resolve target host right on */
     if(!conn->hostaddr) {
       /* it might already be set if reusing a connection */
-      conn->hostaddr = Curl_getaddrinfo(data, conn->name, conn->port,
-                                        &conn->hostent_buf);
+      conn->hostaddr = Curl_resolv(data, conn->name, conn->port,
+                                   &conn->hostent_buf);
     }
     if(!conn->hostaddr) {
       failf(data, "Couldn't resolve host '%s'", conn->name);
@@ -2075,8 +2072,8 @@ static CURLcode CreateConnection(struct SessionHandle *data,
 
     /* resolve proxy */
     /* it might already be set if reusing a connection */
-    conn->hostaddr = Curl_getaddrinfo(data, conn->proxyhost, conn->port,
-                                      &conn->hostent_buf);
+    conn->hostaddr = Curl_resolv(data, conn->proxyhost, conn->port,
+                                 &conn->hostent_buf);
 
     if(!conn->hostaddr) {
       failf(data, "Couldn't resolve proxy '%s'", conn->proxyhost);