Annotation of embedaddon/libevent/evdns.c, revision 1.1.1.1.2.1

1.1.1.1.2.1! misho       1: /* $Id: evdns.c,v 1.1.1.1 2012/02/21 23:02:54 misho Exp $ */
1.1       misho       2: 
                      3: /* The original version of this module was written by Adam Langley; for
                      4:  * a history of modifications, check out the subversion logs.
                      5:  *
                      6:  * When editing this module, try to keep it re-mergeable by Adam.  Don't
                      7:  * reformat the whitespace, add Tor dependencies, or so on.
                      8:  *
                      9:  * TODO:
                     10:  *   - Support IPv6 and PTR records.
                     11:  *   - Replace all externally visible magic numbers with #defined constants.
                     12:  *   - Write doccumentation for APIs of all external functions.
                     13:  */
                     14: 
                     15: /* Async DNS Library
                     16:  * Adam Langley <agl@imperialviolet.org>
                     17:  * http://www.imperialviolet.org/eventdns.html
                     18:  * Public Domain code
                     19:  *
                     20:  * This software is Public Domain. To view a copy of the public domain dedication,
                     21:  * visit http://creativecommons.org/licenses/publicdomain/ or send a letter to
                     22:  * Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
                     23:  *
                     24:  * I ask and expect, but do not require, that all derivative works contain an
                     25:  * attribution similar to:
                     26:  *     Parts developed by Adam Langley <agl@imperialviolet.org>
                     27:  *
                     28:  * You may wish to replace the word "Parts" with something else depending on
                     29:  * the amount of original code.
                     30:  *
                     31:  * (Derivative works does not include programs which link against, run or include
                     32:  * the source verbatim in their source distributions)
                     33:  *
                     34:  * Version: 0.1b
                     35:  */
                     36: 
                     37: #include <sys/types.h>
                     38: #ifdef HAVE_CONFIG_H
                     39: #include "config.h"
                     40: #endif
                     41: 
                     42: #ifdef DNS_USE_FTIME_FOR_ID
                     43: #include <sys/timeb.h>
                     44: #endif
                     45: 
                     46: #ifndef DNS_USE_CPU_CLOCK_FOR_ID
                     47: #ifndef DNS_USE_GETTIMEOFDAY_FOR_ID
                     48: #ifndef DNS_USE_OPENSSL_FOR_ID
                     49: #ifndef DNS_USE_FTIME_FOR_ID
                     50: #error Must configure at least one id generation method.
                     51: #error Please see the documentation.
                     52: #endif
                     53: #endif
                     54: #endif
                     55: #endif
                     56: 
                     57: /* #define _POSIX_C_SOURCE 200507 */
                     58: #define _GNU_SOURCE
                     59: 
                     60: #ifdef DNS_USE_CPU_CLOCK_FOR_ID
                     61: #ifdef DNS_USE_OPENSSL_FOR_ID
                     62: #error Multiple id options selected
                     63: #endif
                     64: #ifdef DNS_USE_GETTIMEOFDAY_FOR_ID
                     65: #error Multiple id options selected
                     66: #endif
                     67: #include <time.h>
                     68: #endif
                     69: 
                     70: #ifdef DNS_USE_OPENSSL_FOR_ID
                     71: #ifdef DNS_USE_GETTIMEOFDAY_FOR_ID
                     72: #error Multiple id options selected
                     73: #endif
                     74: #include <openssl/rand.h>
                     75: #endif
                     76: 
                     77: #ifndef _FORTIFY_SOURCE
                     78: #define _FORTIFY_SOURCE 3
                     79: #endif
                     80: 
                     81: #include <string.h>
                     82: #include <fcntl.h>
                     83: #ifdef HAVE_SYS_TIME_H
                     84: #include <sys/time.h>
                     85: #endif
                     86: #ifdef HAVE_STDINT_H
                     87: #include <stdint.h>
                     88: #endif
                     89: #include <stdlib.h>
                     90: #include <string.h>
                     91: #include <errno.h>
                     92: #include <assert.h>
                     93: #ifdef HAVE_UNISTD_H
                     94: #include <unistd.h>
                     95: #endif
                     96: #include <limits.h>
                     97: #include <sys/stat.h>
                     98: #include <ctype.h>
                     99: #include <stdio.h>
                    100: #include <stdarg.h>
                    101: 
                    102: #include "evdns.h"
                    103: #include "evutil.h"
                    104: #include "log.h"
                    105: #ifdef WIN32
                    106: #include <winsock2.h>
                    107: #include <windows.h>
                    108: #include <iphlpapi.h>
                    109: #include <io.h>
                    110: #else
                    111: #include <sys/socket.h>
                    112: #include <netinet/in.h>
                    113: #include <arpa/inet.h>
                    114: #endif
                    115: 
                    116: #ifdef HAVE_NETINET_IN6_H
                    117: #include <netinet/in6.h>
                    118: #endif
                    119: 
                    120: #define EVDNS_LOG_DEBUG 0
                    121: #define EVDNS_LOG_WARN 1
                    122: 
                    123: #ifndef HOST_NAME_MAX
                    124: #define HOST_NAME_MAX 255
                    125: #endif
                    126: 
                    127: #include <stdio.h>
                    128: 
                    129: #undef MIN
                    130: #define MIN(a,b) ((a)<(b)?(a):(b))
                    131: 
                    132: #ifdef __USE_ISOC99B
                    133: /* libevent doesn't work without this */
                    134: typedef ev_uint8_t u_char;
                    135: typedef unsigned int uint;
                    136: #endif
                    137: #include <event.h>
                    138: 
                    139: #define u64 ev_uint64_t
                    140: #define u32 ev_uint32_t
                    141: #define u16 ev_uint16_t
                    142: #define u8  ev_uint8_t
                    143: 
                    144: #ifdef WIN32
                    145: #define open _open
                    146: #define read _read
                    147: #define close _close
                    148: #define strdup _strdup
                    149: #endif
                    150: 
                    151: #define MAX_ADDRS 32  /* maximum number of addresses from a single packet */
                    152: /* which we bother recording */
                    153: 
                    154: #define TYPE_A         EVDNS_TYPE_A
                    155: #define TYPE_CNAME     5
                    156: #define TYPE_PTR       EVDNS_TYPE_PTR
                    157: #define TYPE_AAAA      EVDNS_TYPE_AAAA
                    158: 
                    159: #define CLASS_INET     EVDNS_CLASS_INET
                    160: 
1.1.1.1.2.1! misho     161: #ifdef HAVE_SETFD
        !           162: #define FD_CLOSEONEXEC(x) do { \
        !           163:        if (fcntl(x, F_SETFD, 1) == -1) \
        !           164:                event_warn("fcntl(%d, F_SETFD)", x); \
        !           165:        } while (0)
        !           166: #else
        !           167: #define FD_CLOSEONEXEC(x) (void)0
        !           168: #endif
        !           169: 
