*************************************************************/
if (strlen(data->set.device)<255) {
struct sockaddr_in sa;
- Curl_addrinfo *h=NULL;
+ struct Curl_dns_entry *h=NULL;
size_t size;
char myhost[256] = "";
in_addr_t in;
if (INADDR_NONE != in) {
if ( h ) {
+ Curl_addrinfo *addr = h->addr;
+
+ h->inuse--; /* decrease the use-counter, we don't need it anymore
+ after this function has returned */
+
memset((char *)&sa, 0, sizeof(sa));
#ifdef ENABLE_IPV6
- memcpy((char *)&sa.sin_addr, h->ai_addr, h->ai_addrlen);
- sa.sin_family = h->ai_family;
+ memcpy((char *)&sa.sin_addr, addr->ai_addr, addr->ai_addrlen);
+ sa.sin_family = addr->ai_family;
#else
- memcpy((char *)&sa.sin_addr, h->h_addr, h->h_length);
+ memcpy((char *)&sa.sin_addr, addr->h_addr, addr->h_length);
sa.sin_family = AF_INET;
#endif
sa.sin_addr.s_addr = in;
*/
CURLcode Curl_connecthost(struct connectdata *conn, /* context */
- Curl_addrinfo *remotehost, /* use one in here */
+ struct Curl_dns_entry *remotehost, /* use this one */
int port, /* connect to this */
int *sockconn, /* the connected socket */
Curl_ipconnect **addr, /* the one we used */
struct addrinfo *ai;
port =0; /* prevent compiler warning */
- for (ai = remotehost; ai; ai = ai->ai_next, aliasindex++) {
+ for (ai = remotehost->addr; ai; ai = ai->ai_next, aliasindex++) {
sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
if (sockfd < 0)
continue;
bool *connected);
CURLcode Curl_connecthost(struct connectdata *conn,
- Curl_addrinfo *host, /* connect to this */
+ struct Curl_dns_entry *host, /* connect to this */
int port, /* connect to this port number */
int *sockconn, /* not set if error is returned */
Curl_ipconnect **addr, /* the one we used */
*/
struct sockaddr_in sa;
struct hostent *h=NULL;
- char *hostdataptr=NULL;
unsigned short porttouse;
char myhost[256] = "";
bool sa_filled_in = FALSE;
sa_filled_in = TRUE; /* the sa struct is filled in */
}
+ if(h)
+ h->inuse--; /* when we return from here, we can forget about this */
+
if ( h || sa_filled_in) {
if( (portsock = socket(AF_INET, SOCK_STREAM, 0)) >= 0 ) {
int size;
if ( listen(portsock, 1) < 0 ) {
failf(data, "listen(2) failed on socket");
- free(hostdataptr);
return CURLE_FTP_PORT_FAILED;
}
}
else {
failf(data, "bind(2) failed on socket");
- free(hostdataptr);
return CURLE_FTP_PORT_FAILED;
}
}
else {
failf(data, "socket(2) failed (%s)");
- free(hostdataptr);
return CURLE_FTP_PORT_FAILED;
}
}
char *buf = data->state.buffer; /* this is our buffer */
int ftpcode; /* receive FTP response codes in this */
CURLcode result;
- Curl_addrinfo *addr=NULL;
+ struct Curl_dns_entry *addr=NULL;
Curl_ipconnect *conninfo;
/*
&conninfo,
connected);
+ addr->inuse--; /* we're done using this address */
+
/*
* When this is used from the multi interface, this might've returned with
* the 'connected' set to FALSE and thus we are now awaiting a non-blocking
#include <string.h>
#include <stdlib.h>
+
#include "hash.h"
#include "llist.h"
(*e)->key = strdup(key);
(*e)->key_len = key_len;
(*e)->ptr = (void *) p;
-
return 0;
}
/* }}} */
}
/* }}} */
-/* {{{ int curl_hash_find (curl_hash *, char *, size_t, void **)
+/* {{{ int curl_hash_pick (curl_hash *, char *, size_t, void **)
*/
-int
-Curl_hash_find(curl_hash *h, char *key, size_t key_len, void **p)
+void *
+Curl_hash_pick(curl_hash *h, char *key, size_t key_len)
{
curl_llist_element *le;
curl_hash_element *he;
le = CURL_LLIST_NEXT(le)) {
he = CURL_LLIST_VALP(le);
if (_hash_key_compare(he->key, he->key_len, key, key_len)) {
- *p = he->ptr;
- return 1;
+ return he->ptr;
}
}
- return 0;
+ return NULL;
}
/* }}} */
*/
void
Curl_hash_apply(curl_hash *h, void *user,
- void (*cb)(void *, curl_hash_element *))
+ void (*cb)(void *user, void *ptr))
{
curl_llist_element *le;
int 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));
+ curl_hash_element *el = CURL_LLIST_VALP(le);
+ cb(user, el->ptr);
}
}
}
typedef struct _curl_hash_element {
void *ptr;
char *key;
- size_t key_len;
+ size_t key_len;
} curl_hash_element;
curl_hash *Curl_hash_alloc(int, curl_hash_dtor);
int Curl_hash_add(curl_hash *, char *, size_t, const void *);
int Curl_hash_delete(curl_hash *h, char *key, size_t key_len);
-int Curl_hash_find(curl_hash *, char *, size_t, void **p);
-void Curl_hash_apply(curl_hash *h, void *user, void (*cb)(void *, curl_hash_element *));
+void *Curl_hash_pick(curl_hash *, char *, size_t);
+void Curl_hash_apply(curl_hash *h, void *user,
+ void (*cb)(void *user, void *ptr));
int Curl_hash_count(curl_hash *h);
void Curl_hash_clean(curl_hash *h);
void Curl_hash_clean_with_criterium(curl_hash *h, void *user, int (*comp)(void *, void *));
void Curl_hash_destroy(curl_hash *h);
-#define Curl_hash_update Curl_hash_add
-
#endif
/*
static curl_hash hostname_cache;
static int host_cache_initialized;
+static Curl_addrinfo *my_getaddrinfo(struct SessionHandle *data,
+ char *hostname,
+ int port,
+ char **bufp);
+
void Curl_global_host_cache_init(void)
{
if (!host_cache_initialized) {
}
}
-struct curl_dns_cache_entry {
- Curl_addrinfo *addr;
- time_t timestamp;
-};
-
/* count the number of characters that an integer takes up */
static int _num_chars(int i)
{
/* Create a hostcache id */
static char *
-_create_hostcache_id(char *server, int port, ssize_t *entry_len)
+create_hostcache_id(char *server, int port, ssize_t *entry_len)
{
char *id = NULL;
};
static int
-_curl_hostcache_timestamp_remove(void *datap, void *hc)
+hostcache_timestamp_remove(void *datap, void *hc)
{
struct hostcache_prune_data *data =
(struct hostcache_prune_data *) datap;
- struct curl_dns_cache_entry *c = (struct curl_dns_cache_entry *) hc;
+ struct Curl_dns_entry *c = (struct Curl_dns_entry *) hc;
- if (data->now - c->timestamp < data->cache_timeout) {
+ if ((data->now - c->timestamp < data->cache_timeout) ||
+ c->inuse) {
+ /* please don't remove */
return 0;
}
+ /* fine, remove */
return 1;
}
Curl_hash_clean_with_criterium(hostcache,
(void *) &user,
- _curl_hostcache_timestamp_remove);
+ hostcache_timestamp_remove);
}
+#ifdef MALLOCDEBUG
+/* Called from Curl_done() to check that there's no DNS cache entry with
+ a non-zero counter left. */
+void Curl_scan_cache_used(void *user, void *ptr)
+{
+ struct Curl_dns_entry *e = ptr;
+ (void)user; /* prevent compiler warning */
+ if(e->inuse) {
+ fprintf(stderr, "*** WARNING: locked DNS cache entry detected: %s\n",
+ e->entry_id);
+ /* perform a segmentation fault to draw attention */
+ *(void **)0 = 0;
+ }
+}
+#endif
+
/* Macro to save redundant free'ing of entry_id */
-#define _hostcache_return(__v) \
+#define HOSTCACHE_RETURN(dns) \
{ \
free(entry_id); \
- return (__v); \
+ return dns; \
}
#ifdef HAVE_SIGSETJMP
sigjmp_buf curl_jmpenv;
#endif
-Curl_addrinfo *Curl_resolv(struct SessionHandle *data,
- char *hostname,
- int port)
+struct Curl_dns_entry *Curl_resolv(struct SessionHandle *data,
+ char *hostname,
+ int port)
{
char *entry_id = NULL;
- struct curl_dns_cache_entry *p = NULL;
+ struct Curl_dns_entry *dns = NULL;
ssize_t entry_len;
time_t now;
char *bufp;
#ifdef HAVE_SIGSETJMP
- if(sigsetjmp(curl_jmpenv, 1) != 0) {
+ /* this allows us to time-out from the name resolver, as the timeout
+ will generate a signal and we will siglongjmp() from that here */
+ if(!data->set.no_signal && sigsetjmp(curl_jmpenv, 1)) {
/* this is coming from a siglongjmp() */
failf(data, "name lookup time-outed");
return NULL;
}
#endif
-#if 0
- /* If the host cache timeout is 0, we don't do DNS cach'ing
- so fall through */
- if (data->set.dns_cache_timeout == 0) {
- return Curl_getaddrinfo(data, hostname, port, &bufp);
- }
-#endif
-
- time(&now);
-
- /* Remove outdated entries from the hostcache */
- hostcache_prune(data->hostcache,
- data->set.dns_cache_timeout,
- now);
-
/* Create an entry id, based upon the hostname and port */
entry_len = strlen(hostname);
- entry_id = _create_hostcache_id(hostname, port, &entry_len);
- /* If we can't create the entry id, don't cache, just fall-through
- to the plain Curl_getaddrinfo() */
- if (!entry_id) {
- return Curl_getaddrinfo(data, hostname, port, &bufp);
- }
+ entry_id = create_hostcache_id(hostname, port, &entry_len);
+ /* If we can't create the entry id, fail */
+ if (!entry_id)
+ return NULL;
/* See if its already in our dns cache */
- if (entry_id &&
- Curl_hash_find(data->hostcache, entry_id, entry_len+1, (void **) &p)) {
- _hostcache_return(p->addr);
- }
+ dns = Curl_hash_pick(data->hostcache, entry_id, entry_len+1);
- /* Create a new cache entry */
- p = (struct curl_dns_cache_entry *)
- malloc(sizeof(struct curl_dns_cache_entry));
- if (!p) {
- _hostcache_return(NULL);
- }
+ if (!dns) {
+ Curl_addrinfo *addr = my_getaddrinfo(data, hostname, port, &bufp);
+
+ if (!addr) {
+ HOSTCACHE_RETURN(NULL);
+ }
+
+ /* Create a new cache entry */
+ dns = (struct Curl_dns_entry *) malloc(sizeof(struct Curl_dns_entry));
+ if (!dns) {
+ Curl_freeaddrinfo(addr);
+ HOSTCACHE_RETURN(NULL);
+ }
- p->addr = Curl_getaddrinfo(data, hostname, port, &bufp);
- if (!p->addr) {
- free(p);
- _hostcache_return(NULL);
+ dns->inuse = 0;
+ dns->addr = addr;
+ /* Save it in our host cache */
+ Curl_hash_add(data->hostcache, entry_id, entry_len+1, (const void *) dns);
}
- p->timestamp = now;
+ time(&now);
+
+ dns->timestamp = now;
+ dns->inuse++; /* mark entry as in-use */
+#ifdef MALLOCDEBUG
+ dns->entry_id = entry_id;
+#endif
- /* Save it in our host cache */
- Curl_hash_update(data->hostcache, entry_id, entry_len+1, (const void *) p);
+ /* Remove outdated and unused entries from the hostcache */
+ hostcache_prune(data->hostcache,
+ data->set.dns_cache_timeout,
+ now);
- _hostcache_return(p->addr);
+ HOSTCACHE_RETURN(dns);
}
/*
*/
void Curl_freeaddrinfo(void *freethis)
{
- struct curl_dns_cache_entry *p = (struct curl_dns_cache_entry *) freethis;
+ struct Curl_dns_entry *p = (struct Curl_dns_entry *) freethis;
#ifdef ENABLE_IPV6
freeaddrinfo(p->addr);
* memory we need to free after use. That meory *MUST* be freed with
* Curl_freeaddrinfo(), nothing else.
*/
-Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
- char *hostname,
- int port,
- char **bufp)
+static Curl_addrinfo *my_getaddrinfo(struct SessionHandle *data,
+ char *hostname,
+ int port,
+ char **bufp)
{
struct addrinfo hints, *res;
int error;
/* The original code to this function was once stolen from the Dancer source
code, written by Bjorn Reese, it has since been patched and modified
considerably. */
-Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
- char *hostname,
- int port,
- char **bufp)
+static Curl_addrinfo *my_getaddrinfo(struct SessionHandle *data,
+ char *hostname,
+ int port,
+ char **bufp)
{
struct hostent *h = NULL;
in_addr_t in;
* $Id$
***************************************************************************/
+#include "setup.h"
#include "hash.h"
struct addrinfo;
#define Curl_global_host_cache_use(__p) ((__p)->set.global_dns_cache)
-Curl_addrinfo *Curl_resolv(struct SessionHandle *data,
- char *hostname,
- int port);
+struct Curl_dns_entry {
+ Curl_addrinfo *addr;
+ time_t timestamp;
+ long inuse; /* use-counter, make very sure you decrease this
+ when you're done using the address you received */
+#ifdef MALLOCDEBUG
+ char *entry_id;
+#endif
+};
+
+struct Curl_dns_entry *Curl_resolv(struct SessionHandle *data,
+ char *hostname,
+ int port);
+
+/* for debugging purposes only: */
+void Curl_scan_cache_used(void *user, void *ptr);
-/* Get name info */
-Curl_addrinfo *Curl_getaddrinfo(struct SessionHandle *data,
- char *hostname,
- int port,
- char **bufp);
/* free name info */
void Curl_freeaddrinfo(void *freethis);
socksreq[3] = 1; /* IPv4 = 1 */
{
- Curl_addrinfo *hp;
- hp = Curl_resolv(conn->data, conn->hostname, conn->remote_port);
+#ifndef ENABLE_IPV6
+ struct Curl_dns_entry *dns;
+ Curl_addrinfo *hp=NULL;
+ dns = Curl_resolv(conn->data, conn->hostname, conn->remote_port);
/*
* We cannot use 'hostent' as a struct that Curl_resolv() returns. It
* returns a Curl_addrinfo pointer that may not always look the same.
*/
-#ifndef ENABLE_IPV6
+ if(dns)
+ hp=dns->addr;
if (hp && hp->h_addr_list[0]) {
socksreq[4] = ((char*)hp->h_addr_list[0])[0];
socksreq[5] = ((char*)hp->h_addr_list[0])[1];
socksreq[6] = ((char*)hp->h_addr_list[0])[2];
socksreq[7] = ((char*)hp->h_addr_list[0])[3];
+
+ dns->inuse--; /* not used anymore from now on */
}
else {
failf(conn->data, "Failed to resolve \"%s\" for SOCKS5 connect.",
}
static CURLcode ConnectPlease(struct connectdata *conn,
- Curl_addrinfo *hostaddr,
+ struct Curl_dns_entry *hostaddr,
bool *connected)
{
CURLcode result;
/* All is cool, then we store the current information from the hostaddr
struct to the serv_addr, as it might be needed later. The address
returned from the function above is crucial here. */
+ conn->connect_addr = hostaddr;
+
#ifdef ENABLE_IPV6
conn->serv_addr = addr;
#else
}
static void verboseconnect(struct connectdata *conn,
- Curl_addrinfo *hostaddr)
+ struct Curl_dns_entry *dns)
{
#ifdef HAVE_INET_NTOA_R
char ntoa_buf[64];
/* Figure out the ip-number and display the first host name it shows: */
#ifdef ENABLE_IPV6
- (void)hostaddr; /* not used in the IPv6 enabled version */
+ (void)dns; /* not used in the IPv6 enabled version */
{
char hbuf[NI_MAXHOST];
#ifdef NI_WITHSCOPEID
}
#else
{
+ Curl_addrinfo *hostaddr=dns->addr;
struct in_addr in;
(void) memcpy(&in.s_addr, &conn->serv_addr.sin_addr, sizeof (in.s_addr));
infof(data, "Connected to %s (%s) port %d\n",
* 'serv_addr' field in the connectdata struct for most of it.
*/
CURLcode Curl_protocol_connect(struct connectdata *conn,
- Curl_addrinfo *hostaddr)
+ struct Curl_dns_entry *hostaddr)
{
struct SessionHandle *data = conn->data;
CURLcode result=CURLE_OK;
struct connectdata *conn;
struct connectdata *conn_temp;
int urllen;
- Curl_addrinfo *hostaddr;
+ struct Curl_dns_entry *hostaddr;
#ifdef HAVE_ALARM
unsigned int prev_alarm=0;
#endif
return code;
}
-
CURLcode Curl_done(struct connectdata *conn)
{
struct SessionHandle *data=conn->data;
free(conn->newurl);
conn->newurl = NULL;
}
-
+
+ if(conn->connect_addr)
+ conn->connect_addr->inuse--; /* done with this */
+
+#ifdef MALLOCDEBUG
+ /* scan for DNS cache entries still marked as in use */
+ Curl_hash_apply(data->hostcache,
+ NULL, Curl_scan_cache_used);
+#endif
+
/* this calls the protocol-specific function pointer previously set */
if(conn->curl_done)
result = conn->curl_done(conn);
CURLcode Curl_done(struct connectdata *);
CURLcode Curl_disconnect(struct connectdata *);
CURLcode Curl_protocol_connect(struct connectdata *conn,
- Curl_addrinfo *hostaddr);
+ struct Curl_dns_entry *dns);
#endif
/* This file is for lib internal stuff */
#include "setup.h"
-#include "hostip.h"
-#include "hash.h"
#define PORT_FTP 21
#define PORT_TELNET 23
#include <curl/curl.h>
#include "http_chunks.h" /* for the structs and enum stuff */
+#include "hostip.h"
+#include "hash.h"
#ifdef HAVE_ZLIB_H
#include <zlib.h> /* for content-encoding 08/28/02 jhrg */
#define PROT_FTPS (1<<9)
#define PROT_SSL (1<<10) /* protocol requires SSL */
+ /* the particular host we use, in two different ways */
+ struct Curl_dns_entry *connect_addr;
+
#ifdef ENABLE_IPV6
- struct addrinfo *serv_addr; /* the particular host we use */
+ struct addrinfo *serv_addr;
#else
struct sockaddr_in serv_addr;
#endif
projects / curl / commitdiff