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

diff --git a/src/dns.cpp b/src/dns.cpp
index aaa6bf89e..d65ec8c88 100644
--- a/src/dns.cpp
+++ b/src/dns.cpp
@@ -53,9 +53,14 @@ using namespace std;
 #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 };
@@ -69,7 +74,7 @@ connlist connections;
 
 Resolver* dns_classes[MAX_DESCRIPTORS];
 
-struct in_addr servers4[8];
+insp_inaddr servers4[8];
 int i4;
 int initdone = 0;
 int lastcreate = -1;
@@ -178,7 +183,7 @@ void DNS::dns_init()
 {
 	FILE *f;
 	int i;
-	in_addr addr4;
+	insp_inaddr addr4;
 	char buf[1024];
 	if (initdone == 1)
 		return;
@@ -186,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;
@@ -199,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));
 			}
 		}
 	}
@@ -208,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);
@@ -269,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;
@@ -287,10 +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
 
-	lastcreate = s->fd;
 	return s;
 }
 
@@ -333,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);
@@ -350,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;
 }
@@ -399,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;
@@ -424,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]);
@@ -453,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
@@ -466,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);
@@ -838,40 +862,81 @@ 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(inet_ntoa(u->ip4)))
-				{
-					if (host.length() < 160)
+					if (dns2.ForwardLookup(host, false))
 					{
-						if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd]))
-							strcpy(u->host,host.c_str());
-						if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd]))
-							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());
+												}
+											}
+										}
+									}
+								}
+							}
+						}
 					}
 				}
 			}
@@ -879,6 +944,7 @@ void* dns_task(void* arg)
 	}
 	if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd]))
 		u->dns_done = true;
+	log(DEBUG,"THREAD EXIT");
 	return NULL;
 }
 #endif