Fixes to way allocations are handled

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

diff --git a/src/dnsqueue.cpp b/src/dnsqueue.cpp
index 4c328e71c7492cc43bfc3228f32c4e48fe9e769f..1e1aa33c85a75d5c9412cb23a6c02b7723ac10e5 100644 (file)
--- a/src/dnsqueue.cpp
+++ b/src/dnsqueue.cpp
@@ -127,6 +127,8 @@ struct StrHashComp
                char a[MAXBUF],b[MAXBUF];
                strlcpy(a,s1.c_str(),MAXBUF);
                strlcpy(b,s2.c_str(),MAXBUF);
+                strlower(a);
+                strlower(b);
                return (strcasecmp(a,b) == 0);
        }
 
@@ -158,62 +160,81 @@ extern user_hash clientlist;
 extern chan_hash chanlist;
 extern user_hash whowas;
 extern command_table cmdlist;
-extern address_cache IP;
 
 extern ClassVector Classes;
 
 extern char DNSServer[MAXBUF];
+long max_fd_alloc = 0;
+
+extern time_t TIME;
 
 class Lookup {
 private:
-       DNS* resolver;
-       userrec* u;
+       DNS resolver;
+       char u[NICKMAX];
 public:
        Lookup()
        {
-               u = NULL;
-               resolver = NULL;
+               strcpy(u,"");
+       }
+
+       void Reset()
+       {
+               strcpy(u,"");
        }
 
        ~Lookup()
        {
-               if (resolver)
-                       delete resolver;
        }
 
-       Lookup(userrec* user)
+       bool DoLookup(std::string nick)
        {
-               u = user;
-               log(DEBUG,"New Lookup class with DNSServer set to '%s'",DNSServer);
-               resolver = new DNS(std::string(DNSServer));
-               resolver->ReverseLookup(std::string(user->host));
+               userrec* usr = Find(nick);
+               if (usr)
+               {
+                       log(DEBUG,"New Lookup class for %s with DNSServer set to '%s'",nick.c_str(),DNSServer);
+                       resolver.SetNS(DNSServer);
+                       if (!resolver.ReverseLookup(usr->host))
+                               return false;
+                       strlcpy(u,nick.c_str(),NICKMAX);
+                       return true;
+               }
+               return false;
        }
 
        bool Done()
        {
-               if (resolver->HasResult())
+               userrec* usr = NULL;
+               if (resolver.HasResult())
                {
-                       log(DEBUG,"resolver says result available!");
-                       if (resolver->GetFD() != 0)
+                       if (resolver.GetFD() != 0)
                        {
-                               log(DEBUG,"Resolver FD is not 0");
-                               std::string hostname = resolver->GetResult();
-                               if (u)
+                               std::string hostname = resolver.GetResult();
+                               usr = Find(u);
+                               if (usr)
                                {
-                                       log(DEBUG,"Applying hostname lookup to %s: %s",u->nick,hostname.c_str());
-                                       if (hostname != "")
+                                       if (usr->registered > 3)
                                        {
-                                               strlcpy(u->host,hostname.c_str(),MAXBUF);
-                                               WriteServ(u->fd,"NOTICE Auth :Resolved your hostname: %s",hostname.c_str());
-                                               u->dns_done = true;
+                                               usr->dns_done = true;
                                                return true;
                                        }
-                                       return false;
+                                       if ((hostname != "") && (usr->registered != 7))
+                                       {
+                                               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());
+                                               usr->dns_done = true;
+                                               return true;
+                                       }
+                                       usr->dns_done = true;
+                                       return true;
                                }
                        }
                        else
                        {
-                               u->dns_done = true;
+                               usr = Find(u);
+                               if (usr)
+                                       usr->dns_done = true;
                                return true;
                        }
                }
@@ -222,39 +243,68 @@ public:
 
        int GetFD()
        {
-               if (u)
-               {
-                       return u->fd;
-               }
-               else return 0;
+               userrec* usr = Find(u);
+               if (!usr)
+                       return 0;
+               if (usr->dns_done)
+                       return 0;
+               return usr->fd;
        }
 };
 
-typedef std::vector<Lookup> dns_queue;
-
-dns_queue dnsq;
+Lookup dnsq[MAXBUF];
 
-bool lookup_dns(userrec* u)
+bool lookup_dns(std::string nick)
 {
-       // place a new user into the queue...
-       log(DEBUG,"Queueing DNS lookup for %s",u->nick);
-       WriteServ(u->fd,"NOTICE Auth :Looking up your hostname...");
-       Lookup L(u);
-       dnsq.push_back(L);
-       return true;
+       userrec* u = Find(nick);
+       if (u)
+       {
+               // place a new user into the queue...
+               log(DEBUG,"Queueing DNS lookup for %s",u->nick);
+               WriteServ(u->fd,"NOTICE Auth :Looking up your hostname...");
+               Lookup L;
+               if (L.DoLookup(nick))
+               {
+                       for (int j = 0; j < MAXBUF; j++)
+                       {
+                               if (!dnsq[j].GetFD())
+                               {
+                                       dnsq[j] = L;
+                                       return true;
+                               }
+                       }
+                       // calculate the maximum value, this saves cpu time later
+                       for (int p = 0; p < MAXBUF; p++)
+                               if (dnsq[p].GetFD())
+                                       max_fd_alloc = p;
+               }
+               else
+               {
+                       return false;
+               }
+       }
+       return false;
 }
 
 void dns_poll()
 {
        // do we have items in the queue?
-       if (dnsq.size())
+       for (int j = 0; j <= max_fd_alloc; j++)
        {
                // are any ready, or stale?
-               if (dnsq[0].Done() || (!dnsq[0].GetFD()))
+               if (dnsq[j].GetFD())
                {
-                       log(DEBUG,"****** DNS lookup for fd %d is complete. ******",dnsq[0].GetFD());
-                       dnsq.erase(dnsq.begin());
+                       if (dnsq[j].Done())
+                       {
+                               dnsq[j].Reset();
+                       }
                }
        }
+       // looks like someones freed an item, recalculate end of list.
+       if ((!dnsq[max_fd_alloc].GetFD()) && (max_fd_alloc != 0))
+               for (int p = 0; p < MAXBUF; p++)
+                       if (dnsq[p].GetFD())
+                               max_fd_alloc = p;
+
 }