X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fdns.cpp;h=a6e41307170d513938cba0f29795373935c5a97c;hb=57bba0c632bf07cdce7810330dffdfa27ae14972;hp=06cff075755b17bbc19a8acd1fd557916651a2a5;hpb=b864f69ce98841fd54e2328b49e34b5be49525b8;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/dns.cpp b/src/dns.cpp
index 06cff0757..a6e413071 100644
--- a/src/dns.cpp
+++ b/src/dns.cpp
@@ -49,12 +49,18 @@ using namespace std;
 #include "dns.h"
 #include "inspircd.h"
 #include "helperfuncs.h"
+#include "inspircd_config.h"
 #include "socketengine.h"
 #include "configreader.h"
 
+#ifdef THREADED_DNS
+pthread_mutex_t connmap_lock = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
 extern InspIRCd* ServerInstance;
 extern ServerConfig* Config;
 extern time_t TIME;
+extern userrec* fd_ref_table[MAX_DESCRIPTORS];
 
 enum QueryType { DNS_QRY_A = 1, DNS_QRY_PTR = 12 };
 enum QueryFlags1 { FLAGS1_MASK_RD = 0x01, FLAGS1_MASK_TC = 0x02, FLAGS1_MASK_AA = 0x04, FLAGS1_MASK_OPCODE = 0x78, FLAGS1_MASK_QR = 0x80 };
@@ -71,7 +77,6 @@ Resolver* dns_classes[MAX_DESCRIPTORS];
 struct in_addr servers4[8];
 int i4;
 int initdone = 0;
-int wantclose = 0;
 int lastcreate = -1;
 
 class s_connection
@@ -169,11 +174,6 @@ void dns_close(int fd)
 		ServerInstance->SE->DelFd(fd);
 #endif
 	log(DEBUG,"DNS: dns_close on fd %d",fd);
-	if (fd == lastcreate)
-	{
-		wantclose = 1;
-		return;
-	}
 	shutdown(fd,2);
 	close(fd);
 	return;
@@ -292,16 +292,15 @@ s_connection *dns_add_query(s_header *h)
 		return NULL;
 	}
 	/* create new connection object, add to linked list */
+#ifdef THREADED_DNS
+	pthread_mutex_lock(&connmap_lock);
+#endif
 	if (connections.find(s->fd) == connections.end())
 		connections[s->fd] = s;
+#ifdef THREADED_DNS
+	pthread_mutex_unlock(&connmap_lock);
+#endif
 
-	if (wantclose == 1)
-	{
-		shutdown(lastcreate,2);
-		close(lastcreate);
-		wantclose = 0;
-	}
-	lastcreate = s->fd;
 	return s;
 }
 
@@ -464,6 +463,14 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS
 		*res = 0;
 
 	/* FireDNS used a linked list for this. How ugly (and slow). */
+
+#ifdef THREADED_DNS
+	/* XXX: STL really does NOT like being poked and prodded in more than
+	 * one orifice by threaded apps. Make sure we remain nice to it, and
+	 * lock a mutex around any access to the std::map.
+	 */
+	pthread_mutex_lock(&connmap_lock);
+#endif
 	connlist_iter n_iter = connections.find(cfd);
 	if (n_iter == connections.end())
 	{
@@ -477,6 +484,9 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS
 		/* We don't delete c here, because its done later when needed */
 		connections.erase(n_iter);
 	}
+#ifdef THREADED_DNS
+	pthread_mutex_unlock(&connmap_lock);
+#endif
 
 	l = recv(c->fd,buffer,sizeof(s_header),0);
 	dns_close(c->fd);
