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                                 in6_addr* ip = (in6_addr*)&data.first;
 523
 524                                 snprintf(formatted,40,"%x:%x:%x:%x:%x:%x:%x:%x",
 525                                                 ntohs(*((unsigned short *)&ip->s6_addr[0])),
 526                                                 ntohs(*((unsigned short *)&ip->s6_addr[2])),
 527                                                 ntohs(*((unsigned short *)&ip->s6_addr[4])),
 528                                                 ntohs(*((unsigned short *)&ip->s6_addr[6])),
 529                                                 ntohs(*((unsigned short *)&ip->s6_addr[8])),
 530                                                 ntohs(*((unsigned short *)&ip->s6_addr[10])),
 531                                                 ntohs(*((unsigned short *)&ip->s6_addr[12])),
 532                                                 ntohs(*((unsigned short *)&ip->s6_addr[14])));
 533                                 char* c = strstr(formatted,":0:");
 534                                 if (c != NULL)
 535                                 {
 536                                         memmove(c+1,c+2,strlen(c+2) + 1);
 537                                         c += 2;
 538                                         while (memcmp(c,"0:",2) == 0)
 539                                                 memmove(c,c+2,strlen(c+2) + 1);
 540                                         if (memcmp(c,"0",2) == 0)
 541                                                 *c = 0;
 542                                         if (memcmp(formatted,"0::",3) == 0)
 543                                                 memmove(formatted,formatted + 1, strlen(formatted + 1) + 1);
 544                                 }
 545                                 resultstr = formatted;
 546                         }
 547                         break;
 548
 549                         case DNS_QUERY_CNAME:
 550                                 /* Identical handling to PTR */
 551
 552                         case DNS_QUERY_PTR:
 553                                 /* Reverse lookups just come back as char* */
 554                                 resultstr = std::string((const char*)data.first);
 555                         break;
 556
 557                 }
 558
 559                 /* Build the reply with the id and hostname/ip in it */
 560                 delete req;
 561                 return std::make_pair(this_id,resultstr);
 562         }
 563 }
 564
 565 /* A result is ready, process it */
 566 DNSInfo DNSRequest::ResultIsReady(DNSHeader &header, int length)
 567 {
 568         int i = 0;
 569         int q = 0;
 570         int curanswer, o;
 571         ResourceRecord rr;
 572         unsigned short ptr;
 573
 574         if (!(header.flags1 & FLAGS_MASK_QR))
 575                 return std::make_pair((unsigned char*)NULL,"Not a query result");
 576
 577         if (header.flags1 & FLAGS_MASK_OPCODE)
 578                 return std::make_pair((unsigned char*)NULL,"Unexpected value in DNS reply packet");
 579
 580         if (header.flags2 & FLAGS_MASK_RCODE)
 581                 return std::make_pair((unsigned char*)NULL,"Domain name not found");
 582
 583         if (header.ancount < 1)
 584                 return std::make_pair((unsigned char*)NULL,"No resource records returned");
 585
 586         /* Subtract the length of the header from the length of the packet */
 587         length -= 12;
 588
 589         while ((unsigned int)q < header.qdcount && i < length)
 590         {
 591                 if (header.payload[i] > 63)
 592                 {
 593                         i += 6;
 594                         q++;
 595                 }
 596                 else
 597                 {
 598                         if (header.payload[i] == 0)
 599                         {
 600                                 q++;
 601                                 i += 5;
 602                         }
 603                         else i += header.payload[i] + 1;
 604                 }
 605         }
 606         curanswer = 0;
 607         while ((unsigned)curanswer < header.ancount)
 608         {
 609                 q = 0;
 610                 while (q == 0 && i < length)
 611                 {
 612                         if (header.payload[i] > 63)
 613                         {
 614                                 i += 2;
 615                                 q = 1;
 616                         }
 617                         else
 618                         {
 619                                 if (header.payload[i] == 0)
 620                                 {
 621                                         i++;
 622                                         q = 1;
 623                                 }
 624                                 else i += header.payload[i] + 1; /* skip length and label */
 625                         }
 626                 }
 627                 if (length - i < 10)
 628                         return std::make_pair((unsigned char*)NULL,"Incorrectly sized DNS reply");
 629
 630                 DNS::FillResourceRecord(&rr,&header.payload[i]);
 631                 i += 10;
 632                 if (rr.type != this->type)
 633                 {
 634                         curanswer++;
 635                         i += rr.rdlength;
 636                         continue;
 637                 }
 638                 if (rr.rr_class != this->rr_class)
 639                 {
 640                         curanswer++;
 641                         i += rr.rdlength;
 642                         continue;
 643                 }
 644                 break;
 645         }
 646         if ((unsigned int)curanswer == header.ancount)
 647                 return std::make_pair((unsigned char*)NULL,"No valid answers");
 648
 649         if (i + rr.rdlength > (unsigned int)length)
 650                 return std::make_pair((unsigned char*)NULL,"Resource record larger than stated");
 651
 652         if (rr.rdlength > 1023)
 653                 return std::make_pair((unsigned char*)NULL,"Resource record too large");
 654
 655         switch (rr.type)
 656         {
 657                 case DNS_QUERY_CNAME:
 658                         /* CNAME and PTR have the same processing code */
 659                 case DNS_QUERY_PTR:
 660                         o = 0;
 661                         q = 0;
 662                         while (q == 0 && i < length && o + 256 < 1023)
 663                         {
 664                                 if (header.payload[i] > 63)
 665                                 {
 666                                         memcpy(&ptr,&header.payload[i],2);
 667                                         i = ntohs(ptr) - 0xC000 - 12;
 668                                 }
 669                                 else
 670                                 {
 671                                         if (header.payload[i] == 0)
 672                                         {
 673                                                 q = 1;
 674                                         }
 675                                         else
 676                                         {
 677                                                 res[o] = 0;
 678                                                 if (o != 0)
 679                                                         res[o++] = '.';
 680                                                 memcpy(&res[o],&header.payload[i + 1],header.payload[i]);
 681                                                 o += header.payload[i];
 682                                                 i += header.payload[i] + 1;
 683                                         }
 684                                 }
 685                         }
 686                         res[o] = 0;
 687                 break;
 688                 case DNS_QUERY_AAAA:
 689                         memcpy(res,&header.payload[i],rr.rdlength);
 690                         res[rr.rdlength] = 0;
 691                 break;
 692                 case DNS_QUERY_A:
 693                         memcpy(res,&header.payload[i],rr.rdlength);
 694                         res[rr.rdlength] = 0;
 695                 break;
 696                 default:
 697                         memcpy(res,&header.payload[i],rr.rdlength);
 698                         res[rr.rdlength] = 0;
 699                 break;
 700         }
 701         return std::make_pair(res,"No error");;
 702 }
 703
 704 /* Close the master socket */
 705 DNS::~DNS()
 706 {
 707         shutdown(MasterSocket, 2);
 708         close(MasterSocket);
 709 }
 710
 711 /* High level abstraction of dns used by application at large */
 712 Resolver::Resolver(const std::string &source, QueryType qt) : input(source), querytype(qt)
 713 {
 714         insp_inaddr binip;
 715
 716         switch (querytype)
 717         {
 718                 case DNS_QUERY_A:
 719                         this->myid = ServerInstance->Res->GetIP(source.c_str());
 720                 break;
 721
 722                 case DNS_QUERY_PTR:
 723                         if (insp_aton(source.c_str(), &binip) > 0)
 724                         {
 725                                 /* Valid ip address */
 726                                 this->myid = ServerInstance->Res->GetName(&binip);
 727                         }
 728                         else
 729                         {
 730                                 this->OnError(RESOLVER_BADIP, "Bad IP address for reverse lookup");
 731                                 throw ModuleException("Resolver: Bad IP address");
 732                                 return;
 733                         }
 734                 break;
 735
 736                 case DNS_QUERY_AAAA:
 737                         this->myid = ServerInstance->Res->GetIP6(source.c_str());
 738                 break;
 739
 740                 case DNS_QUERY_CNAME:
 741                         this->myid = ServerInstance->Res->GetCName(source.c_str());
 742                 break;
 743
 744                 default:
 745                         this->myid = -1;
 746                 break;
 747         }
 748         if (this->myid == -1)
 749         {
 750                 log(DEBUG,"Resolver::Resolver: Could not get an id!");
 751                 this->OnError(RESOLVER_NSDOWN, "Nameserver is down");
 752                 throw ModuleException("Resolver: Couldnt get an id to make a request");
 753                 /* We shouldnt get here really */
 754                 return;
 755         }
 756
 757         log(DEBUG,"Resolver::Resolver: this->myid=%d",this->myid);
 758 }
 759
 760 void Resolver::OnError(ResolverError e, const std::string &errormessage)
 761 {
 762         /* Nothing in here */
 763 }
 764
 765 Resolver::~Resolver()
 766 {
 767         /* Nothing here (yet) either */
 768 }
 769
 770 /* Get the request id associated with this class */
 771 int Resolver::GetId()
 772 {
 773         return this->myid;
 774 }
 775
 776 /* Process a socket read event */
 777 void DNS::MarshallReads(int fd)
 778 {
 779         /* We are only intrested in our single fd */
 780         if (fd == GetMasterSocket())
 781         {
 782                 /* Fetch the id and result of the next available packet */
 783                 DNSResult res = this->GetResult();
 784                 /* Is there a usable request id? */
 785                 if (res.first != -1)
 786                 {
 787                         /* Its an error reply */
 788                         if (res.first & ERROR_MASK)
 789                         {
 790                                 /* Mask off the error bit */
 791                                 res.first -= ERROR_MASK;
 792
 793                                 /* Marshall the error to the correct class */
 794                                 log(DEBUG,"Error available, id=%d",res.first);
 795                                 if (Classes[res.first])
 796                                 {
 797                                         if (ServerInstance && ServerInstance->stats)
 798                                                 ServerInstance->stats->statsDnsBad++;
 799                                         Classes[res.first]->OnError(RESOLVER_NXDOMAIN, res.second);
 800                                         delete Classes[res.first];
 801                                         Classes[res.first] = NULL;
 802                                 }
 803                         }
 804                         else
 805                         {
 806                                 /* It is a non-error result */
 807                                 log(DEBUG,"Result available, id=%d",res.first);
 808                                 /* Marshall the result to the correct class */
 809                                 if (Classes[res.first])
 810                                 {
 811                                         if (ServerInstance && ServerInstance->stats)
 812                                                 ServerInstance->stats->statsDnsGood++;
 813                                         Classes[res.first]->OnLookupComplete(res.second);
 814                                         delete Classes[res.first];
 815                                         Classes[res.first] = NULL;
 816                                 }
 817                         }
 818
 819                         if (ServerInstance && ServerInstance->stats)
 820                                 ServerInstance->stats->statsDns++;
 821
 822                 }
 823         }
 824 }
 825
 826 /* Add a derived Resolver to the working set */
 827 bool DNS::AddResolverClass(Resolver* r)
 828 {
 829         /* Check the pointers validity and the id's validity */
 830         if ((r) && (r->GetId() > -1))
 831         {
 832                 /* Check the slot isnt already occupied -
 833                  * This should NEVER happen unless we have
 834                  * a severely broken DNS server somewhere
 835                  */
 836                 if (!Classes[r->GetId()])
 837                 {
 838                         /* Set up the pointer to the class */
 839                         Classes[r->GetId()] = r;
 840                         return true;
 841                 }
 842                 else
 843                         /* Duplicate id */
 844                         return false;
 845         }
 846         else
 847         {
 848                 /* Pointer or id not valid.
 849                  * Free the item and return
 850                  */
 851                 if (r)
 852                         delete r;
 853
 854                 return false;
 855         }
 856 }
 857
 858 unsigned long DNS::PRNG()
 859 {
 860         unsigned long val = 0;
 861         timeval n;
 862         serverstats* s = ServerInstance->stats;
 863         gettimeofday(&n,NULL);
 864         val = (n.tv_usec ^ getpid() ^ geteuid() ^ (this->currid++)) ^ s->statsAccept + n.tv_sec;
 865         val = val + s->statsCollisions ^ s->statsDnsGood - s->statsDnsBad;
 866         val += (s->statsConnects ^ (unsigned long)s->statsSent ^ (unsigned long)s->statsRecv) - s->BoundPortCount;
 867         return val;
 868 }
 869