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 #ifdef IPV6
 403         return -1;
 404 #else
 405         char query[29];
 406         DNSHeader h;
 407         int id;
 408         int length;
 409
 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
 414         if ((length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload)) == -1)
 415                 return -1;
 416
 417         DNSRequest* req = this->AddQuery(&h, id);
 418
 419         if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1))
 420                 return -1;
 421
 422         return id;
 423 #endif
 424 }
 425
 426 /* Return the next id which is ready, and the result attached to it */
 427 DNSResult DNS::GetResult()
 428 {
 429         /* Fetch dns query response and decide where it belongs */
 430         DNSHeader header;
 431         DNSRequest *req;
 432         unsigned char buffer[sizeof(DNSHeader)];
 433         sockaddr from;
 434         socklen_t x = sizeof(from);
 435         const char* ipaddr_from = "";
 436         unsigned short int port_from = 0;
 437
 438         int length = recvfrom(MasterSocket,buffer,sizeof(DNSHeader),0,&from,&x);
 439
 440         /* Did we get the whole header? */
 441         if (length < 12)
 442                 /* Nope - something screwed up. */
 443                 return std::make_pair(-1,"");
 444
 445         /* Check wether the reply came from a different DNS
 446          * server to the one we sent it to, or the source-port
 447          * is not 53.
 448          * A user could in theory still spoof dns packets anyway
 449          * but this is less trivial than just sending garbage
 450          * to the client, which is possible without this check.
 451          *
 452          * -- Thanks jilles for pointing this one out.
 453          */
 454 #ifdef IPV6
 455         ipaddr_from = insp_ntoa(((sockaddr_in6*)&from)->sin6_addr);
 456         port_from = ntohs(((sockaddr_in6*)&from)->sin6_port);
 457 #else
 458         ipaddr_from = insp_ntoa(((sockaddr_in*)&from)->sin_addr);
 459         port_from = ntohs(((sockaddr_in*)&from)->sin_port);
 460 #endif
 461
 462         if ((port_from != DNS::QUERY_PORT) || (strcasecmp(ipaddr_from, Config->DNSServer)))
 463                 return std::make_pair(-1,"");
 464
 465         /* Put the read header info into a header class */
 466         DNS::FillHeader(&header,buffer,length - 12);
 467
 468         /* Get the id of this request.
 469          * Its a 16 bit value stored in two char's,
 470          * so we use logic shifts to create the value.
 471          */
 472         unsigned long this_id = header.id[1] + (header.id[0] << 8);
 473
 474         /* Do we have a pending request matching this id? */
 475         requestlist_iter n_iter = requests.find(this_id);
 476         if (n_iter == requests.end())
 477         {
 478                 /* Somehow we got a DNS response for a request we never made... */
 479                 log(DEBUG,"DNS: got a response for a query we didnt send with fd=%d queryid=%d",MasterSocket,this_id);
 480                 return std::make_pair(-1,"");
 481         }
 482         else
 483         {
 484                 /* Remove the query from the list of pending queries */
 485                 req = (DNSRequest*)n_iter->second;
 486                 requests.erase(n_iter);
 487         }
 488
 489         /* Inform the DNSRequest class that it has a result to be read.
 490          * When its finished it will return a DNSInfo which is a pair of
 491          * unsigned char* resource record data, and an error message.
 492          */
 493         DNSInfo data = req->ResultIsReady(header, length);
 494         std::string resultstr;
 495
 496         /* Check if we got a result, if we didnt, its an error */
 497         if (data.first == NULL)
 498         {
 499                 /* An error.
 500                  * Mask the ID with the value of ERROR_MASK, so that
 501                  * the dns_deal_with_classes() function knows that its
 502                  * an error response and needs to be treated uniquely.
 503                  * Put the error message in the second field.
 504                  */
 505                 delete req;
 506                 return std::make_pair(this_id | ERROR_MASK, data.second);
 507         }
 508         else
 509         {
 510                 char formatted[128];
 511
 512                 /* Forward lookups come back as binary data. We must format them into ascii */
 513                 switch (req->type)
 514                 {
 515                         case DNS_QUERY_A:
 516                                 snprintf(formatted,16,"%u.%u.%u.%u",data.first[0],data.first[1],data.first[2],data.first[3]);
 517                                 resultstr = formatted;
 518                         break;
 519
 520                         case DNS_QUERY_AAAA:
 521                         {
 522                                 snprintf(formatted,40,"%x:%x:%x:%x:%x:%x:%x:%x",
 523                                                 (ntohs(data.first[0]) + ntohs(data.first[1] << 8)),
 524                                                 (ntohs(data.first[2]) + ntohs(data.first[3] << 8)),
 525                                                 (ntohs(data.first[4]) + ntohs(data.first[5] << 8)),
 526                                                 (ntohs(data.first[6]) + ntohs(data.first[7] << 8)),
 527                                                 (ntohs(data.first[8]) + ntohs(data.first[9] << 8)),
 528                                                 (ntohs(data.first[10]) + ntohs(data.first[11] << 8)),
 529                                                 (ntohs(data.first[12]) + ntohs(data.first[13] << 8)),
 530                                                 (ntohs(data.first[14]) + ntohs(data.first[15] << 8)));
 531                                 char* c = strstr(formatted,":0:");
 532                                 if (c != NULL)
 533                                 {
 534                                         memmove(c+1,c+2,strlen(c+2) + 1);
 535                                         c += 2;
 536                                         while (memcmp(c,"0:",2) == 0)
 537                                                 memmove(c,c+2,strlen(c+2) + 1);
 538                                         if (memcmp(c,"0",2) == 0)
 539                                                 *c = 0;
 540                                         if (memcmp(formatted,"0::",3) == 0)
 541                                                 memmove(formatted,formatted + 1, strlen(formatted + 1) + 1);
 542                                 }
 543                                 resultstr = formatted;
 544                         }
 545                         break;
 546
 547                         case DNS_QUERY_CNAME:
 548                                 /* Identical handling to PTR */
 549
 550                         case DNS_QUERY_PTR:
 551                                 /* Reverse lookups just come back as char* */
 552                                 resultstr = std::string((const char*)data.first);
 553                         break;
 554
 555                 }
 556
 557                 /* Build the reply with the id and hostname/ip in it */
 558                 delete req;
 559                 return std::make_pair(this_id,resultstr);
 560         }
 561 }
 562
 563 /* A result is ready, process it */
 564 DNSInfo DNSRequest::ResultIsReady(DNSHeader &header, int length)
 565 {
 566         int i = 0;
 567         int q = 0;
 568         int curanswer, o;
 569         ResourceRecord rr;
 570         unsigned short ptr;
 571
 572         if (!(header.flags1 & FLAGS_MASK_QR))
 573                 return std::make_pair((unsigned char*)NULL,"Not a query result");
 574
 575         if (header.flags1 & FLAGS_MASK_OPCODE)
 576                 return std::make_pair((unsigned char*)NULL,"Unexpected value in DNS reply packet");
 577
 578         if (header.flags2 & FLAGS_MASK_RCODE)
 579                 return std::make_pair((unsigned char*)NULL,"Domain name not found");
 580
 581         if (header.ancount < 1)
 582                 return std::make_pair((unsigned char*)NULL,"No resource records returned");
 583
 584         /* Subtract the length of the header from the length of the packet */
 585         length -= 12;
 586
 587         while ((unsigned int)q < header.qdcount && i < length)
 588         {
 589                 if (header.payload[i] > 63)
 590                 {
 591                         i += 6;
 592                         q++;
 593                 }
 594                 else
 595                 {
 596                         if (header.payload[i] == 0)
 597                         {
 598                                 q++;
 599                                 i += 5;
 600                         }
 601                         else i += header.payload[i] + 1;
 602                 }
 603         }
 604         curanswer = 0;
 605         while ((unsigned)curanswer < header.ancount)
 606         {
 607                 q = 0;
 608                 while (q == 0 && i < length)
 609                 {
 610                         if (header.payload[i] > 63)
 611                         {
 612                                 i += 2;
 613                                 q = 1;
 614                         }
 615                         else
 616                         {
 617                                 if (header.payload[i] == 0)
 618                                 {
 619                                         i++;
 620                                         q = 1;
 621                                 }
 622                                 else i += header.payload[i] + 1; /* skip length and label */
 623                         }
 624                 }
 625                 if (length - i < 10)
 626                         return std::make_pair((unsigned char*)NULL,"Incorrectly sized DNS reply");
 627
 628                 DNS::FillResourceRecord(&rr,&header.payload[i]);
 629                 i += 10;
 630                 if (rr.type != this->type)
 631                 {
 632                         curanswer++;
 633                         i += rr.rdlength;
 634                         continue;
 635                 }
 636                 if (rr.rr_class != this->rr_class)
 637                 {
 638                         curanswer++;
 639                         i += rr.rdlength;
 640                         continue;
 641                 }
 642                 break;
 643         }
 644         if ((unsigned int)curanswer == header.ancount)
 645                 return std::make_pair((unsigned char*)NULL,"No valid answers");
 646
 647         if (i + rr.rdlength > (unsigned int)length)
 648                 return std::make_pair((unsigned char*)NULL,"Resource record larger than stated");
 649
 650         if (rr.rdlength > 1023)
 651                 return std::make_pair((unsigned char*)NULL,"Resource record too large");
 652
 653         switch (rr.type)
 654         {
 655                 case DNS_QUERY_CNAME:
 656                         /* CNAME and PTR have the same processing code */
 657                 case DNS_QUERY_PTR:
 658                         o = 0;
 659                         q = 0;
 660                         while (q == 0 && i < length && o + 256 < 1023)
 661                         {
 662                                 if (header.payload[i] > 63)
 663                                 {
 664                                         memcpy(&ptr,&header.payload[i],2);
 665                                         i = ntohs(ptr) - 0xC000 - 12;
 666                                 }
 667                                 else
 668                                 {
 669                                         if (header.payload[i] == 0)
 670                                         {
 671                                                 q = 1;
 672                                         }
 673                                         else
 674                                         {
 675                                                 res[o] = 0;
 676                                                 if (o != 0)
 677                                                         res[o++] = '.';
 678                                                 memcpy(&res[o],&header.payload[i + 1],header.payload[i]);
 679                                                 o += header.payload[i];
 680                                                 i += header.payload[i] + 1;
 681                                         }
 682                                 }
 683                         }
 684                         res[o] = 0;
 685                 break;
 686                 case DNS_QUERY_AAAA:
 687                         memcpy(res,&header.payload[i],rr.rdlength);
 688                         res[rr.rdlength] = 0;
 689                 break;
 690                 case DNS_QUERY_A:
 691                         memcpy(res,&header.payload[i],rr.rdlength);
 692                         res[rr.rdlength] = 0;
 693                 break;
 694                 default:
 695                         memcpy(res,&header.payload[i],rr.rdlength);
 696                         res[rr.rdlength] = 0;
 697                 break;
 698         }
 699         return std::make_pair(res,"No error");;
 700 }
 701
 702 /* Close the master socket */
 703 DNS::~DNS()
 704 {
 705         shutdown(MasterSocket, 2);
 706         close(MasterSocket);
 707 }
 708
 709 /* High level abstraction of dns used by application at large */
 710 Resolver::Resolver(const std::string &source, QueryType qt) : input(source), querytype(qt)
 711 {
 712         insp_inaddr binip;
 713
 714         switch (querytype)
 715         {
 716                 case DNS_QUERY_A:
 717                         this->myid = ServerInstance->Res->GetIP(source.c_str());
 718                 break;
 719
 720                 case DNS_QUERY_PTR:
 721                         if (insp_aton(source.c_str(), &binip) > 0)
 722                         {
 723                                 /* Valid ip address */
 724                                 this->myid = ServerInstance->Res->GetName(&binip);
 725                         }
 726                         else
 727                         {
 728                                 this->OnError(RESOLVER_BADIP, "Bad IP address for reverse lookup");
 729                                 throw ModuleException("Resolver: Bad IP address");
 730                                 return;
 731                         }
 732                 break;
 733
 734                 case DNS_QUERY_AAAA:
 735                         this->myid = ServerInstance->Res->GetIP6(source.c_str());
 736                 break;
 737
 738                 case DNS_QUERY_CNAME:
 739                         this->myid = ServerInstance->Res->GetCName(source.c_str());
 740                 break;
 741
 742                 default:
 743                         this->myid = -1;
 744                 break;
 745         }
 746         if (this->myid == -1)
 747         {
 748                 log(DEBUG,"Resolver::Resolver: Could not get an id!");
 749                 this->OnError(RESOLVER_NSDOWN, "Nameserver is down");
 750                 throw ModuleException("Resolver: Couldnt get an id to make a request");
 751                 /* We shouldnt get here really */
 752                 return;
 753         }
 754
 755         log(DEBUG,"Resolver::Resolver: this->myid=%d",this->myid);
 756 }
 757
 758 void Resolver::OnError(ResolverError e, const std::string &errormessage)
 759 {
 760         /* Nothing in here */
 761 }
 762
 763 Resolver::~Resolver()
 764 {
 765         /* Nothing here (yet) either */
 766 }
 767
 768 /* Get the request id associated with this class */
 769 int Resolver::GetId()
 770 {
 771         return this->myid;
 772 }
 773
 774 /* Process a socket read event */
 775 void DNS::MarshallReads(int fd)
 776 {
 777         /* We are only intrested in our single fd */
 778         if (fd == GetMasterSocket())
 779         {
 780                 /* Fetch the id and result of the next available packet */
 781                 DNSResult res = this->GetResult();
 782                 /* Is there a usable request id? */
 783                 if (res.first != -1)
 784                 {
 785                         /* Its an error reply */
 786                         if (res.first & ERROR_MASK)
 787                         {
 788                                 /* Mask off the error bit */
 789                                 res.first -= ERROR_MASK;
 790
 791                                 /* Marshall the error to the correct class */
 792                                 log(DEBUG,"Error available, id=%d",res.first);
 793                                 if (Classes[res.first])
 794                                 {
 795                                         if (ServerInstance && ServerInstance->stats)
 796                                                 ServerInstance->stats->statsDnsBad++;
 797                                         Classes[res.first]->OnError(RESOLVER_NXDOMAIN, res.second);
 798                                         delete Classes[res.first];
 799                                         Classes[res.first] = NULL;
 800                                 }
 801                         }
 802                         else
 803                         {
 804                                 /* It is a non-error result */
 805                                 log(DEBUG,"Result available, id=%d",res.first);
 806                                 /* Marshall the result to the correct class */
 807                                 if (Classes[res.first])
 808                                 {
 809                                         if (ServerInstance && ServerInstance->stats)
 810                                                 ServerInstance->stats->statsDnsGood++;
 811                                         Classes[res.first]->OnLookupComplete(res.second);
 812                                         delete Classes[res.first];
 813                                         Classes[res.first] = NULL;
 814                                 }
 815                         }
 816
 817                         if (ServerInstance && ServerInstance->stats)
 818                                 ServerInstance->stats->statsDns++;
 819
 820                 }
 821         }
 822 }
 823
 824 /* Add a derived Resolver to the working set */
 825 bool DNS::AddResolverClass(Resolver* r)
 826 {
 827         /* Check the pointers validity and the id's validity */
 828         if ((r) && (r->GetId() > -1))
 829         {
 830                 /* Check the slot isnt already occupied -
 831                  * This should NEVER happen unless we have
 832                  * a severely broken DNS server somewhere
 833                  */
 834                 if (!Classes[r->GetId()])
 835                 {
 836                         /* Set up the pointer to the class */
 837                         Classes[r->GetId()] = r;
 838                         return true;
 839                 }
 840                 else
 841                         /* Duplicate id */
 842                         return false;
 843         }
 844         else
 845         {
 846                 /* Pointer or id not valid.
 847                  * Free the item and return
 848                  */
 849                 if (r)
 850                         delete r;
 851
 852                 return false;
 853         }
 854 }
 855
 856 unsigned long DNS::PRNG()
 857 {
 858         unsigned long val = 0;
 859         timeval n;
 860         serverstats* s = ServerInstance->stats;
 861         gettimeofday(&n,NULL);
 862         val = (n.tv_usec ^ getpid() ^ geteuid() ^ (this->currid++)) ^ s->statsAccept + n.tv_sec;
 863         val = val + s->statsCollisions ^ s->statsDnsGood - s->statsDnsBad;
 864         val += (s->statsConnects ^ (unsigned long)s->statsSent ^ (unsigned long)s->statsRecv) - s->BoundPortCount;
 865         return val;
 866 }
 867