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