@@ -595,6 +605,7 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS
 			{
 				if (h.payload[i] > 63)
 				{
+					log(DEBUG,"DNS: h.payload[i] > 63");
 					memcpy(&p,&h.payload[i],2);
 					i = ntohs(p) - 0xC000 - 12;
 				}
@@ -703,7 +714,7 @@ DNS::~DNS()
 {
 }
 
-bool DNS::ReverseLookup(const std::string &ip)
+bool DNS::ReverseLookup(const std::string &ip, bool ins)
 {
 	if (ServerInstance && ServerInstance->stats)
 		ServerInstance->stats->statsDns++;
@@ -720,13 +731,16 @@ bool DNS::ReverseLookup(const std::string &ip)
 	}
 	log(DEBUG,"DNS: ReverseLookup, fd=%d",this->myfd);
 #ifndef THREADED_DNS
-	if (ServerInstance && ServerInstance->SE)
-		ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS);
+	if (ins)
+	{
+		if (ServerInstance && ServerInstance->SE)
+			ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS);
+	}
 #endif
 	return true;
 }
 
-bool DNS::ForwardLookup(const std::string &host)
+bool DNS::ForwardLookup(const std::string &host, bool ins)
 {
 	if (ServerInstance && ServerInstance->stats)
 		ServerInstance->stats->statsDns++;
@@ -737,8 +751,11 @@ bool DNS::ForwardLookup(const std::string &host)
 	}
 	log(DEBUG,"DNS: ForwardLookup, fd=%d",this->myfd);
 #ifndef THREADED_DNS
-	if (ServerInstance && ServerInstance->SE)
-		ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS);
+	if (ins)
+	{
+		if (ServerInstance && ServerInstance->SE)
+			ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS);
+	}
 #endif
 	return true;
 }
@@ -793,6 +810,7 @@ std::string DNS::GetResult()
 		if (ServerInstance && ServerInstance->stats)
 			ServerInstance->stats->statsDnsGood++;
 		dns_close(this->myfd);
+		this->myfd = -1;
 		return result;
 	}
 	else
@@ -802,6 +820,7 @@ std::string DNS::GetResult()
 		if (this->myfd != -1)
 		{
 			dns_close(this->myfd);
+			this->myfd = -1;
 		}
 		return "";
 	}
@@ -815,6 +834,7 @@ std::string DNS::GetResultIP()
 	if (this->myfd != -1)
 	{
 		dns_close(this->myfd);
+		this->myfd = -1;
 	}
 	if (result)
 	{
@@ -839,42 +859,64 @@ std::string DNS::GetResultIP()
 
 
 #ifdef THREADED_DNS
+
+/* This function is a thread function which can be thought of as a lightweight process
+ * to all you non-threaded people. In actuality its so much more, and pretty damn cool.
+ * With threaded dns enabled, each user which connects gets a thread attached to their
+ * user record when their DNS lookup starts. This function starts in parallel, and
+ * commences a blocking dns lookup. Because its a seperate thread, this occurs without
+ * actually blocking the main application. Once the dns lookup is completed, the thread
+ * checks if the user is still around by checking their fd against the reference table,
+ * and if they are, writes the hostname into the struct and terminates, after setting
+ * userrec::dns_done to true. Because this is multi-threaded it can make proper use of
+ * SMP setups (like the one i have here *grin*).
+ * This is in comparison to the non-threaded dns, which must monitor the thread sockets
+ * in a nonblocking fashion, consuming more resources to do so.
+ */
 void* dns_task(void* arg)
 {
 	userrec* u = (userrec*)arg;
+	int thisfd = u->fd;
+
 	log(DEBUG,"DNS thread for user %s",u->nick);
 	DNS dns1;
 	DNS dns2;
 	std::string host;
 	std::string ip;
-	if (dns1.ReverseLookup((char*)inet_ntoa(u->ip4)))
+	if (dns1.ReverseLookup(inet_ntoa(u->ip4),false))
 	{
 		while (!dns1.HasResult())
-		{
 			usleep(100);
-		}
 		host = dns1.GetResult();
 		if (host != "")
 		{
-			if (dns2.ForwardLookup(host))
+			if (dns2.ForwardLookup(host, false))
 			{
 				while (!dns2.HasResult())
-				{
 					usleep(100);
-				}
 				ip = dns2.GetResultIP();
-				if (ip == std::string((char*)inet_ntoa(u->ip4)))
+				if (ip == std::string(inet_ntoa(u->ip4)))
 				{
-					if (host.length() < 160)
+					if (host.length() < 65)
 					{
-						strcpy(u->host,host.c_str());
-						strcpy(u->dhost,host.c_str());
+						if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd]))
+						{
+							if (!u->dns_done)
+							{
+								strcpy(u->host,host.c_str());
+								if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd]))
+								{
+									strcpy(u->dhost,host.c_str());
+								}
+							}
+						}
 					}
 				}
 			}
 		}
 	}
