X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fdns.cpp;h=d65ec8c88cc7e31d394ba1709b39a1bb8092aaf0;hb=c80508b28be5947648f59710e6653f793a73bd76;hp=ce9192785d6cfd438c1e578a70957fa16089b3c6;hpb=2eacbf5448cca3553eb627f1e9610aed08d3b745;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/dns.cpp b/src/dns.cpp
index ce9192785..d65ec8c88 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 };
@@ -68,10 +74,9 @@ connlist connections;
 
 Resolver* dns_classes[MAX_DESCRIPTORS];
 
-struct in_addr servers4[8];
+insp_inaddr 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;
@@ -183,7 +183,7 @@ void DNS::dns_init()
 {
 	FILE *f;
 	int i;
-	in_addr addr4;
+	insp_inaddr addr4;
 	char buf[1024];
 	if (initdone == 1)
 		return;
@@ -191,7 +191,7 @@ void DNS::dns_init()
 
 	initdone = 1;
 	srand((unsigned int) TIME);
-	memset(servers4,'\0',sizeof(in_addr) * 8);
+	memset(servers4,'\0',sizeof(insp_inaddr) * 8);
 	f = fopen("/etc/resolv.conf","r");
 	if (f == NULL)
 		return;
@@ -204,7 +204,7 @@ void DNS::dns_init()
 			if (i4 < 8)
 			{
 				if (dns_aton4_s(&buf[i],&addr4) != NULL)
-					memcpy(&servers4[i4++],&addr4,sizeof(in_addr));
+					memcpy(&servers4[i4++],&addr4,sizeof(insp_inaddr));
 			}
 		}
 	}
@@ -213,19 +213,19 @@ void DNS::dns_init()
 
 void DNS::dns_init_2(const char* dnsserver)
 {
-	in_addr addr4;
+	insp_inaddr addr4;
 	i4 = 0;
 	srand((unsigned int) TIME);
-	memset(servers4,'\0',sizeof(in_addr) * 8);
+	memset(servers4,'\0',sizeof(insp_inaddr) * 8);
 	if (dns_aton4_s(dnsserver,&addr4) != NULL)
-	    memcpy(&servers4[i4++],&addr4,sizeof(in_addr));
+	    memcpy(&servers4[i4++],&addr4,sizeof(insp_inaddr));
 }
 
 
 int dns_send_requests(const s_header *h, const s_connection *s, const int l)
 {
 	int i;
-	sockaddr_in addr4;
+	insp_sockaddr addr4;
 	unsigned char payload[sizeof(s_header)];
 
 	dns_empty_header(payload,h,l);
@@ -274,7 +274,7 @@ s_connection *dns_add_query(s_header *h)
 	}
 	if (s->fd != -1)
 	{
-		sockaddr_in addr;
+		insp_sockaddr addr;
 		memset(&addr,0,sizeof(addr));
 		addr.sin_family = AF_INET;
 		addr.sin_port = 0;
@@ -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;
 }
 
@@ -344,15 +343,15 @@ int dns_build_query_payload(const char * const name, const unsigned short rr, co
 	return payloadpos + 4;
 }
 
-in_addr* DNS::dns_aton4(const char * const ipstring)
+insp_inaddr* DNS::dns_aton4(const char * const ipstring)
 {
-	static in_addr ip;
+	static insp_inaddr ip;
 	return dns_aton4_s(ipstring,&ip);
 }
 
