EXPERIMENTAL new socket engine code

[user/henk/code/inspircd.git] / src / dnsqueue.cpp

diff --git a/src/dnsqueue.cpp b/src/dnsqueue.cpp
index 9d77543e90213f85433815ddd11e4aad80b77743..99f32988e55f382d60f1a2aaee2fbcc37ed9c843 100644 (file)
--- a/src/dnsqueue.cpp
+++ b/src/dnsqueue.cpp
@@ -18,10 +18,10 @@
 
 using namespace std;
 
+#include "inspircd_config.h"
 #include "inspircd.h"
 #include "inspircd_io.h"
 #include "inspircd_util.h"
-#include "inspircd_config.h"
 #include <unistd.h>
 #include <sys/errno.h>
 #include <sys/ioctl.h>
@@ -38,9 +38,7 @@ using namespace std;
 #include <sstream>
 #include <vector>
 #include <deque>
-#include "connection.h"
 #include "users.h"
-#include "servers.h"
 #include "ctables.h"
 #include "globals.h"
 #include "modules.h"
@@ -68,14 +66,13 @@ extern int MaxWhoResults;
 extern std::vector<Module*> modules;
 extern std::vector<std::string> module_names;
 extern std::vector<ircd_module*> factory;
-extern std::vector<int> fd_reap;
 
 extern int MODCOUNT;
 
-typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
-typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
-typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
-typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, StrHashComp> whowas_hash;
+typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
+typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
+typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp> address_cache;
+typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp> whowas_hash;
 typedef std::deque<command_t> command_table;
 
 extern user_hash clientlist;
@@ -90,10 +87,14 @@ long max_fd_alloc = 0;
 
 extern time_t TIME;
 
+//enum LookupState { reverse, forward };
+
 class Lookup {
 private:
-       DNS resolver;
+       DNS resolver1;
+       DNS resolver2;
        char u[NICKMAX];
+       std::string hostname;
 public:
        Lookup()
        {
@@ -103,6 +104,7 @@ public:
        void Reset()
        {
                strcpy(u,"");
+               log(DEBUG,"Reset class Lookup");
        }
 
        ~Lookup()
@@ -111,56 +113,109 @@ public:
 
        bool DoLookup(std::string nick)
        {
+               hostname = "";
                userrec* usr = Find(nick);
                if (usr)
                {
                        log(DEBUG,"New Lookup class for %s with DNSServer set to '%s'",nick.c_str(),DNSServer);
-                       resolver.SetNS(std::string(DNSServer));
-                       if (!resolver.ReverseLookup(std::string(usr->host)))
+                       resolver1.SetNS(std::string(DNSServer));
+                       if (!resolver1.ReverseLookup(std::string(usr->host)))
+                       {
+                               log(DEBUG,"ReverseLookup didnt return true, we're outta here");
                                return false;
+                       }
                        strlcpy(u,nick.c_str(),NICKMAX);
                        return true;
                }
+               log(DEBUG,"We couldnt find that user");
                return false;
        }
 
        bool Done()
        {
-               userrec* usr = NULL;
-               if (resolver.HasResult())
+               if (hostname != "")
                {
-                       if (resolver.GetFD() != 0)
+                       log(DEBUG,"Doing forward lookup here with host %s",hostname.c_str());
+                       // doing forward lookup
+                       userrec* usr = NULL;
+                       if (resolver2.HasResult())
                        {
-                               std::string hostname = resolver.GetResult();
-                               log(DEBUG,"RESULT! %s",hostname.c_str());
-                               usr = Find(u);
-                               if (usr)
+                               log(DEBUG,"resolver2 has result");
+                               if (resolver2.GetFD() != 0)
                                {
-                                       if (usr->registered > 3)
+                                       std::string ip = resolver2.GetResultIP();
+                                       log(DEBUG,"FORWARD RESULT! %s",ip.c_str());
+
+                                       usr = Find(u);
+                                       if (usr)
                                        {
-                                               usr->dns_done = true;
-                                               return true;
+                                               if (usr->registered > 3)
+                                               {
+                                                       log(DEBUG,"Point 1: Returning true as usr->dns_done is true");
+                                                       usr->dns_done = true;
+                                                       return true;
+                                               }
+                                               if ((hostname != "") && (usr->registered != 7))
+                                               {
+                                                       if (std::string(usr->ip) == ip)
+                                                       {
+                                                               strlcpy(usr->host,hostname.c_str(),MAXBUF);
+                                                               strlcpy(usr->dhost,hostname.c_str(),MAXBUF);
+                                                               log(DEBUG,"Forward and reverse match, assigning hostname");
+                                                       }
+                                                       else
+                                                       {
+                                                               log(DEBUG,"AWOOGA! Forward lookup doesn't match reverse: R='%s',F='%s',IP='%s'",hostname.c_str(),ip.c_str(),usr->ip);
+                                                       }
+                                                       usr->dns_done = true;
+                                                       return true;
+                                               }
                                        }
-                                       if ((hostname != "") && (usr->registered != 7))
+                               }
+                               else
+                               {
+                                       usr = Find(u);
+                                       if (usr)
                                        {
-                                               strlcpy(usr->host,hostname.c_str(),MAXBUF);
-                                               strlcpy(usr->dhost,hostname.c_str(),MAXBUF);
-                                               WriteServ(usr->fd,"NOTICE Auth :Resolved your hostname: %s",hostname.c_str());
+                                               log(DEBUG,"Point 2: Returning true");
                                                usr->dns_done = true;
-                                               return true;
                                        }
-                                       usr->dns_done = true;
                                        return true;
                                }
                        }
-                       else
+                       log(DEBUG,"Returning false in forward");
+                       return false;
+               }
+               else
+               {
+                       // doing reverse lookup
+                       userrec* usr = NULL;
+                       if (resolver1.HasResult())
                        {
                                usr = Find(u);
-                               if (usr)
-                                       usr->dns_done = true;
-                               return true;
+                               if ((usr) && (usr->dns_done))
+                                       return true;
+                               if (resolver1.GetFD() != 0)
+                               {
+                                       hostname = resolver1.GetResult();
+                                       if (usr)
+                                       {
+                                               if ((usr->registered > 3) || (hostname == ""))
+                                               {
+                                                       log(DEBUG,"Hostname is blank and user->registered > 3, returning true and setting done");
+                                                       usr->dns_done = true;
+                                                       return true;
+                                               }
+                                       }
+                                       if (hostname != "")
+                                       {
+                                               log(DEBUG,"Starting forwardlookup now for host '%s'...",hostname.c_str());
+                                               resolver2.ForwardLookup(hostname);
+                                       }
+                               }
                        }
                }
+               log(DEBUG,"Returning false");
                return false;
        }