src/dns.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
   6  *                     E-mail:
   7  *              <brain@chatspike.net>
   8  *              <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *          the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 /*
  18 dns.cpp - Nonblocking DNS functions.
  19 Very very loosely based on the firedns library,
  20 Copyright (C) 2002 Ian Gulliver. This file is no
  21 longer anything like firedns, there are many major
  22 differences between this code and the original.
  23 Please do not assume that firedns works like this,
  24 looks like this, walks like this or tastes like this.
  25 */
  26
  27 using namespace std;
  28
  29 #include <string>
  30 #include <time.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <errno.h>
  34 #include <sys/types.h>
  35 #include <sys/socket.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #include <map>
  39 #include "dns.h"
  40 #include "inspircd.h"
  41 #include "helperfuncs.h"
  42 #include "inspircd_config.h"
  43 #include "socketengine.h"
  44 #include "configreader.h"
  45
  46 /* We need these */
  47 extern InspIRCd* ServerInstance;
  48 extern ServerConfig* Config;
  49
  50 /* Master file descriptor */
  51 int DNS::MasterSocket;
  52
  53 /* Masks to mask off the responses we get from the DNSRequest methods */
  54 enum QueryInfo
  55 {
  56         ERROR_MASK      = 0x10000       /* Result is an error */
  57 };
  58
  59 /* Flags which can be ORed into a request or reply for different meanings */
  60 enum QueryFlags
  61 {
  62         FLAGS_MASK_RD           = 0x01, /* Recursive */
  63         FLAGS_MASK_TC           = 0x02,
  64         FLAGS_MASK_AA           = 0x04, /* Authoritative */
  65         FLAGS_MASK_OPCODE       = 0x78,
  66         FLAGS_MASK_QR           = 0x80,
  67         FLAGS_MASK_RCODE        = 0x0F, /* Request */
  68         FLAGS_MASK_Z            = 0x70,
  69         FLAGS_MASK_RA           = 0x80
  70 };
  71
  72
  73 /* Represents a dns resource record (rr) */
  74 class ResourceRecord
  75 {
  76  public:
  77         QueryType       type;           /* Record type */
  78         unsigned int    rr_class;       /* Record class */
  79         unsigned long   ttl;            /* Time to live */
  80         unsigned int    rdlength;       /* Record length */
  81 };
  82
  83 /* Represents a dns request/reply header, and its payload as opaque data.
  84  */
  85 class DNSHeader
  86 {
  87  public:
  88         unsigned char   id[2];          /* Request id */
  89         unsigned int    flags1;         /* Flags */
  90         unsigned int    flags2;         /* Flags */
  91         unsigned int    qdcount;
  92         unsigned int    ancount;        /* Answer count */
  93         unsigned int    nscount;        /* Nameserver count */
  94         unsigned int    arcount;
  95         unsigned char   payload[512];   /* Packet payload */
  96 };
  97
  98 /* Represents a request 'on the wire' with routing information relating to
  99  * where to call when we get a result
 100  */
 101 class DNSRequest
 102 {
 103  public:
 104         unsigned char   id[2];          /* Request id */
 105         unsigned char*  res;            /* Result processing buffer */
 106         unsigned int    rr_class;       /* Request class */
 107         QueryType       type;           /* Request type */
 108         insp_inaddr     myserver;       /* DNS server address*/
 109
 110         /* Allocate the processing buffer */
 111         DNSRequest(insp_inaddr server)
 112         {
 113                 res = new unsigned char[512];
 114                 *res = 0;
 115                 memcpy(&myserver, &server, sizeof(insp_inaddr));
 116         }
 117
 118         /* Deallocate the processing buffer */
 119         ~DNSRequest()
 120         {
 121                 delete[] res;
 122         }
 123
 124         /* Called when a result is ready to be processed which matches this id */
 125         DNSInfo ResultIsReady(DNSHeader &h, int length);
 126
 127         /* Called when there are requests to be sent out */
 128         int SendRequests(const DNSHeader *header, const int length, QueryType qt);
 129 };
 130
 131 /* Fill a ResourceRecord class based on raw data input */
 132 inline void DNS::FillResourceRecord(ResourceRecord* rr, const unsigned char *input)
 133 {
 134         rr->type = (QueryType)((input[0] << 8) + input[1]);
 135         rr->rr_class = (input[2] << 8) + input[3];
 136         rr->ttl = (input[4] << 24) + (input[5] << 16) + (input[6] << 8) + input[7];
 137         rr->rdlength = (input[8] << 8) + input[9];
 138 }
 139
 140 /* Fill a DNSHeader class based on raw data input of a given length */
 141 inline void DNS::FillHeader(DNSHeader *header, const unsigned char *input, const int length)
 142 {
 143         header->id[0] = input[0];
 144         header->id[1] = input[1];
 145         header->flags1 = input[2];
 146         header->flags2 = input[3];
 147         header->qdcount = (input[4] << 8) + input[5];
 148         header->ancount = (input[6] << 8) + input[7];
 149         header->nscount = (input[8] << 8) + input[9];
 150         header->arcount = (input[10] << 8) + input[11];
 151         memcpy(header->payload,&input[12],length);
 152 }
 153
 154 /* Empty a DNSHeader class out into raw data, ready for transmission */
 155 inline void DNS::EmptyHeader(unsigned char *output, const DNSHeader *header, const int length)
 156 {
 157         output[0] = header->id[0];
 158         output[1] = header->id[1];
 159         output[2] = header->flags1;
 160         output[3] = header->flags2;
 161         output[4] = header->qdcount >> 8;
 162         output[5] = header->qdcount & 0xFF;
 163         output[6] = header->ancount >> 8;
 164         output[7] = header->ancount & 0xFF;
 165         output[8] = header->nscount >> 8;
 166         output[9] = header->nscount & 0xFF;
 167         output[10] = header->arcount >> 8;
 168         output[11] = header->arcount & 0xFF;
 169         memcpy(&output[12],header->payload,length);
 170 }
 171
 172 /* Send requests we have previously built down the UDP socket */
 173 int DNSRequest::SendRequests(const DNSHeader *header, const int length, QueryType qt)
 174 {
 175         insp_sockaddr addr;
 176         unsigned char payload[sizeof(DNSHeader)];
 177
 178         this->rr_class = 1;
 179         this->type = qt;
 180
 181         DNS::EmptyHeader(payload,header,length);
 182
 183         memset(&addr,0,sizeof(addr));
 184 #ifdef IPV6
 185         memcpy(&addr.sin6_addr,&myserver,sizeof(addr.sin6_addr));
 186         addr.sin6_family = AF_FAMILY;
 187         addr.sin6_port = htons(DNS::QUERY_PORT);
 188 #else
 189         memcpy(&addr.sin_addr.s_addr,&myserver,sizeof(addr.sin_addr));
 190         addr.sin_family = AF_FAMILY;
 191         addr.sin_port = htons(DNS::QUERY_PORT);
 192 #endif
 193         if (sendto(DNS::GetMasterSocket(), payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) == -1)
 194         {
 195                 log(DEBUG,"Error in sendto!");
 196                 return -1;
 197         }
 198
 199         return 0;
 200 }
 201
 202 /* Add a query with a predefined header, and allocate an ID for it. */
 203 DNSRequest* DNS::AddQuery(DNSHeader *header, int &id)
 204 {
 205         /* Are there already the max number of requests on the go? */
 206         if (requests.size() == DNS::MAX_REQUEST_ID + 1)
 207                 return NULL;
 208
 209         /* Create an id */
 210         id = this->PRNG() & DNS::MAX_REQUEST_ID;
 211
 212         /* If this id is already 'in flight', pick another. */
 213         while (requests.find(id) != requests.end())
 214                 id = this->PRNG() & DNS::MAX_REQUEST_ID;
 215
 216         DNSRequest* req = new DNSRequest(this->myserver);
 217
 218         header->id[0] = req->id[0] = id >> 8;
 219         header->id[1] = req->id[1] = id & 0xFF;
 220         header->flags1 = FLAGS_MASK_RD;
 221         header->flags2 = 0;
 222         header->qdcount = 1;
 223         header->ancount = 0;
 224         header->nscount = 0;
 225         header->arcount = 0;
 226
 227         /* At this point we already know the id doesnt exist,
 228          * so there needs to be no second check for the ::end()
 229          */
 230         requests[id] = req;
 231
 232         /* According to the C++ spec, new never returns NULL. */
 233         return req;
 234 }
 235
 236 int DNS::GetMasterSocket()
 237 {
 238         return MasterSocket;
 239 }
 240
 241 /* Initialise the DNS UDP socket so that we can send requests */
 242 DNS::DNS()
 243 {
 244         insp_inaddr addr;
 245
 246         /* Clear the Resolver class table */
 247         memset(Classes,0,sizeof(Classes));
 248
 249         /* Set the id of the next request to 0
 250          */
 251         currid = 0;
 252
 253         /* Clear the namesever address */
 254         memset(&myserver,0,sizeof(insp_inaddr));
 255
 256         /* Convert the nameserver address into an insp_inaddr */
 257         if (insp_aton(Config->DNSServer,&addr) > 0)
 258                 memcpy(&myserver,&addr,sizeof(insp_inaddr));
 259
 260         /* Initialize mastersocket */
 261         MasterSocket = socket(PF_PROTOCOL, SOCK_DGRAM, 0);
 262         if (MasterSocket != -1)
 263         {
 264                 /* Did it succeed? */
 265                 if (fcntl(MasterSocket, F_SETFL, O_NONBLOCK) != 0)
 266                 {
 267                         /* Couldn't make the socket nonblocking */
 268                         shutdown(MasterSocket,2);
 269                         close(MasterSocket);
 270                         MasterSocket = -1;
 271                 }
 272         }
 273         /* Have we got a socket and is it nonblocking? */
 274         if (MasterSocket != -1)
 275         {
 276 #ifdef IPV6
 277                 insp_sockaddr addr;
 278                 memset(&addr,0,sizeof(addr));
 279                 addr.sin6_family = AF_FAMILY;
 280                 addr.sin6_port = 0;
 281                 memset(&addr.sin6_addr,255,sizeof(in6_addr));
 282 #else
 283                 insp_sockaddr addr;
 284                 memset(&addr,0,sizeof(addr));
 285                 addr.sin_family = AF_FAMILY;
 286                 addr.sin_port = 0;
 287                 addr.sin_addr.s_addr = INADDR_ANY;
 288 #endif
 289                 /* Bind the port */
 290                 if (bind(MasterSocket,(sockaddr *)&addr,sizeof(addr)) != 0)
 291                 {
 292                         /* Failed to bind */
 293                         log(DEBUG,"Cant bind DNS::MasterSocket");
 294                         shutdown(MasterSocket,2);
 295                         close(MasterSocket);
 296                         MasterSocket = -1;
 297                 }
 298
 299                 if (MasterSocket >= 0)
 300                 {
 301                         /* Hook the descriptor into the socket engine */
 302                         if (ServerInstance && ServerInstance->SE)
 303                                 ServerInstance->SE->AddFd(MasterSocket,true,X_ESTAB_DNS);
 304                 }
 305         }
 306 }
 307
 308 /* Build a payload to be placed after the header, based upon input data, a resource type, a class and a pointer to a buffer */
 309 int DNS::MakePayload(const char * const name, const QueryType rr, const unsigned short rr_class, unsigned char * const payload)
 310 {
 311         short payloadpos = 0;
 312         const char* tempchr, *tempchr2 = name;
 313         unsigned short length;
 314
 315         /* split name up into labels, create query */
 316         while ((tempchr = strchr(tempchr2,'.')) != NULL)
 317         {
 318                 length = tempchr - tempchr2;
 319                 if (payloadpos + length + 1 > 507)
 320                         return -1;
 321                 payload[payloadpos++] = length;
 322                 memcpy(&payload[payloadpos],tempchr2,length);
 323                 payloadpos += length;
 324                 tempchr2 = &tempchr[1];
 325         }
 326         length = strlen(tempchr2);
 327         if (length)
 328         {
 329                 if (payloadpos + length + 2 > 507)
 330                         return -1;
 331                 payload[payloadpos++] = length;
 332                 memcpy(&payload[payloadpos],tempchr2,length);
 333                 payloadpos += length;
 334                 payload[payloadpos++] = 0;
 335         }
 336         if (payloadpos > 508)
 337                 return -1;
 338         length = htons(rr);
 339         memcpy(&payload[payloadpos],&length,2);
 340         length = htons(rr_class);
 341         memcpy(&payload[payloadpos + 2],&length,2);
 342         return payloadpos + 4;
 343 }
 344
 345 /* Start lookup of an hostname to an IP address */
 346 int DNS::GetIP(const char *name)
 347 {
 348         DNSHeader h;
 349         int id;
 350         int length;
 351
 352         if ((length = this->MakePayload(name, DNS_QUERY_A, 1, (unsigned char*)&h.payload)) == -1)
 353                 return -1;
 354
 355         DNSRequest* req = this->AddQuery(&h, id);
 356
 357         if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_A) == -1))
 358                 return -1;
 359
 360         return id;
 361 }
 362
 363 /* Start lookup of an hostname to an IPv6 address */
 364 int DNS::GetIP6(const char *name)
 365 {
 366         DNSHeader h;
 367         int id;
 368         int length;
 369
 370         if ((length = this->MakePayload(name, DNS_QUERY_AAAA, 1, (unsigned char*)&h.payload)) == -1)
 371                 return -1;
 372
 373         DNSRequest* req = this->AddQuery(&h, id);
 374
 375         if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_AAAA) == -1))
 376                 return -1;
 377
 378         return id;
 379 }
 380
 381 /* Start lookup of a cname to another name */
 382 int DNS::GetCName(const char *alias)
 383 {
 384         DNSHeader h;
 385         int id;
 386         int length;
 387
 388         if ((length = this->MakePayload(alias, DNS_QUERY_CNAME, 1, (unsigned char*)&h.payload)) == -1)
 389                 return -1;
 390
 391         DNSRequest* req = this->AddQuery(&h, id);
 392
 393         if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_CNAME) == -1))
 394                 return -1;
 395
 396         return id;
 397 }
 398
 399 /* Start lookup of an IP address to a hostname */
 400 int DNS::GetName(const insp_inaddr *ip)
 401 {
 402         char query[128];
 403         DNSHeader h;
 404         int id;
 405         int length;
 406
 407 #ifdef IPV6
 408         DNS::MakeIP6Int(query, (in6_addr*)ip);
 409 #else
 410         unsigned char* c = (unsigned char*)&ip->s_addr;
 411
 412         sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]);
 413 #endif
 414
 415         if ((length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload)) == -1)
 416                 return -1;
 417
 418         DNSRequest* req = this->AddQuery(&h, id);
 419
 420         if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1))
 421                 return -1;
 422
 423         return id;
 424 }
 425
 426 /* Start lookup of an IP address to a hostname */
 427 int DNS::GetNameForce(const char *ip, ForceProtocol fp)
 428 {
 429         char query[128];
 430         DNSHeader h;
 431         int id;
 432         int length;
 433
 434         if (fp == PROTOCOL_IPV6)
 435         {
 436                 in6_addr i;
 437                 if (inet_pton(AF_INET6, ip, &i) > 0)
 438                 {
 439                         DNS::MakeIP6Int(query, &i);
 440                 }
 441                 else
 442                         /* Invalid IP address */
 443                         return -1;
 444         }
 445         else
 446         {
 447                 in_addr i;
 448                 if (inet_aton(ip, &i))
 449                 {
 450                         unsigned char* c = (unsigned char*)&i.s_addr;
 451                         sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]);
 452                 }
 453                 else
 454                         /* Invalid IP address */
 455                         return -1;
 456         }
 457
 458         log(DEBUG,"DNS::GetNameForce: %s %d",query, fp);
 459
 460         if ((length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload)) == -1)
 461                 return -1;
 462
 463         DNSRequest* req = this->AddQuery(&h, id);
 464
 465         if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1))
 466                 return -1;
 467
 468         return id;
 469 }
 470
 471 void DNS::MakeIP6Int(char* query, const in6_addr *ip)
 472 {
 473         const char* hex = "0123456789abcdef";
 474         int step = 31; /* 32 nibbles, 0..31 */
 475         for (int index = 15; index > -1; (!(step-- % 2) ? index-- : index = index)) /* for() loop steps twice per byte */
 476         {
 477                 if (step % 2)
 478                         /* low nibble */
 479                         *query++ = hex[ip->s6_addr[index] & 0x0F];
 480                 else
 481                         /* high nibble */
 482                         *query++ = hex[(ip->s6_addr[index] & 0xF0) >> 4];
 483                 *query++ = '.'; /* Seperator */
 484         }
 485         strcpy(query,"ip6.int"); /* Suffix the string */
 486 }
 487
 488 /* Return the next id which is ready, and the result attached to it */
 489 DNSResult DNS::GetResult()
 490 {
 491         /* Fetch dns query response and decide where it belongs */
 492         DNSHeader header;
 493         DNSRequest *req;
 494         unsigned char buffer[sizeof(DNSHeader)];
 495         sockaddr from;
 496         socklen_t x = sizeof(from);
 497         const char* ipaddr_from = "";
 498         unsigned short int port_from = 0;
 499
 500         int length = recvfrom(MasterSocket,buffer,sizeof(DNSHeader),0,&from,&x);
 501
 502         /* Did we get the whole header? */
 503         if (length < 12)
 504                 /* Nope - something screwed up. */
 505                 return std::make_pair(-1,"");
 506
 507         /* Check wether the reply came from a different DNS
 508          * server to the one we sent it to, or the source-port
 509          * is not 53.
 510          * A user could in theory still spoof dns packets anyway
 511          * but this is less trivial than just sending garbage
 512          * to the client, which is possible without this check.
 513          *
 514          * -- Thanks jilles for pointing this one out.
 515          */
 516 #ifdef IPV6
 517         ipaddr_from = insp_ntoa(((sockaddr_in6*)&from)->sin6_addr);
 518         port_from = ntohs(((sockaddr_in6*)&from)->sin6_port);
 519 #else
 520         ipaddr_from = insp_ntoa(((sockaddr_in*)&from)->sin_addr);
 521         port_from = ntohs(((sockaddr_in*)&from)->sin_port);
 522 #endif
 523
 524         if ((port_from != DNS::QUERY_PORT) || (strcasecmp(ipaddr_from, Config->DNSServer)))
 525                 return std::make_pair(-1,"");
 526
 527         /* Put the read header info into a header class */
 528         DNS::FillHeader(&header,buffer,length - 12);
 529
 530         /* Get the id of this request.
 531          * Its a 16 bit value stored in two char's,
 532          * so we use logic shifts to create the value.
 533          */
 534         unsigned long this_id = header.id[1] + (header.id[0] << 8);
 535
 536         /* Do we have a pending request matching this id? */
 537         requestlist_iter n_iter = requests.find(this_id);
 538         if (n_iter == requests.end())
 539         {
 540                 /* Somehow we got a DNS response for a request we never made... */
 541                 log(DEBUG,"DNS: got a response for a query we didnt send with fd=%d queryid=%d",MasterSocket,this_id);
 542                 return std::make_pair(-1,"");
 543         }
 544         else
 545         {
 546                 /* Remove the query from the list of pending queries */
 547                 req = (DNSRequest*)n_iter->second;
 548                 requests.erase(n_iter);
 549         }
 550
 551         /* Inform the DNSRequest class that it has a result to be read.
 552          * When its finished it will return a DNSInfo which is a pair of
 553          * unsigned char* resource record data, and an error message.
 554          */
 555         DNSInfo data = req->ResultIsReady(header, length);
 556         std::string resultstr;
 557
 558         /* Check if we got a result, if we didnt, its an error */
 559         if (data.first == NULL)
 560         {
 561                 /* An error.
 562                  * Mask the ID with the value of ERROR_MASK, so that
 563                  * the dns_deal_with_classes() function knows that its
 564                  * an error response and needs to be treated uniquely.
 565                  * Put the error message in the second field.
 566                  */
 567                 delete req;
 568                 return std::make_pair(this_id | ERROR_MASK, data.second);
 569         }
 570         else
 571         {
 572                 char formatted[128];
 573
 574                 /* Forward lookups come back as binary data. We must format them into ascii */
 575                 switch (req->type)
 576                 {
 577                         case DNS_QUERY_A:
 578                                 snprintf(formatted,16,"%u.%u.%u.%u",data.first[0],data.first[1],data.first[2],data.first[3]);
 579                                 resultstr = formatted;
 580                         break;
 581
 582                         case DNS_QUERY_AAAA:
 583                         {
 584                                 snprintf(formatted,40,"%x:%x:%x:%x:%x:%x:%x:%x",
 585                                                 (ntohs(data.first[0]) + ntohs(data.first[1] << 8)),
 586                                                 (ntohs(data.first[2]) + ntohs(data.first[3] << 8)),
 587                                                 (ntohs(data.first[4]) + ntohs(data.first[5] << 8)),
 588                                                 (ntohs(data.first[6]) + ntohs(data.first[7] << 8)),
 589                                                 (ntohs(data.first[8]) + ntohs(data.first[9] << 8)),
 590                                                 (ntohs(data.first[10]) + ntohs(data.first[11] << 8)),
 591                                                 (ntohs(data.first[12]) + ntohs(data.first[13] << 8)),
 592                                                 (ntohs(data.first[14]) + ntohs(data.first[15] << 8)));
 593                                 char* c = strstr(formatted,":0:");
 594                                 if (c != NULL)
 595                                 {
 596                                         memmove(c+1,c+2,strlen(c+2) + 1);
 597                                         c += 2;
 598                                         while (memcmp(c,"0:",2) == 0)
 599                                                 memmove(c,c+2,strlen(c+2) + 1);
 600                                         if (memcmp(c,"0",2) == 0)
 601                                                 *c = 0;
 602                                         if (memcmp(formatted,"0::",3) == 0)
 603                                                 memmove(formatted,formatted + 1, strlen(formatted + 1) + 1);
 604                                 }
 605                                 resultstr = formatted;
 606                         }
 607                         break;
 608
 609                         case DNS_QUERY_CNAME:
 610                                 /* Identical handling to PTR */
 611
 612                         case DNS_QUERY_PTR:
 613                                 /* Reverse lookups just come back as char* */
 614                                 resultstr = std::string((const char*)data.first);
 615                         break;
 616
 617                         default:
 618                                 log(DEBUG,"WARNING: Somehow we made a request for a DNS_QUERY_PTR4 or DNS_QUERY_PTR6, but these arent real rr types!");
 619                         break;
 620
 621                 }
 622
 623                 /* Build the reply with the id and hostname/ip in it */
 624                 delete req;
 625                 return std::make_pair(this_id,resultstr);
 626         }
 627 }
 628
 629 /* A result is ready, process it */
 630 DNSInfo DNSRequest::ResultIsReady(DNSHeader &header, int length)
 631 {
 632         int i = 0;
 633         int q = 0;
 634         int curanswer, o;
 635         ResourceRecord rr;
 636         unsigned short ptr;
 637
 638         if (!(header.flags1 & FLAGS_MASK_QR))
 639                 return std::make_pair((unsigned char*)NULL,"Not a query result");
 640
 641         if (header.flags1 & FLAGS_MASK_OPCODE)
 642                 return std::make_pair((unsigned char*)NULL,"Unexpected value in DNS reply packet");
 643
 644         if (header.flags2 & FLAGS_MASK_RCODE)
 645                 return std::make_pair((unsigned char*)NULL,"Domain name not found");
 646
 647         if (header.ancount < 1)
 648                 return std::make_pair((unsigned char*)NULL,"No resource records returned");
 649
 650         /* Subtract the length of the header from the length of the packet */
 651         length -= 12;
 652
 653         while ((unsigned int)q < header.qdcount && i < length)
 654         {
 655                 if (header.payload[i] > 63)
 656                 {
 657                         i += 6;
 658                         q++;
 659                 }
 660                 else
 661                 {
 662                         if (header.payload[i] == 0)
 663                         {
 664                                 q++;
 665                                 i += 5;
 666                         }
 667                         else i += header.payload[i] + 1;
 668                 }
 669         }
 670         curanswer = 0;
 671         while ((unsigned)curanswer < header.ancount)
 672         {
 673                 q = 0;
 674                 while (q == 0 && i < length)
 675                 {
 676                         if (header.payload[i] > 63)
 677                         {
 678                                 i += 2;
 679                                 q = 1;
 680                         }
 681                         else
 682                         {
 683                                 if (header.payload[i] == 0)
 684                                 {
 685                                         i++;
 686                                         q = 1;
 687                                 }
 688                                 else i += header.payload[i] + 1; /* skip length and label */
 689                         }
 690                 }
 691                 if (length - i < 10)
 692                         return std::make_pair((unsigned char*)NULL,"Incorrectly sized DNS reply");
 693
 694                 DNS::FillResourceRecord(&rr,&header.payload[i]);
 695                 i += 10;
 696                 if (rr.type != this->type)
 697                 {
 698                         curanswer++;
 699                         i += rr.rdlength;
 700                         continue;
 701                 }
 702                 if (rr.rr_class != this->rr_class)
 703                 {
 704                         curanswer++;
 705                         i += rr.rdlength;
 706                         continue;
 707                 }
 708                 break;
 709         }
 710         if ((unsigned int)curanswer == header.ancount)
 711                 return std::make_pair((unsigned char*)NULL,"No valid answers");
 712
 713         if (i + rr.rdlength > (unsigned int)length)
 714                 return std::make_pair((unsigned char*)NULL,"Resource record larger than stated");
 715
 716         if (rr.rdlength > 1023)
 717                 return std::make_pair((unsigned char*)NULL,"Resource record too large");
 718
 719         switch (rr.type)
 720         {
 721                 case DNS_QUERY_CNAME:
 722                         /* CNAME and PTR have the same processing code */
 723                 case DNS_QUERY_PTR:
 724                         o = 0;
 725                         q = 0;
 726                         while (q == 0 && i < length && o + 256 < 1023)
 727                         {
 728                                 if (header.payload[i] > 63)
 729                                 {
 730                                         memcpy(&ptr,&header.payload[i],2);
 731                                         i = ntohs(ptr) - 0xC000 - 12;
 732                                 }
 733                                 else
 734                                 {
 735                                         if (header.payload[i] == 0)
 736                                         {
 737                                                 q = 1;
 738                                         }
 739                                         else
 740                                         {
 741                                                 res[o] = 0;
 742                                                 if (o != 0)
 743                                                         res[o++] = '.';
 744                                                 memcpy(&res[o],&header.payload[i + 1],header.payload[i]);
 745                                                 o += header.payload[i];
 746                                                 i += header.payload[i] + 1;
 747                                         }
 748                                 }
 749                         }
 750                         res[o] = 0;
 751                 break;
 752                 case DNS_QUERY_AAAA:
 753                         memcpy(res,&header.payload[i],rr.rdlength);
 754                         res[rr.rdlength] = 0;
 755                 break;
 756                 case DNS_QUERY_A:
 757                         memcpy(res,&header.payload[i],rr.rdlength);
 758                         res[rr.rdlength] = 0;
 759                 break;
 760                 default:
 761                         memcpy(res,&header.payload[i],rr.rdlength);
 762                         res[rr.rdlength] = 0;
 763                 break;
 764         }
 765         return std::make_pair(res,"No error");;
 766 }
 767
 768 /* Close the master socket */
 769 DNS::~DNS()
 770 {
 771         shutdown(MasterSocket, 2);
 772         close(MasterSocket);
 773 }
 774
 775 /* High level abstraction of dns used by application at large */
 776 Resolver::Resolver(const std::string &source, QueryType qt) : input(source), querytype(qt)
 777 {
 778         insp_inaddr binip;
 779
 780         switch (querytype)
 781         {
 782                 case DNS_QUERY_A:
 783                         this->myid = ServerInstance->Res->GetIP(source.c_str());
 784                 break;
 785
 786                 case DNS_QUERY_PTR:
 787                         if (insp_aton(source.c_str(), &binip) > 0)
 788                         {
 789                                 /* Valid ip address */
 790                                 this->myid = ServerInstance->Res->GetName(&binip);
 791                         }
 792                         else
 793                         {
 794                                 this->OnError(RESOLVER_BADIP, "Bad IP address for reverse lookup");
 795                                 throw ModuleException("Resolver: Bad IP address");
 796                                 return;
 797                         }
 798                 break;
 799
 800                 case DNS_QUERY_PTR4:
 801                         querytype = DNS_QUERY_PTR;
 802                         this->myid = ServerInstance->Res->GetNameForce(source.c_str(), PROTOCOL_IPV4);
 803                 break;
 804
 805                 case DNS_QUERY_PTR6:
 806                         querytype = DNS_QUERY_PTR;
 807                         this->myid = ServerInstance->Res->GetNameForce(source.c_str(), PROTOCOL_IPV6);
 808                 break;
 809
 810                 case DNS_QUERY_AAAA:
 811                         this->myid = ServerInstance->Res->GetIP6(source.c_str());
 812                 break;
 813
 814                 case DNS_QUERY_CNAME:
 815                         this->myid = ServerInstance->Res->GetCName(source.c_str());
 816                 break;
 817
 818                 default:
 819                         this->myid = -1;
 820                 break;
 821         }
 822         if (this->myid == -1)
 823         {
 824                 log(DEBUG,"Resolver::Resolver: Could not get an id!");
 825                 this->OnError(RESOLVER_NSDOWN, "Nameserver is down");
 826                 throw ModuleException("Resolver: Couldnt get an id to make a request");
 827                 /* We shouldnt get here really */
 828                 return;
 829         }
 830
 831         log(DEBUG,"Resolver::Resolver: this->myid=%d",this->myid);
 832 }
 833
 834 void Resolver::OnError(ResolverError e, const std::string &errormessage)
 835 {
 836         /* Nothing in here */
 837 }
 838
 839 Resolver::~Resolver()
 840 {
 841         /* Nothing here (yet) either */
 842 }
 843
 844 /* Get the request id associated with this class */
 845 int Resolver::GetId()
 846 {
 847         return this->myid;
 848 }
 849
 850 /* Process a socket read event */
 851 void DNS::MarshallReads(int fd)
 852 {
 853         /* We are only intrested in our single fd */
 854         if (fd == GetMasterSocket())
 855         {
 856                 /* Fetch the id and result of the next available packet */
 857                 DNSResult res = this->GetResult();
 858                 /* Is there a usable request id? */
 859                 if (res.first != -1)
 860                 {
 861                         /* Its an error reply */
 862                         if (res.first & ERROR_MASK)
 863                         {
 864                                 /* Mask off the error bit */
 865                                 res.first -= ERROR_MASK;
 866
 867                                 /* Marshall the error to the correct class */
 868                                 log(DEBUG,"Error available, id=%d",res.first);
 869                                 if (Classes[res.first])
 870                                 {
 871                                         if (ServerInstance && ServerInstance->stats)
 872                                                 ServerInstance->stats->statsDnsBad++;
 873                                         Classes[res.first]->OnError(RESOLVER_NXDOMAIN, res.second);
 874                                         delete Classes[res.first];
 875                                         Classes[res.first] = NULL;
 876                                 }
 877                         }
 878                         else
 879                         {
 880                                 /* It is a non-error result */
 881                                 log(DEBUG,"Result available, id=%d",res.first);
 882                                 /* Marshall the result to the correct class */
 883                                 if (Classes[res.first])
 884                                 {
 885                                         if (ServerInstance && ServerInstance->stats)
 886                                                 ServerInstance->stats->statsDnsGood++;
 887                                         Classes[res.first]->OnLookupComplete(res.second);
 888                                         delete Classes[res.first];
 889                                         Classes[res.first] = NULL;
 890                                 }
 891                         }
 892
 893                         if (ServerInstance && ServerInstance->stats)
 894                                 ServerInstance->stats->statsDns++;
 895
 896                 }
 897         }
 898 }
 899
 900 /* Add a derived Resolver to the working set */
 901 bool DNS::AddResolverClass(Resolver* r)
 902 {
 903         /* Check the pointers validity and the id's validity */
 904         if ((r) && (r->GetId() > -1))
 905         {
 906                 /* Check the slot isnt already occupied -
 907                  * This should NEVER happen unless we have
 908                  * a severely broken DNS server somewhere
 909                  */
 910                 if (!Classes[r->GetId()])
 911                 {
 912                         /* Set up the pointer to the class */
 913                         Classes[r->GetId()] = r;
 914                         return true;
 915                 }
 916                 else
 917                         /* Duplicate id */
 918                         return false;
 919         }
 920         else
 921         {
 922                 /* Pointer or id not valid.
 923                  * Free the item and return
 924                  */
 925                 if (r)
 926                         delete r;
 927
 928                 return false;
 929         }
 930 }
 931
 932 unsigned long DNS::PRNG()
 933 {
 934         unsigned long val = 0;
 935         timeval n;
 936         serverstats* s = ServerInstance->stats;
 937         gettimeofday(&n,NULL);
 938         val = (n.tv_usec ^ getpid() ^ geteuid() ^ (this->currid++)) ^ s->statsAccept + n.tv_sec;
 939         val = val + s->statsCollisions ^ s->statsDnsGood - s->statsDnsBad;
 940         val += (s->statsConnects ^ (unsigned long)s->statsSent ^ (unsigned long)s->statsRecv) - s->BoundPortCount;
 941         return val;
 942 }
 943