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