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