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
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 */
hostent_buf,
sizeof(hostent_buf));
*/
- if(hostdataptr)
- free(hostdataptr); /* allocated by Curl_getaddrinfo() */
return CURLE_HTTP_PORT_FAILED;
}
return CURLE_HTTP_PORT_FAILED;
}
- if(hostdataptr)
- free(hostdataptr); /* allocated by Curl_getaddrinfo() */
-
return CURLE_OK;
} /* end of device selection support */
#include "ssluse.h"
#include "url.h"
#include "getinfo.h"
+#include "hostip.h"
#define _MPRINTF_REPLACE /* use our functions only */
#include <curl/mprintf.h>
{
if (initialized)
return CURLE_OK;
-
+
+ Curl_host_cache_init();
+
if (flags & CURL_GLOBAL_SSL)
Curl_SSL_init();
if (!initialized)
return;
+ Curl_host_cache_dtor();
+
if (init_flags & CURL_GLOBAL_SSL)
Curl_SSL_cleanup();
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);
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);
}
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;
/* 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;
--- /dev/null
+/*****************************************************************************
+ * _ _ ____ _
+ * 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
+ */
--- /dev/null
+#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
#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"
#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
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,
--- /dev/null
+/*****************************************************************************
+ * _ _ ____ _
+ * 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;
+}
--- /dev/null
+#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
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);
/* 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);
/* 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);
projects / thirdparty / curl.git / commitdiff
