X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fdns.cpp;h=33dba1abb72a2e14f3838379bde0185a034e4690;hb=aec772bdc98bdcfe35c2fc8e74942403c9efcc4d;hp=756c2d5dc12c6cfdc442f1fd585e8881d7171d38;hpb=1c52b90e826ca3fdef6d55fccd7abbc4fdd90574;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/dns.cpp b/src/dns.cpp
index 756c2d5dc..33dba1abb 100644
--- a/src/dns.cpp
+++ b/src/dns.cpp
@@ -32,10 +32,10 @@ looks like this, walks like this or tastes like this.
 #include "configreader.h"
 #include "socket.h"
 
-using irc::sockets::insp_sockaddr;
 using irc::sockets::insp_inaddr;
 using irc::sockets::insp_ntoa;
 using irc::sockets::insp_aton;
+using irc::sockets::OpenTCPSocket;
 
 /** Masks to mask off the responses we get from the DNSRequest methods
  */
@@ -61,9 +61,8 @@ enum QueryFlags
 
 /** Represents a dns resource record (rr)
  */
-class ResourceRecord
+struct ResourceRecord
 {
- public:
 	QueryType	type;		/* Record type */
 	unsigned int	rr_class;	/* Record class */
 	unsigned long	ttl;		/* Time to live */
@@ -92,15 +91,31 @@ class DNSRequest
 	unsigned char*  res;		/* Result processing buffer */
 	unsigned int    rr_class;       /* Request class */
 	QueryType       type;		/* Request type */
-	insp_inaddr     myserver;       /* DNS server address*/
 	DNS*            dnsobj;		/* DNS caller (where we get our FD from) */
+	unsigned long	ttl;		/* Time to live */
+	std::string     orig;		/* Original requested name/ip */
 
-	DNSRequest(InspIRCd* Instance, DNS* dns, insp_inaddr server, int id);
+	DNSRequest(InspIRCd* Instance, DNS* dns, int id, const std::string &original);
 	~DNSRequest();
 	DNSInfo ResultIsReady(DNSHeader &h, int length);
 	int SendRequests(const DNSHeader *header, const int length, QueryType qt);
 };
 
+class CacheTimer : public InspTimer
+{
+ private:
+	InspIRCd* ServerInstance;
+	DNS* dns;
+ public:
+	CacheTimer(InspIRCd* Instance, DNS* thisdns)
+		: InspTimer(3600, Instance->Time(), true), ServerInstance(Instance), dns(thisdns) { }
+
+	virtual void Tick(time_t TIME)
+	{
+		dns->PruneCache();
+	}
+};
+
 class RequestTimeout : public InspTimer
 {
 	InspIRCd* ServerInstance;
@@ -109,7 +124,6 @@ class RequestTimeout : public InspTimer
  public:
 	RequestTimeout(unsigned long n, InspIRCd* SI, DNSRequest* watching, int id) : InspTimer(n, time(NULL)), ServerInstance(SI), watch(watching), watchid(id)
 	{
-		ServerInstance->Log(DEBUG, "New DNS timeout set on %08x", watching);
 	}
 
 	void Tick(time_t TIME)
@@ -124,20 +138,18 @@ class RequestTimeout : public InspTimer
 				ServerInstance->Res->Classes[watchid] = NULL;
 			}
 			ServerInstance->Res->requests[watchid] = NULL;
-			delete watch;
-			ServerInstance->Log(DEBUG, "DNS timeout on %08x squished pointer", watch);
+			DELETE(watch);
 			return;
 		}
-		ServerInstance->Log(DEBUG, "DNS timeout on %08x: result already received!", watch);
 	}
 };
 
 /* Allocate the processing buffer */
-DNSRequest::DNSRequest(InspIRCd* Instance, DNS* dns, insp_inaddr server, int id) : dnsobj(dns)
+DNSRequest::DNSRequest(InspIRCd* Instance, DNS* dns, int id, const std::string &original) : dnsobj(dns)
 {
 	res = new unsigned char[512];
 	*res = 0;
-	memcpy(&myserver, &server, sizeof(insp_inaddr));
+	orig = original;
 	RequestTimeout* RT = new RequestTimeout(Instance->Config->dns_timeout ? Instance->Config->dns_timeout : 5, Instance, this, id);
 	Instance->Timers->AddTimer(RT); /* The timer manager frees this */
 }