1.1       misho     170: struct request {
                    171:        u8 *request;  /* the dns packet data */
                    172:        unsigned int request_len;
                    173:        int reissue_count;
                    174:        int tx_count;  /* the number of times that this packet has been sent */
                    175:        unsigned int request_type; /* TYPE_PTR or TYPE_A */
                    176:        void *user_pointer;  /* the pointer given to us for this request */
                    177:        evdns_callback_type user_callback;
                    178:        struct nameserver *ns;  /* the server which we last sent it */
                    179: 
                    180:        /* elements used by the searching code */
                    181:        int search_index;
                    182:        struct search_state *search_state;
                    183:        char *search_origname;  /* needs to be free()ed */
                    184:        int search_flags;
                    185: 
                    186:        /* these objects are kept in a circular list */
                    187:        struct request *next, *prev;
                    188: 
                    189:        struct event timeout_event;
                    190: 
                    191:        u16 trans_id;  /* the transaction id */
                    192:        char request_appended;  /* true if the request pointer is data which follows this struct */
                    193:        char transmit_me;  /* needs to be transmitted */
                    194: };
                    195: 
                    196: #ifndef HAVE_STRUCT_IN6_ADDR
                    197: struct in6_addr {
                    198:        u8 s6_addr[16];
                    199: };
                    200: #endif
                    201: 
                    202: struct reply {
                    203:        unsigned int type;
                    204:        unsigned int have_answer;
                    205:        union {
                    206:                struct {
                    207:                        u32 addrcount;
                    208:                        u32 addresses[MAX_ADDRS];
                    209:                } a;
                    210:                struct {
                    211:                        u32 addrcount;
                    212:                        struct in6_addr addresses[MAX_ADDRS];
                    213:                } aaaa;
                    214:                struct {
                    215:                        char name[HOST_NAME_MAX];
                    216:                } ptr;
                    217:        } data;
                    218: };
                    219: 
                    220: struct nameserver {
                    221:        int socket;  /* a connected UDP socket */
                    222:        u32 address;
                    223:        u16 port;
                    224:        int failed_times;  /* number of times which we have given this server a chance */
                    225:        int timedout;  /* number of times in a row a request has timed out */
                    226:        struct event event;
                    227:        /* these objects are kept in a circular list */
                    228:        struct nameserver *next, *prev;
                    229:        struct event timeout_event;  /* used to keep the timeout for */
                    230:                                     /* when we next probe this server. */
                    231:                                     /* Valid if state == 0 */
                    232:        char state;  /* zero if we think that this server is down */
                    233:        char choked;  /* true if we have an EAGAIN from this server's socket */
                    234:        char write_waiting;  /* true if we are waiting for EV_WRITE events */
                    235: };
                    236: 
                    237: static struct request *req_head = NULL, *req_waiting_head = NULL;
                    238: static struct nameserver *server_head = NULL;
                    239: 
                    240: /* Represents a local port where we're listening for DNS requests. Right now, */
                    241: /* only UDP is supported. */
                    242: struct evdns_server_port {
                    243:        int socket; /* socket we use to read queries and write replies. */
                    244:        int refcnt; /* reference count. */
                    245:        char choked; /* Are we currently blocked from writing? */
                    246:        char closing; /* Are we trying to close this port, pending writes? */
                    247:        evdns_request_callback_fn_type user_callback; /* Fn to handle requests */
                    248:        void *user_data; /* Opaque pointer passed to user_callback */
                    249:        struct event event; /* Read/write event */
                    250:        /* circular list of replies that we want to write. */
                    251:        struct server_request *pending_replies;
                    252: };
                    253: 
                    254: /* Represents part of a reply being built.     (That is, a single RR.) */
                    255: struct server_reply_item {
                    256:        struct server_reply_item *next; /* next item in sequence. */
                    257:        char *name; /* name part of the RR */
                    258:        u16 type : 16; /* The RR type */
                    259:        u16 class : 16; /* The RR class (usually CLASS_INET) */
                    260:        u32 ttl; /* The RR TTL */
                    261:        char is_name; /* True iff data is a label */
                    262:        u16 datalen; /* Length of data; -1 if data is a label */
                    263:        void *data; /* The contents of the RR */
                    264: };
                    265: 
                    266: /* Represents a request that we've received as a DNS server, and holds */
                    267: /* the components of the reply as we're constructing it. */
                    268: struct server_request {
                    269:        /* Pointers to the next and previous entries on the list of replies */
                    270:        /* that we're waiting to write.  Only set if we have tried to respond */
                    271:        /* and gotten EAGAIN. */
                    272:        struct server_request *next_pending;
                    273:        struct server_request *prev_pending;
                    274: 
                    275:        u16 trans_id; /* Transaction id. */
                    276:        struct evdns_server_port *port; /* Which port received this request on? */
                    277:        struct sockaddr_storage addr; /* Where to send the response */
                    278:        socklen_t addrlen; /* length of addr */
                    279: 
                    280:        int n_answer; /* how many answer RRs have been set? */
                    281:        int n_authority; /* how many authority RRs have been set? */
                    282:        int n_additional; /* how many additional RRs have been set? */
                    283: 
                    284:        struct server_reply_item *answer; /* linked list of answer RRs */
                    285:        struct server_reply_item *authority; /* linked list of authority RRs */
                    286:        struct server_reply_item *additional; /* linked list of additional RRs */
                    287: 
                    288:        /* Constructed response.  Only set once we're ready to send a reply. */
                    289:        /* Once this is set, the RR fields are cleared, and no more should be set. */
                    290:        char *response;
                    291:        size_t response_len;
                    292: 
                    293:        /* Caller-visible fields: flags, questions. */
                    294:        struct evdns_server_request base;
                    295: };
                    296: 
                    297: /* helper macro */
                    298: #define OFFSET_OF(st, member) ((off_t) (((char*)&((st*)0)->member)-(char*)0))
                    299: 
                    300: /* Given a pointer to an evdns_server_request, get the corresponding */
                    301: /* server_request. */
                    302: #define TO_SERVER_REQUEST(base_ptr)                                                                            \
                    303:        ((struct server_request*)                                                                                       \
                    304:         (((char*)(base_ptr) - OFFSET_OF(struct server_request, base))))
                    305: 
                    306: /* The number of good nameservers that we have */
                    307: static int global_good_nameservers = 0;
                    308: 
                    309: /* inflight requests are contained in the req_head list */
                    310: /* and are actually going out across the network */
                    311: static int global_requests_inflight = 0;
                    312: /* requests which aren't inflight are in the waiting list */
                    313: /* and are counted here */
                    314: static int global_requests_waiting = 0;
                    315: 
                    316: static int global_max_requests_inflight = 64;
                    317: 
                    318: static struct timeval global_timeout = {5, 0};  /* 5 seconds */
                    319: static int global_max_reissues = 1;  /* a reissue occurs when we get some errors from the server */
                    320: static int global_max_retransmits = 3;  /* number of times we'll retransmit a request which timed out */
                    321: /* number of timeouts in a row before we consider this server to be down */
                    322: static int global_max_nameserver_timeout = 3;
                    323: 
                    324: /* These are the timeout values for nameservers. If we find a nameserver is down */
                    325: /* we try to probe it at intervals as given below. Values are in seconds. */
                    326: static const struct timeval global_nameserver_timeouts[] = {{10, 0}, {60, 0}, {300, 0}, {900, 0}, {3600, 0}};
                    327: static const int global_nameserver_timeouts_length = sizeof(global_nameserver_timeouts)/sizeof(struct timeval);
                    328: 
                    329: static struct nameserver *nameserver_pick(void);
                    330: static void evdns_request_insert(struct request *req, struct request **head);
                    331: static void nameserver_ready_callback(int fd, short events, void *arg);
                    332: static int evdns_transmit(void);
                    333: static int evdns_request_transmit(struct request *req);
                    334: static void nameserver_send_probe(struct nameserver *const ns);
                    335: static void search_request_finished(struct request *const);
                    336: static int search_try_next(struct request *const req);
                    337: static int search_request_new(int type, const char *const name, int flags, evdns_callback_type user_callback, void *user_arg);
                    338: static void evdns_requests_pump_waiting_queue(void);
                    339: static u16 transaction_id_pick(void);
                    340: static struct request *request_new(int type, const char *name, int flags, evdns_callback_type callback, void *ptr);
                    341: static void request_submit(struct request *const req);
                    342: 
                    343: static int server_request_free(struct server_request *req);
                    344: static void server_request_free_answers(struct server_request *req);
                    345: static void server_port_free(struct evdns_server_port *port);
                    346: static void server_port_ready_callback(int fd, short events, void *arg);
                    347: 
                    348: static int strtoint(const char *const str);
                    349: 
                    350: #ifdef WIN32
                    351: static int
                    352: last_error(int sock)
                    353: {
                    354:        int optval, optvallen=sizeof(optval);
                    355:        int err = WSAGetLastError();
                    356:        if (err == WSAEWOULDBLOCK && sock >= 0) {
                    357:                if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&optval,
                    358:                               &optvallen))
                    359:                        return err;
                    360:                if (optval)
                    361:                        return optval;
                    362:        }
                    363:        return err;
                    364: 
                    365: }
                    366: static int
                    367: error_is_eagain(int err)
                    368: {
                    369:        return err == EAGAIN || err == WSAEWOULDBLOCK;
                    370: }
                    371: static int
                    372: inet_aton(const char *c, struct in_addr *addr)
                    373: {
                    374:        ev_uint32_t r;
                    375:        if (strcmp(c, "255.255.255.255") == 0) {
                    376:                addr->s_addr = 0xffffffffu;
                    377:        } else {
                    378:                r = inet_addr(c);
                    379:                if (r == INADDR_NONE)
                    380:                        return 0;
                    381:                addr->s_addr = r;
                    382:        }
                    383:        return 1;
                    384: }
                    385: #else
                    386: #define last_error(sock) (errno)
                    387: #define error_is_eagain(err) ((err) == EAGAIN)
                    388: #endif
                    389: #define CLOSE_SOCKET(s) EVUTIL_CLOSESOCKET(s)
                    390: 
                    391: #define ISSPACE(c) isspace((int)(unsigned char)(c))
                    392: #define ISDIGIT(c) isdigit((int)(unsigned char)(c))
                    393: 
                    394: static const char *
                    395: debug_ntoa(u32 address)
                    396: {
                    397:        static char buf[32];
                    398:        u32 a = ntohl(address);
                    399:        evutil_snprintf(buf, sizeof(buf), "%d.%d.%d.%d",
                    400:                       (int)(u8)((a>>24)&0xff),
                    401:                       (int)(u8)((a>>16)&0xff),
                    402:                       (int)(u8)((a>>8 )&0xff),
                    403:                      (int)(u8)((a    )&0xff));
                    404:        return buf;
                    405: }
                    406: 
                    407: static evdns_debug_log_fn_type evdns_log_fn = NULL;
                    408: 
                    409: void
                    410: evdns_set_log_fn(evdns_debug_log_fn_type fn)
                    411: {
                    412:   evdns_log_fn = fn;
                    413: }
                    414: 
                    415: #ifdef __GNUC__
                    416: #define EVDNS_LOG_CHECK  __attribute__ ((format(printf, 2, 3)))
                    417: #else
                    418: #define EVDNS_LOG_CHECK
                    419: #endif
                    420: 
                    421: static void _evdns_log(int warn, const char *fmt, ...) EVDNS_LOG_CHECK;
                    422: static void
                    423: _evdns_log(int warn, const char *fmt, ...)
                    424: {
                    425:   va_list args;
                    426:   static char buf[512];
                    427:   if (!evdns_log_fn)
                    428:     return;
                    429:   va_start(args,fmt);
                    430:   evutil_vsnprintf(buf, sizeof(buf), fmt, args);
                    431:   buf[sizeof(buf)-1] = '\0';
                    432:   evdns_log_fn(warn, buf);
                    433:   va_end(args);
                    434: }
                    435: 
                    436: #define log _evdns_log
                    437: 
                    438: /* This walks the list of inflight requests to find the */
                    439: /* one with a matching transaction id. Returns NULL on */
                    440: /* failure */
                    441: static struct request *
                    442: request_find_from_trans_id(u16 trans_id) {
                    443:        struct request *req = req_head, *const started_at = req_head;
                    444: 
                    445:        if (req) {
                    446:                do {
                    447:                        if (req->trans_id == trans_id) return req;
                    448:                        req = req->next;
                    449:                } while (req != started_at);
                    450:        }
                    451: 
                    452:        return NULL;
                    453: }
                    454: 
                    455: /* a libevent callback function which is called when a nameserver */
                    456: /* has gone down and we want to test if it has came back to life yet */
                    457: static void
                    458: nameserver_prod_callback(int fd, short events, void *arg) {
                    459:        struct nameserver *const ns = (struct nameserver *) arg;
                    460:         (void)fd;
                    461:         (void)events;
                    462: 
                    463:        nameserver_send_probe(ns);
                    464: }
                    465: 
                    466: /* a libevent callback which is called when a nameserver probe (to see if */
                    467: /* it has come back to life) times out. We increment the count of failed_times */
                    468: /* and wait longer to send the next probe packet. */
                    469: static void
                    470: nameserver_probe_failed(struct nameserver *const ns) {
                    471:        const struct timeval * timeout;
                    472:        (void) evtimer_del(&ns->timeout_event);
                    473:        if (ns->state == 1) {
                    474:                /* This can happen if the nameserver acts in a way which makes us mark */
                    475:                /* it as bad and then starts sending good replies. */
                    476:                return;
                    477:        }
                    478: 
                    479:        timeout =
                    480:          &global_nameserver_timeouts[MIN(ns->failed_times,
                    481:                                          global_nameserver_timeouts_length - 1)];
                    482:        ns->failed_times++;
                    483: 
                    484:        if (evtimer_add(&ns->timeout_event, (struct timeval *) timeout) < 0) {
                    485:           log(EVDNS_LOG_WARN,
                    486:               "Error from libevent when adding timer event for %s",
                    487:               debug_ntoa(ns->address));
                    488:           /* ???? Do more? */
                    489:         }
                    490: }
                    491: 
                    492: /* called when a nameserver has been deemed to have failed. For example, too */
                    493: /* many packets have timed out etc */
                    494: static void
                    495: nameserver_failed(struct nameserver *const ns, const char *msg) {
                    496:        struct request *req, *started_at;
                    497:        /* if this nameserver has already been marked as failed */
                    498:        /* then don't do anything */
                    499:        if (!ns->state) return;
                    500: 
                    501:        log(EVDNS_LOG_WARN, "Nameserver %s has failed: %s",
                    502:             debug_ntoa(ns->address), msg);
                    503:        global_good_nameservers--;
                    504:        assert(global_good_nameservers >= 0);
                    505:        if (global_good_nameservers == 0) {
                    506:                log(EVDNS_LOG_WARN, "All nameservers have failed");
                    507:        }
                    508: 
                    509:        ns->state = 0;
                    510:        ns->failed_times = 1;
                    511: 
                    512:        if (evtimer_add(&ns->timeout_event, (struct timeval *) &global_nameserver_timeouts[0]) < 0) {
                    513:                log(EVDNS_LOG_WARN,
                    514:                    "Error from libevent when adding timer event for %s",
                    515:                    debug_ntoa(ns->address));
                    516:                /* ???? Do more? */
                    517:         }
                    518: 
                    519:        /* walk the list of inflight requests to see if any can be reassigned to */
                    520:        /* a different server. Requests in the waiting queue don't have a */
                    521:        /* nameserver assigned yet */
                    522: 
                    523:        /* if we don't have *any* good nameservers then there's no point */
                    524:        /* trying to reassign requests to one */
                    525:        if (!global_good_nameservers) return;
                    526: 
                    527:        req = req_head;
                    528:        started_at = req_head;
                    529:        if (req) {
                    530:                do {
                    531:                        if (req->tx_count == 0 && req->ns == ns) {
                    532:                                /* still waiting to go out, can be moved */
                    533:                                /* to another server */
                    534:                                req->ns = nameserver_pick();
                    535:                        }
                    536:                        req = req->next;
                    537:                } while (req != started_at);
                    538:        }
                    539: }
                    540: 
                    541: static void
                    542: nameserver_up(struct nameserver *const ns) {
                    543:        if (ns->state) return;
                    544:        log(EVDNS_LOG_WARN, "Nameserver %s is back up",
                    545:            debug_ntoa(ns->address));
                    546:        evtimer_del(&ns->timeout_event);
                    547:        ns->state = 1;
                    548:        ns->failed_times = 0;
                    549:        ns->timedout = 0;
                    550:        global_good_nameservers++;
                    551: }
                    552: 
                    553: static void
                    554: request_trans_id_set(struct request *const req, const u16 trans_id) {
                    555:        req->trans_id = trans_id;
                    556:        *((u16 *) req->request) = htons(trans_id);
                    557: }
                    558: 
                    559: /* Called to remove a request from a list and dealloc it. */
                    560: /* head is a pointer to the head of the list it should be */
                    561: /* removed from or NULL if the request isn't in a list. */
                    562: static void
                    563: request_finished(struct request *const req, struct request **head) {
                    564:        if (head) {
                    565:                if (req->next == req) {
                    566:                        /* only item in the list */
                    567:                        *head = NULL;
                    568:                } else {
                    569:                        req->next->prev = req->prev;
                    570:                        req->prev->next = req->next;
                    571:                        if (*head == req) *head = req->next;
                    572:                }
                    573:        }
                    574: 
                    575:        log(EVDNS_LOG_DEBUG, "Removing timeout for request %lx",
                    576:            (unsigned long) req);
                    577:        evtimer_del(&req->timeout_event);
                    578: 
                    579:        search_request_finished(req);
                    580:        global_requests_inflight--;
                    581: 
                    582:        if (!req->request_appended) {
                    583:                /* need to free the request data on it's own */
                    584:                free(req->request);
                    585:        } else {
                    586:                /* the request data is appended onto the header */
                    587:                /* so everything gets free()ed when we: */
                    588:        }
                    589: 
                    590:        free(req);
                    591: 
                    592:        evdns_requests_pump_waiting_queue();
                    593: }
                    594: 
                    595: /* This is called when a server returns a funny error code. */
                    596: /* We try the request again with another server. */
                    597: /* */
                    598: /* return: */
                    599: /*   0 ok */
                    600: /*   1 failed/reissue is pointless */
                    601: static int
                    602: request_reissue(struct request *req) {
                    603:        const struct nameserver *const last_ns = req->ns;
                    604:        /* the last nameserver should have been marked as failing */
                    605:        /* by the caller of this function, therefore pick will try */
                    606:        /* not to return it */
                    607:        req->ns = nameserver_pick();
                    608:        if (req->ns == last_ns) {
                    609:                /* ... but pick did return it */
                    610:                /* not a lot of point in trying again with the */
                    611:                /* same server */
                    612:                return 1;
                    613:        }
                    614: 
                    615:        req->reissue_count++;
                    616:        req->tx_count = 0;
                    617:        req->transmit_me = 1;
                    618: 
                    619:        return 0;
                    620: }
                    621: 
                    622: /* this function looks for space on the inflight queue and promotes */
                    623: /* requests from the waiting queue if it can. */
                    624: static void
                    625: evdns_requests_pump_waiting_queue(void) {
                    626:        while (global_requests_inflight < global_max_requests_inflight &&
                    627:            global_requests_waiting) {
                    628:                struct request *req;
                    629:                /* move a request from the waiting queue to the inflight queue */
                    630:                assert(req_waiting_head);
                    631:                if (req_waiting_head->next == req_waiting_head) {
                    632:                        /* only one item in the queue */
                    633:                        req = req_waiting_head;
                    634:                        req_waiting_head = NULL;
                    635:                } else {
                    636:                        req = req_waiting_head;
                    637:                        req->next->prev = req->prev;
                    638:                        req->prev->next = req->next;
                    639:                        req_waiting_head = req->next;
                    640:                }
                    641: 
                    642:                global_requests_waiting--;
                    643:                global_requests_inflight++;
                    644: 
                    645:                req->ns = nameserver_pick();
                    646:                request_trans_id_set(req, transaction_id_pick());
                    647: 
                    648:                evdns_request_insert(req, &req_head);
                    649:                evdns_request_transmit(req);
                    650:                evdns_transmit();
                    651:        }
                    652: }
                    653: 
                    654: static void
                    655: reply_callback(struct request *const req, u32 ttl, u32 err, struct reply *reply) {
                    656:        switch (req->request_type) {
                    657:        case TYPE_A:
                    658:                if (reply)
                    659:                        req->user_callback(DNS_ERR_NONE, DNS_IPv4_A,
                    660:                                                           reply->data.a.addrcount, ttl,
                    661:                                                 reply->data.a.addresses,
                    662:                                                           req->user_pointer);
                    663:                else
                    664:                        req->user_callback(err, 0, 0, 0, NULL, req->user_pointer);
                    665:                return;
                    666:        case TYPE_PTR:
                    667:                if (reply) {
                    668:                        char *name = reply->data.ptr.name;
                    669:                        req->user_callback(DNS_ERR_NONE, DNS_PTR, 1, ttl,
                    670:                                                           &name, req->user_pointer);
                    671:                } else {
                    672:                        req->user_callback(err, 0, 0, 0, NULL,
                    673:                                                           req->user_pointer);
                    674:                }
                    675:                return;
                    676:        case TYPE_AAAA:
                    677:                if (reply)
                    678:                        req->user_callback(DNS_ERR_NONE, DNS_IPv6_AAAA,
                    679:                                                           reply->data.aaaa.addrcount, ttl,
                    680:                                                           reply->data.aaaa.addresses,
                    681:                                                           req->user_pointer);
                    682:                else
                    683:                        req->user_callback(err, 0, 0, 0, NULL, req->user_pointer);
                    684:                 return;
                    685:        }
                    686:        assert(0);
                    687: }
                    688: 
                    689: /* this processes a parsed reply packet */
                    690: static void
                    691: reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) {
                    692:        int error;
                    693:        static const int error_codes[] = {
                    694:                DNS_ERR_FORMAT, DNS_ERR_SERVERFAILED, DNS_ERR_NOTEXIST,
                    695:                DNS_ERR_NOTIMPL, DNS_ERR_REFUSED
                    696:        };
                    697: 
                    698:        if (flags & 0x020f || !reply || !reply->have_answer) {
                    699:                /* there was an error */
                    700:                if (flags & 0x0200) {
                    701:                        error = DNS_ERR_TRUNCATED;
                    702:                } else {
                    703:                        u16 error_code = (flags & 0x000f) - 1;
                    704:                        if (error_code > 4) {
                    705:                                error = DNS_ERR_UNKNOWN;
                    706:                        } else {
                    707:                                error = error_codes[error_code];
                    708:                        }
                    709:                }
                    710: 
                    711:                switch(error) {
                    712:                case DNS_ERR_NOTIMPL:
                    713:                case DNS_ERR_REFUSED:
                    714:                        /* we regard these errors as marking a bad nameserver */
                    715:                        if (req->reissue_count < global_max_reissues) {
                    716:                                char msg[64];
                    717:                                evutil_snprintf(msg, sizeof(msg),
                    718:                                    "Bad response %d (%s)",
                    719:                                         error, evdns_err_to_string(error));
                    720:                                nameserver_failed(req->ns, msg);
                    721:                                if (!request_reissue(req)) return;
                    722:                        }
                    723:                        break;
                    724:                case DNS_ERR_SERVERFAILED:
                    725:                        /* rcode 2 (servfailed) sometimes means "we
                    726:                         * are broken" and sometimes (with some binds)
                    727:                         * means "that request was very confusing."
                    728:                         * Treat this as a timeout, not a failure.
                    729:                         */
                    730:                        log(EVDNS_LOG_DEBUG, "Got a SERVERFAILED from nameserver %s; "
                    731:                                "will allow the request to time out.",
                    732:                                debug_ntoa(req->ns->address));
                    733:                        break;
                    734:                default:
                    735:                        /* we got a good reply from the nameserver */
                    736:                        nameserver_up(req->ns);
                    737:                }
                    738: 
                    739:                if (req->search_state && req->request_type != TYPE_PTR) {
                    740:                        /* if we have a list of domains to search in,
                    741:                         * try the next one */
                    742:                        if (!search_try_next(req)) {
                    743:                                /* a new request was issued so this
                    744:                                 * request is finished and */
                    745:                                /* the user callback will be made when
                    746:                                 * that request (or a */
                    747:                                /* child of it) finishes. */
                    748:                                request_finished(req, &req_head);
                    749:                                return;
                    750:                        }
                    751:                }
                    752: 
                    753:                /* all else failed. Pass the failure up */
                    754:                reply_callback(req, 0, error, NULL);
                    755:                request_finished(req, &req_head);
                    756:        } else {
                    757:                /* all ok, tell the user */
                    758:                reply_callback(req, ttl, 0, reply);
                    759:                nameserver_up(req->ns);
                    760:                request_finished(req, &req_head);
                    761:        }
                    762: }
                    763: 
                    764: static int
                    765: name_parse(u8 *packet, int length, int *idx, char *name_out, int name_out_len) {
                    766:        int name_end = -1;
                    767:        int j = *idx;
                    768:        int ptr_count = 0;
                    769: #define GET32(x) do { if (j + 4 > length) goto err; memcpy(&_t32, packet + j, 4); j += 4; x = ntohl(_t32); } while(0)
                    770: #define GET16(x) do { if (j + 2 > length) goto err; memcpy(&_t, packet + j, 2); j += 2; x = ntohs(_t); } while(0)
                    771: #define GET8(x) do { if (j >= length) goto err; x = packet[j++]; } while(0)
                    772: 
                    773:        char *cp = name_out;
                    774:        const char *const end = name_out + name_out_len;
                    775: 
                    776:        /* Normally, names are a series of length prefixed strings terminated */
                    777:        /* with a length of 0 (the lengths are u8's < 63). */
                    778:        /* However, the length can start with a pair of 1 bits and that */
                    779:        /* means that the next 14 bits are a pointer within the current */
                    780:        /* packet. */
                    781: 
                    782:        for(;;) {
                    783:                u8 label_len;
                    784:                if (j >= length) return -1;
                    785:                GET8(label_len);
                    786:                if (!label_len) break;
                    787:                if (label_len & 0xc0) {
                    788:                        u8 ptr_low;
                    789:                        GET8(ptr_low);
                    790:                        if (name_end < 0) name_end = j;
                    791:                        j = (((int)label_len & 0x3f) << 8) + ptr_low;
                    792:                        /* Make sure that the target offset is in-bounds. */
                    793:                        if (j < 0 || j >= length) return -1;
                    794:                        /* If we've jumped more times than there are characters in the
                    795:                         * message, we must have a loop. */
                    796:                        if (++ptr_count > length) return -1;
                    797:                        continue;
                    798:                }
                    799:                if (label_len > 63) return -1;
                    800:                if (cp != name_out) {
                    801:                        if (cp + 1 >= end) return -1;
                    802:                        *cp++ = '.';
                    803:                }
                    804:                if (cp + label_len >= end) return -1;
                    805:                memcpy(cp, packet + j, label_len);
                    806:                cp += label_len;
                    807:                j += label_len;
                    808:        }
                    809:        if (cp >= end) return -1;
                    810:        *cp = '\0';
                    811:        if (name_end < 0)
                    812:                *idx = j;
                    813:        else
                    814:                *idx = name_end;
                    815:        return 0;
                    816:  err:
                    817:        return -1;
                    818: }
                    819: 
                    820: /* parses a raw request from a nameserver */
                    821: static int
                    822: reply_parse(u8 *packet, int length) {
                    823:        int j = 0, k = 0;  /* index into packet */
                    824:        u16 _t;  /* used by the macros */
                    825:        u32 _t32;  /* used by the macros */
                    826:        char tmp_name[256], cmp_name[256]; /* used by the macros */
                    827: 
                    828:        u16 trans_id, questions, answers, authority, additional, datalength;
                    829:         u16 flags = 0;
                    830:        u32 ttl, ttl_r = 0xffffffff;
                    831:        struct reply reply;
                    832:        struct request *req = NULL;
                    833:        unsigned int i;
                    834: 
                    835:        GET16(trans_id);
                    836:        GET16(flags);
                    837:        GET16(questions);
                    838:        GET16(answers);
                    839:        GET16(authority);
                    840:        GET16(additional);
                    841:        (void) authority; /* suppress "unused variable" warnings. */
                    842:        (void) additional; /* suppress "unused variable" warnings. */
                    843: 
                    844:        req = request_find_from_trans_id(trans_id);
                    845:        if (!req) return -1;
                    846: 
                    847:        memset(&reply, 0, sizeof(reply));
                    848: 
                    849:        /* If it's not an answer, it doesn't correspond to any request. */
                    850:        if (!(flags & 0x8000)) return -1;  /* must be an answer */
                    851:        if (flags & 0x020f) {
                    852:                /* there was an error */
                    853:                goto err;
                    854:        }
                    855:        /* if (!answers) return; */  /* must have an answer of some form */
                    856: 
                    857:        /* This macro skips a name in the DNS reply. */
                    858: #define SKIP_NAME \
                    859:        do { tmp_name[0] = '\0';                                \
                    860:                if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0)\
                    861:                        goto err;                               \
                    862:        } while(0)
                    863: #define TEST_NAME \
                    864:        do { tmp_name[0] = '\0';                                \
                    865:                cmp_name[0] = '\0';                             \
                    866:                k = j;                                          \
                    867:                if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0)\
                    868:                        goto err;                                       \
                    869:                if (name_parse(req->request, req->request_len, &k, cmp_name, sizeof(cmp_name))<0)       \
                    870:                        goto err;                               \
                    871:                if (memcmp(tmp_name, cmp_name, strlen (tmp_name)) != 0) \
                    872:                        return (-1); /* we ignore mismatching names */  \
                    873:        } while(0)
                    874: 
                    875:        reply.type = req->request_type;
                    876: 
                    877:        /* skip over each question in the reply */
                    878:        for (i = 0; i < questions; ++i) {
                    879:                /* the question looks like
                    880:                 *   <label:name><u16:type><u16:class>
                    881:                 */
                    882:                TEST_NAME;
                    883:                j += 4;
                    884:                if (j > length) goto err;
                    885:        }
                    886: 
                    887:        /* now we have the answer section which looks like
                    888:         * <label:name><u16:type><u16:class><u32:ttl><u16:len><data...>
                    889:         */
                    890: 
                    891:        for (i = 0; i < answers; ++i) {
                    892:                u16 type, class;
                    893: 
                    894:                SKIP_NAME;
                    895:                GET16(type);
                    896:                GET16(class);
                    897:                GET32(ttl);
                    898:                GET16(datalength);
                    899: 
                    900:                if (type == TYPE_A && class == CLASS_INET) {
                    901:                        int addrcount, addrtocopy;
                    902:                        if (req->request_type != TYPE_A) {
                    903:                                j += datalength; continue;
                    904:                        }
                    905:                        if ((datalength & 3) != 0) /* not an even number of As. */
                    906:                            goto err;
                    907:                        addrcount = datalength >> 2;
                    908:                        addrtocopy = MIN(MAX_ADDRS - reply.data.a.addrcount, (unsigned)addrcount);
                    909: 
                    910:                        ttl_r = MIN(ttl_r, ttl);
                    911:                        /* we only bother with the first four addresses. */
                    912:                        if (j + 4*addrtocopy > length) goto err;
                    913:                        memcpy(&reply.data.a.addresses[reply.data.a.addrcount],
                    914:                                   packet + j, 4*addrtocopy);
                    915:                        j += 4*addrtocopy;
                    916:                        reply.data.a.addrcount += addrtocopy;
                    917:                        reply.have_answer = 1;
                    918:                        if (reply.data.a.addrcount == MAX_ADDRS) break;
                    919:                } else if (type == TYPE_PTR && class == CLASS_INET) {
                    920:                        if (req->request_type != TYPE_PTR) {
                    921:                                j += datalength; continue;
                    922:                        }
                    923:                        if (name_parse(packet, length, &j, reply.data.ptr.name,
                    924:                                                   sizeof(reply.data.ptr.name))<0)
                    925:                                goto err;
                    926:                        ttl_r = MIN(ttl_r, ttl);
                    927:                        reply.have_answer = 1;
                    928:                        break;
                    929:                } else if (type == TYPE_AAAA && class == CLASS_INET) {
                    930:                        int addrcount, addrtocopy;
                    931:                        if (req->request_type != TYPE_AAAA) {
                    932:                                j += datalength; continue;
                    933:                        }
                    934:                        if ((datalength & 15) != 0) /* not an even number of AAAAs. */
                    935:                                goto err;
                    936:                        addrcount = datalength >> 4;  /* each address is 16 bytes long */
                    937:                        addrtocopy = MIN(MAX_ADDRS - reply.data.aaaa.addrcount, (unsigned)addrcount);
                    938:                        ttl_r = MIN(ttl_r, ttl);
                    939: 
                    940:                        /* we only bother with the first four addresses. */
                    941:                        if (j + 16*addrtocopy > length) goto err;
                    942:                        memcpy(&reply.data.aaaa.addresses[reply.data.aaaa.addrcount],
                    943:                                   packet + j, 16*addrtocopy);
                    944:                        reply.data.aaaa.addrcount += addrtocopy;
                    945:                        j += 16*addrtocopy;
                    946:                        reply.have_answer = 1;
                    947:                        if (reply.data.aaaa.addrcount == MAX_ADDRS) break;
                    948:                } else {
                    949:                        /* skip over any other type of resource */
                    950:                        j += datalength;
                    951:                }
                    952:        }
                    953: 
                    954:        reply_handle(req, flags, ttl_r, &reply);
                    955:        return 0;
                    956:  err:
                    957:        if (req)
                    958:                reply_handle(req, flags, 0, NULL);
                    959:        return -1;
                    960: }
                    961: 
                    962: /* Parse a raw request (packet,length) sent to a nameserver port (port) from */
                    963: /* a DNS client (addr,addrlen), and if it's well-formed, call the corresponding */
                    964: /* callback. */
                    965: static int
                    966: request_parse(u8 *packet, int length, struct evdns_server_port *port, struct sockaddr *addr, socklen_t addrlen)
                    967: {
                    968:        int j = 0;      /* index into packet */
                    969:        u16 _t;  /* used by the macros */
                    970:        char tmp_name[256]; /* used by the macros */
                    971: 
                    972:        int i;
                    973:        u16 trans_id, flags, questions, answers, authority, additional;
                    974:        struct server_request *server_req = NULL;
                    975: 
                    976:        /* Get the header fields */
                    977:        GET16(trans_id);
                    978:        GET16(flags);
                    979:        GET16(questions);
                    980:        GET16(answers);
                    981:        GET16(authority);
                    982:        GET16(additional);
                    983: 
                    984:        if (flags & 0x8000) return -1; /* Must not be an answer. */
                    985:        flags &= 0x0110; /* Only RD and CD get preserved. */
                    986: 
                    987:        server_req = malloc(sizeof(struct server_request));
                    988:        if (server_req == NULL) return -1;
                    989:        memset(server_req, 0, sizeof(struct server_request));
                    990: 
                    991:        server_req->trans_id = trans_id;
                    992:        memcpy(&server_req->addr, addr, addrlen);
                    993:        server_req->addrlen = addrlen;
                    994: 
                    995:        server_req->base.flags = flags;
                    996:        server_req->base.nquestions = 0;
                    997:        server_req->base.questions = malloc(sizeof(struct evdns_server_question *) * questions);
                    998:        if (server_req->base.questions == NULL)
                    999:                goto err;
                   1000: 
                   1001:        for (i = 0; i < questions; ++i) {
                   1002:                u16 type, class;
                   1003:                struct evdns_server_question *q;
                   1004:                int namelen;
                   1005:                if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0)
                   1006:                        goto err;
                   1007:                GET16(type);
                   1008:                GET16(class);
                   1009:                namelen = strlen(tmp_name);
                   1010:                q = malloc(sizeof(struct evdns_server_question) + namelen);
                   1011:                if (!q)
                   1012:                        goto err;
                   1013:                q->type = type;
                   1014:                q->dns_question_class = class;
                   1015:                memcpy(q->name, tmp_name, namelen+1);
                   1016:                server_req->base.questions[server_req->base.nquestions++] = q;
                   1017:        }
                   1018: 
                   1019:        /* Ignore answers, authority, and additional. */
                   1020: 
                   1021:        server_req->port = port;
                   1022:        port->refcnt++;
                   1023: 
                   1024:        /* Only standard queries are supported. */
                   1025:        if (flags & 0x7800) {
                   1026:                evdns_server_request_respond(&(server_req->base), DNS_ERR_NOTIMPL);
                   1027:                return -1;
                   1028:        }
                   1029: 
                   1030:        port->user_callback(&(server_req->base), port->user_data);
                   1031: 
                   1032:        return 0;
                   1033: err:
                   1034:        if (server_req) {
                   1035:                if (server_req->base.questions) {
                   1036:                        for (i = 0; i < server_req->base.nquestions; ++i)
                   1037:                                free(server_req->base.questions[i]);
                   1038:                        free(server_req->base.questions);
                   1039:                }
                   1040:                free(server_req);
                   1041:        }
                   1042:        return -1;
                   1043: 
                   1044: #undef SKIP_NAME
                   1045: #undef GET32
                   1046: #undef GET16
                   1047: #undef GET8
                   1048: }
                   1049: 
                   1050: static u16
                   1051: default_transaction_id_fn(void)
                   1052: {
                   1053:        u16 trans_id;
                   1054: #ifdef DNS_USE_CPU_CLOCK_FOR_ID
                   1055:        struct timespec ts;
                   1056:        static int clkid = -1;
                   1057:        if (clkid == -1) {
                   1058:                clkid = CLOCK_REALTIME;
                   1059: #ifdef CLOCK_MONOTONIC
                   1060:                if (clock_gettime(CLOCK_MONOTONIC, &ts) != -1)
                   1061:                        clkid = CLOCK_MONOTONIC;
                   1062: #endif
                   1063:        }
                   1064:        if (clock_gettime(clkid, &ts) == -1)
                   1065:                event_err(1, "clock_gettime");
                   1066:        trans_id = ts.tv_nsec & 0xffff;
                   1067: #endif
                   1068: 
                   1069: #ifdef DNS_USE_FTIME_FOR_ID
                   1070:        struct _timeb tb;
                   1071:        _ftime(&tb);
                   1072:        trans_id = tb.millitm & 0xffff;
                   1073: #endif
                   1074: 
                   1075: #ifdef DNS_USE_GETTIMEOFDAY_FOR_ID
                   1076:        struct timeval tv;
                   1077:        evutil_gettimeofday(&tv, NULL);
                   1078:        trans_id = tv.tv_usec & 0xffff;
                   1079: #endif
                   1080: 
                   1081: #ifdef DNS_USE_OPENSSL_FOR_ID
                   1082:        if (RAND_pseudo_bytes((u8 *) &trans_id, 2) == -1) {
                   1083:                /* in the case that the RAND call fails we back */
                   1084:                /* down to using gettimeofday. */
                   1085:                /*
                   1086:                  struct timeval tv;
                   1087:                  evutil_gettimeofday(&tv, NULL);
                   1088:                  trans_id = tv.tv_usec & 0xffff;
                   1089:                */
                   1090:                abort();
                   1091:        }
                   1092: #endif
                   1093:        return trans_id;
                   1094: }
                   1095: 
                   1096: static ev_uint16_t (*trans_id_function)(void) = default_transaction_id_fn;
                   1097: 
                   1098: void
                   1099: evdns_set_transaction_id_fn(ev_uint16_t (*fn)(void))
                   1100: {
                   1101:        if (fn)
                   1102:                trans_id_function = fn;
                   1103:        else
                   1104:                trans_id_function = default_transaction_id_fn;
                   1105: }
                   1106: 
                   1107: /* Try to choose a strong transaction id which isn't already in flight */
                   1108: static u16
                   1109: transaction_id_pick(void) {
                   1110:        for (;;) {
                   1111:                u16 trans_id = trans_id_function();
                   1112: 
                   1113:                if (trans_id == 0xffff) continue;
1.1.1.1.2.1! misho    1114: 
        !          1115:                if (request_find_from_trans_id(trans_id) == NULL)
        !          1116:                        return trans_id;
1.1       misho    1117:        }
                   1118: }
                   1119: 
                   1120: /* choose a namesever to use. This function will try to ignore */
                   1121: /* nameservers which we think are down and load balance across the rest */
                   1122: /* by updating the server_head global each time. */
                   1123: static struct nameserver *
                   1124: nameserver_pick(void) {
                   1125:        struct nameserver *started_at = server_head, *picked;
                   1126:        if (!server_head) return NULL;
                   1127: 
                   1128:        /* if we don't have any good nameservers then there's no */
                   1129:        /* point in trying to find one. */
                   1130:        if (!global_good_nameservers) {
                   1131:                server_head = server_head->next;
                   1132:                return server_head;
                   1133:        }
                   1134: 
                   1135:        /* remember that nameservers are in a circular list */
                   1136:        for (;;) {
                   1137:                if (server_head->state) {
                   1138:                        /* we think this server is currently good */
                   1139:                        picked = server_head;
                   1140:                        server_head = server_head->next;
                   1141:                        return picked;
                   1142:                }
                   1143: 
                   1144:                server_head = server_head->next;
                   1145:                if (server_head == started_at) {
                   1146:                        /* all the nameservers seem to be down */
                   1147:                        /* so we just return this one and hope for the */
                   1148:                        /* best */
                   1149:                        assert(global_good_nameservers == 0);
                   1150:                        picked = server_head;
                   1151:                        server_head = server_head->next;
                   1152:                        return picked;
                   1153:                }
                   1154:        }
                   1155: }
                   1156: 
                   1157: static int
                   1158: address_is_correct(struct nameserver *ns, struct sockaddr *sa, socklen_t slen)
                   1159: {
                   1160:        struct sockaddr_in *sin = (struct sockaddr_in*) sa;
                   1161:        if (sa->sa_family != AF_INET || slen != sizeof(struct sockaddr_in))
                   1162:                return 0;
                   1163:        if (sin->sin_addr.s_addr != ns->address)
                   1164:                return 0;
                   1165:        return 1;
                   1166: }
                   1167: 
                   1168: /* this is called when a namesever socket is ready for reading */
                   1169: static void
                   1170: nameserver_read(struct nameserver *ns) {
                   1171:        u8 packet[1500];
                   1172:        struct sockaddr_storage ss;
                   1173:        socklen_t addrlen = sizeof(ss);
                   1174: 
                   1175:        for (;;) {
                   1176:                const int r = recvfrom(ns->socket, packet, sizeof(packet), 0,
                   1177:                    (struct sockaddr*)&ss, &addrlen);
                   1178:                if (r < 0) {
                   1179:                        int err = last_error(ns->socket);
                   1180:                        if (error_is_eagain(err)) return;
                   1181:                        nameserver_failed(ns, strerror(err));
                   1182:                        return;
                   1183:                }
                   1184:                if (!address_is_correct(ns, (struct sockaddr*)&ss, addrlen)) {
                   1185:                        log(EVDNS_LOG_WARN, "Address mismatch on received "
                   1186:                            "DNS packet.");
                   1187:                        return;
                   1188:                }
                   1189:                ns->timedout = 0;
                   1190:                reply_parse(packet, r);
                   1191:        }
                   1192: }
                   1193: 
                   1194: /* Read a packet from a DNS client on a server port s, parse it, and */
                   1195: /* act accordingly. */
                   1196: static void
                   1197: server_port_read(struct evdns_server_port *s) {
                   1198:        u8 packet[1500];
                   1199:        struct sockaddr_storage addr;
                   1200:        socklen_t addrlen;
                   1201:        int r;
                   1202: 
                   1203:        for (;;) {
                   1204:                addrlen = sizeof(struct sockaddr_storage);
                   1205:                r = recvfrom(s->socket, packet, sizeof(packet), 0,
                   1206:                                         (struct sockaddr*) &addr, &addrlen);
                   1207:                if (r < 0) {
                   1208:                        int err = last_error(s->socket);
                   1209:                        if (error_is_eagain(err)) return;
                   1210:                        log(EVDNS_LOG_WARN, "Error %s (%d) while reading request.",
                   1211:                                strerror(err), err);
                   1212:                        return;
                   1213:                }
                   1214:                request_parse(packet, r, s, (struct sockaddr*) &addr, addrlen);
                   1215:        }
                   1216: }
                   1217: 
                   1218: /* Try to write all pending replies on a given DNS server port. */
                   1219: static void
                   1220: server_port_flush(struct evdns_server_port *port)
                   1221: {
                   1222:        while (port->pending_replies) {
                   1223:                struct server_request *req = port->pending_replies;
                   1224:                int r = sendto(port->socket, req->response, req->response_len, 0,
                   1225:                           (struct sockaddr*) &req->addr, req->addrlen);
                   1226:                if (r < 0) {
                   1227:                        int err = last_error(port->socket);
                   1228:                        if (error_is_eagain(err))
                   1229:                                return;
                   1230:                        log(EVDNS_LOG_WARN, "Error %s (%d) while writing response to port; dropping", strerror(err), err);
                   1231:                }
                   1232:                if (server_request_free(req)) {
                   1233:                        /* we released the last reference to req->port. */
                   1234:                        return;
                   1235:                }
                   1236:        }
                   1237: 
                   1238:        /* We have no more pending requests; stop listening for 'writeable' events. */
                   1239:        (void) event_del(&port->event);
                   1240:        event_set(&port->event, port->socket, EV_READ | EV_PERSIST,
                   1241:                          server_port_ready_callback, port);
                   1242:        if (event_add(&port->event, NULL) < 0) {
                   1243:                log(EVDNS_LOG_WARN, "Error from libevent when adding event for DNS server.");
                   1244:                /* ???? Do more? */
                   1245:        }
                   1246: }
                   1247: 
                   1248: /* set if we are waiting for the ability to write to this server. */
                   1249: /* if waiting is true then we ask libevent for EV_WRITE events, otherwise */
                   1250: /* we stop these events. */
                   1251: static void
                   1252: nameserver_write_waiting(struct nameserver *ns, char waiting) {
                   1253:        if (ns->write_waiting == waiting) return;
                   1254: 
                   1255:        ns->write_waiting = waiting;
                   1256:        (void) event_del(&ns->event);
                   1257:        event_set(&ns->event, ns->socket, EV_READ | (waiting ? EV_WRITE : 0) | EV_PERSIST,
                   1258:                        nameserver_ready_callback, ns);
                   1259:        if (event_add(&ns->event, NULL) < 0) {
                   1260:           log(EVDNS_LOG_WARN, "Error from libevent when adding event for %s",
                   1261:               debug_ntoa(ns->address));
                   1262:           /* ???? Do more? */
                   1263:         }
                   1264: }
                   1265: 
                   1266: /* a callback function. Called by libevent when the kernel says that */
                   1267: /* a nameserver socket is ready for writing or reading */
                   1268: static void
                   1269: nameserver_ready_callback(int fd, short events, void *arg) {
                   1270:        struct nameserver *ns = (struct nameserver *) arg;
                   1271:         (void)fd;
                   1272: 
                   1273:        if (events & EV_WRITE) {
                   1274:                ns->choked = 0;
                   1275:                if (!evdns_transmit()) {
                   1276:                        nameserver_write_waiting(ns, 0);
                   1277:                }
                   1278:        }
                   1279:        if (events & EV_READ) {
                   1280:                nameserver_read(ns);
                   1281:        }
                   1282: }
                   1283: 
                   1284: /* a callback function. Called by libevent when the kernel says that */
                   1285: /* a server socket is ready for writing or reading. */
                   1286: static void
                   1287: server_port_ready_callback(int fd, short events, void *arg) {
                   1288:        struct evdns_server_port *port = (struct evdns_server_port *) arg;
                   1289:        (void) fd;
                   1290: 
                   1291:        if (events & EV_WRITE) {
                   1292:                port->choked = 0;
                   1293:                server_port_flush(port);
                   1294:        }
                   1295:        if (events & EV_READ) {
                   1296:                server_port_read(port);
                   1297:        }
                   1298: }
                   1299: 
                   1300: /* This is an inefficient representation; only use it via the dnslabel_table_*
                   1301:  * functions, so that is can be safely replaced with something smarter later. */
                   1302: #define MAX_LABELS 128
                   1303: /* Structures used to implement name compression */
                   1304: struct dnslabel_entry { char *v; off_t pos; };
                   1305: struct dnslabel_table {
                   1306:        int n_labels; /* number of current entries */
                   1307:        /* map from name to position in message */
                   1308:        struct dnslabel_entry labels[MAX_LABELS];
                   1309: };
                   1310: 
                   1311: /* Initialize dnslabel_table. */
                   1312: static void
                   1313: dnslabel_table_init(struct dnslabel_table *table)
                   1314: {
                   1315:        table->n_labels = 0;
                   1316: }
                   1317: 
                   1318: /* Free all storage held by table, but not the table itself. */
                   1319: static void
                   1320: dnslabel_clear(struct dnslabel_table *table)
                   1321: {
                   1322:        int i;
                   1323:        for (i = 0; i < table->n_labels; ++i)
                   1324:                free(table->labels[i].v);
                   1325:        table->n_labels = 0;
                   1326: }
                   1327: 
                   1328: /* return the position of the label in the current message, or -1 if the label */
                   1329: /* hasn't been used yet. */
                   1330: static int
                   1331: dnslabel_table_get_pos(const struct dnslabel_table *table, const char *label)
                   1332: {
                   1333:        int i;
                   1334:        for (i = 0; i < table->n_labels; ++i) {
                   1335:                if (!strcmp(label, table->labels[i].v))
                   1336:                        return table->labels[i].pos;
                   1337:        }
                   1338:        return -1;
                   1339: }
                   1340: 
                   1341: /* remember that we've used the label at position pos */
                   1342: static int
                   1343: dnslabel_table_add(struct dnslabel_table *table, const char *label, off_t pos)
                   1344: {
                   1345:        char *v;
                   1346:        int p;
                   1347:        if (table->n_labels == MAX_LABELS)
                   1348:                return (-1);
                   1349:        v = strdup(label);
                   1350:        if (v == NULL)
                   1351:                return (-1);
                   1352:        p = table->n_labels++;
                   1353:        table->labels[p].v = v;
                   1354:        table->labels[p].pos = pos;
                   1355: 
                   1356:        return (0);
                   1357: }
                   1358: 
                   1359: /* Converts a string to a length-prefixed set of DNS labels, starting */
                   1360: /* at buf[j]. name and buf must not overlap. name_len should be the length */
                   1361: /* of name.     table is optional, and is used for compression. */
                   1362: /* */
                   1363: /* Input: abc.def */
                   1364: /* Output: <3>abc<3>def<0> */
                   1365: /* */
                   1366: /* Returns the first index after the encoded name, or negative on error. */
                   1367: /*      -1      label was > 63 bytes */
                   1368: /*      -2      name too long to fit in buffer. */
                   1369: /* */
                   1370: static off_t
                   1371: dnsname_to_labels(u8 *const buf, size_t buf_len, off_t j,
                   1372:                                  const char *name, const int name_len,
                   1373:                                  struct dnslabel_table *table) {
                   1374:        const char *end = name + name_len;
                   1375:        int ref = 0;
                   1376:        u16 _t;
                   1377: 
                   1378: #define APPEND16(x) do {                                                  \
                   1379:                if (j + 2 > (off_t)buf_len)                                \
                   1380:                        goto overflow;                                             \
                   1381:                _t = htons(x);                                                     \
                   1382:                memcpy(buf + j, &_t, 2);                                   \
                   1383:                j += 2;                                                                    \
                   1384:        } while (0)
                   1385: #define APPEND32(x) do {                                                  \
                   1386:                if (j + 4 > (off_t)buf_len)                                \
                   1387:                        goto overflow;                                             \
                   1388:                _t32 = htonl(x);                                                   \
                   1389:                memcpy(buf + j, &_t32, 4);                                 \
                   1390:                j += 4;                                                                    \
                   1391:        } while (0)
                   1392: 
                   1393:        if (name_len > 255) return -2;
                   1394: 
                   1395:        for (;;) {
                   1396:                const char *const start = name;
                   1397:                if (table && (ref = dnslabel_table_get_pos(table, name)) >= 0) {
                   1398:                        APPEND16(ref | 0xc000);
                   1399:                        return j;
                   1400:                }
                   1401:                name = strchr(name, '.');
                   1402:                if (!name) {
                   1403:                        const unsigned int label_len = end - start;
                   1404:                        if (label_len > 63) return -1;
                   1405:                        if ((size_t)(j+label_len+1) > buf_len) return -2;
                   1406:                        if (table) dnslabel_table_add(table, start, j);
                   1407:                        buf[j++] = label_len;
                   1408: 
                   1409:                        memcpy(buf + j, start, end - start);
                   1410:                        j += end - start;
                   1411:                        break;
                   1412:                } else {
                   1413:                        /* append length of the label. */
                   1414:                        const unsigned int label_len = name - start;
                   1415:                        if (label_len > 63) return -1;
                   1416:                        if ((size_t)(j+label_len+1) > buf_len) return -2;
                   1417:                        if (table) dnslabel_table_add(table, start, j);
                   1418:                        buf[j++] = label_len;
                   1419: 
                   1420:                        memcpy(buf + j, start, name - start);
                   1421:                        j += name - start;
                   1422:                        /* hop over the '.' */
                   1423:                        name++;
                   1424:                }
                   1425:        }
                   1426: 
                   1427:        /* the labels must be terminated by a 0. */
                   1428:        /* It's possible that the name ended in a . */
                   1429:        /* in which case the zero is already there */
                   1430:        if (!j || buf[j-1]) buf[j++] = 0;
                   1431:        return j;
                   1432:  overflow:
                   1433:        return (-2);
                   1434: }
                   1435: 
                   1436: /* Finds the length of a dns request for a DNS name of the given */
                   1437: /* length. The actual request may be smaller than the value returned */
                   1438: /* here */
                   1439: static int
                   1440: evdns_request_len(const int name_len) {
                   1441:        return 96 + /* length of the DNS standard header */
                   1442:                name_len + 2 +
                   1443:                4;  /* space for the resource type */
                   1444: }
                   1445: 
                   1446: /* build a dns request packet into buf. buf should be at least as long */
                   1447: /* as evdns_request_len told you it should be. */
                   1448: /* */
                   1449: /* Returns the amount of space used. Negative on error. */
                   1450: static int
                   1451: evdns_request_data_build(const char *const name, const int name_len,
                   1452:     const u16 trans_id, const u16 type, const u16 class,
                   1453:     u8 *const buf, size_t buf_len) {
                   1454:        off_t j = 0;  /* current offset into buf */
                   1455:        u16 _t;  /* used by the macros */
                   1456: 
                   1457:        APPEND16(trans_id);
                   1458:        APPEND16(0x0100);  /* standard query, recusion needed */
                   1459:        APPEND16(1);  /* one question */
                   1460:        APPEND16(0);  /* no answers */
                   1461:        APPEND16(0);  /* no authority */
                   1462:        APPEND16(0);  /* no additional */
                   1463: 
                   1464:        j = dnsname_to_labels(buf, buf_len, j, name, name_len, NULL);
                   1465:        if (j < 0) {
                   1466:                return (int)j;
                   1467:        }
                   1468:        
                   1469:        APPEND16(type);
                   1470:        APPEND16(class);
                   1471: 
                   1472:        return (int)j;
                   1473:  overflow:
                   1474:        return (-1);
                   1475: }
                   1476: 
                   1477: /* exported function */
                   1478: struct evdns_server_port *
                   1479: evdns_add_server_port(int socket, int is_tcp, evdns_request_callback_fn_type cb, void *user_data)
                   1480: {
                   1481:        struct evdns_server_port *port;
                   1482:        if (!(port = malloc(sizeof(struct evdns_server_port))))
                   1483:                return NULL;
                   1484:        memset(port, 0, sizeof(struct evdns_server_port));
                   1485: 
                   1486:        assert(!is_tcp); /* TCP sockets not yet implemented */
                   1487:        port->socket = socket;
                   1488:        port->refcnt = 1;
                   1489:        port->choked = 0;
                   1490:        port->closing = 0;
                   1491:        port->user_callback = cb;
                   1492:        port->user_data = user_data;
                   1493:        port->pending_replies = NULL;
                   1494: 
                   1495:        event_set(&port->event, port->socket, EV_READ | EV_PERSIST,
                   1496:                          server_port_ready_callback, port);
                   1497:        event_add(&port->event, NULL); /* check return. */
                   1498:        return port;
                   1499: }
                   1500: 
                   1501: /* exported function */
                   1502: void
                   1503: evdns_close_server_port(struct evdns_server_port *port)
                   1504: {
                   1505:        if (--port->refcnt == 0)
                   1506:                server_port_free(port);
                   1507:        port->closing = 1;
                   1508: }
                   1509: 
                   1510: /* exported function */
                   1511: int
                   1512: evdns_server_request_add_reply(struct evdns_server_request *_req, int section, const char *name, int type, int class, int ttl, int datalen, int is_name, const char *data)
                   1513: {
                   1514:        struct server_request *req = TO_SERVER_REQUEST(_req);
                   1515:        struct server_reply_item **itemp, *item;
                   1516:        int *countp;
                   1517: 
                   1518:        if (req->response) /* have we already answered? */
                   1519:                return (-1);
                   1520: 
                   1521:        switch (section) {
                   1522:        case EVDNS_ANSWER_SECTION:
                   1523:                itemp = &req->answer;
                   1524:                countp = &req->n_answer;
                   1525:                break;
                   1526:        case EVDNS_AUTHORITY_SECTION:
                   1527:                itemp = &req->authority;
                   1528:                countp = &req->n_authority;
                   1529:                break;
                   1530:        case EVDNS_ADDITIONAL_SECTION:
                   1531:                itemp = &req->additional;
                   1532:                countp = &req->n_additional;
                   1533:                break;
                   1534:        default:
                   1535:                return (-1);
                   1536:        }
                   1537:        while (*itemp) {
                   1538:                itemp = &((*itemp)->next);
                   1539:        }
                   1540:        item = malloc(sizeof(struct server_reply_item));
                   1541:        if (!item)
                   1542:                return -1;
                   1543:        item->next = NULL;
                   1544:        if (!(item->name = strdup(name))) {
                   1545:                free(item);
                   1546:                return -1;
                   1547:        }
                   1548:        item->type = type;
                   1549:        item->dns_question_class = class;
                   1550:        item->ttl = ttl;
                   1551:        item->is_name = is_name != 0;
                   1552:        item->datalen = 0;
                   1553:        item->data = NULL;
                   1554:        if (data) {
                   1555:                if (item->is_name) {
                   1556:                        if (!(item->data = strdup(data))) {
                   1557:                                free(item->name);
                   1558:                                free(item);
                   1559:                                return -1;
                   1560:                        }
                   1561:                        item->datalen = (u16)-1;
                   1562:                } else {
                   1563:                        if (!(item->data = malloc(datalen))) {
                   1564:                                free(item->name);
                   1565:                                free(item);
                   1566:                                return -1;
                   1567:                        }
                   1568:                        item->datalen = datalen;
                   1569:                        memcpy(item->data, data, datalen);
                   1570:                }
                   1571:        }
                   1572: 
                   1573:        *itemp = item;
                   1574:        ++(*countp);
                   1575:        return 0;
                   1576: }
                   1577: 
                   1578: /* exported function */
                   1579: int
                   1580: evdns_server_request_add_a_reply(struct evdns_server_request *req, const char *name, int n, void *addrs, int ttl)
                   1581: {
                   1582:        return evdns_server_request_add_reply(
                   1583:                  req, EVDNS_ANSWER_SECTION, name, TYPE_A, CLASS_INET,
                   1584:                  ttl, n*4, 0, addrs);
                   1585: }
                   1586: 
                   1587: /* exported function */
                   1588: int
                   1589: evdns_server_request_add_aaaa_reply(struct evdns_server_request *req, const char *name, int n, void *addrs, int ttl)
                   1590: {
                   1591:        return evdns_server_request_add_reply(
                   1592:                  req, EVDNS_ANSWER_SECTION, name, TYPE_AAAA, CLASS_INET,
                   1593:                  ttl, n*16, 0, addrs);
                   1594: }
                   1595: 
                   1596: /* exported function */
                   1597: int
                   1598: evdns_server_request_add_ptr_reply(struct evdns_server_request *req, struct in_addr *in, const char *inaddr_name, const char *hostname, int ttl)
                   1599: {
                   1600:        u32 a;
                   1601:        char buf[32];
                   1602:        assert(in || inaddr_name);
                   1603:        assert(!(in && inaddr_name));
                   1604:        if (in) {
                   1605:                a = ntohl(in->s_addr);
                   1606:                evutil_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa",
                   1607:                                (int)(u8)((a    )&0xff),
                   1608:                                (int)(u8)((a>>8 )&0xff),
                   1609:                                (int)(u8)((a>>16)&0xff),
                   1610:                                (int)(u8)((a>>24)&0xff));
                   1611:                inaddr_name = buf;
                   1612:        }
                   1613:        return evdns_server_request_add_reply(
                   1614:                  req, EVDNS_ANSWER_SECTION, inaddr_name, TYPE_PTR, CLASS_INET,
                   1615:                  ttl, -1, 1, hostname);
                   1616: }
                   1617: 
                   1618: /* exported function */
                   1619: int
                   1620: evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char *cname, int ttl)
                   1621: {
                   1622:        return evdns_server_request_add_reply(
                   1623:                  req, EVDNS_ANSWER_SECTION, name, TYPE_CNAME, CLASS_INET,
                   1624:                  ttl, -1, 1, cname);
                   1625: }
                   1626: 
                   1627: 
                   1628: static int
                   1629: evdns_server_request_format_response(struct server_request *req, int err)
                   1630: {
                   1631:        unsigned char buf[1500];
                   1632:        size_t buf_len = sizeof(buf);
                   1633:        off_t j = 0, r;
                   1634:        u16 _t;
                   1635:        u32 _t32;
                   1636:        int i;
                   1637:        u16 flags;
                   1638:        struct dnslabel_table table;
                   1639: 
                   1640:        if (err < 0 || err > 15) return -1;
                   1641: 
                   1642:        /* Set response bit and error code; copy OPCODE and RD fields from
                   1643:         * question; copy RA and AA if set by caller. */
                   1644:        flags = req->base.flags;
                   1645:        flags |= (0x8000 | err);
                   1646: 
                   1647:        dnslabel_table_init(&table);
                   1648:        APPEND16(req->trans_id);
                   1649:        APPEND16(flags);
                   1650:        APPEND16(req->base.nquestions);
                   1651:        APPEND16(req->n_answer);
                   1652:        APPEND16(req->n_authority);
                   1653:        APPEND16(req->n_additional);
                   1654: 
                   1655:        /* Add questions. */
                   1656:        for (i=0; i < req->base.nquestions; ++i) {
                   1657:                const char *s = req->base.questions[i]->name;
                   1658:                j = dnsname_to_labels(buf, buf_len, j, s, strlen(s), &table);
                   1659:                if (j < 0) {
                   1660:                        dnslabel_clear(&table);
                   1661:                        return (int) j;
                   1662:                }
                   1663:                APPEND16(req->base.questions[i]->type);
                   1664:                APPEND16(req->base.questions[i]->dns_question_class);
                   1665:        }
                   1666: 
                   1667:        /* Add answer, authority, and additional sections. */
                   1668:        for (i=0; i<3; ++i) {
                   1669:                struct server_reply_item *item;
                   1670:                if (i==0)
                   1671:                        item = req->answer;
                   1672:                else if (i==1)
                   1673:                        item = req->authority;
                   1674:                else
                   1675:                        item = req->additional;
                   1676:                while (item) {
                   1677:                        r = dnsname_to_labels(buf, buf_len, j, item->name, strlen(item->name), &table);
                   1678:                        if (r < 0)
                   1679:                                goto overflow;
                   1680:                        j = r;
                   1681: 
                   1682:                        APPEND16(item->type);
                   1683:                        APPEND16(item->dns_question_class);
                   1684:                        APPEND32(item->ttl);
                   1685:                        if (item->is_name) {
                   1686:                                off_t len_idx = j, name_start;
                   1687:                                j += 2;
                   1688:                                name_start = j;
                   1689:                                r = dnsname_to_labels(buf, buf_len, j, item->data, strlen(item->data), &table);
                   1690:                                if (r < 0)
                   1691:                                        goto overflow;
                   1692:                                j = r;
                   1693:                                _t = htons( (short) (j-name_start) );
                   1694:                                memcpy(buf+len_idx, &_t, 2);
                   1695:                        } else {
                   1696:                                APPEND16(item->datalen);
                   1697:                                if (j+item->datalen > (off_t)buf_len)
                   1698:                                        goto overflow;
                   1699:                                memcpy(buf+j, item->data, item->datalen);
                   1700:                                j += item->datalen;
                   1701:                        }
                   1702:                        item = item->next;
                   1703:                }
                   1704:        }
                   1705: 
                   1706:        if (j > 512) {
                   1707: overflow:
                   1708:                j = 512;
                   1709:                buf[2] |= 0x02; /* set the truncated bit. */
                   1710:        }
                   1711: 
                   1712:        req->response_len = j;
                   1713: 
                   1714:        if (!(req->response = malloc(req->response_len))) {
                   1715:                server_request_free_answers(req);
                   1716:                dnslabel_clear(&table);
                   1717:                return (-1);
                   1718:        }
                   1719:        memcpy(req->response, buf, req->response_len);
                   1720:        server_request_free_answers(req);
                   1721:        dnslabel_clear(&table);
                   1722:        return (0);
                   1723: }
                   1724: 
                   1725: /* exported function */
                   1726: int
                   1727: evdns_server_request_respond(struct evdns_server_request *_req, int err)
                   1728: {
                   1729:        struct server_request *req = TO_SERVER_REQUEST(_req);
                   1730:        struct evdns_server_port *port = req->port;
                   1731:        int r;
                   1732:        if (!req->response) {
                   1733:                if ((r = evdns_server_request_format_response(req, err))<0)
                   1734:                        return r;
                   1735:        }
                   1736: 
                   1737:        r = sendto(port->socket, req->response, req->response_len, 0,
                   1738:                           (struct sockaddr*) &req->addr, req->addrlen);
                   1739:        if (r<0) {
                   1740:                int sock_err = last_error(port->socket);
                   1741:                if (! error_is_eagain(sock_err))
                   1742:                        return -1;
                   1743: 
                   1744:                if (port->pending_replies) {
                   1745:                        req->prev_pending = port->pending_replies->prev_pending;
                   1746:                        req->next_pending = port->pending_replies;
                   1747:                        req->prev_pending->next_pending =
                   1748:                                req->next_pending->prev_pending = req;
                   1749:                } else {
                   1750:                        req->prev_pending = req->next_pending = req;
                   1751:                        port->pending_replies = req;
                   1752:                        port->choked = 1;
                   1753: 
                   1754:                        (void) event_del(&port->event);
                   1755:                        event_set(&port->event, port->socket, (port->closing?0:EV_READ) | EV_WRITE | EV_PERSIST, server_port_ready_callback, port);
                   1756: 
                   1757:                        if (event_add(&port->event, NULL) < 0) {
                   1758:                                log(EVDNS_LOG_WARN, "Error from libevent when adding event for DNS server");
                   1759:                        }
                   1760: 
                   1761:                }
                   1762: 
                   1763:                return 1;
                   1764:        }
                   1765:        if (server_request_free(req))
                   1766:                return 0;
                   1767: 
                   1768:        if (port->pending_replies)
                   1769:                server_port_flush(port);
                   1770: 
                   1771:        return 0;
                   1772: }
                   1773: 
                   1774: /* Free all storage held by RRs in req. */
                   1775: static void
                   1776: server_request_free_answers(struct server_request *req)
                   1777: {
                   1778:        struct server_reply_item *victim, *next, **list;
                   1779:        int i;
                   1780:        for (i = 0; i < 3; ++i) {
                   1781:                if (i==0)
                   1782:                        list = &req->answer;
                   1783:                else if (i==1)
                   1784:                        list = &req->authority;
                   1785:                else
                   1786:                        list = &req->additional;
                   1787: 
                   1788:                victim = *list;
                   1789:                while (victim) {
                   1790:                        next = victim->next;
                   1791:                        free(victim->name);
                   1792:                        if (victim->data)
                   1793:                                free(victim->data);
                   1794:                        free(victim);
                   1795:                        victim = next;
                   1796:                }
                   1797:                *list = NULL;
                   1798:        }
                   1799: }
                   1800: 
                   1801: /* Free all storage held by req, and remove links to it. */
                   1802: /* return true iff we just wound up freeing the server_port. */
                   1803: static int
                   1804: server_request_free(struct server_request *req)
                   1805: {
                   1806:        int i, rc=1;
                   1807:        if (req->base.questions) {
                   1808:                for (i = 0; i < req->base.nquestions; ++i)
                   1809:                        free(req->base.questions[i]);
                   1810:                free(req->base.questions);
                   1811:        }
                   1812: 
                   1813:        if (req->port) {
                   1814:                if (req->port->pending_replies == req) {
                   1815:                        if (req->next_pending)
                   1816:                                req->port->pending_replies = req->next_pending;
                   1817:                        else
                   1818:                                req->port->pending_replies = NULL;
                   1819:                }
                   1820:                rc = --req->port->refcnt;
                   1821:        }
                   1822: 
                   1823:        if (req->response) {
                   1824:                free(req->response);
                   1825:        }
                   1826: 
                   1827:        server_request_free_answers(req);
                   1828: 
                   1829:        if (req->next_pending && req->next_pending != req) {
                   1830:                req->next_pending->prev_pending = req->prev_pending;
                   1831:                req->prev_pending->next_pending = req->next_pending;
                   1832:        }
                   1833: 
                   1834:        if (rc == 0) {
                   1835:                server_port_free(req->port);
                   1836:                free(req);
                   1837:                return (1);
                   1838:        }
                   1839:        free(req);
                   1840:        return (0);
                   1841: }
                   1842: 
                   1843: /* Free all storage held by an evdns_server_port.  Only called when  */
                   1844: static void
                   1845: server_port_free(struct evdns_server_port *port)
                   1846: {
                   1847:        assert(port);
                   1848:        assert(!port->refcnt);
                   1849:        assert(!port->pending_replies);
                   1850:        if (port->socket > 0) {
                   1851:                CLOSE_SOCKET(port->socket);
                   1852:                port->socket = -1;
                   1853:        }
                   1854:        (void) event_del(&port->event);
                   1855:        /* XXXX actually free the port? -NM */
                   1856: }
                   1857: 
                   1858: /* exported function */
                   1859: int
                   1860: evdns_server_request_drop(struct evdns_server_request *_req)
                   1861: {
                   1862:        struct server_request *req = TO_SERVER_REQUEST(_req);
                   1863:        server_request_free(req);
                   1864:        return 0;
                   1865: }
                   1866: 
                   1867: /* exported function */
                   1868: int
                   1869: evdns_server_request_get_requesting_addr(struct evdns_server_request *_req, struct sockaddr *sa, int addr_len)
                   1870: {
                   1871:        struct server_request *req = TO_SERVER_REQUEST(_req);
                   1872:        if (addr_len < (int)req->addrlen)
                   1873:                return -1;
                   1874:        memcpy(sa, &(req->addr), req->addrlen);
                   1875:        return req->addrlen;
                   1876: }
                   1877: 
                   1878: #undef APPEND16
                   1879: #undef APPEND32
                   1880: 
                   1881: /* this is a libevent callback function which is called when a request */
                   1882: /* has timed out. */
                   1883: static void
                   1884: evdns_request_timeout_callback(int fd, short events, void *arg) {
                   1885:        struct request *const req = (struct request *) arg;
                   1886:         (void) fd;
                   1887:         (void) events;
                   1888: 
                   1889:        log(EVDNS_LOG_DEBUG, "Request %lx timed out", (unsigned long) arg);
                   1890: 
                   1891:        req->ns->timedout++;
                   1892:        if (req->ns->timedout > global_max_nameserver_timeout) {
                   1893:                req->ns->timedout = 0;
                   1894:                nameserver_failed(req->ns, "request timed out.");
                   1895:        }
                   1896: 
                   1897:        (void) evtimer_del(&req->timeout_event);
                   1898:        if (req->tx_count >= global_max_retransmits) {
                   1899:                /* this request has failed */
                   1900:                reply_callback(req, 0, DNS_ERR_TIMEOUT, NULL);
                   1901:                request_finished(req, &req_head);
                   1902:        } else {
                   1903:                /* retransmit it */
                   1904:                evdns_request_transmit(req);
                   1905:        }
                   1906: }
                   1907: 
                   1908: /* try to send a request to a given server. */
                   1909: /* */
                   1910: /* return: */
                   1911: /*   0 ok */
                   1912: /*   1 temporary failure */
                   1913: /*   2 other failure */
                   1914: static int
                   1915: evdns_request_transmit_to(struct request *req, struct nameserver *server) {
                   1916:        struct sockaddr_in sin;
                   1917:        int r;
                   1918:        memset(&sin, 0, sizeof(sin));
                   1919:        sin.sin_addr.s_addr = req->ns->address;
                   1920:        sin.sin_port = req->ns->port;
                   1921:        sin.sin_family = AF_INET;
                   1922: 
                   1923:        r = sendto(server->socket, req->request, req->request_len, 0,
                   1924:            (struct sockaddr*)&sin, sizeof(sin));
                   1925:        if (r < 0) {
                   1926:                int err = last_error(server->socket);
                   1927:                if (error_is_eagain(err)) return 1;
                   1928:                nameserver_failed(req->ns, strerror(err));
                   1929:                return 2;
                   1930:        } else if (r != (int)req->request_len) {
                   1931:                return 1;  /* short write */
                   1932:        } else {
                   1933:                return 0;
                   1934:        }
                   1935: }
                   1936: 
                   1937: /* try to send a request, updating the fields of the request */
                   1938: /* as needed */
                   1939: /* */
                   1940: /* return: */
                   1941: /*   0 ok */
                   1942: /*   1 failed */
                   1943: static int
                   1944: evdns_request_transmit(struct request *req) {
                   1945:        int retcode = 0, r;
                   1946: 
                   1947:        /* if we fail to send this packet then this flag marks it */
                   1948:        /* for evdns_transmit */
                   1949:        req->transmit_me = 1;
                   1950:        if (req->trans_id == 0xffff) abort();
                   1951: 
                   1952:        if (req->ns->choked) {
                   1953:                /* don't bother trying to write to a socket */
                   1954:                /* which we have had EAGAIN from */
                   1955:                return 1;
                   1956:        }
                   1957: 
                   1958:        r = evdns_request_transmit_to(req, req->ns);
                   1959:        switch (r) {
                   1960:        case 1:
                   1961:                /* temp failure */
                   1962:                req->ns->choked = 1;
                   1963:                nameserver_write_waiting(req->ns, 1);
                   1964:                return 1;
                   1965:        case 2:
                   1966:                /* failed in some other way */
                   1967:                retcode = 1;
                   1968:                /* fall through */
                   1969:        default:
                   1970:                /* all ok */
                   1971:                log(EVDNS_LOG_DEBUG,
                   1972:                    "Setting timeout for request %lx", (unsigned long) req);
                   1973:                if (evtimer_add(&req->timeout_event, &global_timeout) < 0) {
                   1974:                   log(EVDNS_LOG_WARN,
                   1975:                      "Error from libevent when adding timer for request %lx",
                   1976:                       (unsigned long) req);
                   1977:                   /* ???? Do more? */
                   1978:                 }
                   1979:                req->tx_count++;
                   1980:                req->transmit_me = 0;
                   1981:                return retcode;
                   1982:        }
                   1983: }
                   1984: 
                   1985: static void
                   1986: nameserver_probe_callback(int result, char type, int count, int ttl, void *addresses, void *arg) {
                   1987:        struct nameserver *const ns = (struct nameserver *) arg;
                   1988:         (void) type;
                   1989:         (void) count;
                   1990:         (void) ttl;
                   1991:         (void) addresses;
                   1992: 
                   1993:        if (result == DNS_ERR_NONE || result == DNS_ERR_NOTEXIST) {
                   1994:                /* this is a good reply */
                   1995:                nameserver_up(ns);
                   1996:        } else nameserver_probe_failed(ns);
                   1997: }
                   1998: 
                   1999: static void
                   2000: nameserver_send_probe(struct nameserver *const ns) {
                   2001:        struct request *req;
                   2002:        /* here we need to send a probe to a given nameserver */
                   2003:        /* in the hope that it is up now. */
                   2004: 
                   2005:        log(EVDNS_LOG_DEBUG, "Sending probe to %s", debug_ntoa(ns->address));
                   2006: 
                   2007:        req = request_new(TYPE_A, "www.google.com", DNS_QUERY_NO_SEARCH, nameserver_probe_callback, ns);
                   2008:         if (!req) return;
                   2009:        /* we force this into the inflight queue no matter what */
                   2010:        request_trans_id_set(req, transaction_id_pick());
                   2011:        req->ns = ns;
                   2012:        request_submit(req);
                   2013: }
                   2014: 
                   2015: /* returns: */
                   2016: /*   0 didn't try to transmit anything */
                   2017: /*   1 tried to transmit something */
                   2018: static int
                   2019: evdns_transmit(void) {
                   2020:        char did_try_to_transmit = 0;
                   2021: 
                   2022:        if (req_head) {
                   2023:                struct request *const started_at = req_head, *req = req_head;
                   2024:                /* first transmit all the requests which are currently waiting */
                   2025:                do {
                   2026:                        if (req->transmit_me) {
                   2027:                                did_try_to_transmit = 1;
                   2028:                                evdns_request_transmit(req);
                   2029:                        }
                   2030: 
                   2031:                        req = req->next;
                   2032:                } while (req != started_at);
                   2033:        }
                   2034: 
                   2035:        return did_try_to_transmit;
                   2036: }
                   2037: 
                   2038: /* exported function */
                   2039: int
                   2040: evdns_count_nameservers(void)
                   2041: {
                   2042:        const struct nameserver *server = server_head;
                   2043:        int n = 0;
                   2044:        if (!server)
                   2045:                return 0;
                   2046:        do {
                   2047:                ++n;
                   2048:                server = server->next;
                   2049:        } while (server != server_head);
                   2050:        return n;
                   2051: }
                   2052: 
                   2053: /* exported function */
                   2054: int
                   2055: evdns_clear_nameservers_and_suspend(void)
                   2056: {
                   2057:        struct nameserver *server = server_head, *started_at = server_head;
                   2058:        struct request *req = req_head, *req_started_at = req_head;
                   2059: 
                   2060:        if (!server)
                   2061:                return 0;
                   2062:        while (1) {
                   2063:                struct nameserver *next = server->next;
                   2064:                (void) event_del(&server->event);
                   2065:                if (evtimer_initialized(&server->timeout_event))
                   2066:                        (void) evtimer_del(&server->timeout_event);
                   2067:                if (server->socket >= 0)
                   2068:                        CLOSE_SOCKET(server->socket);
                   2069:                free(server);
                   2070:                if (next == started_at)
                   2071:                        break;
                   2072:                server = next;
                   2073:        }
                   2074:        server_head = NULL;
                   2075:        global_good_nameservers = 0;
                   2076: 
                   2077:        while (req) {
                   2078:                struct request *next = req->next;
                   2079:                req->tx_count = req->reissue_count = 0;
                   2080:                req->ns = NULL;
                   2081:                /* ???? What to do about searches? */
                   2082:                (void) evtimer_del(&req->timeout_event);
                   2083:                req->trans_id = 0;
                   2084:                req->transmit_me = 0;
                   2085: 
                   2086:                global_requests_waiting++;
                   2087:                evdns_request_insert(req, &req_waiting_head);
                   2088:                /* We want to insert these suspended elements at the front of
                   2089:                 * the waiting queue, since they were pending before any of
                   2090:                 * the waiting entries were added.  This is a circular list,
                   2091:                 * so we can just shift the start back by one.*/
                   2092:                req_waiting_head = req_waiting_head->prev;
                   2093: 
                   2094:                if (next == req_started_at)
                   2095:                        break;
                   2096:                req = next;
                   2097:        }
                   2098:        req_head = NULL;
                   2099:        global_requests_inflight = 0;
                   2100: 
                   2101:        return 0;
                   2102: }
                   2103: 
                   2104: 
                   2105: /* exported function */
                   2106: int
                   2107: evdns_resume(void)
                   2108: {
                   2109:        evdns_requests_pump_waiting_queue();
                   2110:        return 0;
                   2111: }
                   2112: 
                   2113: static int
                   2114: _evdns_nameserver_add_impl(unsigned long int address, int port) {
                   2115:        /* first check to see if we already have this nameserver */
                   2116: 
                   2117:        const struct nameserver *server = server_head, *const started_at = server_head;
                   2118:        struct nameserver *ns;
                   2119:        int err = 0;
                   2120:        if (server) {
                   2121:                do {
                   2122:                        if (server->address == address) return 3;
                   2123:                        server = server->next;
                   2124:                } while (server != started_at);
                   2125:        }
                   2126: 
                   2127:        ns = (struct nameserver *) malloc(sizeof(struct nameserver));
                   2128:         if (!ns) return -1;
                   2129: 
                   2130:        memset(ns, 0, sizeof(struct nameserver));
                   2131: 
                   2132:        evtimer_set(&ns->timeout_event, nameserver_prod_callback, ns);
                   2133: 
                   2134:        ns->socket = socket(PF_INET, SOCK_DGRAM, 0);
                   2135:        if (ns->socket < 0) { err = 1; goto out1; }
1.1.1.1.2.1! misho    2136:        FD_CLOSEONEXEC(ns->socket);
        !          2137:        evutil_make_socket_nonblocking(ns->socket);
1.1       misho    2138: 
                   2139:        ns->address = address;
                   2140:        ns->port = htons(port);
                   2141:        ns->state = 1;
                   2142:        event_set(&ns->event, ns->socket, EV_READ | EV_PERSIST, nameserver_ready_callback, ns);
                   2143:        if (event_add(&ns->event, NULL) < 0) {
                   2144:           err = 2;
                   2145:           goto out2;
                   2146:         }
                   2147: 
                   2148:        log(EVDNS_LOG_DEBUG, "Added nameserver %s", debug_ntoa(address));
                   2149: 
                   2150:        /* insert this nameserver into the list of them */
                   2151:        if (!server_head) {
                   2152:                ns->next = ns->prev = ns;
                   2153:                server_head = ns;
                   2154:        } else {
                   2155:                ns->next = server_head->next;
                   2156:                ns->prev = server_head;
                   2157:                server_head->next = ns;
                   2158:                if (server_head->prev == server_head) {
                   2159:                        server_head->prev = ns;
                   2160:                }
                   2161:        }
                   2162: 
                   2163:        global_good_nameservers++;
                   2164: 
                   2165:        return 0;
                   2166: 
                   2167: out2:
                   2168:        CLOSE_SOCKET(ns->socket);
                   2169: out1:
                   2170:        free(ns);
                   2171:        log(EVDNS_LOG_WARN, "Unable to add nameserver %s: error %d", debug_ntoa(address), err);
                   2172:        return err;
                   2173: }
                   2174: 
                   2175: /* exported function */
                   2176: int
                   2177: evdns_nameserver_add(unsigned long int address) {
                   2178:        return _evdns_nameserver_add_impl(address, 53);
                   2179: }
                   2180: 
                   2181: /* exported function */
                   2182: int
                   2183: evdns_nameserver_ip_add(const char *ip_as_string) {
                   2184:        struct in_addr ina;
                   2185:        int port;
                   2186:        char buf[20];
                   2187:        const char *cp;
                   2188:        cp = strchr(ip_as_string, ':');
                   2189:        if (! cp) {
                   2190:                cp = ip_as_string;
                   2191:                port = 53;
                   2192:        } else {
                   2193:                port = strtoint(cp+1);
                   2194:                if (port < 0 || port > 65535) {
                   2195:                        return 4;
                   2196:                }
                   2197:                if ((cp-ip_as_string) >= (int)sizeof(buf)) {
                   2198:                        return 4;
                   2199:                }
                   2200:                memcpy(buf, ip_as_string, cp-ip_as_string);
                   2201:                buf[cp-ip_as_string] = '\0';
                   2202:                cp = buf;
                   2203:        }
                   2204:        if (!inet_aton(cp, &ina)) {
                   2205:                return 4;
                   2206:        }
                   2207:        return _evdns_nameserver_add_impl(ina.s_addr, port);
                   2208: }
                   2209: 
                   2210: /* insert into the tail of the queue */
                   2211: static void
                   2212: evdns_request_insert(struct request *req, struct request **head) {
                   2213:        if (!*head) {
                   2214:                *head = req;
                   2215:                req->next = req->prev = req;
                   2216:                return;
                   2217:        }
                   2218: 
                   2219:        req->prev = (*head)->prev;
                   2220:        req->prev->next = req;
                   2221:        req->next = *head;
                   2222:        (*head)->prev = req;
                   2223: }
                   2224: 
                   2225: static int
                   2226: string_num_dots(const char *s) {
                   2227:        int count = 0;
                   2228:        while ((s = strchr(s, '.'))) {
                   2229:                s++;
                   2230:                count++;
                   2231:        }
                   2232:        return count;
                   2233: }
                   2234: 
                   2235: static struct request *
                   2236: request_new(int type, const char *name, int flags,
                   2237:     evdns_callback_type callback, void *user_ptr) {
                   2238:        const char issuing_now =
                   2239:            (global_requests_inflight < global_max_requests_inflight) ? 1 : 0;
                   2240: 
                   2241:        const int name_len = strlen(name);
                   2242:        const int request_max_len = evdns_request_len(name_len);
                   2243:        const u16 trans_id = issuing_now ? transaction_id_pick() : 0xffff;
                   2244:        /* the request data is alloced in a single block with the header */
                   2245:        struct request *const req =
                   2246:            (struct request *) malloc(sizeof(struct request) + request_max_len);
                   2247:        int rlen;
                   2248:         (void) flags;
                   2249: 
                   2250:         if (!req) return NULL;
                   2251:        memset(req, 0, sizeof(struct request));
                   2252: 
                   2253:        evtimer_set(&req->timeout_event, evdns_request_timeout_callback, req);
                   2254: 
                   2255:        /* request data lives just after the header */
                   2256:        req->request = ((u8 *) req) + sizeof(struct request);
                   2257:        /* denotes that the request data shouldn't be free()ed */
                   2258:        req->request_appended = 1;
                   2259:        rlen = evdns_request_data_build(name, name_len, trans_id,
                   2260:            type, CLASS_INET, req->request, request_max_len);
                   2261:        if (rlen < 0)
                   2262:                goto err1;
                   2263:        req->request_len = rlen;
                   2264:        req->trans_id = trans_id;
                   2265:        req->tx_count = 0;
                   2266:        req->request_type = type;
                   2267:        req->user_pointer = user_ptr;
                   2268:        req->user_callback = callback;
                   2269:        req->ns = issuing_now ? nameserver_pick() : NULL;
                   2270:        req->next = req->prev = NULL;
                   2271: 
                   2272:        return req;
                   2273: err1:
                   2274:        free(req);
                   2275:        return NULL;
                   2276: }
                   2277: 
                   2278: static void
                   2279: request_submit(struct request *const req) {
                   2280:        if (req->ns) {
                   2281:                /* if it has a nameserver assigned then this is going */
                   2282:                /* straight into the inflight queue */
                   2283:                evdns_request_insert(req, &req_head);
                   2284:                global_requests_inflight++;
                   2285:                evdns_request_transmit(req);
                   2286:        } else {
                   2287:                evdns_request_insert(req, &req_waiting_head);
                   2288:                global_requests_waiting++;
                   2289:        }
                   2290: }
                   2291: 
                   2292: /* exported function */
                   2293: int evdns_resolve_ipv4(const char *name, int flags,
                   2294:     evdns_callback_type callback, void *ptr) {
                   2295:        log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
                   2296:        if (flags & DNS_QUERY_NO_SEARCH) {
                   2297:                struct request *const req =
                   2298:                        request_new(TYPE_A, name, flags, callback, ptr);
                   2299:                if (req == NULL)
                   2300:                        return (1);
                   2301:                request_submit(req);
                   2302:                return (0);
                   2303:        } else {
                   2304:                return (search_request_new(TYPE_A, name, flags, callback, ptr));
                   2305:        }
                   2306: }
                   2307: 
                   2308: /* exported function */
                   2309: int evdns_resolve_ipv6(const char *name, int flags,
                   2310:                                           evdns_callback_type callback, void *ptr) {
                   2311:        log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
                   2312:        if (flags & DNS_QUERY_NO_SEARCH) {
                   2313:                struct request *const req =
                   2314:                        request_new(TYPE_AAAA, name, flags, callback, ptr);
                   2315:                if (req == NULL)
                   2316:                        return (1);
                   2317:                request_submit(req);
                   2318:                return (0);
                   2319:        } else {
                   2320:                return (search_request_new(TYPE_AAAA, name, flags, callback, ptr));
                   2321:        }
                   2322: }
                   2323: 
                   2324: int evdns_resolve_reverse(const struct in_addr *in, int flags, evdns_callback_type callback, void *ptr) {
                   2325:        char buf[32];
                   2326:        struct request *req;
                   2327:        u32 a;
                   2328:        assert(in);
                   2329:        a = ntohl(in->s_addr);
                   2330:        evutil_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa",
                   2331:                        (int)(u8)((a    )&0xff),
                   2332:                        (int)(u8)((a>>8 )&0xff),
                   2333:                        (int)(u8)((a>>16)&0xff),
                   2334:                        (int)(u8)((a>>24)&0xff));
                   2335:        log(EVDNS_LOG_DEBUG, "Resolve requested for %s (reverse)", buf);
                   2336:        req = request_new(TYPE_PTR, buf, flags, callback, ptr);
                   2337:        if (!req) return 1;
                   2338:        request_submit(req);
                   2339:        return 0;
                   2340: }
                   2341: 
                   2342: int evdns_resolve_reverse_ipv6(const struct in6_addr *in, int flags, evdns_callback_type callback, void *ptr) {
                   2343:        /* 32 nybbles, 32 periods, "ip6.arpa", NUL. */
                   2344:        char buf[73];
                   2345:        char *cp;
                   2346:        struct request *req;
                   2347:        int i;
                   2348:        assert(in);
                   2349:        cp = buf;
                   2350:        for (i=15; i >= 0; --i) {
                   2351:                u8 byte = in->s6_addr[i];
                   2352:                *cp++ = "0123456789abcdef"[byte & 0x0f];
                   2353:                *cp++ = '.';
                   2354:                *cp++ = "0123456789abcdef"[byte >> 4];
                   2355:                *cp++ = '.';
                   2356:        }
                   2357:        assert(cp + strlen("ip6.arpa") < buf+sizeof(buf));
                   2358:        memcpy(cp, "ip6.arpa", strlen("ip6.arpa")+1);
                   2359:        log(EVDNS_LOG_DEBUG, "Resolve requested for %s (reverse)", buf);
                   2360:        req = request_new(TYPE_PTR, buf, flags, callback, ptr);
                   2361:        if (!req) return 1;
                   2362:        request_submit(req);
                   2363:        return 0;
                   2364: }
                   2365: 
                   2366: /*/////////////////////////////////////////////////////////////////// */
                   2367: /* Search support */
                   2368: /* */
                   2369: /* the libc resolver has support for searching a number of domains */
                   2370: /* to find a name. If nothing else then it takes the single domain */
                   2371: /* from the gethostname() call. */
                   2372: /* */
                   2373: /* It can also be configured via the domain and search options in a */
                   2374: /* resolv.conf. */
                   2375: /* */
                   2376: /* The ndots option controls how many dots it takes for the resolver */
                   2377: /* to decide that a name is non-local and so try a raw lookup first. */
                   2378: 
                   2379: struct search_domain {
                   2380:        int len;
                   2381:        struct search_domain *next;
                   2382:        /* the text string is appended to this structure */
                   2383: };
                   2384: 
                   2385: struct search_state {
                   2386:        int refcount;
                   2387:        int ndots;
                   2388:        int num_domains;
                   2389:        struct search_domain *head;
                   2390: };
                   2391: 
                   2392: static struct search_state *global_search_state = NULL;
                   2393: 
                   2394: static void
                   2395: search_state_decref(struct search_state *const state) {
                   2396:        if (!state) return;
                   2397:        state->refcount--;
                   2398:        if (!state->refcount) {
                   2399:                struct search_domain *next, *dom;
                   2400:                for (dom = state->head; dom; dom = next) {
                   2401:                        next = dom->next;
                   2402:                        free(dom);
                   2403:                }
                   2404:                free(state);
                   2405:        }
                   2406: }
                   2407: 
                   2408: static struct search_state *
                   2409: search_state_new(void) {
                   2410:        struct search_state *state = (struct search_state *) malloc(sizeof(struct search_state));
                   2411:         if (!state) return NULL;
                   2412:        memset(state, 0, sizeof(struct search_state));
                   2413:        state->refcount = 1;
                   2414:        state->ndots = 1;
                   2415: 
                   2416:        return state;
                   2417: }
                   2418: 
                   2419: static void
                   2420: search_postfix_clear(void) {
                   2421:        search_state_decref(global_search_state);
                   2422: 
                   2423:        global_search_state = search_state_new();
                   2424: }
                   2425: 
                   2426: /* exported function */
                   2427: void
                   2428: evdns_search_clear(void) {
                   2429:        search_postfix_clear();
                   2430: }
                   2431: 
                   2432: static void
                   2433: search_postfix_add(const char *domain) {
                   2434:        int domain_len;
                   2435:        struct search_domain *sdomain;
                   2436:        while (domain[0] == '.') domain++;
                   2437:        domain_len = strlen(domain);
                   2438: 
                   2439:        if (!global_search_state) global_search_state = search_state_new();
                   2440:         if (!global_search_state) return;
                   2441:        global_search_state->num_domains++;
                   2442: 
                   2443:        sdomain = (struct search_domain *) malloc(sizeof(struct search_domain) + domain_len);
                   2444:         if (!sdomain) return;
                   2445:        memcpy( ((u8 *) sdomain) + sizeof(struct search_domain), domain, domain_len);
                   2446:        sdomain->next = global_search_state->head;
                   2447:        sdomain->len = domain_len;
                   2448: 
                   2449:        global_search_state->head = sdomain;
                   2450: }
                   2451: 
                   2452: /* reverse the order of members in the postfix list. This is needed because, */
                   2453: /* when parsing resolv.conf we push elements in the wrong order */
                   2454: static void
                   2455: search_reverse(void) {
                   2456:        struct search_domain *cur, *prev = NULL, *next;
                   2457:        cur = global_search_state->head;
                   2458:        while (cur) {
                   2459:                next = cur->next;
                   2460:                cur->next = prev;
                   2461:                prev = cur;
                   2462:                cur = next;
                   2463:        }
                   2464: 
                   2465:        global_search_state->head = prev;
                   2466: }
                   2467: 
                   2468: /* exported function */
                   2469: void
                   2470: evdns_search_add(const char *domain) {
                   2471:        search_postfix_add(domain);
                   2472: }
                   2473: 
                   2474: /* exported function */
                   2475: void
                   2476: evdns_search_ndots_set(const int ndots) {
                   2477:        if (!global_search_state) global_search_state = search_state_new();
                   2478:         if (!global_search_state) return;
                   2479:        global_search_state->ndots = ndots;
                   2480: }
                   2481: 
                   2482: static void
                   2483: search_set_from_hostname(void) {
                   2484:        char hostname[HOST_NAME_MAX + 1], *domainname;
                   2485: 
                   2486:        search_postfix_clear();
                   2487:        if (gethostname(hostname, sizeof(hostname))) return;
                   2488:        domainname = strchr(hostname, '.');
                   2489:        if (!domainname) return;
                   2490:        search_postfix_add(domainname);
                   2491: }
                   2492: 
                   2493: /* warning: returns malloced string */
                   2494: static char *
                   2495: search_make_new(const struct search_state *const state, int n, const char *const base_name) {
                   2496:        const int base_len = strlen(base_name);
                   2497:        const char need_to_append_dot = base_name[base_len - 1] == '.' ? 0 : 1;
                   2498:        struct search_domain *dom;
                   2499: 
                   2500:        for (dom = state->head; dom; dom = dom->next) {
                   2501:                if (!n--) {
                   2502:                        /* this is the postfix we want */
                   2503:                        /* the actual postfix string is kept at the end of the structure */
                   2504:                        const u8 *const postfix = ((u8 *) dom) + sizeof(struct search_domain);
                   2505:                        const int postfix_len = dom->len;
                   2506:                        char *const newname = (char *) malloc(base_len + need_to_append_dot + postfix_len + 1);
                   2507:                         if (!newname) return NULL;
                   2508:                        memcpy(newname, base_name, base_len);
                   2509:                        if (need_to_append_dot) newname[base_len] = '.';
                   2510:                        memcpy(newname + base_len + need_to_append_dot, postfix, postfix_len);
                   2511:                        newname[base_len + need_to_append_dot + postfix_len] = 0;
                   2512:                        return newname;
                   2513:                }
                   2514:        }
                   2515: 
                   2516:        /* we ran off the end of the list and still didn't find the requested string */
                   2517:        abort();
                   2518:        return NULL; /* unreachable; stops warnings in some compilers. */
                   2519: }
                   2520: 
                   2521: static int
                   2522: search_request_new(int type, const char *const name, int flags, evdns_callback_type user_callback, void *user_arg) {
                   2523:        assert(type == TYPE_A || type == TYPE_AAAA);
                   2524:        if ( ((flags & DNS_QUERY_NO_SEARCH) == 0) &&
                   2525:             global_search_state &&
                   2526:                 global_search_state->num_domains) {
                   2527:                /* we have some domains to search */
                   2528:                struct request *req;
                   2529:                if (string_num_dots(name) >= global_search_state->ndots) {
                   2530:                        req = request_new(type, name, flags, user_callback, user_arg);
                   2531:                        if (!req) return 1;
                   2532:                        req->search_index = -1;
                   2533:                } else {
                   2534:                        char *const new_name = search_make_new(global_search_state, 0, name);
                   2535:                         if (!new_name) return 1;
                   2536:                        req = request_new(type, new_name, flags, user_callback, user_arg);
                   2537:                        free(new_name);
                   2538:                        if (!req) return 1;
                   2539:                        req->search_index = 0;
                   2540:                }
                   2541:                req->search_origname = strdup(name);
                   2542:                req->search_state = global_search_state;
                   2543:                req->search_flags = flags;
                   2544:                global_search_state->refcount++;
                   2545:                request_submit(req);
                   2546:                return 0;
                   2547:        } else {
                   2548:                struct request *const req = request_new(type, name, flags, user_callback, user_arg);
                   2549:                if (!req) return 1;
                   2550:                request_submit(req);
                   2551:                return 0;
                   2552:        }
                   2553: }
                   2554: 
                   2555: /* this is called when a request has failed to find a name. We need to check */
                   2556: /* if it is part of a search and, if so, try the next name in the list */
                   2557: /* returns: */
                   2558: /*   0 another request has been submitted */
                   2559: /*   1 no more requests needed */
                   2560: static int
                   2561: search_try_next(struct request *const req) {
                   2562:        if (req->search_state) {
                   2563:                /* it is part of a search */
                   2564:                char *new_name;
                   2565:                struct request *newreq;
                   2566:                req->search_index++;
                   2567:                if (req->search_index >= req->search_state->num_domains) {
                   2568:                        /* no more postfixes to try, however we may need to try */
                   2569:                        /* this name without a postfix */
                   2570:                        if (string_num_dots(req->search_origname) < req->search_state->ndots) {
                   2571:                                /* yep, we need to try it raw */
                   2572:                                newreq = request_new(req->request_type, req->search_origname, req->search_flags, req->user_callback, req->user_pointer);
                   2573:                                log(EVDNS_LOG_DEBUG, "Search: trying raw query %s", req->search_origname);
                   2574:                                if (newreq) {
                   2575:                                        request_submit(newreq);
                   2576:                                        return 0;
                   2577:                                }
                   2578:                        }
                   2579:                        return 1;
                   2580:                }
                   2581: 
                   2582:                new_name = search_make_new(req->search_state, req->search_index, req->search_origname);
                   2583:                 if (!new_name) return 1;
                   2584:                log(EVDNS_LOG_DEBUG, "Search: now trying %s (%d)", new_name, req->search_index);
                   2585:                newreq = request_new(req->request_type, new_name, req->search_flags, req->user_callback, req->user_pointer);
                   2586:                free(new_name);
                   2587:                if (!newreq) return 1;
                   2588:                newreq->search_origname = req->search_origname;
                   2589:                req->search_origname = NULL;
                   2590:                newreq->search_state = req->search_state;
                   2591:                newreq->search_flags = req->search_flags;
                   2592:                newreq->search_index = req->search_index;
                   2593:                newreq->search_state->refcount++;
                   2594:                request_submit(newreq);
                   2595:                return 0;
                   2596:        }
                   2597:        return 1;
                   2598: }
                   2599: 
                   2600: static void
                   2601: search_request_finished(struct request *const req) {
                   2602:        if (req->search_state) {
                   2603:                search_state_decref(req->search_state);
                   2604:                req->search_state = NULL;
                   2605:        }
                   2606:        if (req->search_origname) {
                   2607:                free(req->search_origname);
                   2608:                req->search_origname = NULL;
                   2609:        }
                   2610: }
                   2611: 
                   2612: /*/////////////////////////////////////////////////////////////////// */
                   2613: /* Parsing resolv.conf files */
                   2614: 
                   2615: static void
                   2616: evdns_resolv_set_defaults(int flags) {
                   2617:        /* if the file isn't found then we assume a local resolver */
                   2618:        if (flags & DNS_OPTION_SEARCH) search_set_from_hostname();
                   2619:        if (flags & DNS_OPTION_NAMESERVERS) evdns_nameserver_ip_add("127.0.0.1");
                   2620: }
                   2621: 
                   2622: #ifndef HAVE_STRTOK_R
                   2623: static char *
                   2624: strtok_r(char *s, const char *delim, char **state) {
                   2625:        return strtok(s, delim);
                   2626: }
                   2627: #endif
                   2628: 
                   2629: /* helper version of atoi which returns -1 on error */
                   2630: static int
                   2631: strtoint(const char *const str) {
                   2632:        char *endptr;
                   2633:        const int r = strtol(str, &endptr, 10);
                   2634:        if (*endptr) return -1;
                   2635:        return r;
                   2636: }
                   2637: 
                   2638: /* helper version of atoi that returns -1 on error and clips to bounds. */
                   2639: static int
                   2640: strtoint_clipped(const char *const str, int min, int max)
                   2641: {
                   2642:        int r = strtoint(str);
                   2643:        if (r == -1)
                   2644:                return r;
                   2645:        else if (r<min)
                   2646:                return min;
                   2647:        else if (r>max)
                   2648:                return max;
                   2649:        else
                   2650:                return r;
                   2651: }
                   2652: 
                   2653: /* exported function */
                   2654: int
                   2655: evdns_set_option(const char *option, const char *val, int flags)
                   2656: {
                   2657:        if (!strncmp(option, "ndots:", 6)) {
                   2658:                const int ndots = strtoint(val);
                   2659:                if (ndots == -1) return -1;
                   2660:                if (!(flags & DNS_OPTION_SEARCH)) return 0;
                   2661:                log(EVDNS_LOG_DEBUG, "Setting ndots to %d", ndots);
                   2662:                if (!global_search_state) global_search_state = search_state_new();
                   2663:                if (!global_search_state) return -1;
                   2664:                global_search_state->ndots = ndots;
                   2665:        } else if (!strncmp(option, "timeout:", 8)) {
                   2666:                const int timeout = strtoint(val);
                   2667:                if (timeout == -1) return -1;
                   2668:                if (!(flags & DNS_OPTION_MISC)) return 0;
                   2669:                log(EVDNS_LOG_DEBUG, "Setting timeout to %d", timeout);
                   2670:                global_timeout.tv_sec = timeout;
                   2671:        } else if (!strncmp(option, "max-timeouts:", 12)) {
                   2672:                const int maxtimeout = strtoint_clipped(val, 1, 255);
                   2673:                if (maxtimeout == -1) return -1;
                   2674:                if (!(flags & DNS_OPTION_MISC)) return 0;
                   2675:                log(EVDNS_LOG_DEBUG, "Setting maximum allowed timeouts to %d",
                   2676:                        maxtimeout);
                   2677:                global_max_nameserver_timeout = maxtimeout;
                   2678:        } else if (!strncmp(option, "max-inflight:", 13)) {
                   2679:                const int maxinflight = strtoint_clipped(val, 1, 65000);
                   2680:                if (maxinflight == -1) return -1;
                   2681:                if (!(flags & DNS_OPTION_MISC)) return 0;
                   2682:                log(EVDNS_LOG_DEBUG, "Setting maximum inflight requests to %d",
                   2683:                        maxinflight);
                   2684:                global_max_requests_inflight = maxinflight;
                   2685:        } else if (!strncmp(option, "attempts:", 9)) {
                   2686:                int retries = strtoint(val);
                   2687:                if (retries == -1) return -1;
                   2688:                if (retries > 255) retries = 255;
                   2689:                if (!(flags & DNS_OPTION_MISC)) return 0;
                   2690:                log(EVDNS_LOG_DEBUG, "Setting retries to %d", retries);
                   2691:                global_max_retransmits = retries;
                   2692:        }
                   2693:        return 0;
                   2694: }
                   2695: 
                   2696: static void
                   2697: resolv_conf_parse_line(char *const start, int flags) {
                   2698:        char *strtok_state;
                   2699:        static const char *const delims = " \t";
                   2700: #define NEXT_TOKEN strtok_r(NULL, delims, &strtok_state)
                   2701: 
                   2702:        char *const first_token = strtok_r(start, delims, &strtok_state);
                   2703:        if (!first_token) return;
                   2704: 
                   2705:        if (!strcmp(first_token, "nameserver") && (flags & DNS_OPTION_NAMESERVERS)) {
                   2706:                const char *const nameserver = NEXT_TOKEN;
                   2707:                struct in_addr ina;
                   2708: 
                   2709:                if (nameserver && inet_aton(nameserver, &ina)) {
                   2710:                        /* address is valid */
                   2711:                        evdns_nameserver_add(ina.s_addr);
                   2712:                }
                   2713:        } else if (!strcmp(first_token, "domain") && (flags & DNS_OPTION_SEARCH)) {
                   2714:                const char *const domain = NEXT_TOKEN;
                   2715:                if (domain) {
                   2716:                        search_postfix_clear();
                   2717:                        search_postfix_add(domain);
                   2718:                }
                   2719:        } else if (!strcmp(first_token, "search") && (flags & DNS_OPTION_SEARCH)) {
                   2720:                const char *domain;
                   2721:                search_postfix_clear();
                   2722: 
                   2723:                while ((domain = NEXT_TOKEN)) {
                   2724:                        search_postfix_add(domain);
                   2725:                }
                   2726:                search_reverse();
                   2727:        } else if (!strcmp(first_token, "options")) {
                   2728:                const char *option;
                   2729:                while ((option = NEXT_TOKEN)) {
                   2730:                        const char *val = strchr(option, ':');
                   2731:                        evdns_set_option(option, val ? val+1 : "", flags);
                   2732:                }
                   2733:        }
                   2734: #undef NEXT_TOKEN
                   2735: }
                   2736: 
                   2737: /* exported function */
                   2738: /* returns: */
                   2739: /*   0 no errors */
                   2740: /*   1 failed to open file */
                   2741: /*   2 failed to stat file */
                   2742: /*   3 file too large */
                   2743: /*   4 out of memory */
                   2744: /*   5 short read from file */
                   2745: int
                   2746: evdns_resolv_conf_parse(int flags, const char *const filename) {
                   2747:        struct stat st;
                   2748:        int fd, n, r;
                   2749:        u8 *resolv;
                   2750:        char *start;
                   2751:        int err = 0;
                   2752: 
                   2753:        log(EVDNS_LOG_DEBUG, "Parsing resolv.conf file %s", filename);
                   2754: 
                   2755:        fd = open(filename, O_RDONLY);
                   2756:        if (fd < 0) {
                   2757:                evdns_resolv_set_defaults(flags);
                   2758:                return 1;
                   2759:        }
                   2760: 
                   2761:        if (fstat(fd, &st)) { err = 2; goto out1; }
                   2762:        if (!st.st_size) {
                   2763:                evdns_resolv_set_defaults(flags);
                   2764:                err = (flags & DNS_OPTION_NAMESERVERS) ? 6 : 0;
                   2765:                goto out1;
                   2766:        }
                   2767:        if (st.st_size > 65535) { err = 3; goto out1; }  /* no resolv.conf should be any bigger */
                   2768: 
                   2769:        resolv = (u8 *) malloc((size_t)st.st_size + 1);
                   2770:        if (!resolv) { err = 4; goto out1; }
                   2771: 
                   2772:        n = 0;
                   2773:        while ((r = read(fd, resolv+n, (size_t)st.st_size-n)) > 0) {
                   2774:                n += r;
                   2775:                if (n == st.st_size)
                   2776:                        break;
                   2777:                assert(n < st.st_size);
                   2778:        }
                   2779:        if (r < 0) { err = 5; goto out2; }
                   2780:        resolv[n] = 0;   /* we malloced an extra byte; this should be fine. */
                   2781: 
                   2782:        start = (char *) resolv;
                   2783:        for (;;) {
                   2784:                char *const newline = strchr(start, '\n');
                   2785:                if (!newline) {
                   2786:                        resolv_conf_parse_line(start, flags);
                   2787:                        break;
                   2788:                } else {
                   2789:                        *newline = 0;
                   2790:                        resolv_conf_parse_line(start, flags);
                   2791:                        start = newline + 1;
                   2792:                }
                   2793:        }
                   2794: 
                   2795:        if (!server_head && (flags & DNS_OPTION_NAMESERVERS)) {
                   2796:                /* no nameservers were configured. */
                   2797:                evdns_nameserver_ip_add("127.0.0.1");
                   2798:                err = 6;
                   2799:        }
                   2800:        if (flags & DNS_OPTION_SEARCH && (!global_search_state || global_search_state->num_domains == 0)) {
                   2801:                search_set_from_hostname();
                   2802:        }
                   2803: 
                   2804: out2:
                   2805:        free(resolv);
                   2806: out1:
                   2807:        close(fd);
                   2808:        return err;
                   2809: }
                   2810: 
                   2811: #ifdef WIN32
                   2812: /* Add multiple nameservers from a space-or-comma-separated list. */
                   2813: static int
                   2814: evdns_nameserver_ip_add_line(const char *ips) {
                   2815:        const char *addr;
                   2816:        char *buf;
                   2817:        int r;
                   2818:        while (*ips) {
                   2819:                while (ISSPACE(*ips) || *ips == ',' || *ips == '\t')
                   2820:                        ++ips;
                   2821:                addr = ips;
                   2822:                while (ISDIGIT(*ips) || *ips == '.' || *ips == ':')
                   2823:                        ++ips;
                   2824:                buf = malloc(ips-addr+1);
                   2825:                if (!buf) return 4;
                   2826:                memcpy(buf, addr, ips-addr);
                   2827:                buf[ips-addr] = '\0';
                   2828:                r = evdns_nameserver_ip_add(buf);
                   2829:                free(buf);
                   2830:                if (r) return r;
                   2831:        }
                   2832:        return 0;
                   2833: }
                   2834: 
                   2835: typedef DWORD(WINAPI *GetNetworkParams_fn_t)(FIXED_INFO *, DWORD*);
                   2836: 
                   2837: /* Use the windows GetNetworkParams interface in iphlpapi.dll to */
                   2838: /* figure out what our nameservers are. */
                   2839: static int
                   2840: load_nameservers_with_getnetworkparams(void)
                   2841: {
                   2842:        /* Based on MSDN examples and inspection of  c-ares code. */
                   2843:        FIXED_INFO *fixed;
                   2844:        HMODULE handle = 0;
                   2845:        ULONG size = sizeof(FIXED_INFO);
                   2846:        void *buf = NULL;
                   2847:        int status = 0, r, added_any;
                   2848:        IP_ADDR_STRING *ns;
                   2849:        GetNetworkParams_fn_t fn;
                   2850: 
                   2851:        if (!(handle = LoadLibraryA("iphlpapi.dll"))) {
                   2852:                log(EVDNS_LOG_WARN, "Could not open iphlpapi.dll");
                   2853:                status = -1;
                   2854:                goto done;
                   2855:        }
                   2856:        if (!(fn = (GetNetworkParams_fn_t) GetProcAddress(handle, "GetNetworkParams"))) {
                   2857:                log(EVDNS_LOG_WARN, "Could not get address of function.");
                   2858:                status = -1;
                   2859:                goto done;
                   2860:        }
                   2861: 
                   2862:        buf = malloc(size);
                   2863:        if (!buf) { status = 4; goto done; }
                   2864:        fixed = buf;
                   2865:        r = fn(fixed, &size);
                   2866:        if (r != ERROR_SUCCESS && r != ERROR_BUFFER_OVERFLOW) {
                   2867:                status = -1;
                   2868:                goto done;
                   2869:        }
                   2870:        if (r != ERROR_SUCCESS) {
                   2871:                free(buf);
                   2872:                buf = malloc(size);
                   2873:                if (!buf) { status = 4; goto done; }
                   2874:                fixed = buf;
                   2875:                r = fn(fixed, &size);
                   2876:                if (r != ERROR_SUCCESS) {
                   2877:                        log(EVDNS_LOG_DEBUG, "fn() failed.");
                   2878:                        status = -1;
                   2879:                        goto done;
                   2880:                }
                   2881:        }
                   2882: 
                   2883:        assert(fixed);
                   2884:        added_any = 0;
                   2885:        ns = &(fixed->DnsServerList);
                   2886:        while (ns) {
                   2887:                r = evdns_nameserver_ip_add_line(ns->IpAddress.String);
                   2888:                if (r) {
                   2889:                        log(EVDNS_LOG_DEBUG,"Could not add nameserver %s to list,error: %d",
                   2890:                                (ns->IpAddress.String),(int)GetLastError());
                   2891:                        status = r;
                   2892:                        goto done;
                   2893:                } else {
                   2894:                        log(EVDNS_LOG_DEBUG,"Succesfully added %s as nameserver",ns->IpAddress.String);
                   2895:                }
                   2896: 
                   2897:                added_any++;
                   2898:                ns = ns->Next;
                   2899:        }
                   2900: 
                   2901:        if (!added_any) {
                   2902:                log(EVDNS_LOG_DEBUG, "No nameservers added.");
                   2903:                status = -1;
                   2904:        }
                   2905: 
                   2906:  done:
                   2907:        if (buf)
                   2908:                free(buf);
                   2909:        if (handle)
                   2910:                FreeLibrary(handle);
                   2911:        return status;
                   2912: }
                   2913: 
                   2914: static int
                   2915: config_nameserver_from_reg_key(HKEY key, const char *subkey)
                   2916: {
                   2917:        char *buf;
                   2918:        DWORD bufsz = 0, type = 0;
                   2919:        int status = 0;
                   2920: 
                   2921:        if (RegQueryValueExA(key, subkey, 0, &type, NULL, &bufsz)
                   2922:            != ERROR_MORE_DATA)
                   2923:                return -1;
                   2924:        if (!(buf = malloc(bufsz)))
                   2925:                return -1;
                   2926: 
                   2927:        if (RegQueryValueExA(key, subkey, 0, &type, (LPBYTE)buf, &bufsz)
                   2928:            == ERROR_SUCCESS && bufsz > 1) {
                   2929:                status = evdns_nameserver_ip_add_line(buf);
                   2930:        }
                   2931: 
                   2932:        free(buf);
                   2933:        return status;
                   2934: }
                   2935: 
                   2936: #define SERVICES_KEY "System\\CurrentControlSet\\Services\\"
                   2937: #define WIN_NS_9X_KEY  SERVICES_KEY "VxD\\MSTCP"
                   2938: #define WIN_NS_NT_KEY  SERVICES_KEY "Tcpip\\Parameters"
                   2939: 
                   2940: static int
                   2941: load_nameservers_from_registry(void)
                   2942: {
                   2943:        int found = 0;
                   2944:        int r;
                   2945: #define TRY(k, name) \
                   2946:        if (!found && config_nameserver_from_reg_key(k,name) == 0) {    \
                   2947:                log(EVDNS_LOG_DEBUG,"Found nameservers in %s/%s",#k,name); \
                   2948:                found = 1;                                              \
                   2949:        } else if (!found) {                                            \
                   2950:                log(EVDNS_LOG_DEBUG,"Didn't find nameservers in %s/%s", \
                   2951:                    #k,#name);                                          \
                   2952:        }
                   2953: 
                   2954:        if (((int)GetVersion()) > 0) { /* NT */
                   2955:                HKEY nt_key = 0, interfaces_key = 0;
                   2956: 
                   2957:                if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0,
                   2958:                                 KEY_READ, &nt_key) != ERROR_SUCCESS) {
                   2959:                        log(EVDNS_LOG_DEBUG,"Couldn't open nt key, %d",(int)GetLastError());
                   2960:                        return -1;
                   2961:                }
                   2962:                r = RegOpenKeyExA(nt_key, "Interfaces", 0,
                   2963:                             KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS,
                   2964:                             &interfaces_key);
                   2965:                if (r != ERROR_SUCCESS) {
                   2966:                        log(EVDNS_LOG_DEBUG,"Couldn't open interfaces key, %d",(int)GetLastError());
                   2967:                        return -1;
                   2968:                }
                   2969:                TRY(nt_key, "NameServer");
                   2970:                TRY(nt_key, "DhcpNameServer");
                   2971:                TRY(interfaces_key, "NameServer");
                   2972:                TRY(interfaces_key, "DhcpNameServer");
                   2973:                RegCloseKey(interfaces_key);
                   2974:                RegCloseKey(nt_key);
                   2975:        } else {
                   2976:                HKEY win_key = 0;
                   2977:                if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_NS_9X_KEY, 0,
                   2978:                                 KEY_READ, &win_key) != ERROR_SUCCESS) {
                   2979:                        log(EVDNS_LOG_DEBUG, "Couldn't open registry key, %d", (int)GetLastError());
                   2980:                        return -1;
                   2981:                }
                   2982:                TRY(win_key, "NameServer");
                   2983:                RegCloseKey(win_key);
                   2984:        }
                   2985: 
                   2986:        if (found == 0) {
                   2987:                log(EVDNS_LOG_WARN,"Didn't find any nameservers.");
                   2988:        }
                   2989: 
                   2990:        return found ? 0 : -1;
                   2991: #undef TRY
                   2992: }
                   2993: 
                   2994: int
                   2995: evdns_config_windows_nameservers(void)
                   2996: {
                   2997:        if (load_nameservers_with_getnetworkparams() == 0)
                   2998:                return 0;
                   2999:        return load_nameservers_from_registry();
                   3000: }
                   3001: #endif
                   3002: 
                   3003: int
                   3004: evdns_init(void)
                   3005: {
                   3006:        int res = 0;
                   3007: #ifdef WIN32
                   3008:        res = evdns_config_windows_nameservers();
                   3009: #else
                   3010:        res = evdns_resolv_conf_parse(DNS_OPTIONS_ALL, "/etc/resolv.conf");
                   3011: #endif
                   3012: 
                   3013:        return (res);
                   3014: }
                   3015: 
                   3016: const char *
                   3017: evdns_err_to_string(int err)
                   3018: {
                   3019:     switch (err) {
                   3020:        case DNS_ERR_NONE: return "no error";
                   3021:        case DNS_ERR_FORMAT: return "misformatted query";
                   3022:        case DNS_ERR_SERVERFAILED: return "server failed";
                   3023:        case DNS_ERR_NOTEXIST: return "name does not exist";
                   3024:        case DNS_ERR_NOTIMPL: return "query not implemented";
                   3025:        case DNS_ERR_REFUSED: return "refused";
                   3026: 
                   3027:        case DNS_ERR_TRUNCATED: return "reply truncated or ill-formed";
                   3028:        case DNS_ERR_UNKNOWN: return "unknown";
                   3029:        case DNS_ERR_TIMEOUT: return "request timed out";
                   3030:        case DNS_ERR_SHUTDOWN: return "dns subsystem shut down";
                   3031:        default: return "[Unknown error code]";
                   3032:     }
                   3033: }
                   3034: 
                   3035: void
                   3036: evdns_shutdown(int fail_requests)
                   3037: {
                   3038:        struct nameserver *server, *server_next;
                   3039:        struct search_domain *dom, *dom_next;
                   3040: 
                   3041:        while (req_head) {
                   3042:                if (fail_requests)
                   3043:                        reply_callback(req_head, 0, DNS_ERR_SHUTDOWN, NULL);
                   3044:                request_finished(req_head, &req_head);
                   3045:        }
                   3046:        while (req_waiting_head) {
                   3047:                if (fail_requests)
                   3048:                        reply_callback(req_waiting_head, 0, DNS_ERR_SHUTDOWN, NULL);
                   3049:                request_finished(req_waiting_head, &req_waiting_head);
                   3050:        }
                   3051:        global_requests_inflight = global_requests_waiting = 0;
                   3052: 
                   3053:        for (server = server_head; server; server = server_next) {
                   3054:                server_next = server->next;
                   3055:                if (server->socket >= 0)
                   3056:                        CLOSE_SOCKET(server->socket);
                   3057:                (void) event_del(&server->event);
                   3058:                if (server->state == 0)
                   3059:                         (void) event_del(&server->timeout_event);
                   3060:                free(server);
                   3061:                if (server_next == server_head)
                   3062:                        break;
                   3063:        }
                   3064:        server_head = NULL;
                   3065:        global_good_nameservers = 0;
                   3066: 
                   3067:        if (global_search_state) {
                   3068:                for (dom = global_search_state->head; dom; dom = dom_next) {
                   3069:                        dom_next = dom->next;
                   3070:                        free(dom);
                   3071:                }
                   3072:                free(global_search_state);
                   3073:                global_search_state = NULL;
                   3074:        }
                   3075:        evdns_log_fn = NULL;
                   3076: }
                   3077: 
                   3078: #ifdef EVDNS_MAIN
                   3079: void
                   3080: main_callback(int result, char type, int count, int ttl,
                   3081:                          void *addrs, void *orig) {
                   3082:        char *n = (char*)orig;
                   3083:        int i;
                   3084:        for (i = 0; i < count; ++i) {
                   3085:                if (type == DNS_IPv4_A) {
                   3086:                        printf("%s: %s\n", n, debug_ntoa(((u32*)addrs)[i]));
                   3087:                } else if (type == DNS_PTR) {
                   3088:                        printf("%s: %s\n", n, ((char**)addrs)[i]);
                   3089:                }
                   3090:        }
                   3091:        if (!count) {
                   3092:                printf("%s: No answer (%d)\n", n, result);
                   3093:        }
                   3094:        fflush(stdout);
                   3095: }
                   3096: void
                   3097: evdns_server_callback(struct evdns_server_request *req, void *data)
                   3098: {
                   3099:        int i, r;
                   3100:        (void)data;
                   3101:        /* dummy; give 192.168.11.11 as an answer for all A questions,
                   3102:         *      give foo.bar.example.com as an answer for all PTR questions. */
                   3103:        for (i = 0; i < req->nquestions; ++i) {
                   3104:                u32 ans = htonl(0xc0a80b0bUL);
                   3105:                if (req->questions[i]->type == EVDNS_TYPE_A &&
                   3106:                        req->questions[i]->dns_question_class == EVDNS_CLASS_INET) {
                   3107:                        printf(" -- replying for %s (A)\n", req->questions[i]->name);
                   3108:                        r = evdns_server_request_add_a_reply(req, req->questions[i]->name,
                   3109:                                                                                  1, &ans, 10);
                   3110:                        if (r<0)
                   3111:                                printf("eeep, didn't work.\n");
                   3112:                } else if (req->questions[i]->type == EVDNS_TYPE_PTR &&
                   3113:                                   req->questions[i]->dns_question_class == EVDNS_CLASS_INET) {
                   3114:                        printf(" -- replying for %s (PTR)\n", req->questions[i]->name);
                   3115:                        r = evdns_server_request_add_ptr_reply(req, NULL, req->questions[i]->name,
                   3116:                                                                                        "foo.bar.example.com", 10);
                   3117:                } else {
                   3118:                        printf(" -- skipping %s [%d %d]\n", req->questions[i]->name,
                   3119:                                   req->questions[i]->type, req->questions[i]->dns_question_class);
                   3120:                }
                   3121:        }
                   3122: 
                   3123:        r = evdns_request_respond(req, 0);
                   3124:        if (r<0)
                   3125:                printf("eeek, couldn't send reply.\n");
                   3126: }
                   3127: 
                   3128: void
                   3129: logfn(int is_warn, const char *msg) {
                   3130:   (void) is_warn;
                   3131:   fprintf(stderr, "%s\n", msg);
                   3132: }
                   3133: int
                   3134: main(int c, char **v) {
                   3135:        int idx;
                   3136:        int reverse = 0, verbose = 1, servertest = 0;
                   3137:        if (c<2) {
                   3138:                fprintf(stderr, "syntax: %s [-x] [-v] hostname\n", v[0]);
                   3139:                fprintf(stderr, "syntax: %s [-servertest]\n", v[0]);
                   3140:                return 1;
                   3141:        }
                   3142:        idx = 1;
                   3143:        while (idx < c && v[idx][0] == '-') {
                   3144:                if (!strcmp(v[idx], "-x"))
                   3145:                        reverse = 1;
                   3146:                else if (!strcmp(v[idx], "-v"))
                   3147:                        verbose = 1;
                   3148:                else if (!strcmp(v[idx], "-servertest"))
                   3149:                        servertest = 1;
                   3150:                else
                   3151:                        fprintf(stderr, "Unknown option %s\n", v[idx]);
                   3152:                ++idx;
                   3153:        }
                   3154:        event_init();
                   3155:        if (verbose)
                   3156:                evdns_set_log_fn(logfn);
                   3157:        evdns_resolv_conf_parse(DNS_OPTION_NAMESERVERS, "/etc/resolv.conf");
                   3158:        if (servertest) {
                   3159:                int sock;
                   3160:                struct sockaddr_in my_addr;
                   3161:                sock = socket(PF_INET, SOCK_DGRAM, 0);
                   3162:                 evutil_make_socket_nonblocking(sock);
                   3163:                my_addr.sin_family = AF_INET;
                   3164:                my_addr.sin_port = htons(10053);
                   3165:                my_addr.sin_addr.s_addr = INADDR_ANY;
                   3166:                if (bind(sock, (struct sockaddr*)&my_addr, sizeof(my_addr))<0) {
                   3167:                        perror("bind");
                   3168:                        exit(1);
                   3169:                }
                   3170:                evdns_add_server_port(sock, 0, evdns_server_callback, NULL);
                   3171:        }
                   3172:        for (; idx < c; ++idx) {
                   3173:                if (reverse) {
                   3174:                        struct in_addr addr;
                   3175:                        if (!inet_aton(v[idx], &addr)) {
                   3176:                                fprintf(stderr, "Skipping non-IP %s\n", v[idx]);
                   3177:                                continue;
                   3178:                        }
                   3179:                        fprintf(stderr, "resolving %s...\n",v[idx]);
                   3180:                        evdns_resolve_reverse(&addr, 0, main_callback, v[idx]);
                   3181:                } else {
                   3182:                        fprintf(stderr, "resolving (fwd) %s...\n",v[idx]);
                   3183:                        evdns_resolve_ipv4(v[idx], 0, main_callback, v[idx]);
                   3184:                }
                   3185:        }
                   3186:        fflush(stdout);
                   3187:        event_dispatch();
                   3188:        return 0;
                   3189: }
                   3190: #endif

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>