1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at http://curl.haxx.se/docs/copyright.html.
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
22 ***************************************************************************/
31 #ifdef HAVE_SYS_SOCKET_H
32 #include <sys/socket.h>
34 #ifdef HAVE_NETINET_IN_H
35 #include <netinet/in.h>
40 #ifdef HAVE_ARPA_INET_H
41 #include <arpa/inet.h>
44 #include <stdlib.h> /* required for free() prototypes */
47 #include <unistd.h> /* for the close() proto */
70 #include "inet_ntop.h"
72 #define _MPRINTF_REPLACE /* use our functions only */
73 #include <curl/mprintf.h>
75 #if defined(HAVE_INET_NTOA_R) && !defined(HAVE_INET_NTOA_R_DECL)
76 #include "inet_ntoa_r.h"
80 /* The last #include file should be: */
87 * The main COMPILE-TIME DEFINES to keep in mind when reading the host*.c
88 * source file are these:
90 * CURLRES_IPV6 - this host has getaddrinfo() and family, and thus we use
91 * that. The host may not be able to resolve IPv6, but we don't really have to
92 * take that into account. Hosts that aren't IPv6-enabled have CURLRES_IPV4
95 * CURLRES_ARES - is defined if libcurl is built to use c-ares for
96 * asynchronous name resolves. This can be Windows or *nix.
98 * CURLRES_THREADED - is defined if libcurl is built to run under (native)
99 * Windows, and then the name resolve will be done in a new thread, and the
100 * supported API will be the same as for ares-builds.
102 * If any of the two previous are defined, CURLRES_ASYNCH is defined too. If
103 * libcurl is not built to use an asynchronous resolver, CURLRES_SYNCH is
106 * The host*.c sources files are split up like this:
108 * hostip.c - method-independent resolver functions and utility functions
109 * hostasyn.c - functions for asynchronous name resolves
110 * hostsyn.c - functions for synchronous name resolves
111 * hostares.c - functions for ares-using name resolves
112 * hostthre.c - functions for threaded name resolves
113 * hostip4.c - ipv4-specific functions
114 * hostip6.c - ipv6-specific functions
116 * The hostip.h is the united header file for all this. It defines the
117 * CURLRES_* defines based on the config*.h and setup.h defines.
120 /* These two symbols are for the global DNS cache */
121 static struct curl_hash hostname_cache;
122 static int host_cache_initialized;
124 static void freednsentry(void *freethis);
127 * Curl_global_host_cache_init() initializes and sets up a global DNS cache.
128 * Global DNS cache is general badness. Do not use. This will be removed in
129 * a future version. Use the share interface instead!
131 * Returns a struct curl_hash pointer on success, NULL on failure.
133 struct curl_hash *Curl_global_host_cache_init(void)
136 if(!host_cache_initialized) {
137 rc = Curl_hash_init(&hostname_cache, 7, Curl_hash_str,
138 Curl_str_key_compare, freednsentry);
140 host_cache_initialized = 1;
142 return rc?NULL:&hostname_cache;
146 * Destroy and cleanup the global DNS cache
148 void Curl_global_host_cache_dtor(void)
150 if(host_cache_initialized) {
151 Curl_hash_clean(&hostname_cache);
152 host_cache_initialized = 0;
157 * Return # of adresses in a Curl_addrinfo struct
159 int Curl_num_addresses(const Curl_addrinfo *addr)
162 for (i = 0; addr; addr = addr->ai_next, i++)
168 * Curl_printable_address() returns a printable version of the 1st address
169 * given in the 'ip' argument. The result will be stored in the buf that is
172 * If the conversion fails, it returns NULL.
174 const char *Curl_printable_address(const Curl_addrinfo *ip,
175 char *buf, size_t bufsize)
177 const void *ip4 = &((const struct sockaddr_in*)ip->ai_addr)->sin_addr;
178 int af = ip->ai_family;
180 const void *ip6 = &((const struct sockaddr_in6*)ip->ai_addr)->sin6_addr;
182 const void *ip6 = NULL;
185 return Curl_inet_ntop(af, af == AF_INET ? ip4 : ip6, buf, bufsize);
189 * Return a hostcache id string for the providing host + port, to be used by
193 create_hostcache_id(const char *server, int port)
195 /* create and return the new allocated entry */
196 return aprintf("%s:%d", server, port);
199 struct hostcache_prune_data {
205 * This function is set as a callback to be called for every entry in the DNS
206 * cache when we want to prune old unused entries.
208 * Returning non-zero means remove the entry, return 0 to keep it in the
212 hostcache_timestamp_remove(void *datap, void *hc)
214 struct hostcache_prune_data *data =
215 (struct hostcache_prune_data *) datap;
216 struct Curl_dns_entry *c = (struct Curl_dns_entry *) hc;
218 if((data->now - c->timestamp < data->cache_timeout) ||
220 /* please don't remove */
229 * Prune the DNS cache. This assumes that a lock has already been taken.
232 hostcache_prune(struct curl_hash *hostcache, long cache_timeout, time_t now)
234 struct hostcache_prune_data user;
236 user.cache_timeout = cache_timeout;
239 Curl_hash_clean_with_criterium(hostcache,
241 hostcache_timestamp_remove);
245 * Library-wide function for pruning the DNS cache. This function takes and
246 * returns the appropriate locks.
248 void Curl_hostcache_prune(struct SessionHandle *data)
252 if((data->set.dns_cache_timeout == -1) || !data->dns.hostcache)
253 /* cache forever means never prune, and NULL hostcache means
258 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
262 /* Remove outdated and unused entries from the hostcache */
263 hostcache_prune(data->dns.hostcache,
264 data->set.dns_cache_timeout,
268 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
272 remove_entry_if_stale(struct SessionHandle *data, struct Curl_dns_entry *dns)
274 struct hostcache_prune_data user;
276 if( !dns || (data->set.dns_cache_timeout == -1) || !data->dns.hostcache)
277 /* cache forever means never prune, and NULL hostcache means
282 user.cache_timeout = data->set.dns_cache_timeout;
284 if( !hostcache_timestamp_remove(&user,dns) )
287 /* ok, we do need to clear the cache. although we need to remove just a
288 single entry we clean the entire hash, as no explicit delete function
291 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
293 Curl_hash_clean_with_criterium(data->dns.hostcache,
295 hostcache_timestamp_remove);
298 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
304 #ifdef HAVE_SIGSETJMP
305 /* Beware this is a global and unique instance. This is used to store the
306 return address that we can jump back to from inside a signal handler. This
307 is not thread-safe stuff. */
308 sigjmp_buf curl_jmpenv;
313 * Curl_cache_addr() stores a 'Curl_addrinfo' struct in the DNS cache.
315 * When calling Curl_resolv() has resulted in a response with a returned
316 * address, we call this function to store the information in the dns
319 * Returns the Curl_dns_entry entry pointer or NULL if the storage failed.
321 struct Curl_dns_entry *
322 Curl_cache_addr(struct SessionHandle *data,
324 const char *hostname,
329 struct Curl_dns_entry *dns;
330 struct Curl_dns_entry *dns2;
333 /* Create an entry id, based upon the hostname and port */
334 entry_id = create_hostcache_id(hostname, port);
335 /* If we can't create the entry id, fail */
338 entry_len = strlen(entry_id);
340 /* Create a new cache entry */
341 dns = (struct Curl_dns_entry *) calloc(sizeof(struct Curl_dns_entry), 1);
347 dns->inuse = 0; /* init to not used */
348 dns->addr = addr; /* this is the address(es) */
350 /* Store the resolved data in our DNS cache. This function may return a
351 pointer to an existing struct already present in the hash, and it may
352 return the same argument we pass in. Make no assumptions. */
353 dns2 = Curl_hash_add(data->dns.hostcache, entry_id, entry_len+1,
356 /* Major badness, run away. */
364 dns->timestamp = now; /* used now */
365 dns->inuse++; /* mark entry as in-use */
367 /* free the allocated entry_id again */
374 * Curl_resolv() is the main name resolve function within libcurl. It resolves
375 * a name and returns a pointer to the entry in the 'entry' argument (if one
376 * is provided). This function might return immediately if we're using asynch
377 * resolves. See the return codes.
379 * The cache entry we return will get its 'inuse' counter increased when this
380 * function is used. You MUST call Curl_resolv_unlock() later (when you're
381 * done using this struct) to decrease the counter again.
385 * CURLRESOLV_ERROR (-1) = error, no pointer
386 * CURLRESOLV_RESOLVED (0) = OK, pointer provided
387 * CURLRESOLV_PENDING (1) = waiting for response, no pointer
390 int Curl_resolv(struct connectdata *conn,
391 const char *hostname,
393 struct Curl_dns_entry **entry)
395 char *entry_id = NULL;
396 struct Curl_dns_entry *dns = NULL;
398 struct SessionHandle *data = conn->data;
403 #ifdef HAVE_SIGSETJMP
404 /* this allows us to time-out from the name resolver, as the timeout
405 will generate a signal and we will siglongjmp() from that here */
406 if(!data->set.no_signal) {
407 if(sigsetjmp(curl_jmpenv, 1)) {
408 /* this is coming from a siglongjmp() */
409 failf(data, "name lookup timed out");
410 return CURLRESOLV_ERROR;
415 /* Create an entry id, based upon the hostname and port */
416 entry_id = create_hostcache_id(hostname, port);
417 /* If we can't create the entry id, fail */
419 return CURLRESOLV_ERROR;
421 entry_len = strlen(entry_id);
424 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
426 /* See if its already in our dns cache */
427 dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len+1);
430 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
432 /* free the allocated entry_id again */
435 /* See whether the returned entry is stale. Deliberately done after the
437 if( remove_entry_if_stale(data,dns) )
438 dns = NULL; /* the memory deallocation is being handled by the hash */
440 rc = CURLRESOLV_ERROR; /* default to failure */
443 /* The entry was not in the cache. Resolve it to IP address */
448 /* Check what IP specifics the app has requested and if we can provide it.
449 * If not, bail out. */
450 if(!Curl_ipvalid(data))
451 return CURLRESOLV_ERROR;
453 /* If Curl_getaddrinfo() returns NULL, 'respwait' might be set to a
454 non-zero value indicating that we need to wait for the response to the
456 addr = Curl_getaddrinfo(conn, hostname, port, &respwait);
460 /* the response to our resolve call will come asynchronously at
461 a later time, good or bad */
462 /* First, check that we haven't received the info by now */
463 result = Curl_is_resolved(conn, &dns);
464 if(result) /* error detected */
465 return CURLRESOLV_ERROR;
467 rc = CURLRESOLV_RESOLVED; /* pointer provided */
469 rc = CURLRESOLV_PENDING; /* no info yet */
474 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
476 /* we got a response, store it in the cache */
477 dns = Curl_cache_addr(data, addr, hostname, port);
480 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
483 /* returned failure, bail out nicely */
484 Curl_freeaddrinfo(addr);
486 rc = CURLRESOLV_RESOLVED;
491 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
492 dns->inuse++; /* we use it! */
494 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
495 rc = CURLRESOLV_RESOLVED;
504 * Curl_resolv_unlock() unlocks the given cached DNS entry. When this has been
505 * made, the struct may be destroyed due to pruning. It is important that only
506 * one unlock is made for each Curl_resolv() call.
508 void Curl_resolv_unlock(struct SessionHandle *data, struct Curl_dns_entry *dns)
510 DEBUGASSERT(dns && (dns->inuse>0));
513 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
518 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
522 * File-internal: free a cache dns entry.
524 static void freednsentry(void *freethis)
526 struct Curl_dns_entry *p = (struct Curl_dns_entry *) freethis;
528 Curl_freeaddrinfo(p->addr);
534 * Curl_mk_dnscache() creates a new DNS cache and returns the handle for it.
536 struct curl_hash *Curl_mk_dnscache(void)
538 return Curl_hash_alloc(7, Curl_hash_str, Curl_str_key_compare, freednsentry);
541 #ifdef CURLRES_ADDRINFO_COPY
543 /* align on even 64bit boundaries */
544 #define MEMALIGN(x) ((x)+(8-(((unsigned long)(x))&0x7)))
547 * Curl_addrinfo_copy() performs a "deep" copy of a hostent into a buffer and
548 * returns a pointer to the malloc()ed copy. You need to call free() on the
549 * returned buffer when you're done with it.
551 Curl_addrinfo *Curl_addrinfo_copy(const void *org, int port)
553 const struct hostent *orig = org;
555 return Curl_he2ai(orig, port);
557 #endif /* CURLRES_ADDRINFO_COPY */
559 /***********************************************************************
560 * Only for plain-ipv4 and c-ares builds
561 **********************************************************************/
563 #if defined(CURLRES_IPV4) || defined(CURLRES_ARES)
565 * This is a function for freeing name information in a protocol independent
568 void Curl_freeaddrinfo(Curl_addrinfo *ai)
572 /* walk over the list and free all entries */
576 free(ai->ai_canonname);
583 struct hostent hostentry;
584 char *h_addr_list[2];
585 struct in_addr addrentry;
586 char h_name[16]; /* 123.123.123.123 = 15 letters is maximum */
590 * Curl_ip2addr() takes a 32bit ipv4 internet address as input parameter
591 * together with a pointer to the string version of the address, and it
592 * returns a Curl_addrinfo chain filled in correctly with information for this
595 * The input parameters ARE NOT checked for validity but they are expected
596 * to have been checked already when this is called.
598 Curl_addrinfo *Curl_ip2addr(in_addr_t num, const char *hostname, int port)
602 #if defined(VMS) && \
603 defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64)
604 #pragma pointer_size save
605 #pragma pointer_size short
606 #pragma message disable PTRMISMATCH
610 struct in_addr *addrentry;
611 struct namebuf buffer;
612 struct namebuf *buf = &buffer;
615 h->h_addr_list = &buf->h_addr_list[0];
616 addrentry = &buf->addrentry;
618 /* On UNICOS, s_addr is a bit field and for some reason assigning to it
619 * doesn't work. There must be a better fix than this ugly hack.
621 memcpy(addrentry, &num, SIZEOF_in_addr);
623 addrentry->s_addr = num;
625 h->h_addr_list[0] = (char*)addrentry;
626 h->h_addr_list[1] = NULL;
627 h->h_addrtype = AF_INET;
628 h->h_length = sizeof(*addrentry);
629 h->h_name = &buf->h_name[0];
632 /* Now store the dotted version of the address */
633 snprintf((char *)h->h_name, 16, "%s", hostname);
635 #if defined(VMS) && \
636 defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64)
637 #pragma pointer_size restore
638 #pragma message enable PTRMISMATCH
641 ai = Curl_he2ai(h, port);
645 #endif /* CURLRES_IPV4 || CURLRES_ARES */