src/coremods/core_dns.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2013 Adam <Adam@anope.org>
   5  *   Copyright (C) 2003-2013 Anope Team <team@anope.org>
   6  *
   7  * This file is part of InspIRCd.  InspIRCd is free software: you can
   8  * redistribute it and/or modify it under the terms of the GNU General Public
   9  * License as published by the Free Software Foundation, version 2.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14  * details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "inspircd.h"
  21 #include "modules/dns.h"
  22 #include <iostream>
  23 #include <fstream>
  24
  25 #ifdef _WIN32
  26 #include <Iphlpapi.h>
  27 #pragma comment(lib, "Iphlpapi.lib")
  28 #endif
  29
  30 namespace DNS
  31 {
  32         /** Maximum value of a dns request id, 16 bits wide, 0xFFFF.
  33          */
  34         const unsigned int MAX_REQUEST_ID = 0xFFFF;
  35 }
  36
  37 using namespace DNS;
  38
  39 /** A full packet sent or recieved to/from the nameserver
  40  */
  41 class Packet : public Query
  42 {
  43         static bool IsValidName(const std::string& name)
  44         {
  45                 return (name.find_first_not_of("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-") == std::string::npos);
  46         }
  47
  48         void PackName(unsigned char* output, unsigned short output_size, unsigned short& pos, const std::string& name)
  49         {
  50                 if (pos + name.length() + 2 > output_size)
  51                         throw Exception("Unable to pack name");
  52
  53                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Packing name " + name);
  54
  55                 irc::sepstream sep(name, '.');
  56                 std::string token;
  57
  58                 while (sep.GetToken(token))
  59                 {
  60                         output[pos++] = token.length();
  61                         memcpy(&output[pos], token.data(), token.length());
  62                         pos += token.length();
  63                 }
  64
  65                 output[pos++] = 0;
  66         }
  67
  68         std::string UnpackName(const unsigned char* input, unsigned short input_size, unsigned short& pos)
  69         {
  70                 std::string name;
  71                 unsigned short pos_ptr = pos, lowest_ptr = input_size;
  72                 bool compressed = false;
  73
  74                 if (pos_ptr >= input_size)
  75                         throw Exception("Unable to unpack name - no input");
  76
  77                 while (input[pos_ptr] > 0)
  78                 {
  79                         unsigned short offset = input[pos_ptr];
  80
  81                         if (offset & POINTER)
  82                         {
  83                                 if ((offset & POINTER) != POINTER)
  84                                         throw Exception("Unable to unpack name - bogus compression header");
  85                                 if (pos_ptr + 1 >= input_size)
  86                                         throw Exception("Unable to unpack name - bogus compression header");
  87
  88                                 /* Place pos at the second byte of the first (farthest) compression pointer */
  89                                 if (compressed == false)
  90                                 {
  91                                         ++pos;
  92                                         compressed = true;
  93                                 }
  94
  95                                 pos_ptr = (offset & LABEL) << 8 | input[pos_ptr + 1];
  96
  97                                 /* Pointers can only go back */
  98                                 if (pos_ptr >= lowest_ptr)
  99                                         throw Exception("Unable to unpack name - bogus compression pointer");
 100                                 lowest_ptr = pos_ptr;
 101                         }
 102                         else
 103                         {
 104                                 if (pos_ptr + offset + 1 >= input_size)
 105                                         throw Exception("Unable to unpack name - offset too large");
 106                                 if (!name.empty())
 107                                         name += ".";
 108                                 for (unsigned i = 1; i <= offset; ++i)
 109                                         name += input[pos_ptr + i];
 110
 111                                 pos_ptr += offset + 1;
 112                                 if (compressed == false)
 113                                         /* Move up pos */
 114                                         pos = pos_ptr;
 115                         }
 116                 }
 117
 118                 /* +1 pos either to one byte after the compression pointer or one byte after the ending \0 */
 119                 ++pos;
 120
 121                 if (name.empty())
 122                         throw Exception("Unable to unpack name - no name");
 123
 124                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Unpack name " + name);
 125
 126                 return name;
 127         }
 128
 129         Question UnpackQuestion(const unsigned char* input, unsigned short input_size, unsigned short& pos)
 130         {
 131                 Question q;
 132
 133                 q.name = this->UnpackName(input, input_size, pos);
 134
 135                 if (pos + 4 > input_size)
 136                         throw Exception("Unable to unpack question");
 137
 138                 q.type = static_cast<QueryType>(input[pos] << 8 | input[pos + 1]);
 139                 pos += 2;
 140
 141                 // Skip over query class code
 142                 pos += 2;
 143
 144                 return q;
 145         }
 146
 147         ResourceRecord UnpackResourceRecord(const unsigned char* input, unsigned short input_size, unsigned short& pos)
 148         {
 149                 ResourceRecord record = static_cast<ResourceRecord>(this->UnpackQuestion(input, input_size, pos));
 150
 151                 if (pos + 6 > input_size)
 152                         throw Exception("Unable to unpack resource record");
 153
 154                 record.ttl = (input[pos] << 24) | (input[pos + 1] << 16) | (input[pos + 2] << 8) | input[pos + 3];
 155                 pos += 4;
 156
 157                 //record.rdlength = input[pos] << 8 | input[pos + 1];
 158                 pos += 2;
 159
 160                 switch (record.type)
 161                 {
 162                         case QUERY_A:
 163                         {
 164                                 if (pos + 4 > input_size)
 165                                         throw Exception("Unable to unpack resource record");
 166
 167                                 irc::sockets::sockaddrs addrs;
 168                                 memset(&addrs, 0, sizeof(addrs));
 169
 170                                 addrs.in4.sin_family = AF_INET;
 171                                 addrs.in4.sin_addr.s_addr = input[pos] | (input[pos + 1] << 8) | (input[pos + 2] << 16)  | (input[pos + 3] << 24);
 172                                 pos += 4;
 173
 174                                 record.rdata = addrs.addr();
 175                                 break;
 176                         }
 177                         case QUERY_AAAA:
 178                         {
 179                                 if (pos + 16 > input_size)
 180                                         throw Exception("Unable to unpack resource record");
 181
 182                                 irc::sockets::sockaddrs addrs;
 183                                 memset(&addrs, 0, sizeof(addrs));
 184
 185                                 addrs.in6.sin6_family = AF_INET6;
 186                                 for (int j = 0; j < 16; ++j)
 187                                         addrs.in6.sin6_addr.s6_addr[j] = input[pos + j];
 188                                 pos += 16;
 189
 190                                 record.rdata = addrs.addr();
 191
 192                                 break;
 193                         }
 194                         case QUERY_CNAME:
 195                         case QUERY_PTR:
 196                         {
 197                                 record.rdata = this->UnpackName(input, input_size, pos);
 198                                 if (!IsValidName(record.rdata))
 199                                         throw Exception("Invalid name"); // XXX: Causes the request to time out
 200
 201                                 break;
 202                         }
 203                         default:
 204                                 break;
 205                 }
 206
 207                 if (!record.name.empty() && !record.rdata.empty())
 208                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, record.name + " -> " + record.rdata);
 209
 210                 return record;
 211         }
 212
 213  public:
 214         static const int POINTER = 0xC0;
 215         static const int LABEL = 0x3F;
 216         static const int HEADER_LENGTH = 12;
 217
 218         /* ID for this packet */
 219         RequestId id;
 220         /* Flags on the packet */
 221         unsigned short flags;
 222
 223         Packet() : id(0), flags(0)
 224         {
 225         }
 226
 227         void Fill(const unsigned char* input, const unsigned short len)
 228         {
 229                 if (len < HEADER_LENGTH)
 230                         throw Exception("Unable to fill packet");
 231
 232                 unsigned short packet_pos = 0;
 233
 234                 this->id = (input[packet_pos] << 8) | input[packet_pos + 1];
 235                 packet_pos += 2;
 236
 237                 this->flags = (input[packet_pos] << 8) | input[packet_pos + 1];
 238                 packet_pos += 2;
 239
 240                 unsigned short qdcount = (input[packet_pos] << 8) | input[packet_pos + 1];
 241                 packet_pos += 2;
 242
 243                 unsigned short ancount = (input[packet_pos] << 8) | input[packet_pos + 1];
 244                 packet_pos += 2;
 245
 246                 unsigned short nscount = (input[packet_pos] << 8) | input[packet_pos + 1];
 247                 packet_pos += 2;
 248
 249                 unsigned short arcount = (input[packet_pos] << 8) | input[packet_pos + 1];
 250                 packet_pos += 2;
 251
 252                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "qdcount: " + ConvToStr(qdcount) + " ancount: " + ConvToStr(ancount) + " nscount: " + ConvToStr(nscount) + " arcount: " + ConvToStr(arcount));
 253
 254                 if (qdcount != 1)
 255                         throw Exception("Question count != 1 in incoming packet");
 256
 257                 this->question = this->UnpackQuestion(input, len, packet_pos);
 258
 259                 for (unsigned i = 0; i < ancount; ++i)
 260                         this->answers.push_back(this->UnpackResourceRecord(input, len, packet_pos));
 261         }
 262
 263         unsigned short Pack(unsigned char* output, unsigned short output_size)
 264         {
 265                 if (output_size < HEADER_LENGTH)
 266                         throw Exception("Unable to pack packet");
 267
 268                 unsigned short pos = 0;
 269
 270                 output[pos++] = this->id >> 8;
 271                 output[pos++] = this->id & 0xFF;
 272                 output[pos++] = this->flags >> 8;
 273                 output[pos++] = this->flags & 0xFF;
 274                 output[pos++] = 0; // Question count, high byte
 275                 output[pos++] = 1; // Question count, low byte
 276                 output[pos++] = 0; // Answer count, high byte
 277                 output[pos++] = 0; // Answer count, low byte
 278                 output[pos++] = 0;
 279                 output[pos++] = 0;
 280                 output[pos++] = 0;
 281                 output[pos++] = 0;
 282
 283                 {
 284                         Question& q = this->question;
 285
 286                         if (q.type == QUERY_PTR)
 287                         {
 288                                 irc::sockets::sockaddrs ip;
 289                                 irc::sockets::aptosa(q.name, 0, ip);
 290
 291                                 if (q.name.find(':') != std::string::npos)
 292                                 {
 293                                         static const char* const hex = "0123456789abcdef";
 294                                         char reverse_ip[128];
 295                                         unsigned reverse_ip_count = 0;
 296                                         for (int j = 15; j >= 0; --j)
 297                                         {
 298                                                 reverse_ip[reverse_ip_count++] = hex[ip.in6.sin6_addr.s6_addr[j] & 0xF];
 299                                                 reverse_ip[reverse_ip_count++] = '.';
 300                                                 reverse_ip[reverse_ip_count++] = hex[ip.in6.sin6_addr.s6_addr[j] >> 4];
 301                                                 reverse_ip[reverse_ip_count++] = '.';
 302                                         }
 303                                         reverse_ip[reverse_ip_count++] = 0;
 304
 305                                         q.name = reverse_ip;
 306                                         q.name += "ip6.arpa";
 307                                 }
 308                                 else
 309                                 {
 310                                         unsigned long forward = ip.in4.sin_addr.s_addr;
 311                                         ip.in4.sin_addr.s_addr = forward << 24 | (forward & 0xFF00) << 8 | (forward & 0xFF0000) >> 8 | forward >> 24;
 312
 313                                         q.name = ip.addr() + ".in-addr.arpa";
 314                                 }
 315                         }
 316
 317                         this->PackName(output, output_size, pos, q.name);
 318
 319                         if (pos + 4 >= output_size)
 320                                 throw Exception("Unable to pack packet");
 321
 322                         short s = htons(q.type);
 323                         memcpy(&output[pos], &s, 2);
 324                         pos += 2;
 325
 326                         // Query class, always IN
 327                         output[pos++] = 0;
 328                         output[pos++] = 1;
 329                 }
 330
 331                 return pos;
 332         }
 333 };
 334
 335 class MyManager : public Manager, public Timer, public EventHandler
 336 {
 337         typedef TR1NS::unordered_map<Question, Query, Question::hash> cache_map;
 338         cache_map cache;
 339
 340         irc::sockets::sockaddrs myserver;
 341         bool unloading;
 342
 343         /** Maximum number of entries in cache
 344          */
 345         static const unsigned int MAX_CACHE_SIZE = 1000;
 346
 347         static bool IsExpired(const Query& record, time_t now = ServerInstance->Time())
 348         {
 349                 const ResourceRecord& req = record.answers[0];
 350                 return (req.created + static_cast<time_t>(req.ttl) < now);
 351         }
 352
 353         /** Check the DNS cache to see if request can be handled by a cached result
 354          * @return true if a cached result was found.
 355          */
 356         bool CheckCache(DNS::Request* req, const DNS::Question& question)
 357         {
 358                 ServerInstance->Logs->Log(MODNAME, LOG_SPARSE, "cache: Checking cache for " + question.name);
 359
 360                 cache_map::iterator it = this->cache.find(question);
 361                 if (it == this->cache.end())
 362                         return false;
 363
 364                 Query& record = it->second;
 365                 if (IsExpired(record))
 366                 {
 367                         this->cache.erase(it);
 368                         return false;
 369                 }
 370
 371                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "cache: Using cached result for " + question.name);
 372                 record.cached = true;
 373                 req->OnLookupComplete(&record);
 374                 return true;
 375         }
 376
 377         /** Add a record to the dns cache
 378          * @param r The record
 379          */
 380         void AddCache(Query& r)
 381         {
 382                 if (cache.size() >= MAX_CACHE_SIZE)
 383                         cache.clear();
 384
 385                 // Determine the lowest TTL value and use that as the TTL of the cache entry
 386                 unsigned int cachettl = UINT_MAX;
 387                 for (std::vector<ResourceRecord>::const_iterator i = r.answers.begin(); i != r.answers.end(); ++i)
 388                 {
 389                         const ResourceRecord& rr = *i;
 390                         if (rr.ttl < cachettl)
 391                                 cachettl = rr.ttl;
 392                 }
 393
 394                 cachettl = std::min(cachettl, (unsigned int)5*60);
 395                 ResourceRecord& rr = r.answers.front();
 396                 // Set TTL to what we've determined to be the lowest
 397                 rr.ttl = cachettl;
 398                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "cache: added cache for " + rr.name + " -> " + rr.rdata + " ttl: " + ConvToStr(rr.ttl));
 399                 this->cache[r.question] = r;
 400         }
 401
 402  public:
 403         DNS::Request* requests[MAX_REQUEST_ID+1];
 404
 405         MyManager(Module* c) : Manager(c), Timer(5*60, true)
 406                 , unloading(false)
 407         {
 408                 for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i)
 409                         requests[i] = NULL;
 410                 ServerInstance->Timers.AddTimer(this);
 411         }
 412
 413         ~MyManager()
 414         {
 415                 // Ensure Process() will fail for new requests
 416                 unloading = true;
 417
 418                 for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i)
 419                 {
 420                         DNS::Request* request = requests[i];
 421                         if (!request)
 422                                 continue;
 423
 424                         Query rr(request->question);
 425                         rr.error = ERROR_UNKNOWN;
 426                         request->OnError(&rr);
 427
 428                         delete request;
 429                 }
 430         }
 431
 432         void Process(DNS::Request* req)
 433         {
 434                 if ((unloading) || (req->creator->dying))
 435                         throw Exception("Module is being unloaded");
 436
 437                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Processing request to lookup " + req->question.name + " of type " + ConvToStr(req->question.type) + " to " + this->myserver.addr());
 438
 439                 /* Create an id */
 440                 unsigned int tries = 0;
 441                 int id;
 442                 do
 443                 {
 444                         id = ServerInstance->GenRandomInt(DNS::MAX_REQUEST_ID+1);
 445
 446                         if (++tries == DNS::MAX_REQUEST_ID*5)
 447                         {
 448                                 // If we couldn't find an empty slot this many times, do a sequential scan as a last
 449                                 // resort. If an empty slot is found that way, go on, otherwise throw an exception
 450                                 id = -1;
 451                                 for (unsigned int i = 0; i <= DNS::MAX_REQUEST_ID; i++)
 452                                 {
 453                                         if (!this->requests[i])
 454                                         {
 455                                                 id = i;
 456                                                 break;
 457                                         }
 458                                 }
 459
 460                                 if (id == -1)
 461                                         throw Exception("DNS: All ids are in use");
 462
 463                                 break;
 464                         }
 465                 }
 466                 while (this->requests[id]);
 467
 468                 req->id = id;
 469                 this->requests[req->id] = req;
 470
 471                 Packet p;
 472                 p.flags = QUERYFLAGS_RD;
 473                 p.id = req->id;
 474                 p.question = req->question;
 475
 476                 unsigned char buffer[524];
 477                 unsigned short len = p.Pack(buffer, sizeof(buffer));
 478
 479                 /* Note that calling Pack() above can actually change the contents of p.question.name, if the query is a PTR,
 480                  * to contain the value that would be in the DNS cache, which is why this is here.
 481                  */
 482                 if (req->use_cache && this->CheckCache(req, p.question))
 483                 {
 484                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Using cached result");
 485                         delete req;
 486                         return;
 487                 }
 488
 489                 // Update name in the original request so question checking works for PTR queries
 490                 req->question.name = p.question.name;
 491
 492                 if (SocketEngine::SendTo(this, buffer, len, 0, &this->myserver.sa, this->myserver.sa_size()) != len)
 493                         throw Exception("DNS: Unable to send query");
 494
 495                 // Add timer for timeout
 496                 ServerInstance->Timers.AddTimer(req);
 497         }
 498
 499         void RemoveRequest(DNS::Request* req)
 500         {
 501                 if (requests[req->id] == req)
 502                         requests[req->id] = NULL;
 503         }
 504
 505         std::string GetErrorStr(Error e)
 506         {
 507                 switch (e)
 508                 {
 509                         case ERROR_UNLOADED:
 510                                 return "Module is unloading";
 511                         case ERROR_TIMEDOUT:
 512                                 return "Request timed out";
 513                         case ERROR_NOT_AN_ANSWER:
 514                         case ERROR_NONSTANDARD_QUERY:
 515                         case ERROR_FORMAT_ERROR:
 516                         case ERROR_MALFORMED:
 517                                 return "Malformed answer";
 518                         case ERROR_SERVER_FAILURE:
 519                         case ERROR_NOT_IMPLEMENTED:
 520                         case ERROR_REFUSED:
 521                         case ERROR_INVALIDTYPE:
 522                                 return "Nameserver failure";
 523                         case ERROR_DOMAIN_NOT_FOUND:
 524                         case ERROR_NO_RECORDS:
 525                                 return "Domain not found";
 526                         case ERROR_NONE:
 527                         case ERROR_UNKNOWN:
 528                         default:
 529                                 return "Unknown error";
 530                 }
 531         }
 532
 533         void OnEventHandlerError(int errcode) CXX11_OVERRIDE
 534         {
 535                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "UDP socket got an error event");
 536         }
 537
 538         void OnEventHandlerRead() CXX11_OVERRIDE
 539         {
 540                 unsigned char buffer[524];
 541                 irc::sockets::sockaddrs from;
 542                 socklen_t x = sizeof(from);
 543
 544                 int length = SocketEngine::RecvFrom(this, buffer, sizeof(buffer), 0, &from.sa, &x);
 545
 546                 if (length < Packet::HEADER_LENGTH)
 547                         return;
 548
 549                 if (myserver != from)
 550                 {
 551                         std::string server1 = from.str();
 552                         std::string server2 = myserver.str();
 553                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Got a result from the wrong server! Bad NAT or DNS forging attempt? '%s' != '%s'",
 554                                 server1.c_str(), server2.c_str());
 555                         return;
 556                 }
 557
 558                 Packet recv_packet;
 559                 bool valid = false;
 560
 561                 try
 562                 {
 563                         recv_packet.Fill(buffer, length);
 564                         valid = true;
 565                 }
 566                 catch (Exception& ex)
 567                 {
 568                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, ex.GetReason());
 569                 }
 570
 571                 // recv_packet.id must be filled in here
 572                 DNS::Request* request = this->requests[recv_packet.id];
 573                 if (request == NULL)
 574                 {
 575                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Received an answer for something we didn't request");
 576                         return;
 577                 }
 578
 579                 if (request->question != recv_packet.question)
 580                 {
 581                         // This can happen under high latency, drop it silently, do not fail the request
 582                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Received an answer that isn't for a question we asked");
 583                         return;
 584                 }
 585
 586                 if (!valid)
 587                 {
 588                         ServerInstance->stats.DnsBad++;
 589                         recv_packet.error = ERROR_MALFORMED;
 590                         request->OnError(&recv_packet);
 591                 }
 592                 else if (recv_packet.flags & QUERYFLAGS_OPCODE)
 593                 {
 594                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Received a nonstandard query");
 595                         ServerInstance->stats.DnsBad++;
 596                         recv_packet.error = ERROR_NONSTANDARD_QUERY;
 597                         request->OnError(&recv_packet);
 598                 }
 599                 else if (!(recv_packet.flags & QUERYFLAGS_QR) || (recv_packet.flags & QUERYFLAGS_RCODE))
 600                 {
 601                         Error error = ERROR_UNKNOWN;
 602
 603                         switch (recv_packet.flags & QUERYFLAGS_RCODE)
 604                         {
 605                                 case 1:
 606                                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "format error");
 607                                         error = ERROR_FORMAT_ERROR;
 608                                         break;
 609                                 case 2:
 610                                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "server error");
 611                                         error = ERROR_SERVER_FAILURE;
 612                                         break;
 613                                 case 3:
 614                                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "domain not found");
 615                                         error = ERROR_DOMAIN_NOT_FOUND;
 616                                         break;
 617                                 case 4:
 618                                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "not implemented");
 619                                         error = ERROR_NOT_IMPLEMENTED;
 620                                         break;
 621                                 case 5:
 622                                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "refused");
 623                                         error = ERROR_REFUSED;
 624                                         break;
 625                                 default:
 626                                         break;
 627                         }
 628
 629                         ServerInstance->stats.DnsBad++;
 630                         recv_packet.error = error;
 631                         request->OnError(&recv_packet);
 632                 }
 633                 else if (recv_packet.answers.empty())
 634                 {
 635                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "No resource records returned");
 636                         ServerInstance->stats.DnsBad++;
 637                         recv_packet.error = ERROR_NO_RECORDS;
 638                         request->OnError(&recv_packet);
 639                 }
 640                 else
 641                 {
 642                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Lookup complete for " + request->question.name);
 643                         ServerInstance->stats.DnsGood++;
 644                         request->OnLookupComplete(&recv_packet);
 645                         this->AddCache(recv_packet);
 646                 }
 647
 648                 ServerInstance->stats.Dns++;
 649
 650                 /* Request's destructor removes it from the request map */
 651                 delete request;
 652         }
 653
 654         bool Tick(time_t now)
 655         {
 656                 ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "cache: purging DNS cache");
 657
 658                 for (cache_map::iterator it = this->cache.begin(); it != this->cache.end(); )
 659                 {
 660                         const Query& query = it->second;
 661                         if (IsExpired(query, now))
 662                                 this->cache.erase(it++);
 663                         else
 664                                 ++it;
 665                 }
 666                 return true;
 667         }
 668
 669         void Rehash(const std::string& dnsserver, std::string sourceaddr, unsigned int sourceport)
 670         {
 671                 if (this->GetFd() > -1)
 672                 {
 673                         SocketEngine::Shutdown(this, 2);
 674                         SocketEngine::Close(this);
 675
 676                         /* Remove expired entries from the cache */
 677                         this->Tick(ServerInstance->Time());
 678                 }
 679
 680                 irc::sockets::aptosa(dnsserver, DNS::PORT, myserver);
 681
 682                 /* Initialize mastersocket */
 683                 int s = socket(myserver.sa.sa_family, SOCK_DGRAM, 0);
 684                 this->SetFd(s);
 685
 686                 /* Have we got a socket? */
 687                 if (this->GetFd() != -1)
 688                 {
 689                         SocketEngine::SetReuse(s);
 690                         SocketEngine::NonBlocking(s);
 691
 692                         irc::sockets::sockaddrs bindto;
 693                         if (sourceaddr.empty())
 694                         {
 695                                 // set a sourceaddr for irc::sockets::aptosa() based on the servers af type
 696                                 if (myserver.sa.sa_family == AF_INET)
 697                                         sourceaddr = "0.0.0.0";
 698                                 else if (myserver.sa.sa_family == AF_INET6)
 699                                         sourceaddr = "::";
 700                         }
 701                         irc::sockets::aptosa(sourceaddr, sourceport, bindto);
 702
 703                         if (SocketEngine::Bind(this->GetFd(), bindto) < 0)
 704                         {
 705                                 /* Failed to bind */
 706                                 ServerInstance->Logs->Log(MODNAME, LOG_SPARSE, "Error binding dns socket - hostnames will NOT resolve");
 707                                 SocketEngine::Close(this->GetFd());
 708                                 this->SetFd(-1);
 709                         }
 710                         else if (!SocketEngine::AddFd(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE))
 711                         {
 712                                 ServerInstance->Logs->Log(MODNAME, LOG_SPARSE, "Internal error starting DNS - hostnames will NOT resolve.");
 713                                 SocketEngine::Close(this->GetFd());
 714                                 this->SetFd(-1);
 715                         }
 716
 717                         if (bindto.sa.sa_family != myserver.sa.sa_family)
 718                                 ServerInstance->Logs->Log(MODNAME, LOG_SPARSE, "Nameserver address family differs from source address family - hostnames might not resolve");
 719                 }
 720                 else
 721                 {
 722                         ServerInstance->Logs->Log(MODNAME, LOG_SPARSE, "Error creating DNS socket - hostnames will NOT resolve");
 723                 }
 724         }
 725 };
 726
 727 class ModuleDNS : public Module
 728 {
 729         MyManager manager;
 730         std::string DNSServer;
 731         std::string SourceIP;
 732         unsigned int SourcePort;
 733
 734         void FindDNSServer()
 735         {
 736 #ifdef _WIN32
 737                 // attempt to look up their nameserver from the system
 738                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "WARNING: <dns:server> not defined, attempting to find a working server in the system settings...");
 739
 740                 PFIXED_INFO pFixedInfo;
 741                 DWORD dwBufferSize = sizeof(FIXED_INFO);
 742                 pFixedInfo = (PFIXED_INFO) HeapAlloc(GetProcessHeap(), 0, sizeof(FIXED_INFO));
 743
 744                 if (pFixedInfo)
 745                 {
 746                         if (GetNetworkParams(pFixedInfo, &dwBufferSize) == ERROR_BUFFER_OVERFLOW)
 747                         {
 748                                 HeapFree(GetProcessHeap(), 0, pFixedInfo);
 749                                 pFixedInfo = (PFIXED_INFO) HeapAlloc(GetProcessHeap(), 0, dwBufferSize);
 750                         }
 751
 752                         if (pFixedInfo)
 753                         {
 754                                 if (GetNetworkParams(pFixedInfo, &dwBufferSize) == NO_ERROR)
 755                                         DNSServer = pFixedInfo->DnsServerList.IpAddress.String;
 756
 757                                 HeapFree(GetProcessHeap(), 0, pFixedInfo);
 758                         }
 759
 760                         if (!DNSServer.empty())
 761                         {
 762                                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "<dns:server> set to '%s' as first active resolver in the system settings.", DNSServer.c_str());
 763                                 return;
 764                         }
 765                 }
 766
 767                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "No viable nameserver found! Defaulting to nameserver '127.0.0.1'!");
 768 #else
 769                 // attempt to look up their nameserver from /etc/resolv.conf
 770                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "WARNING: <dns:server> not defined, attempting to find working server in /etc/resolv.conf...");
 771
 772                 std::ifstream resolv("/etc/resolv.conf");
 773
 774                 while (resolv >> DNSServer)
 775                 {
 776                         if (DNSServer == "nameserver")
 777                         {
 778                                 resolv >> DNSServer;
 779                                 if (DNSServer.find_first_not_of("0123456789.") == std::string::npos || DNSServer.find_first_not_of("0123456789ABCDEFabcdef:") == std::string::npos)
 780                                 {
 781                                         ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "<dns:server> set to '%s' as first resolver in /etc/resolv.conf.",DNSServer.c_str());
 782                                         return;
 783                                 }
 784                         }
 785                 }
 786
 787                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "/etc/resolv.conf contains no viable nameserver entries! Defaulting to nameserver '127.0.0.1'!");
 788 #endif
 789                 DNSServer = "127.0.0.1";
 790         }
 791
 792  public:
 793         ModuleDNS() : manager(this)
 794                 , SourcePort(0)
 795         {
 796         }
 797
 798         void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
 799         {
 800                 std::string oldserver = DNSServer;
 801                 const std::string oldip = SourceIP;
 802                 const unsigned int oldport = SourcePort;
 803
 804                 ConfigTag* tag = ServerInstance->Config->ConfValue("dns");
 805                 DNSServer = tag->getString("server");
 806                 SourceIP = tag->getString("sourceip");
 807                 SourcePort = tag->getInt("sourceport", 0, 0, 65535);
 808
 809                 if (DNSServer.empty())
 810                         FindDNSServer();
 811
 812                 if (oldserver != DNSServer || oldip != SourceIP || oldport != SourcePort)
 813                         this->manager.Rehash(DNSServer, SourceIP, SourcePort);
 814         }
 815
 816         void OnUnloadModule(Module* mod)
 817         {
 818                 for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i)
 819                 {
 820                         DNS::Request* req = this->manager.requests[i];
 821                         if (!req)
 822                                 continue;
 823
 824                         if (req->creator == mod)
 825                         {
 826                                 Query rr(req->question);
 827                                 rr.error = ERROR_UNLOADED;
 828                                 req->OnError(&rr);
 829
 830                                 delete req;
 831                         }
 832                 }
 833         }
 834
 835         Version GetVersion()
 836         {
 837                 return Version("DNS support", VF_CORE|VF_VENDOR);
 838         }
 839 };
 840
 841 MODULE_INIT(ModuleDNS)
 842