-/* +------------------------------------+
\r * | Inspire Internet Relay Chat Daemon |
\r * +------------------------------------+
\r *
\r * InspIRCd: (C) 2002-2007 InspIRCd Development Team
\r * See: http://www.inspircd.org/wiki/index.php/Credits
\r *
\r * This program is free but copyrighted software; see
\r * the file COPYING for details.
\r *
\r * ---------------------------------------------------
\r */
\r\r/*
\rdns.cpp - Nonblocking DNS functions.
\rVery very loosely based on the firedns library,
\rCopyright (C) 2002 Ian Gulliver. This file is no
\rlonger anything like firedns, there are many major
\rdifferences between this code and the original.
\rPlease do not assume that firedns works like this,
\rlooks like this, walks like this or tastes like this.
\r*/
\r\r#ifndef WIN32
\r#include <sys/types.h>
\r#include <sys/socket.h>
\r#include <errno.h>
\r#include <netinet/in.h>
\r#include <arpa/inet.h>
\r#else
\r#include "inspircd_win32wrapper.h"
\r#include "inspircd_se_config.h"
\r#endif
\r\r#include "dns.h"
\r#include "inspircd.h"
\r#include "socketengine.h"
\r#include "configreader.h"
\r#include "socket.h"
\r\rusing irc::sockets::insp_inaddr;
\rusing irc::sockets::insp_ntoa;
\rusing irc::sockets::insp_aton;
\rusing irc::sockets::OpenTCPSocket;
\r\r/** Masks to mask off the responses we get from the DNSRequest methods
\r */
\renum QueryInfo
\r{
\r ERROR_MASK = 0x10000 /* Result is an error */
\r};
\r\r/** Flags which can be ORed into a request or reply for different meanings
\r */
\renum QueryFlags
\r{
\r FLAGS_MASK_RD = 0x01, /* Recursive */
\r FLAGS_MASK_TC = 0x02,
\r FLAGS_MASK_AA = 0x04, /* Authoritative */
\r FLAGS_MASK_OPCODE = 0x78,
\r FLAGS_MASK_QR = 0x80,
\r FLAGS_MASK_RCODE = 0x0F, /* Request */
\r FLAGS_MASK_Z = 0x70,
\r FLAGS_MASK_RA = 0x80
\r};
\r\r\r/** Represents a dns resource record (rr)
\r */
\rstruct ResourceRecord
\r{
\r QueryType type; /* Record type */
\r unsigned int rr_class; /* Record class */
\r unsigned long ttl; /* Time to live */
\r unsigned int rdlength; /* Record length */
\r};
\r\r/** Represents a dns request/reply header, and its payload as opaque data.
\r */
\rclass DNSHeader
\r{
\r public:
\r unsigned char id[2]; /* Request id */
\r unsigned int flags1; /* Flags */
\r unsigned int flags2; /* Flags */
\r unsigned int qdcount;
\r unsigned int ancount; /* Answer count */
\r unsigned int nscount; /* Nameserver count */
\r unsigned int arcount;
\r unsigned char payload[512]; /* Packet payload */
\r};
\r\rclass DNSRequest
\r{
\r public:
\r unsigned char id[2]; /* Request id */
\r unsigned char* res; /* Result processing buffer */
\r unsigned int rr_class; /* Request class */
\r QueryType type; /* Request type */
\r DNS* dnsobj; /* DNS caller (where we get our FD from) */
\r unsigned long ttl; /* Time to live */
\r std::string orig; /* Original requested name/ip */
\r\r DNSRequest(InspIRCd* Instance, DNS* dns, int id, const std::string &original);
\r ~DNSRequest();
\r DNSInfo ResultIsReady(DNSHeader &h, int length);
\r int SendRequests(const DNSHeader *header, const int length, QueryType qt);
\r};
\r\rclass CacheTimer : public InspTimer
\r{
\r private:
\r InspIRCd* ServerInstance;
\r DNS* dns;
\r public:
\r CacheTimer(InspIRCd* Instance, DNS* thisdns)
\r : InspTimer(3600, Instance->Time(), true), ServerInstance(Instance), dns(thisdns) { }
\r\r virtual void Tick(time_t TIME)
\r {
\r dns->PruneCache();
\r }
\r};
\r\rclass RequestTimeout : public InspTimer
\r{
\r InspIRCd* ServerInstance;
\r DNSRequest* watch;
\r int watchid;
\r public:
\r RequestTimeout(unsigned long n, InspIRCd* SI, DNSRequest* watching, int id) : InspTimer(n, time(NULL)), ServerInstance(SI), watch(watching), watchid(id)
\r {
\r }
\r\r void Tick(time_t TIME)
\r {
\r if (ServerInstance->Res->requests[watchid] == watch)
\r {
\r /* Still exists, whack it */
\r if (ServerInstance->Res->Classes[watchid])
\r {
\r ServerInstance->Res->Classes[watchid]->OnError(RESOLVER_TIMEOUT, "Request timed out");
\r delete ServerInstance->Res->Classes[watchid];
\r ServerInstance->Res->Classes[watchid] = NULL;
\r }
\r ServerInstance->Res->requests[watchid] = NULL;
\r DELETE(watch);
\r return;
\r }
\r }
\r};
\r\r/* Allocate the processing buffer */
\rDNSRequest::DNSRequest(InspIRCd* Instance, DNS* dns, int id, const std::string &original) : dnsobj(dns)
\r{
\r res = new unsigned char[512];
\r *res = 0;
\r orig = original;
\r RequestTimeout* RT = new RequestTimeout(Instance->Config->dns_timeout ? Instance->Config->dns_timeout : 5, Instance, this, id);
\r Instance->Timers->AddTimer(RT); /* The timer manager frees this */
\r}
\r\r/* Deallocate the processing buffer */
\rDNSRequest::~DNSRequest()
\r{
\r delete[] res;
\r}
\r\r/** Fill a ResourceRecord class based on raw data input */
\rinline void DNS::FillResourceRecord(ResourceRecord* rr, const unsigned char *input)
\r{
\r rr->type = (QueryType)((input[0] << 8) + input[1]);
\r rr->rr_class = (input[2] << 8) + input[3];
\r rr->ttl = (input[4] << 24) + (input[5] << 16) + (input[6] << 8) + input[7];
\r rr->rdlength = (input[8] << 8) + input[9];
\r}
\r\r/** Fill a DNSHeader class based on raw data input of a given length */
\rinline void DNS::FillHeader(DNSHeader *header, const unsigned char *input, const int length)
\r{
\r header->id[0] = input[0];
\r header->id[1] = input[1];
\r header->flags1 = input[2];
\r header->flags2 = input[3];
\r header->qdcount = (input[4] << 8) + input[5];
\r header->ancount = (input[6] << 8) + input[7];
\r header->nscount = (input[8] << 8) + input[9];
\r header->arcount = (input[10] << 8) + input[11];
\r memcpy(header->payload,&input[12],length);
\r}
\r\r/** Empty a DNSHeader class out into raw data, ready for transmission */
\rinline void DNS::EmptyHeader(unsigned char *output, const DNSHeader *header, const int length)
\r{
\r output[0] = header->id[0];
\r output[1] = header->id[1];
\r output[2] = header->flags1;
\r output[3] = header->flags2;
\r output[4] = header->qdcount >> 8;
\r output[5] = header->qdcount & 0xFF;
\r output[6] = header->ancount >> 8;
\r output[7] = header->ancount & 0xFF;
\r output[8] = header->nscount >> 8;
\r output[9] = header->nscount & 0xFF;
\r output[10] = header->arcount >> 8;
\r output[11] = header->arcount & 0xFF;
\r memcpy(&output[12],header->payload,length);
\r}
\r\r/** Send requests we have previously built down the UDP socket */
\rint DNSRequest::SendRequests(const DNSHeader *header, const int length, QueryType qt)
\r{
\r unsigned char payload[sizeof(DNSHeader)];
\r\r this->rr_class = 1;
\r this->type = qt;
\r \r DNS::EmptyHeader(payload,header,length);
\r\r#ifdef IPV6
\r if (this->dnsobj->socketfamily == AF_INET6)
\r {
\r sockaddr_in6 addr;
\r memset(&addr,0,sizeof(addr));
\r memcpy(&addr.sin6_addr,&dnsobj->myserver6,sizeof(addr.sin6_addr));
\r addr.sin6_family = AF_INET6;
\r addr.sin6_port = htons(DNS::QUERY_PORT);
\r if (sendto(dnsobj->GetFd(), payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) != length+12)
\r return -1;
\r }
\r else
\r {
\r sockaddr_in addr;
\r memset(&addr,0,sizeof(addr));
\r memcpy(&addr.sin_addr.s_addr,&dnsobj->myserver4,sizeof(addr.sin_addr));
\r addr.sin_family = AF_INET;
\r addr.sin_port = htons(DNS::QUERY_PORT);
\r if (sendto(dnsobj->GetFd(), payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) != length+12)
\r return -1;
\r }
\r#else
\r sockaddr_in addr;
\r memset(&addr,0,sizeof(addr));
\r memcpy(&addr.sin_addr.s_addr, &dnsobj->myserver4, sizeof(addr.sin_addr));
\r addr.sin_family = AF_INET;
\r addr.sin_port = htons(DNS::QUERY_PORT);
\r if (sendto(dnsobj->GetFd(), (const char*)payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) != length+12)
\r return -1;
\r#endif
\r\r return 0;
\r}
\r\r/** Add a query with a predefined header, and allocate an ID for it. */
\rDNSRequest* DNS::AddQuery(DNSHeader *header, int &id, const char* original)
\r{
\r /* Is the DNS connection down? */
\r if (this->GetFd() == -1)
\r return NULL;
\r \r /* Create an id */
\r id = this->PRNG() & DNS::MAX_REQUEST_ID;
\r\r /* If this id is already 'in flight', pick another. */
\r while (requests[id])
\r id = this->PRNG() & DNS::MAX_REQUEST_ID;
\r\r DNSRequest* req = new DNSRequest(ServerInstance, this, id, original);
\r\r header->id[0] = req->id[0] = id >> 8;
\r header->id[1] = req->id[1] = id & 0xFF;
\r header->flags1 = FLAGS_MASK_RD;
\r header->flags2 = 0;
\r header->qdcount = 1;
\r header->ancount = 0;
\r header->nscount = 0;
\r header->arcount = 0;
\r\r /* At this point we already know the id doesnt exist,
\r * so there needs to be no second check for the ::end()
\r */
\r requests[id] = req;
\r\r /* According to the C++ spec, new never returns NULL. */
\r return req;
\r}
\r\rint DNS::ClearCache()
\r{
\r /* This ensures the buckets are reset to sane levels */
\r int rv = this->cache->size();
\r delete this->cache;
\r this->cache = new dnscache();
\r return rv;
\r}
\r\rint DNS::PruneCache()
\r{
\r int n = 0;
\r dnscache* newcache = new dnscache();
\r for (dnscache::iterator i = this->cache->begin(); i != this->cache->end(); i++)
\r /* Dont include expired items (theres no point) */
\r if (i->second.CalcTTLRemaining())
\r newcache->insert(*i);
\r else
\r n++;
\r\r delete this->cache;
\r this->cache = newcache;
\r return n;
\r}
\r\rvoid DNS::Rehash()
\r{
\r ip6munge = false;
\r int portpass = 0;
\r\r if (this->GetFd() > -1)
\r {
\r if (ServerInstance && ServerInstance->SE)
\r ServerInstance->SE->DelFd(this);
\r shutdown(this->GetFd(), 2);
\r close(this->GetFd());
\r this->SetFd(-1);
\r\r /* Rehash the cache */
\r this->PruneCache();
\r }
\r else
\r {
\r /* Create initial dns cache */
\r this->cache = new dnscache();
\r }
\r\r if ((strstr(ServerInstance->Config->DNSServer,"::ffff:") == (char*)&ServerInstance->Config->DNSServer) || (strstr(ServerInstance->Config->DNSServer,"::FFFF:") == (char*)&ServerInstance->Config->DNSServer))
\r {
\r ServerInstance->Log(DEFAULT,"WARNING: Using IPv4 addresses over IPv6 forces some DNS checks to be disabled.");
\r ServerInstance->Log(DEFAULT," This should not cause a problem, however it is recommended you migrate");
\r ServerInstance->Log(DEFAULT," to a true IPv6 environment.");
\r this->ip6munge = true;
\r }
\r\r this->socketfamily = AF_INET;
\r#ifdef IPV6
\r if (strchr(ServerInstance->Config->DNSServer,':'))
\r {
\r this->socketfamily = AF_INET6;
\r inet_pton(AF_INET6, ServerInstance->Config->DNSServer, &this->myserver6);
\r }
\r else
\r {
\r inet_aton(ServerInstance->Config->DNSServer, &this->myserver4);
\r portpass = -1;
\r }
\r#else
\r inet_aton(ServerInstance->Config->DNSServer, &this->myserver4);
\r#endif
\r\r /* Initialize mastersocket */
\r int s = OpenTCPSocket(ServerInstance->Config->DNSServer, SOCK_DGRAM);
\r this->SetFd(s);
\r\r /* Have we got a socket and is it nonblocking? */
\r if (this->GetFd() != -1)
\r {
\r /* Bind the port - port 0 INADDR_ANY */
\r if (!ServerInstance->BindSocket(this->GetFd(), portpass, "", false))
\r {
\r /* Failed to bind */
\r shutdown(this->GetFd(),2);
\r close(this->GetFd());
\r this->SetFd(-1);
\r }
\r\r if (this->GetFd() >= 0)
\r {
\r /* Hook the descriptor into the socket engine */
\r if (ServerInstance && ServerInstance->SE)
\r {
\r if (!ServerInstance->SE->AddFd(this))
\r {
\r ServerInstance->Log(DEFAULT,"Internal error starting DNS - hostnames will NOT resolve.");
\r shutdown(this->GetFd(),2);
\r close(this->GetFd());
\r this->SetFd(-1);
\r }
\r }
\r }
\r }
\r}
\r\r/** Initialise the DNS UDP socket so that we can send requests */
\rDNS::DNS(InspIRCd* Instance) : ServerInstance(Instance)
\r{
\r /* Clear the Resolver class table */
\r memset(Classes,0,sizeof(Classes));
\r\r /* Clear the requests class table */
\r memset(requests,0,sizeof(requests));
\r\r /* Set the id of the next request to 0
\r */
\r currid = 0;
\r\r /* DNS::Rehash() sets this to a valid ptr
\r */
\r this->cache = NULL;
\r \r /* Again, DNS::Rehash() sets this to a
\r * valid value
\r */
\r this->SetFd(-1);
\r\r /* Actually read the settings
\r */
\r this->Rehash();
\r\r this->PruneTimer = new CacheTimer(ServerInstance, this);
\r\r ServerInstance->Timers->AddTimer(this->PruneTimer);
\r}
\r\r/** Build a payload to be placed after the header, based upon input data, a resource type, a class and a pointer to a buffer */
\rint DNS::MakePayload(const char * const name, const QueryType rr, const unsigned short rr_class, unsigned char * const payload)
\r{
\r short payloadpos = 0;
\r const char* tempchr, *tempchr2 = name;
\r unsigned short length;
\r\r /* split name up into labels, create query */
\r while ((tempchr = strchr(tempchr2,'.')) != NULL)
\r {
\r length = tempchr - tempchr2;
\r if (payloadpos + length + 1 > 507)
\r return -1;
\r payload[payloadpos++] = length;
\r memcpy(&payload[payloadpos],tempchr2,length);
\r payloadpos += length;
\r tempchr2 = &tempchr[1];
\r }
\r length = strlen(tempchr2);
\r if (length)
\r {
\r if (payloadpos + length + 2 > 507)
\r return -1;
\r payload[payloadpos++] = length;
\r memcpy(&payload[payloadpos],tempchr2,length);
\r payloadpos += length;
\r payload[payloadpos++] = 0;
\r }
\r if (payloadpos > 508)
\r return -1;
\r length = htons(rr);
\r memcpy(&payload[payloadpos],&length,2);
\r length = htons(rr_class);
\r memcpy(&payload[payloadpos + 2],&length,2);
\r return payloadpos + 4;
\r}
\r\r/** Start lookup of an hostname to an IP address */
\rint DNS::GetIP(const char *name)
\r{
\r DNSHeader h;
\r int id;
\r int length;
\r \r if ((length = this->MakePayload(name, DNS_QUERY_A, 1, (unsigned char*)&h.payload)) == -1)
\r return -1;
\r\r DNSRequest* req = this->AddQuery(&h, id, name);
\r\r if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_A) == -1))
\r return -1;
\r\r return id;
\r}
\r\r/** Start lookup of an hostname to an IPv6 address */
\rint DNS::GetIP6(const char *name)
\r{
\r DNSHeader h;
\r int id;
\r int length;
\r\r if ((length = this->MakePayload(name, DNS_QUERY_AAAA, 1, (unsigned char*)&h.payload)) == -1)
\r return -1;
\r\r DNSRequest* req = this->AddQuery(&h, id, name);
\r\r if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_AAAA) == -1))
\r return -1;
\r\r return id;
\r}
\r\r/** Start lookup of a cname to another name */
\rint DNS::GetCName(const char *alias)
\r{
\r DNSHeader h;
\r int id;
\r int length;
\r\r if ((length = this->MakePayload(alias, DNS_QUERY_CNAME, 1, (unsigned char*)&h.payload)) == -1)
\r return -1;
\r\r DNSRequest* req = this->AddQuery(&h, id, alias);
\r\r if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_CNAME) == -1))
\r return -1;
\r\r return id;
\r}
\r\r/** Start lookup of an IP address to a hostname */
\rint DNS::GetName(const insp_inaddr *ip)
\r{
\r char query[128];
\r DNSHeader h;
\r int id;
\r int length;
\r\r#ifdef IPV6
\r unsigned char* c = (unsigned char*)&ip->s6_addr;
\r if (c[0] == 0 && c[1] == 0 && c[2] == 0 && c[3] == 0 &&
\r c[4] == 0 && c[5] == 0 && c[6] == 0 && c[7] == 0 &&
\r c[8] == 0 && c[9] == 0 && c[10] == 0xFF && c[11] == 0xFF)
\r sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[15],c[14],c[13],c[12]);
\r else
\r DNS::MakeIP6Int(query, (in6_addr*)ip);
\r#else
\r unsigned char* c = (unsigned char*)&ip->s_addr;
\r sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]);
\r#endif
\r\r if ((length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload)) == -1)
\r return -1;
\r\r DNSRequest* req = this->AddQuery(&h, id, insp_ntoa(*ip));
\r\r if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1))
\r return -1;
\r\r return id;
\r}
\r\r/** Start lookup of an IP address to a hostname */
\rint DNS::GetNameForce(const char *ip, ForceProtocol fp)
\r{
\r char query[128];
\r DNSHeader h;
\r int id;
\r int length;
\r#ifdef SUPPORT_IP6LINKS
\r if (fp == PROTOCOL_IPV6)
\r {
\r in6_addr i;
\r if (inet_pton(AF_INET6, ip, &i) > 0)
\r {
\r DNS::MakeIP6Int(query, &i);
\r }
\r else
\r /* Invalid IP address */
\r return -1;
\r }
\r else
\r#endif
\r {
\r in_addr i;
\r if (inet_aton(ip, &i))
\r {
\r unsigned char* c = (unsigned char*)&i.s_addr;
\r sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]);
\r }
\r else
\r /* Invalid IP address */
\r return -1;
\r }
\r\r if ((length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload)) == -1)
\r return -1;
\r\r DNSRequest* req = this->AddQuery(&h, id, ip);
\r\r if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1))
\r return -1;
\r\r return id;
\r}
\r\r/** Build an ipv6 reverse domain from an in6_addr
\r */
\rvoid DNS::MakeIP6Int(char* query, const in6_addr *ip)
\r{
\r#ifdef SUPPORT_IP6LINKS
\r const char* hex = "0123456789abcdef";
\r for (int index = 31; index >= 0; index--) /* for() loop steps twice per byte */
\r {
\r if (index % 2)
\r /* low nibble */
\r *query++ = hex[ip->s6_addr[index / 2] & 0x0F];
\r else
\r /* high nibble */
\r *query++ = hex[(ip->s6_addr[index / 2] & 0xF0) >> 4];
\r *query++ = '.'; /* Seperator */
\r }
\r strcpy(query,"ip6.arpa"); /* Suffix the string */
\r#else
\r *query = 0;
\r#endif
\r}
\r\r/** Return the next id which is ready, and the result attached to it */
\rDNSResult DNS::GetResult()
\r{
\r /* Fetch dns query response and decide where it belongs */
\r DNSHeader header;
\r DNSRequest *req;
\r unsigned char buffer[sizeof(DNSHeader)];
\r sockaddr* from = new sockaddr[2];
\r#ifdef IPV6
\r socklen_t x = this->socketfamily == AF_INET ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
\r#else
\r socklen_t x = sizeof(sockaddr_in);
\r#endif
\r const char* ipaddr_from;
\r unsigned short int port_from = 0;
\r int length = _recvfrom(this->GetFd(),(char*)buffer,sizeof(DNSHeader),0,from,&x);
\r\r /* Did we get the whole header? */
\r if (length < 12)
\r {
\r /* Nope - something screwed up. */
\r delete[] from;
\r return DNSResult(-1,"",0,"");
\r }
\r\r /* Check wether the reply came from a different DNS
\r * server to the one we sent it to, or the source-port
\r * is not 53.
\r * A user could in theory still spoof dns packets anyway
\r * but this is less trivial than just sending garbage
\r * to the client, which is possible without this check.
\r *
\r * -- Thanks jilles for pointing this one out.
\r */
\r#ifdef IPV6
\r char nbuf[MAXBUF];
\r if (this->socketfamily == AF_INET6)
\r {
\r ipaddr_from = inet_ntop(AF_INET6, &((sockaddr_in6*)from)->sin6_addr, nbuf, sizeof(nbuf));
\r port_from = ntohs(((sockaddr_in6*)from)->sin6_port);
\r }
\r else
\r#endif
\r {
\r ipaddr_from = inet_ntoa(((sockaddr_in*)from)->sin_addr);
\r port_from = ntohs(((sockaddr_in*)from)->sin_port);
\r }
\r\r delete[] from;
\r\r /* We cant perform this security check if you're using 4in6.
\r * Tough luck to you, choose one or't other!
\r */
\r if (!ip6munge)
\r {
\r if ((port_from != DNS::QUERY_PORT) || (strcasecmp(ipaddr_from, ServerInstance->Config->DNSServer)))
\r {
\r return DNSResult(-1,"",0,"");
\r }
\r }
\r\r /* Put the read header info into a header class */
\r DNS::FillHeader(&header,buffer,length - 12);
\r\r /* Get the id of this request.
\r * Its a 16 bit value stored in two char's,
\r * so we use logic shifts to create the value.
\r */
\r unsigned long this_id = header.id[1] + (header.id[0] << 8);
\r\r /* Do we have a pending request matching this id? */
\r if (!requests[this_id])
\r {
\r /* Somehow we got a DNS response for a request we never made... */
\r return DNSResult(-1,"",0,"");
\r }
\r else
\r {
\r /* Remove the query from the list of pending queries */
\r req = requests[this_id];
\r requests[this_id] = NULL;
\r }
\r\r /* Inform the DNSRequest class that it has a result to be read.
\r * When its finished it will return a DNSInfo which is a pair of
\r * unsigned char* resource record data, and an error message.
\r */
\r DNSInfo data = req->ResultIsReady(header, length);
\r std::string resultstr;
\r\r /* Check if we got a result, if we didnt, its an error */
\r if (data.first == NULL)
\r {
\r /* An error.
\r * Mask the ID with the value of ERROR_MASK, so that
\r * the dns_deal_with_classes() function knows that its
\r * an error response and needs to be treated uniquely.
\r * Put the error message in the second field.
\r */
\r std::string ro = req->orig;
\r delete req;
\r return DNSResult(this_id | ERROR_MASK, data.second, 0, ro);
\r }
\r else
\r {
\r unsigned long ttl = req->ttl;
\r char formatted[128];
\r\r /* Forward lookups come back as binary data. We must format them into ascii */
\r switch (req->type)
\r {
\r case DNS_QUERY_A:
\r snprintf(formatted,16,"%u.%u.%u.%u",data.first[0],data.first[1],data.first[2],data.first[3]);
\r resultstr = formatted;
\r break;
\r\r case DNS_QUERY_AAAA:
\r {
\r snprintf(formatted,40,"%x:%x:%x:%x:%x:%x:%x:%x",
\r (ntohs(data.first[0]) + ntohs(data.first[1] << 8)),
\r (ntohs(data.first[2]) + ntohs(data.first[3] << 8)),
\r (ntohs(data.first[4]) + ntohs(data.first[5] << 8)),
\r (ntohs(data.first[6]) + ntohs(data.first[7] << 8)),
\r (ntohs(data.first[8]) + ntohs(data.first[9] << 8)),
\r (ntohs(data.first[10]) + ntohs(data.first[11] << 8)),
\r (ntohs(data.first[12]) + ntohs(data.first[13] << 8)),
\r (ntohs(data.first[14]) + ntohs(data.first[15] << 8)));
\r char* c = strstr(formatted,":0:");
\r if (c != NULL)
\r {
\r memmove(c+1,c+2,strlen(c+2) + 1);
\r c += 2;
\r while (memcmp(c,"0:",2) == 0)
\r memmove(c,c+2,strlen(c+2) + 1);
\r if (memcmp(c,"0",2) == 0)
\r *c = 0;
\r if (memcmp(formatted,"0::",3) == 0)
\r memmove(formatted,formatted + 1, strlen(formatted + 1) + 1);
\r }
\r resultstr = formatted;
\r\r /* Special case. Sending ::1 around between servers
\r * and to clients is dangerous, because the : on the
\r * start makes the client or server interpret the IP
\r * as the last parameter on the line with a value ":1".
\r */
\r if (*formatted == ':')
\r resultstr.insert(0, "0");
\r }
\r break;
\r\r case DNS_QUERY_CNAME:
\r /* Identical handling to PTR */
\r\r case DNS_QUERY_PTR:
\r /* Reverse lookups just come back as char* */
\r resultstr = std::string((const char*)data.first);
\r break;
\r\r default:
\r break;
\r \r }
\r\r /* Build the reply with the id and hostname/ip in it */
\r std::string ro = req->orig;
\r delete req;
\r return DNSResult(this_id,resultstr,ttl,ro);
\r }
\r}
\r\r/** A result is ready, process it */
\rDNSInfo DNSRequest::ResultIsReady(DNSHeader &header, int length)
\r{
\r int i = 0;
\r int q = 0;
\r int curanswer, o;
\r ResourceRecord rr;
\r unsigned short ptr;
\r\r /* This is just to keep _FORTIFY_SOURCE happy */
\r rr.type = DNS_QUERY_NONE;
\r rr.rdlength = 0;
\r rr.ttl = 1; /* GCC is a whiney bastard -- see the XXX below. */
\r\r if (!(header.flags1 & FLAGS_MASK_QR))
\r return std::make_pair((unsigned char*)NULL,"Not a query result");
\r\r if (header.flags1 & FLAGS_MASK_OPCODE)
\r return std::make_pair((unsigned char*)NULL,"Unexpected value in DNS reply packet");
\r\r if (header.flags2 & FLAGS_MASK_RCODE)
\r return std::make_pair((unsigned char*)NULL,"Domain name not found");
\r\r if (header.ancount < 1)
\r return std::make_pair((unsigned char*)NULL,"No resource records returned");
\r\r /* Subtract the length of the header from the length of the packet */
\r length -= 12;
\r\r while ((unsigned int)q < header.qdcount && i < length)
\r {
\r if (header.payload[i] > 63)
\r {
\r i += 6;
\r q++;
\r }
\r else
\r {
\r if (header.payload[i] == 0)
\r {
\r q++;
\r i += 5;
\r }
\r else i += header.payload[i] + 1;
\r }
\r }
\r curanswer = 0;
\r while ((unsigned)curanswer < header.ancount)
\r {
\r q = 0;
\r while (q == 0 && i < length)
\r {
\r if (header.payload[i] > 63)
\r {
\r i += 2;
\r q = 1;
\r }
\r else
\r {
\r if (header.payload[i] == 0)
\r {
\r i++;
\r q = 1;
\r }
\r else i += header.payload[i] + 1; /* skip length and label */
\r }
\r }
\r if (length - i < 10)
\r return std::make_pair((unsigned char*)NULL,"Incorrectly sized DNS reply");
\r\r /* XXX: We actually initialise 'rr' here including its ttl field */
\r DNS::FillResourceRecord(&rr,&header.payload[i]);
\r i += 10;
\r if (rr.type != this->type)
\r {
\r curanswer++;
\r i += rr.rdlength;
\r continue;
\r }
\r if (rr.rr_class != this->rr_class)
\r {
\r curanswer++;
\r i += rr.rdlength;
\r continue;
\r }
\r break;
\r }
\r if ((unsigned int)curanswer == header.ancount)
\r return std::make_pair((unsigned char*)NULL,"No valid answers");
\r\r if (i + rr.rdlength > (unsigned int)length)
\r return std::make_pair((unsigned char*)NULL,"Resource record larger than stated");
\r\r if (rr.rdlength > 1023)
\r return std::make_pair((unsigned char*)NULL,"Resource record too large");
\r\r this->ttl = rr.ttl;
\r\r switch (rr.type)
\r {
\r case DNS_QUERY_CNAME:
\r /* CNAME and PTR have the same processing code */
\r case DNS_QUERY_PTR:
\r o = 0;
\r q = 0;
\r while (q == 0 && i < length && o + 256 < 1023)
\r {
\r if (header.payload[i] > 63)
\r {
\r memcpy(&ptr,&header.payload[i],2);
\r i = ntohs(ptr) - 0xC000 - 12;
\r }
\r else
\r {
\r if (header.payload[i] == 0)
\r {
\r q = 1;
\r }
\r else
\r {
\r res[o] = 0;
\r if (o != 0)
\r res[o++] = '.';
\r memcpy(&res[o],&header.payload[i + 1],header.payload[i]);
\r o += header.payload[i];
\r i += header.payload[i] + 1;
\r }
\r }
\r }
\r res[o] = 0;
\r break;
\r case DNS_QUERY_AAAA:
\r memcpy(res,&header.payload[i],rr.rdlength);
\r res[rr.rdlength] = 0;
\r break;
\r case DNS_QUERY_A:
\r memcpy(res,&header.payload[i],rr.rdlength);
\r res[rr.rdlength] = 0;
\r break;
\r default:
\r memcpy(res,&header.payload[i],rr.rdlength);
\r res[rr.rdlength] = 0;
\r break;
\r }
\r return std::make_pair(res,"No error");;
\r}
\r\r/** Close the master socket */
\rDNS::~DNS()
\r{
\r shutdown(this->GetFd(), 2);
\r close(this->GetFd());
\r ServerInstance->Timers->DelTimer(this->PruneTimer);
\r delete this->PruneTimer;
\r}
\r\rCachedQuery* DNS::GetCache(const std::string &source)
\r{
\r dnscache::iterator x = cache->find(source.c_str());
\r if (x != cache->end())
\r return &(x->second);
\r else
\r return NULL;
\r}
\r \rvoid DNS::DelCache(const std::string &source)
\r{
\r cache->erase(source.c_str());
\r}
\r\rvoid Resolver::TriggerCachedResult()
\r{
\r if (CQ)
\r OnLookupComplete(CQ->data, time_left, true);
\r}
\r\r/** High level abstraction of dns used by application at large */
\rResolver::Resolver(InspIRCd* Instance, const std::string &source, QueryType qt, bool &cached, Module* creator) : ServerInstance(Instance), Creator(creator), input(source), querytype(qt)
\r{
\r cached = false;
\r\r CQ = ServerInstance->Res->GetCache(source);
\r if (CQ)
\r {
\r time_left = CQ->CalcTTLRemaining();
\r if (!time_left)
\r {
\r ServerInstance->Res->DelCache(source);
\r }
\r else
\r {
\r cached = true;
\r return;
\r }
\r }
\r\r insp_inaddr binip;
\r\r switch (querytype)
\r {
\r case DNS_QUERY_A:
\r this->myid = ServerInstance->Res->GetIP(source.c_str());
\r break;
\r\r case DNS_QUERY_PTR:
\r if (insp_aton(source.c_str(), &binip) > 0)
\r {
\r /* Valid ip address */
\r this->myid = ServerInstance->Res->GetName(&binip);
\r }
\r else
\r {
\r this->OnError(RESOLVER_BADIP, "Bad IP address for reverse lookup");
\r throw ModuleException("Resolver: Bad IP address");
\r return;
\r }
\r break;
\r\r case DNS_QUERY_PTR4:
\r querytype = DNS_QUERY_PTR;
\r this->myid = ServerInstance->Res->GetNameForce(source.c_str(), PROTOCOL_IPV4);
\r break;
\r\r case DNS_QUERY_PTR6:
\r querytype = DNS_QUERY_PTR;
\r this->myid = ServerInstance->Res->GetNameForce(source.c_str(), PROTOCOL_IPV6);
\r break;
\r\r case DNS_QUERY_AAAA:
\r this->myid = ServerInstance->Res->GetIP6(source.c_str());
\r break;
\r\r case DNS_QUERY_CNAME:
\r this->myid = ServerInstance->Res->GetCName(source.c_str());
\r break;
\r\r default:
\r this->myid = -1;
\r break;
\r }
\r if (this->myid == -1)
\r {
\r this->OnError(RESOLVER_NSDOWN, "Nameserver is down");
\r throw ModuleException("Resolver: Couldnt get an id to make a request");
\r /* We shouldnt get here really */
\r return;
\r }
\r}
\r\r/** Called when an error occurs */
\rvoid Resolver::OnError(ResolverError e, const std::string &errormessage)
\r{
\r /* Nothing in here */
\r}
\r\r/** Destroy a resolver */
\rResolver::~Resolver()
\r{
\r /* Nothing here (yet) either */
\r}
\r\r/** Get the request id associated with this class */
\rint Resolver::GetId()
\r{
\r return this->myid;
\r}
\r\rModule* Resolver::GetCreator()
\r{
\r return this->Creator;
\r}
\r\r/** Process a socket read event */
\rvoid DNS::HandleEvent(EventType et, int errornum)
\r{
\r /* Fetch the id and result of the next available packet */
\r DNSResult res = this->GetResult();
\r /* Is there a usable request id? */
\r if (res.id != -1)
\r {
\r /* Its an error reply */
\r if (res.id & ERROR_MASK)
\r {
\r /* Mask off the error bit */
\r res.id -= ERROR_MASK;
\r /* Marshall the error to the correct class */
\r if (Classes[res.id])
\r {
\r if (ServerInstance && ServerInstance->stats)
\r ServerInstance->stats->statsDnsBad++;
\r Classes[res.id]->OnError(RESOLVER_NXDOMAIN, res.result);
\r delete Classes[res.id];
\r Classes[res.id] = NULL;
\r }
\r }
\r else
\r {
\r /* It is a non-error result, marshall the result to the correct class */
\r if (Classes[res.id])
\r {
\r if (ServerInstance && ServerInstance->stats)
\r ServerInstance->stats->statsDnsGood++;
\r\r if (!this->GetCache(res.original.c_str()))
\r this->cache->insert(std::make_pair(res.original.c_str(), CachedQuery(res.result, res.ttl)));
\r\r Classes[res.id]->OnLookupComplete(res.result, res.ttl, false);
\r delete Classes[res.id];
\r Classes[res.id] = NULL;
\r }
\r }
\r\r if (ServerInstance && ServerInstance->stats)
\r ServerInstance->stats->statsDns++;
\r }
\r}
\r\r/** Add a derived Resolver to the working set */
\rbool DNS::AddResolverClass(Resolver* r)
\r{
\r /* Check the pointers validity and the id's validity */
\r if ((r) && (r->GetId() > -1))
\r {
\r /* Check the slot isnt already occupied -
\r * This should NEVER happen unless we have
\r * a severely broken DNS server somewhere
\r */
\r if (!Classes[r->GetId()])
\r {
\r /* Set up the pointer to the class */
\r Classes[r->GetId()] = r;
\r return true;
\r }
\r else
\r /* Duplicate id */
\r return false;
\r }
\r else
\r {
\r /* Pointer or id not valid.
\r * Free the item and return
\r */
\r if (r)
\r delete r;
\r\r return false;
\r }
\r}
\r\rvoid DNS::CleanResolvers(Module* module)
\r{
\r for (int i = 0; i < MAX_REQUEST_ID; i++)
\r {
\r if (Classes[i])
\r {
\r if (Classes[i]->GetCreator() == module)
\r {
\r Classes[i]->OnError(RESLOVER_FORCEUNLOAD, "Parent module is unloading");
\r delete Classes[i];
\r Classes[i] = NULL;
\r }
\r }
\r }
\r}
\r\r/** Generate pseudo-random number */
\runsigned long DNS::PRNG()
\r{
\r#ifndef WIN32
\r unsigned long val = 0;
\r timeval n;
\r serverstats* s = ServerInstance->stats;
\r gettimeofday(&n,NULL);
\r val = (n.tv_usec ^ getpid() ^ geteuid() ^ (this->currid++)) ^ s->statsAccept + n.tv_sec;
\r val = val + s->statsCollisions ^ s->statsDnsGood - s->statsDnsBad;
\r val += (s->statsConnects ^ (unsigned long)s->statsSent ^ (unsigned long)s->statsRecv) - ServerInstance->Config->ports.size();
\r return val;
\r#else
\r unsigned long val = 0;
\r serverstats* s = ServerInstance->stats;
\r val = (time(NULL) ^ GetCurrentProcessId() ^ GetCurrentThreadId() ^ (this->currid++)) ^ s->statsAccept + time(NULL);
\r val = val + s->statsCollisions ^ s->statsDnsGood - s->statsDnsBad;
\r val += (s->statsConnects ^ (unsigned long)s->statsSent ^ (unsigned long)s->statsRecv);
\r return val;
\r#endif
\r}
\r\r\ No newline at end of file
+/*
+ * InspIRCd -- Internet Relay Chat Daemon
+ *
+ * Copyright (C) 2012 William Pitcock <nenolod@dereferenced.org>
+ * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
+ * Copyright (C) 2006, 2009 Robin Burchell <robin+git@viroteck.net>
+ * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org>
+ * Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
+ * Copyright (C) 2005-2007 Craig Edwards <craigedwards@brainbox.cc>
+ *
+ * This file is part of InspIRCd. InspIRCd is free software: you can
+ * redistribute it and/or modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation, version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+/* $Core */
+
+/*
+dns.cpp - Nonblocking DNS functions.
+Very very loosely based on the firedns library,
+Copyright (C) 2002 Ian Gulliver. This file is no
+longer anything like firedns, there are many major
+differences between this code and the original.
+Please do not assume that firedns works like this,
+looks like this, walks like this or tastes like this.
+*/
+
+#ifndef _WIN32
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#else
+#include "inspircd_win32wrapper.h"
+#endif
+
+#include "inspircd.h"
+#include "socketengine.h"
+#include "configreader.h"
+#include "socket.h"
+
+#define DN_COMP_BITMASK 0xC000 /* highest 6 bits in a DN label header */
+
+/** Masks to mask off the responses we get from the DNSRequest methods
+ */
+enum QueryInfo
+{
+ ERROR_MASK = 0x10000 /* Result is an error */
+};
+
+/** Flags which can be ORed into a request or reply for different meanings
+ */
+enum QueryFlags
+{
+ FLAGS_MASK_RD = 0x01, /* Recursive */
+ FLAGS_MASK_TC = 0x02,
+ FLAGS_MASK_AA = 0x04, /* Authoritative */
+ FLAGS_MASK_OPCODE = 0x78,
+ FLAGS_MASK_QR = 0x80,
+ FLAGS_MASK_RCODE = 0x0F, /* Request */
+ FLAGS_MASK_Z = 0x70,
+ FLAGS_MASK_RA = 0x80
+};
+
+
+/** Represents a dns resource record (rr)
+ */
+struct ResourceRecord
+{
+ QueryType type; /* Record type */
+ unsigned int rr_class; /* Record class */
+ unsigned long ttl; /* Time to live */
+ unsigned int rdlength; /* Record length */
+};
+
+/** Represents a dns request/reply header, and its payload as opaque data.
+ */
+class DNSHeader
+{
+ public:
+ unsigned char id[2]; /* Request id */
+ unsigned int flags1; /* Flags */
+ unsigned int flags2; /* Flags */
+ unsigned int qdcount;
+ unsigned int ancount; /* Answer count */
+ unsigned int nscount; /* Nameserver count */
+ unsigned int arcount;
+ unsigned char payload[512]; /* Packet payload */
+};
+
+class DNSRequest
+{
+ public:
+ unsigned char id[2]; /* Request id */
+ unsigned char* res; /* Result processing buffer */
+ unsigned int rr_class; /* Request class */
+ QueryType type; /* Request type */
+ DNS* dnsobj; /* DNS caller (where we get our FD from) */
+ unsigned long ttl; /* Time to live */
+ std::string orig; /* Original requested name/ip */
+
+ DNSRequest(DNS* dns, int id, const std::string &original);
+ ~DNSRequest();
+ DNSInfo ResultIsReady(DNSHeader &h, unsigned length);
+ int SendRequests(const DNSHeader *header, const int length, QueryType qt);
+};
+
+class CacheTimer : public Timer
+{
+ private:
+ DNS* dns;
+ public:
+ CacheTimer(DNS* thisdns)
+ : Timer(3600, ServerInstance->Time(), true), dns(thisdns) { }
+
+ virtual void Tick(time_t)
+ {
+ dns->PruneCache();
+ }
+};
+
+class RequestTimeout : public Timer
+{
+ DNSRequest* watch;
+ int watchid;
+ public:
+ RequestTimeout(unsigned long n, DNSRequest* watching, int id) : Timer(n, ServerInstance->Time()), watch(watching), watchid(id)
+ {
+ }
+ ~RequestTimeout()
+ {
+ if (ServerInstance->Res)
+ Tick(0);
+ }
+
+ void Tick(time_t)
+ {
+ if (ServerInstance->Res->requests[watchid] == watch)
+ {
+ /* Still exists, whack it */
+ if (ServerInstance->Res->Classes[watchid])
+ {
+ ServerInstance->Res->Classes[watchid]->OnError(RESOLVER_TIMEOUT, "Request timed out");
+ delete ServerInstance->Res->Classes[watchid];
+ ServerInstance->Res->Classes[watchid] = NULL;
+ }
+ ServerInstance->Res->requests[watchid] = NULL;
+ delete watch;
+ }
+ }
+};
+
+CachedQuery::CachedQuery(const std::string &res, QueryType qt, unsigned int ttl) : data(res), type(qt)
+{
+ expires = ServerInstance->Time() + ttl;
+}
+
+int CachedQuery::CalcTTLRemaining()
+{
+ int n = expires - ServerInstance->Time();
+ return (n < 0 ? 0 : n);
+}
+
+/* Allocate the processing buffer */
+DNSRequest::DNSRequest(DNS* dns, int rid, const std::string &original) : dnsobj(dns)
+{
+ /* hardening against overflow here: make our work buffer twice the theoretical
+ * maximum size so that hostile input doesn't screw us over.
+ */
+ res = new unsigned char[sizeof(DNSHeader) * 2];
+ *res = 0;
+ orig = original;
+ RequestTimeout* RT = new RequestTimeout(ServerInstance->Config->dns_timeout ? ServerInstance->Config->dns_timeout : 5, this, rid);
+ ServerInstance->Timers->AddTimer(RT); /* The timer manager frees this */
+}
+
+/* Deallocate the processing buffer */
+DNSRequest::~DNSRequest()
+{
+ delete[] res;
+}
+
+/** Fill a ResourceRecord class based on raw data input */
+inline void DNS::FillResourceRecord(ResourceRecord* rr, const unsigned char *input)
+{
+ rr->type = (QueryType)((input[0] << 8) + input[1]);
+ rr->rr_class = (input[2] << 8) + input[3];
+ rr->ttl = (input[4] << 24) + (input[5] << 16) + (input[6] << 8) + input[7];
+ rr->rdlength = (input[8] << 8) + input[9];
+}
+
+/** Fill a DNSHeader class based on raw data input of a given length */
+inline void DNS::FillHeader(DNSHeader *header, const unsigned char *input, const int length)
+{
+ header->id[0] = input[0];
+ header->id[1] = input[1];
+ header->flags1 = input[2];
+ header->flags2 = input[3];
+ header->qdcount = (input[4] << 8) + input[5];
+ header->ancount = (input[6] << 8) + input[7];
+ header->nscount = (input[8] << 8) + input[9];
+ header->arcount = (input[10] << 8) + input[11];
+ memcpy(header->payload,&input[12],length);
+}
+
+/** Empty a DNSHeader class out into raw data, ready for transmission */
+inline void DNS::EmptyHeader(unsigned char *output, const DNSHeader *header, const int length)
+{
+ output[0] = header->id[0];
+ output[1] = header->id[1];
+ output[2] = header->flags1;
+ output[3] = header->flags2;
+ output[4] = header->qdcount >> 8;
+ output[5] = header->qdcount & 0xFF;
+ output[6] = header->ancount >> 8;
+ output[7] = header->ancount & 0xFF;
+ output[8] = header->nscount >> 8;
+ output[9] = header->nscount & 0xFF;
+ output[10] = header->arcount >> 8;
+ output[11] = header->arcount & 0xFF;
+ memcpy(&output[12],header->payload,length);
+}
+
+/** Send requests we have previously built down the UDP socket */
+int DNSRequest::SendRequests(const DNSHeader *header, const int length, QueryType qt)
+{
+ ServerInstance->Logs->Log("RESOLVER", DEBUG,"DNSRequest::SendRequests");
+
+ unsigned char payload[sizeof(DNSHeader)];
+
+ this->rr_class = 1;
+ this->type = qt;
+
+ DNS::EmptyHeader(payload,header,length);
+
+ if (ServerInstance->SE->SendTo(dnsobj, payload, length + 12, 0, &(dnsobj->myserver.sa), sa_size(dnsobj->myserver)) != length+12)
+ return -1;
+
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"Sent OK");
+ return 0;
+}
+
+/** Add a query with a predefined header, and allocate an ID for it. */
+DNSRequest* DNS::AddQuery(DNSHeader *header, int &id, const char* original)
+{
+ /* Is the DNS connection down? */
+ if (this->GetFd() == -1)
+ return NULL;
+
+ /* Create an id */
+ unsigned int tries = 0;
+ do {
+ id = ServerInstance->GenRandomInt(DNS::MAX_REQUEST_ID);
+ if (++tries == DNS::MAX_REQUEST_ID*5)
+ {
+ // If we couldn't find an empty slot this many times, do a sequential scan as a last
+ // resort. If an empty slot is found that way, go on, otherwise throw an exception
+ id = -1;
+ for (int i = 0; i < DNS::MAX_REQUEST_ID; i++)
+ {
+ if (!requests[i])
+ {
+ id = i;
+ break;
+ }
+ }
+
+ if (id == -1)
+ throw ModuleException("DNS: All ids are in use");
+
+ break;
+ }
+ } while (requests[id]);
+
+ DNSRequest* req = new DNSRequest(this, id, original);
+
+ header->id[0] = req->id[0] = id >> 8;
+ header->id[1] = req->id[1] = id & 0xFF;
+ header->flags1 = FLAGS_MASK_RD;
+ header->flags2 = 0;
+ header->qdcount = 1;
+ header->ancount = 0;
+ header->nscount = 0;
+ header->arcount = 0;
+
+ /* At this point we already know the id doesnt exist,
+ * so there needs to be no second check for the ::end()
+ */
+ requests[id] = req;
+
+ /* According to the C++ spec, new never returns NULL. */
+ return req;
+}
+
+int DNS::ClearCache()
+{
+ /* This ensures the buckets are reset to sane levels */
+ int rv = this->cache->size();
+ delete this->cache;
+ this->cache = new dnscache();
+ return rv;
+}
+
+int DNS::PruneCache()
+{
+ int n = 0;
+ dnscache* newcache = new dnscache();
+ for (dnscache::iterator i = this->cache->begin(); i != this->cache->end(); i++)
+ /* Dont include expired items (theres no point) */
+ if (i->second.CalcTTLRemaining())
+ newcache->insert(*i);
+ else
+ n++;
+
+ delete this->cache;
+ this->cache = newcache;
+ return n;
+}
+
+void DNS::Rehash()
+{
+ if (this->GetFd() > -1)
+ {
+ ServerInstance->SE->DelFd(this);
+ ServerInstance->SE->Shutdown(this, 2);
+ ServerInstance->SE->Close(this);
+ this->SetFd(-1);
+
+ /* Rehash the cache */
+ this->PruneCache();
+ }
+ else
+ {
+ /* Create initial dns cache */
+ this->cache = new dnscache();
+ }
+
+ irc::sockets::aptosa(ServerInstance->Config->DNSServer, DNS::QUERY_PORT, myserver);
+
+ /* Initialize mastersocket */
+ int s = socket(myserver.sa.sa_family, SOCK_DGRAM, 0);
+ this->SetFd(s);
+
+ /* Have we got a socket and is it nonblocking? */
+ if (this->GetFd() != -1)
+ {
+ ServerInstance->SE->SetReuse(s);
+ ServerInstance->SE->NonBlocking(s);
+ irc::sockets::sockaddrs bindto;
+ memset(&bindto, 0, sizeof(bindto));
+ bindto.sa.sa_family = myserver.sa.sa_family;
+ if (ServerInstance->SE->Bind(this->GetFd(), bindto) < 0)
+ {
+ /* Failed to bind */
+ ServerInstance->Logs->Log("RESOLVER",SPARSE,"Error binding dns socket - hostnames will NOT resolve");
+ ServerInstance->SE->Shutdown(this, 2);
+ ServerInstance->SE->Close(this);
+ this->SetFd(-1);
+ }
+ else if (!ServerInstance->SE->AddFd(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE))
+ {
+ ServerInstance->Logs->Log("RESOLVER",SPARSE,"Internal error starting DNS - hostnames will NOT resolve.");
+ ServerInstance->SE->Shutdown(this, 2);
+ ServerInstance->SE->Close(this);
+ this->SetFd(-1);
+ }
+ }
+ else
+ {
+ ServerInstance->Logs->Log("RESOLVER",SPARSE,"Error creating DNS socket - hostnames will NOT resolve");
+ }
+}
+
+/** Initialise the DNS UDP socket so that we can send requests */
+DNS::DNS()
+{
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS::DNS");
+ /* Clear the Resolver class table */
+ memset(Classes,0,sizeof(Classes));
+
+ /* Clear the requests class table */
+ memset(requests,0,sizeof(requests));
+
+ /* DNS::Rehash() sets this to a valid ptr
+ */
+ this->cache = NULL;
+
+ /* Again, DNS::Rehash() sets this to a
+ * valid value
+ */
+ this->SetFd(-1);
+
+ /* Actually read the settings
+ */
+ this->Rehash();
+
+ this->PruneTimer = new CacheTimer(this);
+
+ ServerInstance->Timers->AddTimer(this->PruneTimer);
+}
+
+/** Build a payload to be placed after the header, based upon input data, a resource type, a class and a pointer to a buffer */
+int DNS::MakePayload(const char * const name, const QueryType rr, const unsigned short rr_class, unsigned char * const payload)
+{
+ short payloadpos = 0;
+ const char* tempchr, *tempchr2 = name;
+ unsigned short length;
+
+ /* split name up into labels, create query */
+ while ((tempchr = strchr(tempchr2,'.')) != NULL)
+ {
+ length = tempchr - tempchr2;
+ if (payloadpos + length + 1 > 507)
+ return -1;
+ payload[payloadpos++] = length;
+ memcpy(&payload[payloadpos],tempchr2,length);
+ payloadpos += length;
+ tempchr2 = &tempchr[1];
+ }
+ length = strlen(tempchr2);
+ if (length)
+ {
+ if (payloadpos + length + 2 > 507)
+ return -1;
+ payload[payloadpos++] = length;
+ memcpy(&payload[payloadpos],tempchr2,length);
+ payloadpos += length;
+ payload[payloadpos++] = 0;
+ }
+ if (payloadpos > 508)
+ return -1;
+ length = htons(rr);
+ memcpy(&payload[payloadpos],&length,2);
+ length = htons(rr_class);
+ memcpy(&payload[payloadpos + 2],&length,2);
+ return payloadpos + 4;
+}
+
+/** Start lookup of an hostname to an IP address */
+int DNS::GetIP(const char *name)
+{
+ DNSHeader h;
+ int id;
+ int length;
+
+ if ((length = this->MakePayload(name, DNS_QUERY_A, 1, (unsigned char*)&h.payload)) == -1)
+ return -1;
+
+ DNSRequest* req = this->AddQuery(&h, id, name);
+
+ if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_A) == -1))
+ return -1;
+
+ return id;
+}
+
+/** Start lookup of an hostname to an IPv6 address */
+int DNS::GetIP6(const char *name)
+{
+ DNSHeader h;
+ int id;
+ int length;
+
+ if ((length = this->MakePayload(name, DNS_QUERY_AAAA, 1, (unsigned char*)&h.payload)) == -1)
+ return -1;
+
+ DNSRequest* req = this->AddQuery(&h, id, name);
+
+ if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_AAAA) == -1))
+ return -1;
+
+ return id;
+}
+
+/** Start lookup of a cname to another name */
+int DNS::GetCName(const char *alias)
+{
+ DNSHeader h;
+ int id;
+ int length;
+
+ if ((length = this->MakePayload(alias, DNS_QUERY_CNAME, 1, (unsigned char*)&h.payload)) == -1)
+ return -1;
+
+ DNSRequest* req = this->AddQuery(&h, id, alias);
+
+ if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_CNAME) == -1))
+ return -1;
+
+ return id;
+}
+
+/** Start lookup of an IP address to a hostname */
+int DNS::GetNameForce(const char *ip, ForceProtocol fp)
+{
+ char query[128];
+ DNSHeader h;
+ int id;
+ int length;
+
+ if (fp == PROTOCOL_IPV6)
+ {
+ in6_addr i;
+ if (inet_pton(AF_INET6, ip, &i) > 0)
+ {
+ DNS::MakeIP6Int(query, &i);
+ }
+ else
+ {
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS::GetNameForce IPv6 bad format for '%s'", ip);
+ /* Invalid IP address */
+ return -1;
+ }
+ }
+ else
+ {
+ in_addr i;
+ if (inet_aton(ip, &i))
+ {
+ unsigned char* c = (unsigned char*)&i.s_addr;
+ sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]);
+ }
+ else
+ {
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS::GetNameForce IPv4 bad format for '%s'", ip);
+ /* Invalid IP address */
+ return -1;
+ }
+ }
+
+ length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload);
+ if (length == -1)
+ {
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS::GetNameForce can't query '%s' using '%s' because it's too long", ip, query);
+ return -1;
+ }
+
+ DNSRequest* req = this->AddQuery(&h, id, ip);
+
+ if (!req)
+ {
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS::GetNameForce can't add query (resolver down?)");
+ return -1;
+ }
+
+ if (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1)
+ {
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS::GetNameForce can't send (firewall?)");
+ return -1;
+ }
+
+ return id;
+}
+
+/** Build an ipv6 reverse domain from an in6_addr
+ */
+void DNS::MakeIP6Int(char* query, const in6_addr *ip)
+{
+ const char* hex = "0123456789abcdef";
+ for (int index = 31; index >= 0; index--) /* for() loop steps twice per byte */
+ {
+ if (index % 2)
+ /* low nibble */
+ *query++ = hex[ip->s6_addr[index / 2] & 0x0F];
+ else
+ /* high nibble */
+ *query++ = hex[(ip->s6_addr[index / 2] & 0xF0) >> 4];
+ *query++ = '.'; /* Seperator */
+ }
+ strcpy(query,"ip6.arpa"); /* Suffix the string */
+}
+
+/** Return the next id which is ready, and the result attached to it */
+DNSResult DNS::GetResult()
+{
+ /* Fetch dns query response and decide where it belongs */
+ DNSHeader header;
+ DNSRequest *req;
+ unsigned char buffer[sizeof(DNSHeader)];
+ irc::sockets::sockaddrs from;
+ memset(&from, 0, sizeof(from));
+ socklen_t x = sizeof(from);
+
+ int length = ServerInstance->SE->RecvFrom(this, (char*)buffer, sizeof(DNSHeader), 0, &from.sa, &x);
+
+ /* Did we get the whole header? */
+ if (length < 12)
+ {
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"GetResult didn't get a full packet (len=%d)", length);
+ /* Nope - something screwed up. */
+ return DNSResult(-1,"",0,"");
+ }
+
+ /* Check wether the reply came from a different DNS
+ * server to the one we sent it to, or the source-port
+ * is not 53.
+ * A user could in theory still spoof dns packets anyway
+ * but this is less trivial than just sending garbage
+ * to the server, which is possible without this check.
+ *
+ * -- Thanks jilles for pointing this one out.
+ */
+ if (from != myserver)
+ {
+ std::string server1 = from.str();
+ std::string server2 = myserver.str();
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"Got a result from the wrong server! Bad NAT or DNS forging attempt? '%s' != '%s'",
+ server1.c_str(), server2.c_str());
+ return DNSResult(-1,"",0,"");
+ }
+
+ /* Put the read header info into a header class */
+ DNS::FillHeader(&header,buffer,length - 12);
+
+ /* Get the id of this request.
+ * Its a 16 bit value stored in two char's,
+ * so we use logic shifts to create the value.
+ */
+ unsigned long this_id = header.id[1] + (header.id[0] << 8);
+
+ /* Do we have a pending request matching this id? */
+ if (!requests[this_id])
+ {
+ /* Somehow we got a DNS response for a request we never made... */
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"Hmm, got a result that we didn't ask for (id=%lx). Ignoring.", this_id);
+ return DNSResult(-1,"",0,"");
+ }
+ else
+ {
+ /* Remove the query from the list of pending queries */
+ req = requests[this_id];
+ requests[this_id] = NULL;
+ }
+
+ /* Inform the DNSRequest class that it has a result to be read.
+ * When its finished it will return a DNSInfo which is a pair of
+ * unsigned char* resource record data, and an error message.
+ */
+ DNSInfo data = req->ResultIsReady(header, length);
+ std::string resultstr;
+
+ /* Check if we got a result, if we didnt, its an error */
+ if (data.first == NULL)
+ {
+ /* An error.
+ * Mask the ID with the value of ERROR_MASK, so that
+ * the dns_deal_with_classes() function knows that its
+ * an error response and needs to be treated uniquely.
+ * Put the error message in the second field.
+ */
+ std::string ro = req->orig;
+ delete req;
+ return DNSResult(this_id | ERROR_MASK, data.second, 0, ro);
+ }
+ else
+ {
+ unsigned long ttl = req->ttl;
+ char formatted[128];
+
+ /* Forward lookups come back as binary data. We must format them into ascii */
+ switch (req->type)
+ {
+ case DNS_QUERY_A:
+ snprintf(formatted,16,"%u.%u.%u.%u",data.first[0],data.first[1],data.first[2],data.first[3]);
+ resultstr = formatted;
+ break;
+
+ case DNS_QUERY_AAAA:
+ {
+ if (!inet_ntop(AF_INET6, data.first, formatted, sizeof(formatted)))
+ {
+ std::string ro = req->orig;
+ delete req;
+ return DNSResult(this_id | ERROR_MASK, "inet_ntop() failed", 0, ro);
+ }
+
+ resultstr = formatted;
+
+ /* Special case. Sending ::1 around between servers
+ * and to clients is dangerous, because the : on the
+ * start makes the client or server interpret the IP
+ * as the last parameter on the line with a value ":1".
+ */
+ if (*formatted == ':')
+ resultstr.insert(0, "0");
+ }
+ break;
+
+ case DNS_QUERY_CNAME:
+ /* Identical handling to PTR */
+
+ case DNS_QUERY_PTR:
+ {
+ /* Reverse lookups just come back as char* */
+ resultstr = std::string((const char*)data.first);
+ if (resultstr.find_first_not_of("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-") != std::string::npos)
+ {
+ std::string ro = req->orig;
+ delete req;
+ return DNSResult(this_id | ERROR_MASK, "Invalid char(s) in reply", 0, ro);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ /* Build the reply with the id and hostname/ip in it */
+ std::string ro = req->orig;
+ DNSResult result = DNSResult(this_id,resultstr,ttl,ro,req->type);
+ delete req;
+ return result;
+ }
+}
+
+/** A result is ready, process it */
+DNSInfo DNSRequest::ResultIsReady(DNSHeader &header, unsigned length)
+{
+ unsigned i = 0, o;
+ int q = 0;
+ int curanswer;
+ ResourceRecord rr;
+ unsigned short ptr;
+
+ /* This is just to keep _FORTIFY_SOURCE happy */
+ rr.type = DNS_QUERY_NONE;
+ rr.rdlength = 0;
+ rr.ttl = 1; /* GCC is a whiney bastard -- see the XXX below. */
+ rr.rr_class = 0; /* Same for VC++ */
+
+ if (!(header.flags1 & FLAGS_MASK_QR))
+ return std::make_pair((unsigned char*)NULL,"Not a query result");
+
+ if (header.flags1 & FLAGS_MASK_OPCODE)
+ return std::make_pair((unsigned char*)NULL,"Unexpected value in DNS reply packet");
+
+ if (header.flags2 & FLAGS_MASK_RCODE)
+ return std::make_pair((unsigned char*)NULL,"Domain name not found");
+
+ if (header.ancount < 1)
+ return std::make_pair((unsigned char*)NULL,"No resource records returned");
+
+ /* Subtract the length of the header from the length of the packet */
+ length -= 12;
+
+ while ((unsigned int)q < header.qdcount && i < length)
+ {
+ if (header.payload[i] > 63)
+ {
+ i += 6;
+ q++;
+ }
+ else
+ {
+ if (header.payload[i] == 0)
+ {
+ q++;
+ i += 5;
+ }
+ else i += header.payload[i] + 1;
+ }
+ }
+ curanswer = 0;
+ while ((unsigned)curanswer < header.ancount)
+ {
+ q = 0;
+ while (q == 0 && i < length)
+ {
+ if (header.payload[i] > 63)
+ {
+ i += 2;
+ q = 1;
+ }
+ else
+ {
+ if (header.payload[i] == 0)
+ {
+ i++;
+ q = 1;
+ }
+ else i += header.payload[i] + 1; /* skip length and label */
+ }
+ }
+ if (static_cast<int>(length - i) < 10)
+ return std::make_pair((unsigned char*)NULL,"Incorrectly sized DNS reply");
+
+ /* XXX: We actually initialise 'rr' here including its ttl field */
+ DNS::FillResourceRecord(&rr,&header.payload[i]);
+
+ i += 10;
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"Resolver: rr.type is %d and this.type is %d rr.class %d this.class %d", rr.type, this->type, rr.rr_class, this->rr_class);
+ if (rr.type != this->type)
+ {
+ curanswer++;
+ i += rr.rdlength;
+ continue;
+ }
+ if (rr.rr_class != this->rr_class)
+ {
+ curanswer++;
+ i += rr.rdlength;
+ continue;
+ }
+ break;
+ }
+ if ((unsigned int)curanswer == header.ancount)
+ return std::make_pair((unsigned char*)NULL,"No A, AAAA or PTR type answers (" + ConvToStr(header.ancount) + " answers)");
+
+ if (i + rr.rdlength > (unsigned int)length)
+ return std::make_pair((unsigned char*)NULL,"Resource record larger than stated");
+
+ if (rr.rdlength > 1023)
+ return std::make_pair((unsigned char*)NULL,"Resource record too large");
+
+ this->ttl = rr.ttl;
+
+ switch (rr.type)
+ {
+ /*
+ * CNAME and PTR are compressed. We need to decompress them.
+ */
+ case DNS_QUERY_CNAME:
+ case DNS_QUERY_PTR:
+ {
+ unsigned short lowest_pos = length;
+ o = 0;
+ q = 0;
+ while (q == 0 && i < length && o + 256 < 1023)
+ {
+ /* DN label found (byte over 63) */
+ if (header.payload[i] > 63)
+ {
+ memcpy(&ptr,&header.payload[i],2);
+
+ i = ntohs(ptr);
+
+ /* check that highest two bits are set. if not, we've been had */
+ if ((i & DN_COMP_BITMASK) != DN_COMP_BITMASK)
+ return std::make_pair((unsigned char *) NULL, "DN label decompression header is bogus");
+
+ /* mask away the two highest bits. */
+ i &= ~DN_COMP_BITMASK;
+
+ /* and decrease length by 12 bytes. */
+ i -= 12;
+
+ if (i >= lowest_pos)
+ return std::make_pair((unsigned char *) NULL, "Invalid decompression pointer");
+ lowest_pos = i;
+ }
+ else
+ {
+ if (header.payload[i] == 0)
+ {
+ q = 1;
+ }
+ else
+ {
+ res[o] = 0;
+ if (o != 0)
+ res[o++] = '.';
+
+ if (o + header.payload[i] > sizeof(DNSHeader))
+ return std::make_pair((unsigned char *) NULL, "DN label decompression is impossible -- malformed/hostile packet?");
+
+ memcpy(&res[o], &header.payload[i + 1], header.payload[i]);
+ o += header.payload[i];
+ i += header.payload[i] + 1;
+ }
+ }
+ }
+ res[o] = 0;
+ }
+ break;
+ case DNS_QUERY_AAAA:
+ if (rr.rdlength != sizeof(struct in6_addr))
+ return std::make_pair((unsigned char *) NULL, "rr.rdlength is larger than 16 bytes for an ipv6 entry -- malformed/hostile packet?");
+
+ memcpy(res,&header.payload[i],rr.rdlength);
+ res[rr.rdlength] = 0;
+ break;
+ case DNS_QUERY_A:
+ if (rr.rdlength != sizeof(struct in_addr))
+ return std::make_pair((unsigned char *) NULL, "rr.rdlength is larger than 4 bytes for an ipv4 entry -- malformed/hostile packet?");
+
+ memcpy(res,&header.payload[i],rr.rdlength);
+ res[rr.rdlength] = 0;
+ break;
+ default:
+ return std::make_pair((unsigned char *) NULL, "don't know how to handle undefined type (" + ConvToStr(rr.type) + ") -- rejecting");
+ break;
+ }
+ return std::make_pair(res,"No error");
+}
+
+/** Close the master socket */
+DNS::~DNS()
+{
+ ServerInstance->SE->Shutdown(this, 2);
+ ServerInstance->SE->Close(this);
+ ServerInstance->Timers->DelTimer(this->PruneTimer);
+ if (cache)
+ delete cache;
+}
+
+CachedQuery* DNS::GetCache(const std::string &source)
+{
+ dnscache::iterator x = cache->find(source.c_str());
+ if (x != cache->end())
+ return &(x->second);
+ else
+ return NULL;
+}
+
+void DNS::DelCache(const std::string &source)
+{
+ cache->erase(source.c_str());
+}
+
+void Resolver::TriggerCachedResult()
+{
+ if (CQ)
+ OnLookupComplete(CQ->data, time_left, true);
+}
+
+/** High level abstraction of dns used by application at large */
+Resolver::Resolver(const std::string &source, QueryType qt, bool &cached, Module* creator) : Creator(creator), input(source), querytype(qt)
+{
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"Resolver::Resolver");
+ cached = false;
+
+ CQ = ServerInstance->Res->GetCache(source);
+ if (CQ)
+ {
+ time_left = CQ->CalcTTLRemaining();
+ if (!time_left)
+ {
+ ServerInstance->Res->DelCache(source);
+ }
+ else if (CQ->type == qt)
+ {
+ cached = true;
+ return;
+ }
+ CQ = NULL;
+ }
+
+ switch (querytype)
+ {
+ case DNS_QUERY_A:
+ this->myid = ServerInstance->Res->GetIP(source.c_str());
+ break;
+
+ case DNS_QUERY_PTR4:
+ querytype = DNS_QUERY_PTR;
+ this->myid = ServerInstance->Res->GetNameForce(source.c_str(), PROTOCOL_IPV4);
+ break;
+
+ case DNS_QUERY_PTR6:
+ querytype = DNS_QUERY_PTR;
+ this->myid = ServerInstance->Res->GetNameForce(source.c_str(), PROTOCOL_IPV6);
+ break;
+
+ case DNS_QUERY_AAAA:
+ this->myid = ServerInstance->Res->GetIP6(source.c_str());
+ break;
+
+ case DNS_QUERY_CNAME:
+ this->myid = ServerInstance->Res->GetCName(source.c_str());
+ break;
+
+ default:
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS request with unknown query type %d", querytype);
+ this->myid = -1;
+ break;
+ }
+ if (this->myid == -1)
+ {
+ throw ModuleException("Resolver: Couldn't get an id to make a request");
+ }
+ else
+ {
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS request id %d", this->myid);
+ }
+}
+
+/** Called when an error occurs */
+void Resolver::OnError(ResolverError, const std::string&)
+{
+ /* Nothing in here */
+}
+
+/** Destroy a resolver */
+Resolver::~Resolver()
+{
+ /* Nothing here (yet) either */
+}
+
+/** Get the request id associated with this class */
+int Resolver::GetId()
+{
+ return this->myid;
+}
+
+Module* Resolver::GetCreator()
+{
+ return this->Creator;
+}
+
+/** Process a socket read event */
+void DNS::HandleEvent(EventType, int)
+{
+ /* Fetch the id and result of the next available packet */
+ DNSResult res(0,"",0,"");
+ res.id = 0;
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"Handle DNS event");
+
+ res = this->GetResult();
+
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"Result id %d", res.id);
+
+ /* Is there a usable request id? */
+ if (res.id != -1)
+ {
+ /* Its an error reply */
+ if (res.id & ERROR_MASK)
+ {
+ /* Mask off the error bit */
+ res.id -= ERROR_MASK;
+ /* Marshall the error to the correct class */
+ if (Classes[res.id])
+ {
+ if (ServerInstance && ServerInstance->stats)
+ ServerInstance->stats->statsDnsBad++;
+ Classes[res.id]->OnError(RESOLVER_NXDOMAIN, res.result);
+ delete Classes[res.id];
+ Classes[res.id] = NULL;
+ }
+ return;
+ }
+ else
+ {
+ /* It is a non-error result, marshall the result to the correct class */
+ if (Classes[res.id])
+ {
+ if (ServerInstance && ServerInstance->stats)
+ ServerInstance->stats->statsDnsGood++;
+
+ if (!this->GetCache(res.original.c_str()))
+ this->cache->insert(std::make_pair(res.original.c_str(), CachedQuery(res.result, res.type, res.ttl)));
+
+ Classes[res.id]->OnLookupComplete(res.result, res.ttl, false);
+ delete Classes[res.id];
+ Classes[res.id] = NULL;
+ }
+ }
+
+ if (ServerInstance && ServerInstance->stats)
+ ServerInstance->stats->statsDns++;
+ }
+}
+
+/** Add a derived Resolver to the working set */
+bool DNS::AddResolverClass(Resolver* r)
+{
+ ServerInstance->Logs->Log("RESOLVER",DEBUG,"AddResolverClass 0x%08lx", (unsigned long)r);
+ /* Check the pointers validity and the id's validity */
+ if ((r) && (r->GetId() > -1))
+ {
+ /* Check the slot isnt already occupied -
+ * This should NEVER happen unless we have
+ * a severely broken DNS server somewhere
+ */
+ if (!Classes[r->GetId()])
+ {
+ /* Set up the pointer to the class */
+ Classes[r->GetId()] = r;
+ return true;
+ }
+ }
+
+ /* Pointer or id not valid, or duplicate id.
+ * Free the item and return
+ */
+ delete r;
+ return false;
+}
+
+void DNS::CleanResolvers(Module* module)
+{
+ for (int i = 0; i < MAX_REQUEST_ID; i++)
+ {
+ if (Classes[i])
+ {
+ if (Classes[i]->GetCreator() == module)
+ {
+ Classes[i]->OnError(RESOLVER_FORCEUNLOAD, "Parent module is unloading");
+ delete Classes[i];
+ Classes[i] = NULL;
+ }
+ }
+ }
+}
projects / user / henk / code / inspircd.git / blobdiff