-in_addr* DNS::dns_aton4_r(const char *ipstring) { /* ascii to numeric (reentrant): convert string to new 4part IP addr struct */
-	in_addr* ip;
-	ip = new in_addr;
+insp_inaddr* DNS::dns_aton4_r(const char *ipstring) { /* ascii to numeric (reentrant): convert string to new 4part IP addr struct */
+	insp_inaddr* ip;
+	ip = new insp_inaddr;
 	if(dns_aton4_s(ipstring,ip) == NULL)
 	{
 		DELETE(ip);
@@ -361,7 +360,7 @@ in_addr* DNS::dns_aton4_r(const char *ipstring) { /* ascii to numeric (reentrant
 	return ip;
 }
 
-in_addr* DNS::dns_aton4_s(const char *ipstring, in_addr *ip) { /* ascii to numeric (buffered): convert string to given 4part IP addr struct */
+insp_inaddr* DNS::dns_aton4_s(const char *ipstring, insp_inaddr *ip) { /* ascii to numeric (buffered): convert string to given 4part IP addr struct */
 	inet_aton(ipstring,ip);
 	return ip;
 }
@@ -410,7 +409,7 @@ int DNS::dns_getip4list(const char *name) { /* build, add and send A query; retr
 	return s->fd;
 }
 
-int DNS::dns_getname4(const in_addr *ip) { /* build, add and send PTR query; retrieve result with dns_getresult() */
+int DNS::dns_getname4(const insp_inaddr *ip) { /* build, add and send PTR query; retrieve result with dns_getresult() */
 	char query[512];
 	s_header h;
 	s_connection * s;
@@ -435,12 +434,12 @@ int DNS::dns_getname4(const in_addr *ip) { /* build, add and send PTR query; ret
 	return s->fd;
 }
 
-char* DNS::dns_ntoa4(const in_addr * const ip) { /* numeric to ascii: convert 4part IP addr struct to static string */
+char* DNS::dns_ntoa4(const insp_inaddr * const ip) { /* numeric to ascii: convert 4part IP addr struct to static string */
 	static char r[256];
 	return dns_ntoa4_s(ip,r);
 }
 
-char* DNS::dns_ntoa4_s(const in_addr *ip, char *r) { /* numeric to ascii (buffered): convert 4part IP addr struct to given string */
+char* DNS::dns_ntoa4_s(const insp_inaddr *ip, char *r) { /* numeric to ascii (buffered): convert 4part IP addr struct to given string */
 	unsigned char *m;
 	m = (unsigned char *)&ip->s_addr;
 	sprintf(r,"%d.%d.%d.%d",m[0],m[1],m[2],m[3]);
@@ -464,10 +463,21 @@ 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())
 	{
 		log(DEBUG,"DNS: got a response for a query we didnt send with fd=%d",cfd);
+#ifdef THREADED_DNS
+		pthread_mutex_unlock(&connmap_lock);
+#endif
 		return NULL;
 	}
 	else
@@ -477,6 +487,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 +608,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;
 				}
@@ -799,6 +813,7 @@ std::string DNS::GetResult()
 		if (ServerInstance && ServerInstance->stats)
 			ServerInstance->stats->statsDnsGood++;
 		dns_close(this->myfd);
+		this->myfd = -1;
 		return result;
 	}
 	else
@@ -808,6 +823,7 @@ std::string DNS::GetResult()
 		if (this->myfd != -1)
 		{
 			dns_close(this->myfd);
+			this->myfd = -1;
 		}
 		return "";
 	}
@@ -821,6 +837,7 @@ std::string DNS::GetResultIP()
 	if (this->myfd != -1)
 	{
 		dns_close(this->myfd);
+		this->myfd = -1;
 	}
 	if (result)
 	{
@@ -845,42 +862,89 @@ 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.
+ *
+ * NB: Yes this does scale, thank you. Even with large numbers of connecting clients
+ * in any one timeframe, they wont all connect *at the same time* therefore any argument
+ * of "but there will be thousands of threads it'll blow up" is moot, ive tested this and
+ * there will only ever be somewhere around the listen backlog in number of pending
+ * lookups at any one time. This is significant on any modern SMP system.
+ */
 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;
+	DNS dns1(Config->DNSServer);
+	DNS dns2(Config->DNSServer);
 	std::string host;
 	std::string ip;
-	if (dns1.ReverseLookup((char*)inet_ntoa(u->ip4)))
+	int iterations = 0;
+
+	if (dns1.ReverseLookup(inet_ntoa(u->ip4),false))
 	{
-		while (!dns1.HasResult())
-		{
+		/* FIX: Dont make these infinite! */
+		while ((!dns1.HasResult()) && (++iterations < 20))
 			usleep(100);
-		}
-		host = dns1.GetResult();
-		if (host != "")
+
+		if (iterations < 20)
 		{
-			if (dns2.ForwardLookup(host), false)
+			if (dns1.GetFD() != -1)
 			{
-				while (!dns2.HasResult())
+				host = dns1.GetResult();
+				if (host != "")
 				{
-					usleep(100);
-				}
-				ip = dns2.GetResultIP();
-				if (ip == std::string((char*)inet_ntoa(u->ip4)))
-				{
-					if (host.length() < 160)
+					if (dns2.ForwardLookup(host, false))
 					{
-						strcpy(u->host,host.c_str());
-						strcpy(u->dhost,host.c_str());
+						iterations = 0;
+						while ((!dns2.HasResult()) && (++iterations < 20))
+							usleep(100);
+
+						if (iterations < 20)
+						{
+							if (dns2.GetFD() != -1)
+							{
+								ip = dns2.GetResultIP();
+								if (ip == std::string(inet_ntoa(u->ip4)))
+								{
+									if (host.length() < 65)
+									{
+										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;
+	log(DEBUG,"THREAD EXIT");
 	return NULL;
 }
 #endif
@@ -906,6 +970,9 @@ Resolver::Resolver(const std::string &source, bool forward, const std::string &d
 	{
 		log(DEBUG,"Resolver::Resolver: RESOLVER_NSDOWN");
 		this->OnError(RESOLVER_NSDOWN);
+		ModuleException e("Resolver: Nameserver is down");
+		throw e;
+		/* We shouldnt get here really */
 		return;
 	}
 
@@ -918,6 +985,10 @@ Resolver::Resolver(const std::string &source, bool forward, const std::string &d
 	{
 		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;
 	}
 }