ircd/res.c

   1 /*
   2  * src/res.c (C)opyright 1992 Darren Reed. All rights reserved.
   3  * This file may not be distributed without the author's permission in any
   4  * shape or form. The author takes no responsibility for any damage or loss
   5  * of property which results from the use of this software.
   6  *
   7  * $Id$
   8  *
   9  * July 1999 - Rewrote a bunch of stuff here. Change hostent builder code,
  10  *     added callbacks and reference counting of returned hostents.
  11  *     --Bleep (Thomas Helvey <tomh@inxpress.net>)
  12  */
  13 #include "res.h"
  14 #include "client.h"
  15 #include "ircd.h"
  16 #include "ircd_alloc.h"
  17 #include "ircd_log.h"
  18 #include "ircd_osdep.h"
  19 #include "ircd_reply.h"
  20 #include "ircd_string.h"
  21 #include "msg.h"
  22 #include "numeric.h"
  23 #include "s_bsd.h"
  24 #include "s_debug.h"
  25 #include "s_misc.h"
  26 #include "send.h"
  27 #include "sprintf_irc.h"
  28 #include "struct.h"
  29 #include "support.h"
  30 #include "sys.h"
  31
  32 #include <assert.h>
  33 #include <errno.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36 #include <sys/time.h>
  37 #include <sys/socket.h>
  38 #include <fcntl.h>
  39 #include <unistd.h>
  40 #include <regex.h>
  41
  42 #include <arpa/nameser.h>
  43 #include <resolv.h>
  44 #include <netdb.h>
  45 #include <arpa/inet.h>
  46
  47 #include <limits.h>
  48 #if (CHAR_BIT != 8)
  49 #error this code needs to be able to address individual octets
  50 #endif
  51
  52 /*
  53  * Some systems do not define INADDR_NONE (255.255.255.255)
  54  * INADDR_NONE is actually a valid address, but it should never
  55  * be returned from any nameserver.
  56  * NOTE: The bit pattern for INADDR_NONE and INADDR_ANY (0.0.0.0) should be
  57  * the same on all hosts so we shouldn't need to use htonl or ntohl to
  58  * compare or set the values.
  59  */
  60 #ifndef INADDR_NONE
  61 #define INADDR_NONE ((unsigned int) 0xffffffff)
  62 #endif
  63
  64 #define MAXPACKET       1024  /* rfc sez 512 but we expand names so ... */
  65 #define RES_MAXALIASES  35    /* maximum aliases allowed */
  66 #define RES_MAXADDRS    35    /* maximum addresses allowed */
  67 /*
  68  * OSF1 doesn't have RES_NOALIASES
  69  */
  70 #ifndef RES_NOALIASES
  71 #define RES_NOALIASES 0
  72 #endif
  73
  74 /*
  75  * macros used to calulate offsets into fixed query buffer
  76  */
  77 #define ALIAS_BLEN  ((RES_MAXALIASES + 1) * sizeof(char*))
  78 #define ADDRS_BLEN  ((RES_MAXADDRS + 1) * sizeof(struct in_addr*))
  79
  80 #define ADDRS_OFFSET   (ALIAS_BLEN + ADDRS_BLEN)
  81 #define ADDRS_DLEN     (RES_MAXADDRS * sizeof(struct in_addr))
  82 #define NAMES_OFFSET   (ADDRS_OFFSET + ADDRS_DLEN)
  83 #define MAXGETHOSTLEN  (NAMES_OFFSET + MAXPACKET)
  84
  85 #define AR_TTL          600   /* TTL in seconds for dns cache entries */
  86
  87 /*
  88  * the following values should be prime
  89  */
  90 #define ARES_CACSIZE    307
  91 #define MAXCACHED       281
  92
  93 /*
  94  * RFC 1104/1105 wasn't very helpful about what these fields
  95  * should be named, so for now, we'll just name them this way.
  96  * we probably should look at what named calls them or something.
  97  */
  98 #define TYPE_SIZE       2
  99 #define CLASS_SIZE      2
 100 #define TTL_SIZE        4
 101 #define RDLENGTH_SIZE   2
 102 #define ANSWER_FIXED_SIZE (TYPE_SIZE + CLASS_SIZE + TTL_SIZE + RDLENGTH_SIZE)
 103
 104 /*
 105  * Building the Hostent
 106  * The Hostent struct is arranged like this:
 107  *          +-------------------------------+
 108  * Hostent: | struct hostent h              |
 109  *          |-------------------------------|
 110  *          | char *buf                     |
 111  *          +-------------------------------+
 112  *
 113  * allocated:
 114  *
 115  *          +-------------------------------+
 116  * buf:     | h_aliases pointer array       | Max size: ALIAS_BLEN;
 117  *          | NULL                          | contains `char *'s
 118  *          |-------------------------------|
 119  *          | h_addr_list pointer array     | Max size: ADDRS_BLEN;
 120  *          | NULL                          | contains `struct in_addr *'s
 121  *          |-------------------------------|
 122  *          | h_addr_list addresses         | Max size: ADDRS_DLEN;
 123  *          |                               | contains `struct in_addr's
 124  *          |-------------------------------|
 125  *          | storage for hostname strings  | Max size: ALIAS_DLEN;
 126  *          +-------------------------------+ contains `char's
 127  *
 128  *  For requests the size of the h_aliases, and h_addr_list pointer
 129  *  array sizes are set to MAXALISES and MAXADDRS respectively, and
 130  *  buf is a fixed size with enough space to hold the largest expected
 131  *  reply from a nameserver, see RFC 1034 and RFC 1035.
 132  *  For cached entries the sizes are dependent on the actual number
 133  *  of aliases and addresses. If new aliases and addresses are found
 134  *  for cached entries, the buffer is grown and the new entries are added.
 135  *  The hostent struct is filled in with the addresses of the entries in
 136  *  the Hostent buf as follows:
 137  *  h_name      - contains a pointer to the start of the hostname string area,
 138  *                or NULL if none is set.  The h_name is followed by the
 139  *                aliases, in the storage for hostname strings area.
 140  *  h_aliases   - contains a pointer to the start of h_aliases pointer array.
 141  *                This array contains pointers to the storage for hostname
 142  *                strings area and is terminated with a NULL.  The first alias
 143  *                is stored directly after the h_name.
 144  *  h_addr_list - contains a pointer to the start of h_addr_list pointer array.
 145  *                This array contains pointers to in_addr structures in the
 146  *                h_addr_list addresses area and is terminated with a NULL.
 147  *
 148  *  Filling the buffer this way allows for proper alignment of the h_addr_list
 149  *  addresses.
 150  *
 151  *  This arrangement allows us to alias a Hostent struct pointer as a
 152  *  real struct hostent* without lying. It also allows us to change the
 153  *  values contained in the cached entries and requests without changing
 154  *  the actual hostent pointer, which is saved in a client struct and can't
 155  *  be changed without blowing things up or a lot more fiddling around.
 156  *  It also allows for defered allocation of the fixed size buffers until
 157  *  they are really needed.
 158  *  Nov. 17, 1997 --Bleep
 159  */
 160
 161 struct Hostent {
 162   struct hostent h;      /* the hostent struct we are passing around */
 163   char*          buf;    /* buffer for data pointed to from hostent */
 164 };
 165
 166 struct ResRequest {
 167   struct ResRequest* next;
 168   int                id;
 169   int                sent;          /* number of requests sent */
 170   time_t             ttl;
 171   char               type;
 172   char               retries;       /* retry counter */
 173   char               sends;         /* number of sends (>1 means resent) */
 174   char               resend;        /* send flag. 0 == dont resend */
 175   time_t             sentat;
 176   time_t             timeout;
 177   struct in_addr     addr;
 178   char*              name;
 179   struct DNSQuery    query;         /* query callback for this request */
 180   struct Hostent     he;
 181 };
 182
 183 struct CacheEntry {
 184   struct CacheEntry* hname_next;
 185   struct CacheEntry* hnum_next;
 186   struct CacheEntry* list_next;
 187   time_t             expireat;
 188   time_t             ttl;
 189   struct Hostent     he;
 190   struct DNSReply    reply;
 191 };
 192
 193 struct CacheTable {
 194   struct CacheEntry* num_list;
 195   struct CacheEntry* name_list;
 196 };
 197
 198
 199 int ResolverFileDescriptor    = -1;   /* GLOBAL - used in s_bsd.c */
 200
 201 static time_t nextDNSCheck    = 0;
 202 static time_t nextCacheExpire = 1;
 203
 204 /*
 205  * Keep a spare file descriptor open. res_init calls fopen to read the
 206  * resolv.conf file. If ircd is hogging all the file descriptors below 256,
 207  * on systems with crippled FILE structures this will cause wierd bugs.
 208  * This is definitely needed for Solaris which uses an unsigned char to
 209  * hold the file descriptor.  --Dianora
 210  */
 211 static int                spare_fd = -1;
 212
 213 static int                cachedCount = 0;
 214 static struct CacheTable  hashtable[ARES_CACSIZE];
 215 static struct CacheEntry* cacheTop;
 216 static struct ResRequest* requestListHead;   /* head of resolver request list */
 217 static struct ResRequest* requestListTail;   /* tail of resolver request list */
 218
 219
 220 static void     add_request(struct ResRequest* request);
 221 static void     rem_request(struct ResRequest* request);
 222 static struct ResRequest*   make_request(const struct DNSQuery* query);
 223 static void     rem_cache(struct CacheEntry*);
 224 static void     do_query_name(const struct DNSQuery* query,
 225                               const char* name,
 226                               struct ResRequest* request);
 227 static void     do_query_number(const struct DNSQuery* query,
 228                                 const struct in_addr*,
 229                                 struct ResRequest* request);
 230 static void     query_name(const char* name,
 231                            int query_class,
 232                            int query_type,
 233                            struct ResRequest* request);
 234 static void     resend_query(struct ResRequest* request);
 235 static struct CacheEntry*  make_cache(struct ResRequest* request);
 236 static struct CacheEntry*  find_cache_name(const char* name);
 237 static struct CacheEntry*  find_cache_number(struct ResRequest* request,
 238                                              const char* addr);
 239 static struct ResRequest*   find_id(int);
 240
 241 static struct cacheinfo {
 242   int  ca_adds;
 243   int  ca_dels;
 244   int  ca_expires;
 245   int  ca_lookups;
 246   int  ca_na_hits;
 247   int  ca_nu_hits;
 248   int  ca_updates;
 249 } cainfo;
 250
 251 static  struct  resinfo {
 252   int  re_errors;
 253   int  re_nu_look;
 254   int  re_na_look;
 255   int  re_replies;
 256   int  re_requests;
 257   int  re_resends;
 258   int  re_sent;
 259   int  re_timeouts;
 260   int  re_shortttl;
 261   int  re_unkrep;
 262 } reinfo;
 263
 264
 265 /*
 266  * From bind 8.3, these aren't declared in earlier versions of bind
 267  */
 268 extern u_short  _getshort(const u_char *);
 269 extern u_int    _getlong(const u_char *);
 270 /*
 271  * int
 272  * res_isourserver(ina)
 273  *      looks up "ina" in _res.ns_addr_list[]
 274  * returns:
 275  *      0  : not found
 276  *      >0 : found
 277  * author:
 278  *      paul vixie, 29may94
 279  */
 280 static int
 281 res_ourserver(const struct __res_state* statp, const struct sockaddr_in* inp)
 282 {
 283   struct sockaddr_in ina;
 284   int ns;
 285
 286   ina = *inp;
 287   for (ns = 0;  ns < statp->nscount;  ns++) {
 288     const struct sockaddr_in *srv = &statp->nsaddr_list[ns];
 289
 290     if (srv->sin_family == ina.sin_family &&
 291          srv->sin_port == ina.sin_port &&
 292          (srv->sin_addr.s_addr == INADDR_ANY ||
 293           srv->sin_addr.s_addr == ina.sin_addr.s_addr))
 294              return (1);
 295   }
 296   return (0);
 297 }
 298
 299 /*
 300  * start_resolver - do everything we need to read the resolv.conf file
 301  * and initialize the resolver file descriptor if needed
 302  */
 303 static void start_resolver(void)
 304 {
 305   Debug((DEBUG_DNS, "Resolver: start_resolver"));
 306   /*
 307    * close the spare file descriptor so res_init can read resolv.conf
 308    * successfully. Needed on Solaris
 309    */
 310   if (spare_fd > -1)
 311     close(spare_fd);
 312
 313   res_init();      /* res_init always returns 0 */
 314   /*
 315    * make sure we have a valid file descriptor below 256 so we can
 316    * do this again. Needed on Solaris
 317    */
 318   spare_fd = open("/dev/null",O_RDONLY,0);
 319   if ((spare_fd < 0) || (spare_fd > 255)) {
 320     char sparemsg[80];
 321     sprintf_irc(sparemsg, "invalid spare_fd %d", spare_fd);
 322     server_restart(sparemsg);
 323   }
 324
 325   if (!_res.nscount) {
 326     _res.nscount = 1;
 327     _res.nsaddr_list[0].sin_addr.s_addr = inet_addr("127.0.0.1");
 328   }
 329   _res.options |= RES_NOALIASES;
 330
 331   if (ResolverFileDescriptor < 0) {
 332     ResolverFileDescriptor = socket(AF_INET, SOCK_DGRAM, 0);
 333     if (-1 == ResolverFileDescriptor) {
 334       report_error("Resolver: error creating socket for %s: %s",
 335                    me.name, errno);
 336       return;
 337     }
 338     if (!os_set_nonblocking(ResolverFileDescriptor))
 339       report_error("Resolver: error setting non-blocking for %s: %s",
 340                    me.name, errno);
 341   }
 342 }
 343
 344 /*
 345  * init_resolver - initialize resolver and resolver library
 346  */
 347 int init_resolver(void)
 348 {
 349   Debug((DEBUG_DNS, "Resolver: init_resolver"));
 350 #ifdef  LRAND48
 351   srand48(CurrentTime);
 352 #endif
 353   memset(&cainfo,   0, sizeof(cainfo));
 354   memset(hashtable, 0, sizeof(hashtable));
 355   memset(&reinfo,   0, sizeof(reinfo));
 356
 357   requestListHead = requestListTail = 0;
 358
 359   errno = h_errno = 0;
 360
 361   start_resolver();
 362   Debug((DEBUG_DNS, "Resolver: fd %d errno: %d h_errno: %d: %s",
 363          ResolverFileDescriptor, errno, h_errno,
 364          (strerror(errno)) ? strerror(errno) : "Unknown"));
 365   return ResolverFileDescriptor;
 366 }
 367
 368 /*
 369  * restart_resolver - flush the cache, reread resolv.conf, reopen socket
 370  */
 371 void restart_resolver(void)
 372 {
 373   /* flush_cache();  flush the dns cache */
 374   start_resolver();
 375 }
 376
 377 static int validate_hostent(const struct hostent* hp)
 378 {
 379   const char* name;
 380   int  i = 0;
 381   assert(0 != hp);
 382   for (name = hp->h_name; name; name = hp->h_aliases[i++]) {
 383     if (!string_is_hostname(name))
 384       return 0;
 385   }
 386   return 1;
 387 }
 388
 389 /*
 390  * add_request - place a new request in the request list
 391  */
 392 static void add_request(struct ResRequest* request)
 393 {
 394   assert(0 != request);
 395   if (!requestListHead)
 396     requestListHead = requestListTail = request;
 397   else {
 398     requestListTail->next = request;
 399     requestListTail = request;
 400   }
 401   request->next = NULL;
 402   ++reinfo.re_requests;
 403 }
 404
 405 /*
 406  * rem_request - remove a request from the list.
 407  * This must also free any memory that has been allocated for
 408  * temporary storage of DNS results.
 409  */
 410 static void rem_request(struct ResRequest* request)
 411 {
 412   struct ResRequest** current;
 413   struct ResRequest*  prev = NULL;
 414
 415   assert(0 != request);
 416   for (current = &requestListHead; *current; ) {
 417     if (*current == request) {
 418       *current = request->next;
 419       if (requestListTail == request)
 420         requestListTail = prev;
 421       break;
 422     }
 423     prev    = *current;
 424     current = &(*current)->next;
 425   }
 426   MyFree(request->he.buf);
 427   MyFree(request->name);
 428   MyFree(request);
 429 }
 430
 431 /*
 432  * make_request - Create a DNS request record for the server.
 433  */
 434 static struct ResRequest* make_request(const struct DNSQuery* query)
 435 {
 436   struct ResRequest* request;
 437   assert(0 != query);
 438   request = (struct ResRequest*) MyMalloc(sizeof(struct ResRequest));
 439   memset(request, 0, sizeof(struct ResRequest));
 440
 441   request->sentat           = CurrentTime;
 442   request->retries          = 3;
 443   request->resend           = 1;
 444   request->timeout          = 5;    /* start at 5 per RFC1123 */
 445   request->addr.s_addr      = INADDR_NONE;
 446   request->he.h.h_addrtype  = AF_INET;
 447   request->he.h.h_length    = sizeof(struct in_addr);
 448   request->query.vptr       = query->vptr;
 449   request->query.callback   = query->callback;
 450
 451 #if defined(NULL_POINTER_NOT_ZERO)
 452   request->next             = NULL;
 453   request->he.buf           = NULL;
 454   request->he.h.h_name      = NULL;
 455   request->he.h.h_aliases   = NULL;
 456   request->he.h.h_addr_list = NULL;
 457 #endif
 458   add_request(request);
 459   return request;
 460 }
 461
 462 /*
 463  * timeout_query_list - Remove queries from the list which have been
 464  * there too long without being resolved.
 465  */
 466 static time_t timeout_query_list(time_t now)
 467 {
 468   struct ResRequest* request;
 469   struct ResRequest* next_request = 0;
 470   time_t             next_time    = 0;
 471   time_t             timeout      = 0;
 472
 473   Debug((DEBUG_DNS, "Resolver: timeout_query_list at %s", myctime(now)));
 474   for (request = requestListHead; request; request = next_request) {
 475     next_request = request->next;
 476     timeout = request->sentat + request->timeout;
 477     if (timeout < now) {
 478       if (--request->retries <= 0) {
 479         ++reinfo.re_timeouts;
 480         (*request->query.callback)(request->query.vptr, 0);
 481         rem_request(request);
 482         continue;
 483       }
 484       else {
 485         request->sentat = now;
 486         request->timeout += request->timeout;
 487         resend_query(request);
 488       }
 489     }
 490     if (!next_time || timeout < next_time) {
 491       next_time = timeout;
 492     }
 493   }
 494   return (next_time > now) ? next_time : (now + AR_TTL);
 495 }
 496
 497 /*
 498  * expire_cache - removes entries from the cache which are older
 499  * than their expiry times. returns the time at which the server
 500  * should next poll the cache.
 501  */
 502 static time_t expire_cache(time_t now)
 503 {
 504   struct CacheEntry* cp;
 505   struct CacheEntry* cp_next;
 506   time_t             expire = 0;
 507
 508   Debug((DEBUG_DNS, "Resolver: expire_cache at %s", myctime(now)));
 509   for (cp = cacheTop; cp; cp = cp_next) {
 510     cp_next = cp->list_next;
 511     if (cp->expireat < now) {
 512       ++cainfo.ca_expires;
 513       rem_cache(cp);
 514     }
 515     else if (!expire || expire > cp->expireat)
 516       expire = cp->expireat;
 517   }
 518   return (expire > now) ? expire : (now + AR_TTL);
 519 }
 520
 521 /*
 522  * timeout_resolver - check request list and cache for expired entries
 523  */
 524 time_t timeout_resolver(time_t now)
 525 {
 526   if (nextDNSCheck < now)
 527     nextDNSCheck = timeout_query_list(now);
 528   if (nextCacheExpire < now)
 529     nextCacheExpire = expire_cache(now);
 530   return IRCD_MIN(nextDNSCheck, nextCacheExpire);
 531 }
 532
 533
 534 /*
 535  * delete_resolver_queries - cleanup outstanding queries
 536  * for which there no longer exist clients or conf lines.
 537  */
 538 void delete_resolver_queries(const void* vptr)
 539 {
 540   struct ResRequest* request;
 541   struct ResRequest* next_request;
 542
 543   for (request = requestListHead; request; request = next_request) {
 544     next_request = request->next;
 545     if (vptr == request->query.vptr)
 546       rem_request(request);
 547   }
 548 }
 549
 550 /*
 551  * send_res_msg - sends msg to all nameservers found in the "_res" structure.
 552  * This should reflect /etc/resolv.conf. We will get responses
 553  * which arent needed but is easier than checking to see if nameserver
 554  * isnt present. Returns number of messages successfully sent to
 555  * nameservers or -1 if no successful sends.
 556  */
 557 static int send_res_msg(const u_char* msg, int len, int rcount)
 558 {
 559   int i;
 560   int sent = 0;
 561   int max_queries = IRCD_MIN(_res.nscount, rcount);
 562
 563   assert(0 != msg);
 564   /*
 565    * RES_PRIMARY option is not implemented
 566    * if (_res.options & RES_PRIMARY || 0 == max_queries)
 567    */
 568   if (0 == max_queries)
 569     max_queries = 1;
 570
 571   Debug((DEBUG_DNS, "Resolver: sendto %d", max_queries));
 572
 573   for (i = 0; i < max_queries; i++) {
 574     if (sendto(ResolverFileDescriptor, msg, len, 0,
 575                (struct sockaddr*) &(_res.nsaddr_list[i]),
 576                sizeof(struct sockaddr_in)) == len) {
 577       ++reinfo.re_sent;
 578       ++sent;
 579     }
 580     else
 581       log_write(LS_RESOLVER, L_ERROR, 0, "Resolver: send failed %m");
 582   }
 583   return sent;
 584 }
 585
 586 /*
 587  * find_id - find a dns request id (id is determined by dn_mkquery)
 588  */
 589 static struct ResRequest* find_id(int id)
 590 {
 591   struct ResRequest* request;
 592
 593   for (request = requestListHead; request; request = request->next) {
 594     if (request->id == id)
 595       return request;
 596   }
 597   return NULL;
 598 }
 599
 600 /*
 601  * gethost_byname - get host address from name
 602  */
 603 struct DNSReply* gethost_byname(const char* name,
 604                                const struct DNSQuery* query)
 605 {
 606   struct CacheEntry* cp;
 607   assert(0 != name);
 608
 609   Debug((DEBUG_DNS, "Resolver: gethost_byname %s", name));
 610   ++reinfo.re_na_look;
 611   if ((cp = find_cache_name(name)))
 612     return &(cp->reply);
 613
 614   do_query_name(query, name, NULL);
 615   nextDNSCheck = 1;
 616   return NULL;
 617 }
 618
 619 /*
 620  * gethost_byaddr - get host name from address
 621  */
 622 struct DNSReply* gethost_byaddr(const char* addr,
 623                                 const struct DNSQuery* query)
 624 {
 625   struct CacheEntry *cp;
 626
 627   assert(0 != addr);
 628
 629   Debug((DEBUG_DNS, "Resolver: gethost_byaddr %s", ircd_ntoa(addr)));
 630
 631   ++reinfo.re_nu_look;
 632   if ((cp = find_cache_number(NULL, addr)))
 633     return &(cp->reply);
 634
 635   do_query_number(query, (const struct in_addr*) addr, NULL);
 636   nextDNSCheck = 1;
 637   return NULL;
 638 }
 639
 640 /*
 641  * do_query_name - nameserver lookup name
 642  */
 643 static void do_query_name(const struct DNSQuery* query,
 644                           const char* name, struct ResRequest* request)
 645 {
 646   char  hname[HOSTLEN + 1];
 647   assert(0 != name);
 648
 649   ircd_strncpy(hname, name, HOSTLEN);
 650   hname[HOSTLEN] = '\0';
 651
 652   if (!request) {
 653     request       = make_request(query);
 654     request->type = T_A;
 655     request->name = (char*) MyMalloc(strlen(hname) + 1);
 656     strcpy(request->name, hname);
 657   }
 658   query_name(hname, C_IN, T_A, request);
 659 }
 660
 661 /*
 662  * do_query_number - Use this to do reverse IP# lookups.
 663  */
 664 static void do_query_number(const struct DNSQuery* query,
 665                             const struct in_addr* addr,
 666                             struct ResRequest* request)
 667 {
 668   char  ipbuf[32];
 669   const unsigned char* cp;
 670
 671   assert(0 != addr);
 672   cp = (const unsigned char*) &addr->s_addr;
 673   sprintf_irc(ipbuf, "%u.%u.%u.%u.in-addr.arpa.",
 674               (unsigned int)(cp[3]), (unsigned int)(cp[2]),
 675               (unsigned int)(cp[1]), (unsigned int)(cp[0]));
 676
 677   if (!request) {
 678     request              = make_request(query);
 679     request->type        = T_PTR;
 680     request->addr.s_addr = addr->s_addr;
 681   }
 682   query_name(ipbuf, C_IN, T_PTR, request);
 683 }
 684
 685 /*
 686  * query_name - generate a query based on class, type and name.
 687  */
 688 static void query_name(const char* name, int query_class,
 689                        int type, struct ResRequest* request)
 690 {
 691   char buf[MAXPACKET];
 692   int  request_len = 0;
 693
 694   assert(0 != name);
 695   assert(0 != request);
 696
 697   Debug((DEBUG_DNS, "Resolver: query_name: %s %d %d", name, query_class, type));
 698   memset(buf, 0, sizeof(buf));
 699   if ((request_len = res_mkquery(QUERY, name, query_class, type,
 700                                  0, 0, 0, (unsigned char*) buf, sizeof(buf))) > 0) {
 701     HEADER* header = (HEADER*) buf;
 702 #ifndef LRAND48
 703     int            k = 0;
 704     struct timeval tv;
 705 #endif
 706     /*
 707      * generate a unique id
 708      * NOTE: we don't have to worry about converting this to and from
 709      * network byte order, the nameserver does not interpret this value
 710      * and returns it unchanged
 711      */
 712 #ifdef LRAND48
 713     do {
 714       header->id = (header->id + lrand48()) & 0xffff;
 715     } while (find_id(header->id));
 716 #else
 717     gettimeofday(&tv, NULL);
 718     do {
 719       header->id = (header->id + k + tv.tv_usec) & 0xffff;
 720       ++k;
 721     } while (find_id(header->id));
 722 #endif /* LRAND48 */
 723     request->id = header->id;
 724     ++request->sends;
 725     Debug((DEBUG_DNS, "Resolver: query_name %d: %s %d %d", request->id,
 726           name, query_class, type));
 727     request->sent += send_res_msg((const unsigned char*) buf, request_len, request->sends);
 728   }
 729 }
 730
 731 static void resend_query(struct ResRequest* request)
 732 {
 733   assert(0 != request);
 734
 735   if (request->resend == 0)
 736     return;
 737   ++reinfo.re_resends;
 738   switch(request->type) {
 739   case T_PTR:
 740     do_query_number(NULL, &request->addr, request);
 741     break;
 742   case T_A:
 743     do_query_name(NULL, request->name, request);
 744     break;
 745   default:
 746     break;
 747   }
 748 }
 749
 750 /*
 751  * proc_answer - process name server reply
 752  * build a hostent struct in the passed request
 753  */
 754 static int proc_answer(struct ResRequest* request, HEADER* header,
 755                        u_char* buf, u_char* eob)
 756 {
 757   char   hostbuf[HOSTLEN + 1]; /* working buffer */
 758   u_char* current;             /* current position in buf */
 759   char** alias;                /* alias list */
 760   char** addr;                 /* address list */
 761   char*  name;                 /* pointer to name string */
 762   char*  address;              /* pointer to address */
 763   char*  endp;                 /* end of our buffer */
 764   int    query_class;          /* answer class */
 765   int    type;                 /* answer type */
 766   int    rd_length;            /* record data length */
 767   int    answer_count = 0;     /* answer counter */
 768   int    n;                    /* temp count */
 769   int    addr_count  = 0;      /* number of addresses in hostent */
 770   int    alias_count = 0;      /* number of aliases in hostent */
 771   struct hostent* hp;          /* hostent getting filled */
 772
 773   assert(0 != request);
 774   assert(0 != header);
 775   assert(0 != buf);
 776   assert(0 != eob);
 777
 778   current = buf + sizeof(HEADER);
 779   hp = &(request->he.h);
 780   /*
 781    * lazy allocation of request->he.buf, we don't allocate a buffer
 782    * unless there is something to put in it.
 783    */
 784   if (!request->he.buf) {
 785     request->he.buf = (char*) MyMalloc(MAXGETHOSTLEN + 1);
 786     request->he.buf[MAXGETHOSTLEN] = '\0';
 787     /*
 788      * array of alias list pointers starts at beginning of buf
 789      */
 790     hp->h_aliases = (char**) request->he.buf;
 791     hp->h_aliases[0] = NULL;
 792     /*
 793      * array of address list pointers starts after alias list pointers
 794      * the actual addresses follow the the address list pointers
 795      */
 796     hp->h_addr_list = (char**)(request->he.buf + ALIAS_BLEN);
 797     /*
 798      * don't copy the host address to the beginning of h_addr_list
 799      */
 800     hp->h_addr_list[0] = NULL;
 801   }
 802   endp = request->he.buf + MAXGETHOSTLEN;
 803   /*
 804    * find the end of the address list
 805    */
 806   addr = hp->h_addr_list;
 807   while (*addr) {
 808     ++addr;
 809     ++addr_count;
 810   }
 811   /*
 812    * make address point to first available address slot
 813    */
 814   address = request->he.buf + ADDRS_OFFSET +
 815                     (sizeof(struct in_addr) * addr_count);
 816   /*
 817    * find the end of the alias list
 818    */
 819   alias = hp->h_aliases;
 820   while (*alias) {
 821     ++alias;
 822     ++alias_count;
 823   }
 824   /*
 825    * make name point to first available space in request->buf
 826    */
 827   if (alias_count > 0) {
 828     name = hp->h_aliases[alias_count - 1];
 829     name += (strlen(name) + 1);
 830   }
 831   else if (hp->h_name)
 832     name = hp->h_name + strlen(hp->h_name) + 1;
 833   else
 834     name = request->he.buf + ADDRS_OFFSET + ADDRS_DLEN;
 835
 836   /*
 837    * skip past queries
 838    */
 839   while (header->qdcount-- > 0) {
 840     if ((n = dn_skipname(current, eob)) < 0)
 841       break;
 842     current += (n + QFIXEDSZ);
 843   }
 844   /*
 845    * process each answer sent to us blech.
 846    */
 847   while (header->ancount-- > 0 && current < eob && name < endp) {
 848     n = dn_expand(buf, eob, current, hostbuf, sizeof(hostbuf));
 849     if (n <= 0) {
 850       /*
 851        * no more answers left
 852        */
 853       return answer_count;
 854     }
 855     hostbuf[HOSTLEN] = '\0';
 856     /*
 857      * With Address arithmetic you have to be very anal
 858      * this code was not working on alpha due to that
 859      * (spotted by rodder/jailbird/dianora)
 860      */
 861     current += (size_t) n;
 862
 863     if (!((current + ANSWER_FIXED_SIZE) < eob))
 864       break;
 865
 866     type = _getshort(current);
 867     current += TYPE_SIZE;
 868
 869     query_class = _getshort(current);
 870     current += CLASS_SIZE;
 871
 872     request->ttl = _getlong(current);
 873     current += TTL_SIZE;
 874
 875     rd_length = _getshort(current);
 876     current += RDLENGTH_SIZE;
 877
 878     /*
 879      * Wait to set request->type until we verify this structure
 880      */
 881     switch(type) {
 882     case T_A:
 883       /*
 884        * check for invalid rd_length or too many addresses
 885        */
 886       if (rd_length != sizeof(struct in_addr))
 887         return answer_count;
 888       if (++addr_count < RES_MAXADDRS) {
 889         if (answer_count == 1)
 890           hp->h_addrtype = (query_class == C_IN) ?  AF_INET : AF_UNSPEC;
 891
 892         memcpy(address, current, sizeof(struct in_addr));
 893         *addr++ = address;
 894         *addr = 0;
 895         address += sizeof(struct in_addr);
 896
 897         if (!hp->h_name) {
 898           strcpy(name, hostbuf);
 899           hp->h_name = name;
 900           name += strlen(name) + 1;
 901         }
 902         Debug((DEBUG_DNS, "Resolver: A %s for %s",
 903                ircd_ntoa((char*) hp->h_addr_list[addr_count - 1]), hostbuf));
 904       }
 905       current += rd_length;
 906       ++answer_count;
 907       break;
 908     case T_PTR:
 909       n = dn_expand(buf, eob, current, hostbuf, sizeof(hostbuf));
 910       if (n < 0) {
 911         /*
 912          * broken message
 913          */
 914         return 0;
 915       }
 916       else if (n == 0) {
 917         /*
 918          * no more answers left
 919          */
 920         return answer_count;
 921       }
 922       /*
 923        * This comment is based on analysis by Shadowfax, Wohali and johan,
 924        * not me.  (Dianora) I am only commenting it.
 925        *
 926        * dn_expand is guaranteed to not return more than sizeof(hostbuf)
 927        * but do all implementations of dn_expand also guarantee
 928        * buffer is terminated with null byte? Lets not take chances.
 929        *  -Dianora
 930        */
 931       hostbuf[HOSTLEN] = '\0';
 932       current += (size_t) n;
 933
 934       Debug((DEBUG_DNS, "Resolver: PTR %s", hostbuf));
 935       /*
 936        * copy the returned hostname into the host name
 937        * ignore duplicate ptr records
 938        */
 939       if (!hp->h_name) {
 940         strcpy(name, hostbuf);
 941         hp->h_name = name;
 942         name += strlen(name) + 1;
 943       }
 944       ++answer_count;
 945       break;
 946     case T_CNAME:
 947       Debug((DEBUG_DNS, "Resolver: CNAME %s", hostbuf));
 948       if (++alias_count < RES_MAXALIASES) {
 949         ircd_strncpy(name, hostbuf, endp - name);
 950         *alias++ = name;
 951         *alias   = 0;
 952         name += strlen(name) + 1;
 953       }
 954       current += rd_length;
 955       ++answer_count;
 956       break;
 957     default :
 958       Debug((DEBUG_DNS,"Resolver: proc_answer type: %d for: %s", type, hostbuf));
 959       break;
 960     }
 961   }
 962   return answer_count;
 963 }
 964
 965 /*
 966  * resolver_read - read a dns reply from the nameserver and process it.
 967  * return 0 if nothing was read from the socket, otherwise return 1
 968  */
 969 int resolver_read(void)
 970 {
 971   u_char             buf[sizeof(HEADER) + MAXPACKET];
 972   HEADER*            header       = 0;
 973   struct ResRequest* request      = 0;
 974   struct CacheEntry* cp           = 0;
 975   unsigned int       rc           = 0;
 976   int                answer_count = 0;
 977   struct sockaddr_in sin;
 978
 979   Debug((DEBUG_DNS, "Resolver: read"));
 980   if (IO_SUCCESS != os_recvfrom_nonb(ResolverFileDescriptor,
 981                                      (char*) buf, sizeof(buf), &rc, &sin)) {
 982     return 0;
 983   }
 984   if (rc < sizeof(HEADER)) {
 985     Debug((DEBUG_DNS, "Resolver: short reply %d: %s", rc,
 986            (strerror(errno)) ? strerror(errno) : "Unknown"));
 987     return 0;
 988   }
 989   /*
 990    * convert DNS reply reader from Network byte order to CPU byte order.
 991    */
 992   header = (HEADER*) buf;
 993   /* header->id = ntohs(header->id); */
 994   header->ancount = ntohs(header->ancount);
 995   header->qdcount = ntohs(header->qdcount);
 996   header->nscount = ntohs(header->nscount);
 997   header->arcount = ntohs(header->arcount);
 998   ++reinfo.re_replies;
 999   /*
1000    * response for an id which we have already received an answer for
1001    * just ignore this response.
1002    */
1003   if (0 == (request = find_id(header->id))) {
1004     Debug((DEBUG_DNS, "Resolver: can't find request id: %d", header->id));
1005     return 1;
1006   }
1007   /*
1008    * check against possibly fake replies
1009    */
1010   if (!res_ourserver(&_res, &sin)) {
1011     Debug((DEBUG_DNS, "Resolver: fake reply from: %s", (const char*) &sin.sin_addr));
1012     ++reinfo.re_unkrep;
1013     return 1;
1014   }
1015
1016   if ((header->rcode != NOERROR) || (header->ancount == 0)) {
1017     ++reinfo.re_errors;
1018     if (SERVFAIL == header->rcode)
1019       resend_query(request);
1020     else {
1021       /*
1022        * If a bad error was returned, we stop here and dont send
1023        * send any more (no retries granted).
1024        * Isomer: Perhaps we should return these error messages back to
1025        *         the client?
1026        */
1027 #ifdef DEBUGMODE
1028       switch (header->rcode) {
1029         case NOERROR:
1030           Debug((DEBUG_DNS, "Fatal DNS error: No Error"));
1031           break;
1032         case FORMERR:
1033           Debug((DEBUG_DNS, "Fatal DNS error: Format Error"));
1034           break;
1035         case SERVFAIL:
1036           Debug((DEBUG_DNS, "Fatal DNS error: Server Failure"));
1037           break;
1038         case NXDOMAIN:
1039           Debug((DEBUG_DNS, "DNS error: Non Existant Domain"));
1040           break;
1041         case NOTIMP:
1042           Debug((DEBUG_DNS, "Fatal DNS error: Not Implemented"));
1043           break;
1044         case REFUSED:
1045           Debug((DEBUG_DNS, "Fatal DNS error: Query Refused"));
1046           break;
1047         default:
1048           Debug((DEBUG_DNS, "Unassigned fatal DNS error: %i", header->rcode));
1049           break;
1050       }
1051 #endif /* DEBUGMODE */
1052       (*request->query.callback)(request->query.vptr, 0);
1053       rem_request(request);
1054     }
1055     return 1;
1056   }
1057   /*
1058    * If this fails there was an error decoding the received packet,
1059    * try it again and hope it works the next time.
1060    */
1061   answer_count = proc_answer(request, header, buf, buf + rc);
1062   if (answer_count) {
1063     if (T_PTR == request->type) {
1064       struct DNSReply* reply = 0;
1065       if (0 == request->he.h.h_name) {
1066         /*
1067          * got a PTR response with no name, something bogus is happening
1068          * don't bother trying again, the client address doesn't resolve
1069          */
1070         (*request->query.callback)(request->query.vptr, reply);
1071         rem_request(request);
1072         return 1;
1073       }
1074       Debug((DEBUG_DNS, "relookup %s <-> %s",
1075              request->he.h.h_name, ircd_ntoa((char*) &request->addr)));
1076       /*
1077        * Lookup the 'authoritive' name that we were given for the
1078        * ip#.  By using this call rather than regenerating the
1079        * type we automatically gain the use of the cache with no
1080        * extra kludges.
1081        */
1082       reply = gethost_byname(request->he.h.h_name, &request->query);
1083       if (reply) {
1084         (*request->query.callback)(request->query.vptr, reply);
1085       }
1086       else {
1087         /*
1088          * If name wasn't found, a request has been queued and it will
1089          * be the last one queued.  This is rather nasty way to keep
1090          * a host alias with the query. -avalon
1091          */
1092         MyFree(requestListTail->he.buf);
1093         requestListTail->he.buf = request->he.buf;
1094         request->he.buf = 0;
1095         memcpy(&requestListTail->he.h, &request->he.h, sizeof(struct hostent));
1096       }
1097       rem_request(request);
1098     }
1099     else {
1100       /*
1101        * got a name and address response, client resolved
1102        * XXX - Bug found here by Dianora -
1103        * make_cache() occasionally returns a NULL pointer when a
1104        * PTR returned a CNAME, cp was not checked before so the
1105        * callback was being called with a value of 0x2C != NULL.
1106        */
1107       struct DNSReply* reply = 0;
1108       if (validate_hostent(&request->he.h)) {
1109         if ((cp = make_cache(request)))
1110           reply = &cp->reply;
1111       }
1112       (*request->query.callback)(request->query.vptr, reply);
1113       rem_request(request);
1114     }
1115   }
1116   else if (!request->sent) {
1117     /*
1118      * XXX - we got a response for a query we didn't send with a valid id?
1119      * this should never happen, bail here and leave the client unresolved
1120      */
1121     (*request->query.callback)(request->query.vptr, 0);
1122     rem_request(request);
1123   }
1124   return 1;
1125 }
1126
1127 /*
1128  * resolver_read_multiple - process up to count reads
1129  */
1130 void resolver_read_multiple(int count)
1131 {
1132   int i = 0;
1133   for ( ; i < count; ++i) {
1134     if (0 == resolver_read())
1135       return;
1136   }
1137 }
1138
1139 static size_t calc_hostent_buffer_size(const struct hostent* hp)
1140 {
1141   char** p;
1142   size_t count = 0;
1143   assert(0 != hp);
1144
1145   /*
1146    * space for name
1147    */
1148   count += (strlen(hp->h_name) + 1);
1149   /*
1150    * space for aliases
1151    */
1152   for (p = hp->h_aliases; *p; ++p)
1153     count += (strlen(*p) + 1 + sizeof(char*));
1154   /*
1155    * space for addresses
1156    */
1157   for (p = hp->h_addr_list; *p; ++p)
1158     count += (hp->h_length + sizeof(char*));
1159   /*
1160    * space for 2 nulls to terminate h_aliases and h_addr_list
1161    */
1162   count += (2 * sizeof(char*));
1163   return count;
1164 }
1165
1166
1167 /*
1168  * dup_hostent - Duplicate a hostent struct, allocate only enough memory for
1169  * the data we're putting in it.
1170  */
1171 static void dup_hostent(struct Hostent* new_hp, struct hostent* hp)
1172 {
1173   char*  p;
1174   char** ap;
1175   char** pp;
1176   int    alias_count = 0;
1177   int    addr_count = 0;
1178   size_t bytes_needed = 0;
1179
1180   assert(0 != new_hp);
1181   assert(0 != hp);
1182
1183   /* how much buffer do we need? */
1184   bytes_needed += (strlen(hp->h_name) + 1);
1185
1186   pp = hp->h_aliases;
1187   while (*pp) {
1188     bytes_needed += (strlen(*pp++) + 1 + sizeof(char*));
1189     ++alias_count;
1190   }
1191   pp = hp->h_addr_list;
1192   while (*pp++) {
1193     bytes_needed += (hp->h_length + sizeof(char*));
1194     ++addr_count;
1195   }
1196   /* Reserve space for 2 nulls to terminate h_aliases and h_addr_list */
1197   bytes_needed += (2 * sizeof(char*));
1198
1199   /* Allocate memory */
1200   new_hp->buf = (char*) MyMalloc(bytes_needed);
1201
1202   new_hp->h.h_addrtype = hp->h_addrtype;
1203   new_hp->h.h_length = hp->h_length;
1204
1205   /* first write the address list */
1206   pp = hp->h_addr_list;
1207   ap = new_hp->h.h_addr_list =
1208       (char**)(new_hp->buf + ((alias_count + 1) * sizeof(char*)));
1209   p = (char*)ap + ((addr_count + 1) * sizeof(char*));
1210   while (*pp)
1211   {
1212     *ap++ = p;
1213     memcpy(p, *pp++, hp->h_length);
1214     p += hp->h_length;
1215   }
1216   *ap = 0;
1217   /* next write the name */
1218   new_hp->h.h_name = p;
1219   strcpy(p, hp->h_name);
1220   p += (strlen(p) + 1);
1221
1222   /* last write the alias list */
1223   pp = hp->h_aliases;
1224   ap = new_hp->h.h_aliases = (char**) new_hp->buf;
1225   while (*pp) {
1226     *ap++ = p;
1227     strcpy(p, *pp++);
1228     p += (strlen(p) + 1);
1229   }
1230   *ap = 0;
1231 }
1232
1233 /*
1234  * update_hostent - Add records to a Hostent struct in place.
1235  */
1236 static void update_hostent(struct Hostent* hp, char** addr, char** alias)
1237 {
1238   char*  p;
1239   char** ap;
1240   char** pp;
1241   int    alias_count = 0;
1242   int    addr_count = 0;
1243   char*  buf = NULL;
1244   size_t bytes_needed = 0;
1245
1246   if (!hp || !hp->buf)
1247     return;
1248
1249   /* how much buffer do we need? */
1250   bytes_needed = strlen(hp->h.h_name) + 1;
1251   pp = hp->h.h_aliases;
1252   while (*pp) {
1253     bytes_needed += (strlen(*pp++) + 1 + sizeof(char*));
1254     ++alias_count;
1255   }
1256   if (alias) {
1257     pp = alias;
1258     while (*pp) {
1259       bytes_needed += (strlen(*pp++) + 1 + sizeof(char*));
1260       ++alias_count;
1261     }
1262   }
1263   pp = hp->h.h_addr_list;
1264   while (*pp++) {
1265     bytes_needed += (hp->h.h_length + sizeof(char*));
1266     ++addr_count;
1267   }
1268   if (addr) {
1269     pp = addr;
1270     while (*pp++) {
1271       bytes_needed += (hp->h.h_length + sizeof(char*));
1272       ++addr_count;
1273     }
1274   }
1275   /* Reserve space for 2 nulls to terminate h_aliases and h_addr_list */
1276   bytes_needed += 2 * sizeof(char*);
1277
1278   /* Allocate memory */
1279   buf = (char*) MyMalloc(bytes_needed);
1280   assert(0 != buf);
1281
1282   /* first write the address list */
1283   pp = hp->h.h_addr_list;
1284   ap = hp->h.h_addr_list =
1285       (char**)(buf + ((alias_count + 1) * sizeof(char*)));
1286   p = (char*)ap + ((addr_count + 1) * sizeof(char*));
1287   while (*pp) {
1288     memcpy(p, *pp++, hp->h.h_length);
1289     *ap++ = p;
1290     p += hp->h.h_length;
1291   }
1292   if (addr) {
1293     while (*addr) {
1294       memcpy(p, *addr++, hp->h.h_length);
1295       *ap++ = p;
1296       p += hp->h.h_length;
1297     }
1298   }
1299   *ap = 0;
1300
1301   /* next write the name */
1302   strcpy(p, hp->h.h_name);
1303   hp->h.h_name = p;
1304   p += (strlen(p) + 1);
1305
1306   /* last write the alias list */
1307   pp = hp->h.h_aliases;
1308   ap = hp->h.h_aliases = (char**) buf;
1309   while (*pp) {
1310     strcpy(p, *pp++);
1311     *ap++ = p;
1312     p += (strlen(p) + 1);
1313   }
1314   if (alias) {
1315     while (*alias) {
1316       strcpy(p, *alias++);
1317       *ap++ = p;
1318       p += (strlen(p) + 1);
1319     }
1320   }
1321   *ap = 0;
1322   /* release the old buffer */
1323   p = hp->buf;
1324   hp->buf = buf;
1325   MyFree(p);
1326 }
1327
1328 /*
1329  * hash_number - IP address hash function
1330  */
1331 static int hash_number(const unsigned char* ip)
1332 {
1333   /* could use loop but slower */
1334   unsigned int hashv;
1335   const u_char* p = (const u_char*) ip;
1336
1337   assert(0 != p);
1338
1339   hashv = *p++;
1340   hashv += hashv + *p++;
1341   hashv += hashv + *p++;
1342   hashv += hashv + *p;
1343   hashv %= ARES_CACSIZE;
1344   return hashv;
1345 }
1346
1347 /*
1348  * hash_name - hostname hash function
1349  */
1350 static int hash_name(const char* name)
1351 {
1352   unsigned int hashv = 0;
1353   const u_char* p = (const u_char*) name;
1354
1355   assert(0 != p);
1356
1357   for (; *p && *p != '.'; ++p)
1358     hashv += *p;
1359   hashv %= ARES_CACSIZE;
1360   return hashv;
1361 }
1362
1363 /*
1364  * add_to_cache - Add a new cache item to the queue and hash table.
1365  */
1366 static struct CacheEntry* add_to_cache(struct CacheEntry* ocp)
1367 {
1368   int  hashv;
1369
1370   assert(0 != ocp);
1371
1372   ocp->list_next = cacheTop;
1373   cacheTop = ocp;
1374
1375   hashv = hash_name(ocp->he.h.h_name);
1376
1377   ocp->hname_next = hashtable[hashv].name_list;
1378   hashtable[hashv].name_list = ocp;
1379
1380   hashv = hash_number((const unsigned char*) ocp->he.h.h_addr);
1381
1382   ocp->hnum_next = hashtable[hashv].num_list;
1383   hashtable[hashv].num_list = ocp;
1384
1385   /*
1386    * LRU deletion of excessive cache entries.
1387    */
1388   if (++cachedCount > MAXCACHED) {
1389     struct CacheEntry* cp;
1390     struct CacheEntry* cp_next;
1391     for (cp = ocp->list_next; cp; cp = cp_next) {
1392       cp_next = cp->list_next;
1393       rem_cache(cp);
1394     }
1395   }
1396   ++cainfo.ca_adds;
1397   return ocp;
1398 }
1399
1400 /*
1401  * update_list - does not alter the cache structure passed. It is assumed that
1402  * it already contains the correct expire time, if it is a new entry. Old
1403  * entries have the expirey time updated.
1404 */
1405 static void update_list(struct ResRequest* request, struct CacheEntry* cachep)
1406 {
1407 #if 0
1408   struct CacheEntry** cpp;
1409 #endif
1410   struct CacheEntry*  cp = cachep;
1411   char*    s;
1412   char*    t;
1413   int      i;
1414   int      j;
1415   char**   ap;
1416   char*    addrs[RES_MAXADDRS + 1];
1417   char*    aliases[RES_MAXALIASES + 1];
1418
1419   /*
1420    * search for the new cache item in the cache list by hostname.
1421    * If found, move the entry to the top of the list and return.
1422    */
1423   ++cainfo.ca_updates;
1424 #if 0
1425   for (cpp = &cacheTop; *cpp; cpp = &((*cpp)->list_next)) {
1426     if (cp == *cpp)
1427       break;
1428   }
1429   if (!*cpp)
1430     return;
1431   *cpp = cp->list_next;
1432   cp->list_next = cacheTop;
1433   cacheTop = cp;
1434 #endif
1435
1436   if (!request)
1437     return;
1438   /*
1439    * Compare the cache entry against the new record.  Add any
1440    * previously missing names for this entry.
1441    */
1442   *aliases = 0;
1443   ap = aliases;
1444   for (i = 0, s = request->he.h.h_name; s; s = request->he.h.h_aliases[i++]) {
1445     for (j = 0, t = cp->he.h.h_name; t; t = cp->he.h.h_aliases[j++]) {
1446       if (0 == ircd_strcmp(t, s))
1447         break;
1448     }
1449     if (!t) {
1450       *ap++ = s;
1451       *ap = 0;
1452     }
1453   }
1454   /*
1455    * Do the same again for IP#'s.
1456    */
1457   *addrs = 0;
1458   ap = addrs;
1459   for (i = 0; (s = request->he.h.h_addr_list[i]); i++) {
1460     for (j = 0; (t = cp->he.h.h_addr_list[j]); j++) {
1461       if (!memcmp(t, s, sizeof(struct in_addr)))
1462         break;
1463     }
1464     if (!t) {
1465       *ap++ = s;
1466       *ap = 0;
1467     }
1468   }
1469   if (*addrs || *aliases)
1470     update_hostent(&cp->he, addrs, aliases);
1471 }
1472
1473 /*
1474  * find_cache_name - find name in nameserver cache
1475  */
1476 static struct CacheEntry* find_cache_name(const char* name)
1477 {
1478   struct CacheEntry* cp;
1479   char*   s;
1480   int     hashv;
1481   int     i;
1482
1483   assert(0 != name);
1484   hashv = hash_name(name);
1485
1486   cp = hashtable[hashv].name_list;
1487
1488   for (; cp; cp = cp->hname_next) {
1489     for (i = 0, s = cp->he.h.h_name; s; s = cp->he.h.h_aliases[i++]) {
1490       if (0 == ircd_strcmp(s, name)) {
1491         ++cainfo.ca_na_hits;
1492         return cp;
1493       }
1494     }
1495   }
1496
1497   for (cp = cacheTop; cp; cp = cp->list_next) {
1498     /*
1499      * if no aliases or the hash value matches, we've already
1500      * done this entry and all possiblilities concerning it.
1501      */
1502     if (!cp->he.h.h_name || hashv == hash_name(cp->he.h.h_name))
1503       continue;
1504     for (i = 0, s = cp->he.h.h_aliases[i]; s; s = cp->he.h.h_aliases[++i]) {
1505       if (0 == ircd_strcmp(name, s)) {
1506         ++cainfo.ca_na_hits;
1507         return cp;
1508       }
1509     }
1510   }
1511   return NULL;
1512 }
1513
1514 /*
1515  * find_cache_number - find a cache entry by ip# and update its expire time
1516  */
1517 static struct CacheEntry* find_cache_number(struct ResRequest* request,
1518                                             const char* addr)
1519 {
1520   struct CacheEntry* cp;
1521   int     hashv;
1522   int     i;
1523
1524   assert(0 != addr);
1525   hashv = hash_number((const unsigned char*) addr);
1526   cp = hashtable[hashv].num_list;
1527
1528   for (; cp; cp = cp->hnum_next) {
1529     for (i = 0; cp->he.h.h_addr_list[i]; ++i) {
1530       if (!memcmp(cp->he.h.h_addr_list[i], addr, sizeof(struct in_addr))) {
1531         ++cainfo.ca_nu_hits;
1532         return cp;
1533       }
1534     }
1535   }
1536   for (cp = cacheTop; cp; cp = cp->list_next) {
1537     /*
1538      * single address entry...would have been done by hashed
1539      * search above...
1540      * if the first IP# has the same hashnumber as the IP# we
1541      * are looking for, its been done already.
1542      */
1543     if (!cp->he.h.h_addr_list[1] ||
1544         hashv == hash_number((const unsigned char*) cp->he.h.h_addr_list[0]))
1545       continue;
1546     for (i = 1; cp->he.h.h_addr_list[i]; ++i) {
1547       if (!memcmp(cp->he.h.h_addr_list[i], addr, sizeof(struct in_addr))) {
1548         ++cainfo.ca_nu_hits;
1549         return cp;
1550       }
1551     }
1552   }
1553   return NULL;
1554 }
1555
1556 static struct CacheEntry* make_cache(struct ResRequest* request)
1557 {
1558   struct CacheEntry* cp;
1559   int     i;
1560   struct hostent* hp;
1561   assert(0 != request);
1562
1563   hp = &request->he.h;
1564   /*
1565    * shouldn't happen but it just might...
1566    */
1567   assert(0 != hp->h_name);
1568   assert(0 != hp->h_addr_list[0]);
1569   if (!hp->h_name || !hp->h_addr_list[0])
1570     return NULL;
1571   /*
1572    * Make cache entry.  First check to see if the cache already exists
1573    * and if so, return a pointer to it.
1574    */
1575   for (i = 0; hp->h_addr_list[i]; ++i) {
1576     if ((cp = find_cache_number(request, hp->h_addr_list[i]))) {
1577       update_list(request, cp);
1578       return cp;
1579     }
1580   }
1581   /*
1582    * a matching entry wasnt found in the cache so go and make one up.
1583    */
1584   cp = (struct CacheEntry*) MyMalloc(sizeof(struct CacheEntry));
1585   assert(0 != cp);
1586
1587   memset(cp, 0, sizeof(struct CacheEntry));
1588   dup_hostent(&cp->he, hp);
1589   cp->reply.hp = &cp->he.h;
1590   /*
1591    * hmmm... we could time out the cache after 10 minutes regardless
1592    * would that be reasonable since we don't save the reply?
1593    */
1594   if (request->ttl < AR_TTL) {
1595     ++reinfo.re_shortttl;
1596     cp->ttl = AR_TTL;
1597   }
1598   else
1599     cp->ttl = request->ttl;
1600   cp->expireat = CurrentTime + cp->ttl;
1601   return add_to_cache(cp);
1602 }
1603
1604 /*
1605  * rem_cache - delete a cache entry from the cache structures
1606  * and lists and return all memory used for the cache back to the memory pool.
1607  */
1608 static void rem_cache(struct CacheEntry* ocp)
1609 {
1610   struct CacheEntry** cp;
1611   int                 hashv;
1612   struct hostent*     hp;
1613   assert(0 != ocp);
1614
1615
1616   if (0 < ocp->reply.ref_count) {
1617     if (ocp->expireat < CurrentTime) {
1618       ocp->expireat = CurrentTime + AR_TTL;
1619       Debug((DEBUG_DNS, "Resolver: referenced cache entry not removed for: %s",
1620             ocp->he.h.h_name));
1621     }
1622     return;
1623   }
1624   /*
1625    * remove cache entry from linked list
1626    */
1627   for (cp = &cacheTop; *cp; cp = &((*cp)->list_next)) {
1628     if (*cp == ocp) {
1629       *cp = ocp->list_next;
1630       break;
1631     }
1632   }
1633   hp = &ocp->he.h;
1634   /*
1635    * remove cache entry from hashed name list
1636    */
1637   assert(0 != hp->h_name);
1638   hashv = hash_name(hp->h_name);
1639
1640   for (cp = &hashtable[hashv].name_list; *cp; cp = &((*cp)->hname_next)) {
1641     if (*cp == ocp) {
1642       *cp = ocp->hname_next;
1643       break;
1644     }
1645   }
1646   /*
1647    * remove cache entry from hashed number list
1648    */
1649   hashv = hash_number((const unsigned char*) hp->h_addr);
1650   assert(-1 < hashv);
1651
1652   for (cp = &hashtable[hashv].num_list; *cp; cp = &((*cp)->hnum_next)) {
1653     if (*cp == ocp) {
1654       *cp = ocp->hnum_next;
1655       break;
1656     }
1657   }
1658   /*
1659    * free memory used to hold the various host names and the array
1660    * of alias pointers.
1661    */
1662   MyFree(ocp->he.buf);
1663   MyFree(ocp);
1664   --cachedCount;
1665   ++cainfo.ca_dels;
1666 }
1667
1668 void flush_resolver_cache(void)
1669 {
1670   /*
1671    * stubbed - iterate cache and remove everything that isn't referenced
1672    */
1673 }
1674
1675 /*
1676  * m_dns - dns status query
1677  */
1678 int m_dns(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
1679 {
1680 #if !defined(NDEBUG)
1681   struct CacheEntry* cp;
1682   int     i;
1683   struct hostent* hp;
1684
1685   if (parv[1] && *parv[1] == 'l') {
1686     for(cp = cacheTop; cp; cp = cp->list_next) {
1687       hp = &cp->he.h;
1688       sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Ex %d ttl %d host %s(%s)",
1689                     sptr, cp->expireat - CurrentTime, cp->ttl,
1690                     hp->h_name, ircd_ntoa(hp->h_addr));
1691       for (i = 0; hp->h_aliases[i]; i++)
1692         sendcmdto_one(&me, CMD_NOTICE, sptr, "%C : %s = %s (CN)", sptr,
1693                       hp->h_name, hp->h_aliases[i]);
1694       for (i = 1; hp->h_addr_list[i]; i++)
1695         sendcmdto_one(&me, CMD_NOTICE, sptr, "%C : %s = %s (IP)", sptr,
1696                       hp->h_name, ircd_ntoa(hp->h_addr_list[i]));
1697     }
1698     return 0;
1699   }
1700   if (parv[1] && *parv[1] == 'd') {
1701     sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :ResolverFileDescriptor = %d",
1702                   sptr, ResolverFileDescriptor);
1703     return 0;
1704   }
1705   sendcmdto_one(&me, CMD_NOTICE, sptr,"%C :Ca %d Cd %d Ce %d Cl %d Ch %d:%d "
1706                 "Cu %d", sptr,
1707                 cainfo.ca_adds, cainfo.ca_dels, cainfo.ca_expires,
1708                 cainfo.ca_lookups, cainfo.ca_na_hits, cainfo.ca_nu_hits,
1709                 cainfo.ca_updates);
1710
1711   sendcmdto_one(&me, CMD_NOTICE, sptr,"%C :Re %d Rl %d/%d Rp %d Rq %d",
1712                 sptr, reinfo.re_errors, reinfo.re_nu_look,
1713                 reinfo.re_na_look, reinfo.re_replies, reinfo.re_requests);
1714   sendcmdto_one(&me, CMD_NOTICE, sptr,"%C :Ru %d Rsh %d Rs %d(%d) Rt %d", sptr,
1715                 reinfo.re_unkrep, reinfo.re_shortttl, reinfo.re_sent,
1716                 reinfo.re_resends, reinfo.re_timeouts);
1717 #endif
1718   return 0;
1719 }
1720
1721 size_t cres_mem(struct Client* sptr)
1722 {
1723   struct CacheEntry* entry;
1724   struct ResRequest* request;
1725   size_t cache_mem     = 0;
1726   size_t request_mem   = 0;
1727   int    cache_count   = 0;
1728   int    request_count = 0;
1729
1730   for (entry = cacheTop; entry; entry = entry->list_next) {
1731     cache_mem += sizeof(struct CacheEntry);
1732     cache_mem += calc_hostent_buffer_size(&entry->he.h);
1733     ++cache_count;
1734   }
1735   for (request = requestListHead; request; request = request->next) {
1736     request_mem += sizeof(struct ResRequest);
1737     if (request->name)
1738       request_mem += strlen(request->name) + 1;
1739     if (request->he.buf)
1740       request_mem += MAXGETHOSTLEN + 1;
1741     ++request_count;
1742   }
1743
1744   if (cachedCount != cache_count) {
1745     send_reply(sptr, SND_EXPLICIT | RPL_STATSDEBUG,
1746                ":Resolver: cache count mismatch: %d != %d", cachedCount,
1747                cache_count);
1748     assert(cachedCount == cache_count);
1749   }
1750   send_reply(sptr, SND_EXPLICIT | RPL_STATSDEBUG,
1751              ":Resolver: cache %d(%d) requests %d(%d)", cache_count,
1752              cache_mem, request_count, request_mem);
1753   return cache_mem + request_mem;
1754 }
1755