diff options
Diffstat (limited to 'src/dns.c')
| -rw-r--r-- | src/dns.c | 535 |
1 files changed, 535 insertions, 0 deletions
diff --git a/src/dns.c b/src/dns.c new file mode 100644 index 00000000..2813f54f --- /dev/null +++ b/src/dns.c @@ -0,0 +1,535 @@ +/* + * File: dns.c + * + * Copyright (C) 1999-2006 Jorge Arellano Cid <jcid@dillo.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + */ + +/* + * Non blocking pthread-handled Dns scheme + */ + +#include <pthread.h> + +#include <netdb.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <errno.h> +#include <unistd.h> +#include <stdlib.h> +#include <stdio.h> +#include <signal.h> +#include <string.h> + +#include "msg.h" +#include "dns.h" +#include "list.h" +#include "timeout.hh" + +#define DEBUG_LEVEL 5 +#include "debug.h" + + +/* + * Uncomment the following line for debugging or gprof profiling. + */ +/* #undef D_DNS_THREADED */ + +/* + * Uncomment the following line for libc5 optimization + */ +/* #define LIBC5 */ + + +/* Maximum dns resolving threads */ +#ifdef D_DNS_THREADED +# define D_DNS_MAX_SERVERS 4 +#else +# define D_DNS_MAX_SERVERS 1 +#endif + + +typedef struct { + int channel; /* Index of this channel [0 based] */ + bool_t in_use; /* boolean to tell if server is doing a lookup */ + bool_t ip_ready; /* boolean: is IP lookup done? */ + Dlist *addr_list; /* IP address */ + char *hostname; /* Adress to resolve */ + int status; /* errno code for resolving function */ +#ifdef D_DNS_THREADED + pthread_t th1; /* Thread id */ +#endif +} DnsServer; + +typedef struct { + char *hostname; /* host name for cache */ + Dlist *addr_list; /* addresses of host */ +} GDnsCache; + +typedef struct { + int channel; /* -2 if waiting, otherwise index to dns_server[] */ + char *hostname; /* The one we're resolving */ + DnsCallback_t cb_func; /* callback function */ + void *cb_data; /* extra data for the callback function */ +} GDnsQueue; + + +/* + * Forward declarations + */ +static void Dns_timeout_client(void *data); + +/* + * Local Data + */ +static DnsServer dns_server[D_DNS_MAX_SERVERS]; +static int num_servers; +static GDnsCache *dns_cache; +static int dns_cache_size, dns_cache_size_max; +static GDnsQueue *dns_queue; +static int dns_queue_size, dns_queue_size_max; +static bool_t ipv6_enabled; + + +/* ---------------------------------------------------------------------- + * Dns queue functions + */ +static void Dns_queue_add(int channel, const char *hostname, + DnsCallback_t cb_func, void *cb_data) +{ + a_List_add(dns_queue, dns_queue_size, dns_queue_size_max); + dns_queue[dns_queue_size].channel = channel; + dns_queue[dns_queue_size].hostname = dStrdup(hostname); + dns_queue[dns_queue_size].cb_func = cb_func; + dns_queue[dns_queue_size].cb_data = cb_data; + dns_queue_size++; +} + +/* + * Find hostname index in dns_queue + * (if found, returns queue index; -1 if not) + */ +static int Dns_queue_find(const char *hostname) +{ + int i; + + for (i = 0; i < dns_queue_size; i++) + if (!strcmp(hostname, dns_queue[i].hostname)) + return i; + + return -1; +} + +/* + * Given an index, remove an entry from the dns_queue + */ +static void Dns_queue_remove(int index) +{ + int i; + + DEBUG_MSG(2, "Dns_queue_remove: deleting client [%d] [queue_size=%d]\n", + index, dns_queue_size); + + if (index < dns_queue_size) { + dFree(dns_queue[index].hostname); + --dns_queue_size; /* you'll find out why ;-) */ + for (i = index; i < dns_queue_size; i++) + dns_queue[i] = dns_queue[i + 1]; + } +} + +/* + * Debug function + * +void Dns_queue_print() +{ + int i; + + MSG("Queue: ["); + for (i = 0; i < dns_queue_size; i++) + MSG("%d:%s ", dns_queue[i].channel, dns_queue[i].hostname); + MSG("]\n"); +} + */ + +/* + * Add an IP/hostname pair to Dns-cache + */ +static void Dns_cache_add(char *hostname, Dlist *addr_list) +{ + a_List_add(dns_cache, dns_cache_size, dns_cache_size_max); + dns_cache[dns_cache_size].hostname = dStrdup(hostname); + dns_cache[dns_cache_size].addr_list = addr_list; + ++dns_cache_size; + DEBUG_MSG(1, "Cache objects: %d\n", dns_cache_size); +} + + +/* + * Initializer function + */ +void a_Dns_init(void) +{ + int i; + +#ifdef D_DNS_THREADED + DEBUG_MSG(5, "dillo_dns_init: Here we go! (threaded)\n"); +#else + DEBUG_MSG(5, "dillo_dns_init: Here we go! (not threaded)\n"); +#endif + + dns_queue_size = 0; + dns_queue_size_max = 16; + dns_queue = dNew(GDnsQueue, dns_queue_size_max); + + dns_cache_size = 0; + dns_cache_size_max = 16; + dns_cache = dNew(GDnsCache, dns_cache_size_max); + + num_servers = D_DNS_MAX_SERVERS; + + /* Initialize servers data */ + for (i = 0; i < num_servers; ++i) { + dns_server[i].channel = i; + dns_server[i].in_use = FALSE; + dns_server[i].ip_ready = FALSE; + dns_server[i].addr_list = NULL; + dns_server[i].hostname = NULL; + dns_server[i].status = 0; +#ifdef D_DNS_THREADED + dns_server[i].th1 = (pthread_t) -1; +#endif + } + + /* IPv6 test */ + ipv6_enabled = FALSE; +#ifdef ENABLE_IPV6 + { + /* If the IPv6 address family is not available there is no point + wasting time trying to connect to v6 addresses. */ + int fd = socket(AF_INET6, SOCK_STREAM, 0); + if (fd >= 0) { + close(fd); + ipv6_enabled = TRUE; + } + } +#endif +} + +/* + * Allocate a host structure and add it to the list + */ +static void Dns_note_hosts(Dlist *list, int af, struct hostent *host) +{ + int i; + + if (host->h_length > DILLO_ADDR_MAX) + return; + for (i = 0; host->h_addr_list[i]; i++) { + DilloHost *dh = dNew0(DilloHost, 1); + dh->af = af; + dh->alen = host->h_length; + memcpy(&dh->data[0], host->h_addr_list[i], (size_t)host->h_length); + dList_append(list, dh); + } +} + +#ifdef D_DNS_THREADED +/* + * Server function (runs on its own thread) + */ +static void *Dns_server(void *data) +{ + struct hostent *host; + int channel = VOIDP2INT(data); +#ifdef LIBC5 + int h_err; + char buff[1024]; + struct hostent sh; +#endif + Dlist *hosts = dList_new(2); + + DEBUG_MSG(3, "Dns_server: starting...\n ch: %d host: %s\n", + channel, dns_server[channel].hostname); + +#ifdef ENABLE_IPV6 + if (ipv6_enabled) { + host = gethostbyname2(dns_server[channel].hostname, AF_INET6); + if (host) { + Dns_note_hosts(hosts, AF_INET6, host); + } + } +#endif + +#ifdef LIBC5 + host = gethostbyname_r(dns_server[channel].hostname, &sh, buff, + sizeof(buff), &h_err); +#else + host = gethostbyname(dns_server[channel].hostname); +#endif + + if (!host) { +#ifdef LIBC5 + dns_server[channel].status = h_err; +#else + dns_server[channel].status = h_errno; + if (h_errno == HOST_NOT_FOUND) + MSG("DNS error: HOST_NOT_FOUND\n"); + else if (h_errno == TRY_AGAIN) + MSG("DNS error: TRY_AGAIN\n"); + else if (h_errno == NO_RECOVERY) + MSG("DNS error: NO_RECOVERY\n"); + else if (h_errno == NO_ADDRESS) + MSG("DNS error: NO_ADDRESS\n"); +#endif + } else { + dns_server[channel].status = 0; + Dns_note_hosts(hosts, AF_INET, host); + } + if (dList_length(hosts) > 0) { + dns_server[channel].status = 0; + } else { + dList_free(hosts); + hosts = NULL; + } + + /* tell our findings */ + DEBUG_MSG(5, "Dns_server [%d]: %s is %p\n", channel, + dns_server[channel].hostname, hosts); + dns_server[channel].addr_list = hosts; + dns_server[channel].ip_ready = TRUE; + + return NULL; /* (avoids a compiler warning) */ +} +#endif + +#ifndef D_DNS_THREADED +/* + * Blocking server-function (it doesn't use threads) + */ +static void Dns_blocking_server(void) +{ + int channel = 0; + struct hostent *host = NULL; + dList *hosts = dList_new(2); +#ifdef LIBC5 + int h_err; +#endif + + DEBUG_MSG(3, "Dns_blocking_server: starting...\n"); + DEBUG_MSG(3, "Dns_blocking_server: dns_server[%d].hostname = %s\n", + channel, dns_server[channel].hostname); + +#ifdef ENABLE_IPV6 + if (ipv6_enabled) { + host = gethostbyname2(dns_server[channel].hostname, AF_INET6); + if (host) { + Dns_note_hosts(hosts, AF_INET6, host); + } + } +#endif + +#ifdef LIBC5 + host = gethostbyname_r(dns_server[channel].hostname, &sh, buff, + sizeof(buff), &h_err); +#else + host = gethostbyname(dns_server[channel].hostname); +#endif + + if (!host) { +#ifdef LIBC5 + dns_server[channel].status = h_err; +#else + dns_server[channel].status = h_errno; +#endif + } else { + Dns_note_hosts(hosts, AF_INET, host); + } + if (dList_length(hosts) > 0) { + /* at least one entry on the list is ok */ + dns_server[channel].status = 0; + } else { + dList_free(hosts); + hosts = NULL; + } + + /* write IP to server data channel */ + DEBUG_MSG(3, "Dns_blocking_server: IP of %s is %p\n", + dns_server[channel].hostname, hosts); + dns_server[channel].addr_list = hosts; + dns_server[channel].ip_ready = TRUE; + + DEBUG_MSG(3, "Dns_blocking_server: leaving...\n"); +} +#endif + +/* + * Request function (spawn a server and let it handle the request) + */ +static void Dns_server_req(int channel, const char *hostname) +{ +#ifdef D_DNS_THREADED + static pthread_attr_t thrATTR; + static int thrATTRInitialized = 0; +#endif + + dns_server[channel].in_use = TRUE; + dns_server[channel].ip_ready = FALSE; + + dFree(dns_server[channel].hostname); + dns_server[channel].hostname = dStrdup(hostname); + + /* Let's set a timeout client to poll the server channel (5 times/sec) */ + a_Timeout_add(0.2,Dns_timeout_client,(void*)(dns_server[channel].channel)); + +#ifdef D_DNS_THREADED + /* set the thread attribute to the detached state */ + if (!thrATTRInitialized) { + pthread_attr_init(&thrATTR); + pthread_attr_setdetachstate(&thrATTR, PTHREAD_CREATE_DETACHED); + thrATTRInitialized = 1; + } + /* Spawn thread */ + pthread_create(&dns_server[channel].th1, &thrATTR, Dns_server, + INT2VOIDP(dns_server[channel].channel)); +#else + Dns_blocking_server(); +#endif +} + +/* + * Return the IP for the given hostname using a callback. + * Side effect: a thread is spawned when hostname is not cached. + */ +void a_Dns_resolve(const char *hostname, DnsCallback_t cb_func, void *cb_data) +{ + int i, channel; + + if (!hostname) + return; + + /* check for cache hit. */ + for (i = 0; i < dns_cache_size; i++) + if (!strcmp(hostname, dns_cache[i].hostname)) + break; + + if (i < dns_cache_size) { + /* already resolved, call the Callback inmediately. */ + cb_func(0, dns_cache[i].addr_list, cb_data); + + } else if ((i = Dns_queue_find(hostname)) != -1) { + /* hit in queue, but answer hasn't come back yet. */ + Dns_queue_add(dns_queue[i].channel, hostname, cb_func, cb_data); + + } else { + /* Never requested before -- we must resolve it! */ + + /* Find a channel we can send the request to */ + for (channel = 0; channel < num_servers; channel++) + if (!dns_server[channel].in_use) + break; + if (channel < num_servers) { + /* Found a free channel! */ + Dns_queue_add(channel, hostname, cb_func, cb_data); + Dns_server_req(channel, hostname); + } else { + /* We'll have to wait for a thread to finish... */ + Dns_queue_add(-2, hostname, cb_func, cb_data); + } + } +} + +/* + * Give answer to all queued callbacks on this channel + */ +static void Dns_serve_channel(int channel) +{ + int i; + DnsServer *srv = &dns_server[channel]; + + for (i = 0; i < dns_queue_size; i++) { + if (dns_queue[i].channel == channel) { + dns_queue[i].cb_func(srv->status, srv->addr_list, + dns_queue[i].cb_data); + Dns_queue_remove(i); + --i; + } + } + /* set current channel free */ + srv->in_use = FALSE; +} + +/* + * Assign free channels to waiting clients (-2) + */ +static void Dns_assign_channels(void) +{ + int ch, i, j; + + for (ch = 0; ch < num_servers; ++ch) { + if (dns_server[ch].in_use == FALSE) { + /* Find the next query in the queue (we're a FIFO) */ + for (i = 0; i < dns_queue_size; i++) + if (dns_queue[i].channel == -2) + break; + + if (i < dns_queue_size) { + /* assign this channel to every queued request + * with the same hostname*/ + for (j = i; j < dns_queue_size; j++) + if (dns_queue[j].channel == -2 && + !strcmp(dns_queue[j].hostname, dns_queue[i].hostname)) + dns_queue[j].channel = ch; + Dns_server_req(ch, dns_queue[i].hostname); + } else + return; + } + } +} + +/* + * This is a timeout function that + * reads the DNS results and resumes the stopped jobs. + */ +static void Dns_timeout_client(void *data) +{ + int channel = (int)data; + DnsServer *srv = &dns_server[channel]; + + if (srv->ip_ready) { + if (srv->addr_list != NULL) { + /* DNS succeeded, let's cache it */ + Dns_cache_add(srv->hostname, srv->addr_list); + } + Dns_serve_channel(channel); + Dns_assign_channels(); + a_Timeout_remove(); /* Done! */ + + } else { + /* IP not already resolved, keep on trying... */ + a_Timeout_repeat(0.2, Dns_timeout_client, data); + } +} + + +/* + * Dns memory-deallocation + * (Call this one at exit time) + * The Dns_queue is deallocated at execution time (no need to do that here) + * 'dns_cache' is the only one that grows dinamically + */ +void a_Dns_freeall(void) +{ + int i; + + for ( i = 0; i < dns_cache_size; ++i ){ + dFree(dns_cache[i].hostname); + } + dFree(dns_cache); +} + |