-	u->dns_done = true;
+	if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd]))
+		u->dns_done = true;
 	return NULL;
 }
 #endif
@@ -887,20 +929,44 @@ Resolver::Resolver(const std::string &source, bool forward, const std::string &d
 		Query.SetNS(Config->DNSServer);
 
 	if (forward)
-		this->fd = Query.ForwardLookup(input.c_str());
+	{
+		Query.ForwardLookup(input.c_str(), false);
+		this->fd = Query.GetFD();
+	}
 	else
-		this->fd = Query.ReverseLookup(input.c_str());
+	{
+		Query.ReverseLookup(input.c_str(), false);
+		this->fd = Query.GetFD();
+	}
 	if (fd < 0)
+	{
+		log(DEBUG,"Resolver::Resolver: RESOLVER_NSDOWN");
 		this->OnError(RESOLVER_NSDOWN);
+		ModuleException e("Resolver: Nameserver is down");
+		throw e;
+		/* We shouldnt get here really */
+		return;
+	}
 
 	if (ServerInstance && ServerInstance->SE)
+	{
+		log(DEBUG,"Resolver::Resolver: this->fd=%d",this->fd);
 		ServerInstance->SE->AddFd(this->fd,true,X_ESTAB_CLASSDNS);
+	}
 	else
+	{
+		log(DEBUG,"Resolver::Resolver: RESOLVER_NOTREADY");
 		this->OnError(RESOLVER_NOTREADY);
+		ModuleException e("Resolver: Core not initialized yet");
+		throw e;
+		/* We shouldnt get here really */
+		return;
+	}
 }
 
 Resolver::~Resolver()
 {
+	log(DEBUG,"Resolver::~Resolver");
 	if (ServerInstance && ServerInstance->SE)
 		ServerInstance->SE->DelFd(this->fd);
 }
@@ -912,6 +978,7 @@ int Resolver::GetFd()
 
 bool Resolver::ProcessResult()
 {
+	log(DEBUG,"Resolver::ProcessResult");
 	if (this->fwd)
 		result = Query.GetResultIP();
 	else
@@ -919,11 +986,13 @@ bool Resolver::ProcessResult()
 
 	if (result != "")
 	{
+		log(DEBUG,"Resolver::OnLookupComplete(%s)",result.c_str());
 		this->OnLookupComplete(result);
 		return true;
 	}
 	else
 	{
+		log(DEBUG,"Resolver::OnError(RESOLVER_NXDOMAIN)");
 		this->OnError(RESOLVER_NXDOMAIN);
 		return false;
 	}
@@ -939,8 +1008,10 @@ void Resolver::OnError(ResolverError e)
 
 void dns_deal_with_classes(int fd)
 {
+	log(DEBUG,"dns_deal_with_classes(%d)",fd);
 	if ((fd > -1) && (dns_classes[fd]))
 	{
+		log(DEBUG,"Valid fd %d",fd);
 		dns_classes[fd]->ProcessResult();
 		delete dns_classes[fd];
 		dns_classes[fd] = NULL;
@@ -949,20 +1020,24 @@ void dns_deal_with_classes(int fd)
 
 bool dns_add_class(Resolver* r)
 {
+	log(DEBUG,"dns_add_class");
 	if ((r) && (r->GetFd() > -1))
 	{
 		if (!dns_classes[r->GetFd()])
 		{
+			log(DEBUG,"dns_add_class: added class");
 			dns_classes[r->GetFd()] = r;
 			return true;
 		}
 		else
 		{
+			log(DEBUG,"Space occupied!");
 			return false;
 		}
 	}
 	else
 	{
+		log(DEBUG,"Bad class");
 		delete r;
 		return true;
 	}