@@ -192,7 +204,6 @@ inline void DNS::EmptyHeader(unsigned char *output, const DNSHeader *header, con
 /** Send requests we have previously built down the UDP socket */
 int DNSRequest::SendRequests(const DNSHeader *header, const int length, QueryType qt)
 {
-	insp_sockaddr addr;
 	unsigned char payload[sizeof(DNSHeader)];
 
 	this->rr_class = 1;
@@ -200,24 +211,42 @@ int DNSRequest::SendRequests(const DNSHeader *header, const int length, QueryTyp
 		
 	DNS::EmptyHeader(payload,header,length);
 
-	memset(&addr,0,sizeof(addr));
 #ifdef IPV6
-	memcpy(&addr.sin6_addr,&myserver,sizeof(addr.sin6_addr));
-	addr.sin6_family = AF_FAMILY;
-	addr.sin6_port = htons(DNS::QUERY_PORT);
+	if (this->dnsobj->socketfamily == AF_INET6)
+	{
+		sockaddr_in6 addr;
+		memset(&addr,0,sizeof(addr));
+		memcpy(&addr.sin6_addr,&dnsobj->myserver6,sizeof(addr.sin6_addr));
+		addr.sin6_family = AF_INET6;
+		addr.sin6_port = htons(DNS::QUERY_PORT);
+		if (sendto(dnsobj->GetFd(), payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) != length+12)
+			return -1;
+	}
+	else
+	{
+		sockaddr_in addr;
+		memset(&addr,0,sizeof(addr));
+		memcpy(&addr.sin_addr.s_addr,&dnsobj->myserver4,sizeof(addr.sin_addr));
+		addr.sin_family = AF_INET;
+		addr.sin_port = htons(DNS::QUERY_PORT);
+		if (sendto(dnsobj->GetFd(), payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) != length+12)
+			return -1;
+	}
 #else
-	memcpy(&addr.sin_addr.s_addr,&myserver,sizeof(addr.sin_addr));
-	addr.sin_family = AF_FAMILY;
+	sockaddr_in addr;
+	memset(&addr,0,sizeof(addr));
+	memcpy(&addr.sin_addr.s_addr, &dnsobj->myserver4, sizeof(addr.sin_addr));
+	addr.sin_family = AF_INET;
 	addr.sin_port = htons(DNS::QUERY_PORT);
-#endif
-	if (sendto(dnsobj->GetFd(), payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) == -1)
+	if (sendto(dnsobj->GetFd(), payload, length + 12, 0, (sockaddr *) &addr, sizeof(addr)) != length+12)
 		return -1;
+#endif
 
 	return 0;
 }
 
 /** Add a query with a predefined header, and allocate an ID for it. */
-DNSRequest* DNS::AddQuery(DNSHeader *header, int &id)
+DNSRequest* DNS::AddQuery(DNSHeader *header, int &id, const char* original)
 {
 	/* Is the DNS connection down? */
 	if (this->GetFd() == -1)
@@ -230,7 +259,7 @@ DNSRequest* DNS::AddQuery(DNSHeader *header, int &id)
 	while (requests[id])
 		id = this->PRNG() & DNS::MAX_REQUEST_ID;
 
-	DNSRequest* req = new DNSRequest(ServerInstance, this, this->myserver, id);
+	DNSRequest* req = new DNSRequest(ServerInstance, this, id, original);
 
 	header->id[0] = req->id[0] = id >> 8;
 	header->id[1] = req->id[1] = id & 0xFF;
@@ -250,90 +279,88 @@ DNSRequest* DNS::AddQuery(DNSHeader *header, int &id)
 	return req;
 }
 
-/** Initialise the DNS UDP socket so that we can send requests */
-DNS::DNS(InspIRCd* Instance) : ServerInstance(Instance)
+int DNS::ClearCache()
 {
-	ServerInstance->Log(DEBUG,"DNS::DNS: Instance = %08x",Instance);
-
-	insp_inaddr addr;
-
-	/* Clear the Resolver class table */
-	memset(Classes,0,sizeof(Classes));
+	/* This ensures the buckets are reset to sane levels */
+	int rv = this->cache->size();
+	delete this->cache;
+	this->cache = new dnscache();
+	return rv;
+}
 
-	/* Clear the requests class table */
-	memset(requests,0,sizeof(requests));
+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++;
 
-	/* Set the id of the next request to 0
-	 */
-	currid = 0;
+	delete this->cache;
+	this->cache = newcache;
+	return n;
+}
 
-	/* By default we're not munging ip's
-	 */
+void DNS::Rehash()
+{
 	ip6munge = false;
+	int portpass = 0;
 
-	/* Clear the namesever address */
-	memset(&myserver,0,sizeof(insp_inaddr));
-
-	/* Convert the nameserver address into an insp_inaddr */
-	if (insp_aton(ServerInstance->Config->DNSServer,&addr) > 0)
+	if (this->GetFd() > -1)
 	{
-		memcpy(&myserver,&addr,sizeof(insp_inaddr));
-		if ((strstr(ServerInstance->Config->DNSServer,"::ffff:") == (char*)&ServerInstance->Config->DNSServer) ||  (strstr(ServerInstance->Config->DNSServer,"::FFFF:") == (char*)&ServerInstance->Config->DNSServer))
-		{
-			/* These dont come back looking like they did when they went in.
-			 * We're forced to turn some checks off.
-			 * If anyone knows how to fix this, let me know. --Brain
-			 */
-			ServerInstance->Log(DEFAULT,"WARNING: Using IPv4 addresses over IPv6 forces some DNS checks to be disabled.");
-			ServerInstance->Log(DEFAULT,"         This should not cause a problem, however it is recommended you migrate");
-			ServerInstance->Log(DEFAULT,"         to a true IPv6 environment.");
-			this->ip6munge = true;
-		}
-		ServerInstance->Log(DEBUG,"Added nameserver '%s'",ServerInstance->Config->DNSServer);
+		if (ServerInstance && ServerInstance->SE)
+			ServerInstance->SE->DelFd(this);
+		shutdown(this->GetFd(), 2);
+		close(this->GetFd());
+		this->SetFd(-1);
+
+		/* Rehash the cache */
+		this->PruneCache();
 	}
 	else
 	{
-		ServerInstance->Log(DEBUG,"GACK! insp_aton says the nameserver '%s' is invalid!",ServerInstance->Config->DNSServer);
+		/* Create initial dns cache */
+		this->cache = new dnscache();
 	}
 
-	/* Initialize mastersocket */
-	this->SetFd(socket(PF_PROTOCOL, SOCK_DGRAM, 0));
-	if (this->GetFd() != -1)
+	if ((strstr(ServerInstance->Config->DNSServer,"::ffff:") == (char*)&ServerInstance->Config->DNSServer) ||  (strstr(ServerInstance->Config->DNSServer,"::FFFF:") == (char*)&ServerInstance->Config->DNSServer))
 	{
-		/* Did it succeed? */
-		if (fcntl(this->GetFd(), F_SETFL, O_NONBLOCK) != 0)
-		{
-			/* Couldn't make the socket nonblocking */
-			shutdown(this->GetFd(),2);
-			close(this->GetFd());
-			this->SetFd(-1);
-		}
+		ServerInstance->Log(DEFAULT,"WARNING: Using IPv4 addresses over IPv6 forces some DNS checks to be disabled.");
+		ServerInstance->Log(DEFAULT,"         This should not cause a problem, however it is recommended you migrate");
+		ServerInstance->Log(DEFAULT,"         to a true IPv6 environment.");
+		this->ip6munge = true;
+	}
+
+	this->socketfamily = AF_INET;
+#ifdef IPV6
+	if (strchr(ServerInstance->Config->DNSServer,':'))
+	{
+		this->socketfamily = AF_INET6;
+		inet_pton(AF_INET6, ServerInstance->Config->DNSServer, &this->myserver6);
 	}
 	else
 	{
-		ServerInstance->Log(DEBUG,"I cant socket() this socket! (%s)",strerror(errno));
+		inet_aton(ServerInstance->Config->DNSServer, &this->myserver4);
+		portpass = -1;
 	}
+#else
+	inet_aton(ServerInstance->Config->DNSServer, &this->myserver4);
+#endif
+
+	/* Initialize mastersocket */
+	int s = OpenTCPSocket(ServerInstance->Config->DNSServer, SOCK_DGRAM);
+	this->SetFd(s);
+
 	/* Have we got a socket and is it nonblocking? */
 	if (this->GetFd() != -1)
 	{
-#ifdef IPV6
-		insp_sockaddr addr;
-		memset(&addr,0,sizeof(addr));
-		addr.sin6_family = AF_FAMILY;
-		addr.sin6_port = 0;
-		addr.sin6_addr = in6addr_any;
-#else
-		insp_sockaddr addr;
-		memset(&addr,0,sizeof(addr));
-		addr.sin_family = AF_FAMILY;
-		addr.sin_port = 0;
-		addr.sin_addr.s_addr = INADDR_ANY;
-#endif
-		/* Bind the port */
-		if (bind(this->GetFd(),(sockaddr *)&addr,sizeof(addr)) != 0)
+		/* Bind the port - port 0 INADDR_ANY */
+		if (!ServerInstance->BindSocket(this->GetFd(), portpass, "", false))
 		{
 			/* Failed to bind */
-			ServerInstance->Log(DEBUG,"Cant bind DNS fd");
 			shutdown(this->GetFd(),2);
 			close(this->GetFd());
 			this->SetFd(-1);
@@ -341,7 +368,6 @@ DNS::DNS(InspIRCd* Instance) : ServerInstance(Instance)
 
 		if (this->GetFd() >= 0)
 		{
-			ServerInstance->Log(DEBUG,"Add master socket %d",this->GetFd());
 			/* Hook the descriptor into the socket engine */
 			if (ServerInstance && ServerInstance->SE)
 			{
@@ -357,6 +383,37 @@ DNS::DNS(InspIRCd* Instance) : ServerInstance(Instance)
 	}
 }
 
+/** Initialise the DNS UDP socket so that we can send requests */
+DNS::DNS(InspIRCd* Instance) : ServerInstance(Instance)
+{
+	/* Clear the Resolver class table */
+	memset(Classes,0,sizeof(Classes));
+
+	/* Clear the requests class table */
+	memset(requests,0,sizeof(requests));
+
+	/* Set the id of the next request to 0
+	 */
+	currid = 0;
+
+	/* 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(ServerInstance, 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)
 {
@@ -404,7 +461,7 @@ int DNS::GetIP(const char *name)
 	if ((length = this->MakePayload(name, DNS_QUERY_A, 1, (unsigned char*)&h.payload)) == -1)
 		return -1;
 
-	DNSRequest* req = this->AddQuery(&h, id);
+	DNSRequest* req = this->AddQuery(&h, id, name);
 
 	if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_A) == -1))
 		return -1;
@@ -422,7 +479,7 @@ int DNS::GetIP6(const char *name)
 	if ((length = this->MakePayload(name, DNS_QUERY_AAAA, 1, (unsigned char*)&h.payload)) == -1)
 		return -1;
 
-	DNSRequest* req = this->AddQuery(&h, id);
+	DNSRequest* req = this->AddQuery(&h, id, name);
 
 	if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_AAAA) == -1))
 		return -1;
@@ -440,7 +497,7 @@ int DNS::GetCName(const char *alias)
 	if ((length = this->MakePayload(alias, DNS_QUERY_CNAME, 1, (unsigned char*)&h.payload)) == -1)
 		return -1;
 
-	DNSRequest* req = this->AddQuery(&h, id);
+	DNSRequest* req = this->AddQuery(&h, id, alias);
 
 	if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_CNAME) == -1))
 		return -1;
@@ -472,7 +529,7 @@ int DNS::GetName(const insp_inaddr *ip)
 	if ((length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload)) == -1)
 		return -1;
 
-	DNSRequest* req = this->AddQuery(&h, id);
+	DNSRequest* req = this->AddQuery(&h, id, insp_ntoa(*ip));
 
 	if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1))
 		return -1;
@@ -513,12 +570,10 @@ int DNS::GetNameForce(const char *ip, ForceProtocol fp)
 			return -1;
 	}
 
-	ServerInstance->Log(DEBUG,"DNS::GetNameForce: %s %d",query, fp);
-
 	if ((length = this->MakePayload(query, DNS_QUERY_PTR, 1, (unsigned char*)&h.payload)) == -1)
 		return -1;
 
-	DNSRequest* req = this->AddQuery(&h, id);
+	DNSRequest* req = this->AddQuery(&h, id, ip);
 
 	if ((!req) || (req->SendRequests(&h, length, DNS_QUERY_PTR) == -1))
 		return -1;
@@ -555,22 +610,23 @@ DNSResult DNS::GetResult()
 	DNSHeader header;
 	DNSRequest *req;
 	unsigned char buffer[sizeof(DNSHeader)];
-	sockaddr from;
-	socklen_t x = sizeof(from);
-	const char* ipaddr_from = "";
+	sockaddr* from = new sockaddr[2];
+#ifdef IPV6
+	socklen_t x = this->socketfamily == AF_INET ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
+#else
+	socklen_t x = sizeof(sockaddr_in);
+#endif
+	const char* ipaddr_from;
 	unsigned short int port_from = 0;
 
-	int length = recvfrom(this->GetFd(),buffer,sizeof(DNSHeader),0,&from,&x);
-
-	if (length < 0)
-		ServerInstance->Log(DEBUG,"Error in recvfrom()! (%s)",strerror(errno));
+	int length = recvfrom(this->GetFd(),buffer,sizeof(DNSHeader),0,from,&x);
 
 	/* Did we get the whole header? */
 	if (length < 12)
 	{
 		/* Nope - something screwed up. */
-		ServerInstance->Log(DEBUG,"Whole header not read!");
-		return std::make_pair(-1,"");
+		delete[] from;
+		return DNSResult(-1,"",0,"");
 	}
 
 	/* Check wether the reply came from a different DNS
@@ -583,13 +639,24 @@ DNSResult DNS::GetResult()
 	 * -- Thanks jilles for pointing this one out.
 	 */
 #ifdef IPV6
-	ipaddr_from = insp_ntoa(((sockaddr_in6*)&from)->sin6_addr);
-	port_from = ntohs(((sockaddr_in6*)&from)->sin6_port);
+	char nbuf[MAXBUF];
+	if (this->socketfamily == AF_INET6)
+	{
+		ipaddr_from = inet_ntop(AF_INET6, &((sockaddr_in6*)from)->sin6_addr, nbuf, sizeof(nbuf));
+		port_from = ntohs(((sockaddr_in6*)from)->sin6_port);
+	}
+	else
+	{
+		ipaddr_from = inet_ntoa(((sockaddr_in*)from)->sin_addr);
+		port_from = ntohs(((sockaddr_in*)from)->sin_port);
+	}
 #else
-	ipaddr_from = insp_ntoa(((sockaddr_in*)&from)->sin_addr);
-	port_from = ntohs(((sockaddr_in*)&from)->sin_port);
+	ipaddr_from = inet_ntoa(((sockaddr_in*)from)->sin_addr);
+	port_from = ntohs(((sockaddr_in*)from)->sin_port);
 #endif
 
+	delete[] from;
+
 	/* We cant perform this security check if you're using 4in6.
 	 * Tough luck to you, choose one or't other!
 	 */
@@ -597,8 +664,7 @@ DNSResult DNS::GetResult()
 	{
 		if ((port_from != DNS::QUERY_PORT) || (strcasecmp(ipaddr_from, ServerInstance->Config->DNSServer)))
 		{
-			ServerInstance->Log(DEBUG,"port %d is not 53, or %s is not %s",port_from, ipaddr_from, ServerInstance->Config->DNSServer);
-			return std::make_pair(-1,"");
+			return DNSResult(-1,"",0,"");
 		}
 	}
 
@@ -615,8 +681,7 @@ DNSResult DNS::GetResult()
 	if (!requests[this_id])
 	{
 		/* Somehow we got a DNS response for a request we never made... */
-		ServerInstance->Log(DEBUG,"DNS: got a response for a query we didnt send with fd=%d queryid=%d",this->GetFd(),this_id);
-		return std::make_pair(-1,"");
+		return DNSResult(-1,"",0,"");
 	}
 	else
 	{
@@ -641,11 +706,13 @@ DNSResult DNS::GetResult()
 		 * 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 std::make_pair(this_id | ERROR_MASK, data.second);
+		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 */
@@ -700,14 +767,14 @@ DNSResult DNS::GetResult()
 			break;
 
 			default:
-				ServerInstance->Log(DEBUG,"WARNING: Somehow we made a request for a DNS_QUERY_PTR4 or DNS_QUERY_PTR6, but these arent real rr types!");
 			break;
 			
 		}
 
 		/* Build the reply with the id and hostname/ip in it */
+		std::string ro = req->orig;
 		delete req;
-		return std::make_pair(this_id,resultstr);
+		return DNSResult(this_id,resultstr,ttl,ro);
 	}
 }
 
@@ -723,6 +790,7 @@ DNSInfo DNSRequest::ResultIsReady(DNSHeader &header, int length)
 	/* 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. */
 
 	if (!(header.flags1 & FLAGS_MASK_QR))
 		return std::make_pair((unsigned char*)NULL,"Not a query result");
@@ -780,6 +848,7 @@ DNSInfo DNSRequest::ResultIsReady(DNSHeader &header, int length)
 		if (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;
 		if (rr.type != this->type)
@@ -805,6 +874,8 @@ DNSInfo DNSRequest::ResultIsReady(DNSHeader &header, int length)
 	if (rr.rdlength > 1023)
 		return std::make_pair((unsigned char*)NULL,"Resource record too large");
 
+	this->ttl = rr.ttl;
+
 	switch (rr.type)
 	{
 		case DNS_QUERY_CNAME:
@@ -859,12 +930,49 @@ DNS::~DNS()
 {
 	shutdown(this->GetFd(), 2);
 	close(this->GetFd());
+	ServerInstance->Timers->DelTimer(this->PruneTimer);
+	delete this->PruneTimer;
+}
+
+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(InspIRCd* Instance, const std::string &source, QueryType qt, Module* creator) : ServerInstance(Instance), Creator(creator), input(source), querytype(qt)
+Resolver::Resolver(InspIRCd* Instance, const std::string &source, QueryType qt, bool &cached, Module* creator) : ServerInstance(Instance), Creator(creator), input(source), querytype(qt)
 {
-	ServerInstance->Log(DEBUG,"Instance: %08x %08x",Instance, ServerInstance);
+	cached = false;
+
+	CQ = ServerInstance->Res->GetCache(source);
+	if (CQ)
+	{
+		time_left = CQ->CalcTTLRemaining();
+		if (!time_left)
+		{
+			ServerInstance->Res->DelCache(source);
+		}
+		else
+		{
+			cached = true;
+			return;
+		}
+	}
 
 	insp_inaddr binip;
 
@@ -912,14 +1020,11 @@ Resolver::Resolver(InspIRCd* Instance, const std::string &source, QueryType qt,
 	}
 	if (this->myid == -1)
 	{
-		ServerInstance->Log(DEBUG,"Resolver::Resolver: Could not get an id!");
 		this->OnError(RESOLVER_NSDOWN, "Nameserver is down");
 		throw ModuleException("Resolver: Couldnt get an id to make a request");
 		/* We shouldnt get here really */
 		return;
 	}
-
-	ServerInstance->Log(DEBUG,"Resolver::Resolver: this->myid=%d",this->myid);
 }
 
 /** Called when an error occurs */
@@ -951,36 +1056,37 @@ void DNS::HandleEvent(EventType et, int errornum)
 	/* Fetch the id and result of the next available packet */
 	DNSResult res = this->GetResult();
 	/* Is there a usable request id? */
-	if (res.first != -1)
+	if (res.id != -1)
 	{
 		/* Its an error reply */
-		if (res.first & ERROR_MASK)
+		if (res.id & ERROR_MASK)
 		{
 			/* Mask off the error bit */
-			res.first -= ERROR_MASK;
+			res.id -= ERROR_MASK;
 			/* Marshall the error to the correct class */
-			ServerInstance->Log(DEBUG,"Error available, id=%d",res.first);
-			if (Classes[res.first])
+			if (Classes[res.id])
 			{
 				if (ServerInstance && ServerInstance->stats)
 					ServerInstance->stats->statsDnsBad++;
-				Classes[res.first]->OnError(RESOLVER_NXDOMAIN, res.second);
-				delete Classes[res.first];
-				Classes[res.first] = NULL;
+				Classes[res.id]->OnError(RESOLVER_NXDOMAIN, res.result);
+				delete Classes[res.id];
+				Classes[res.id] = NULL;
 			}
 		}
 		else
 		{
-			/* It is a non-error result */
-			ServerInstance->Log(DEBUG,"Result available, id=%d",res.first);
-			/* Marshall the result to the correct class */
-			if (Classes[res.first])
+			/* It is a non-error result, marshall the result to the correct class */
+			if (Classes[res.id])
 			{
 				if (ServerInstance && ServerInstance->stats)
 					ServerInstance->stats->statsDnsGood++;
-				Classes[res.first]->OnLookupComplete(res.second);
-				delete Classes[res.first];
-				Classes[res.first] = NULL;
+
+				if (!this->GetCache(res.original.c_str()))
+					this->cache->insert(std::make_pair(res.original.c_str(), CachedQuery(res.result, res.ttl)));
+
+				Classes[res.id]->OnLookupComplete(res.result, res.ttl, false);
+				delete Classes[res.id];
+				Classes[res.id] = NULL;
 			}
 		}