Remove debug stuff

[user/henk/code/inspircd.git] / src / modules / m_dnsbl.cpp

diff --git a/src/modules/m_dnsbl.cpp b/src/modules/m_dnsbl.cpp
index d07b268f7bf4a4db4f9bdc48318fba97e7353c82..c92a2c111fe5952a3c793773b9a84ae410b770de 100644 (file)
--- a/src/modules/m_dnsbl.cpp
+++ b/src/modules/m_dnsbl.cpp
@@ -13,10 +13,6 @@
 
 #include "inspircd.h"
 #include "xline.h"
-#include "dns.h"
-#include "users.h"
-#include "channels.h"
-#include "modules.h"
 
 #ifndef WINDOWS
 #include <sys/types.h>
@@ -32,12 +28,15 @@ class DNSBLConfEntry
 {
        public:
                enum EnumBanaction { I_UNKNOWN, I_KILL, I_ZLINE, I_KLINE, I_GLINE };
+               enum EnumType { A_RECORD, A_BITMASK };
                std::string name, domain, reason;
                EnumBanaction banaction;
+               EnumType type;
                long duration;
                int bitmask;
+               unsigned char records[256];
                unsigned long stats_hits, stats_misses;
-               DNSBLConfEntry(): duration(86400),bitmask(0),stats_hits(0), stats_misses(0) {}
+               DNSBLConfEntry(): type(A_BITMASK),duration(86400),bitmask(0),stats_hits(0), stats_misses(0) {}
                ~DNSBLConfEntry() { }
 };
 
@@ -47,12 +46,12 @@ class DNSBLConfEntry
 class DNSBLResolver : public Resolver
 {
        int theirfd;
-       userrec* them;
+       User* them;
        DNSBLConfEntry *ConfEntry;
 
  public:
 
-       DNSBLResolver(Module *me, InspIRCd *ServerInstance, const std::string &hostname, userrec* u, int userfd, DNSBLConfEntry *conf, bool &cached)
+       DNSBLResolver(Module *me, InspIRCd *ServerInstance, const std::string &hostname, User* u, int userfd, DNSBLConfEntry *conf, bool &cached)
                : Resolver(ServerInstance, hostname, DNS_QUERY_A, cached, me)
        {
                theirfd = userfd;
@@ -60,28 +59,39 @@ class DNSBLResolver : public Resolver
                ConfEntry = conf;
        }
 
-       virtual void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached)
+       /* Note: This may be called multiple times for multiple A record results */
+       virtual void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached, int resultnum = 0)
        {
+               /* for bitmask reply types, we arent interested in any but the first result (number 0) */
+               if ((ConfEntry->type == DNSBLConfEntry::A_BITMASK) && (resultnum))
+                       return;
+
                /* Check the user still exists */
                if ((them) && (them == ServerInstance->SE->GetRef(theirfd)))
                {
                        // Now we calculate the bitmask: 256*(256*(256*a+b)+c)+d
                        if(result.length())
                        {
-                               unsigned int bitmask = 0;
-                               bool show = false;
+                               unsigned int bitmask = 0, record = 0;
+                               bool show = false, match = false;
                                in_addr resultip;
 
-                               /* Convert the result to an in_addr (we can gaurantee we got ipv4)
-                                * Whoever did the loop that was here before, I AM CONFISCATING
-                                * YOUR CRACKPIPE. you know who you are. -- Brain
-                                */
                                inet_aton(result.c_str(), &resultip);
-                               bitmask = resultip.s_addr >> 24; /* Last octet (network byte order */
 
-                               bitmask &= ConfEntry->bitmask;
+                               switch (ConfEntry->type)
+                               {
+                                       case DNSBLConfEntry::A_BITMASK:
+                                               bitmask = resultip.s_addr >> 24; /* Last octet (network byte order) */
+                                               bitmask &= ConfEntry->bitmask;
+                                               match = (bitmask != 0);
+                                       break;
+                                       case DNSBLConfEntry::A_RECORD:
+                                               record = resultip.s_addr >> 24; /* Last octet */
+                                               match = (ConfEntry->records[record] == 1);
+                                       break;
+                               }
 
-                               if (bitmask != 0)
+                               if (match)
                                {
                                        std::string reason = ConfEntry->reason;
                                        std::string::size_type x = reason.find("%ip%");
@@ -98,7 +108,7 @@ class DNSBLResolver : public Resolver
                                        {
                                                case DNSBLConfEntry::I_KILL:
                                                {
-                                                       userrec::QuitUser(ServerInstance, them, std::string("Killed (") + reason + ")");
+                                                       User::QuitUser(ServerInstance, them, std::string("Killed (") + reason + ")");
                                                        break;
                                                }
                                                case DNSBLConfEntry::I_KLINE:
@@ -222,9 +232,26 @@ class ModuleDNSBL : public Module
                        e->name = MyConf->ReadValue("dnsbl", "name", i);
                        e->reason = MyConf->ReadValue("dnsbl", "reason", i);
                        e->domain = MyConf->ReadValue("dnsbl", "domain", i);
+
+                       if (MyConf->ReadValue("dnsbl", "type", i) == "bitmask")
+                       {
+                               e->type = DNSBLConfEntry::A_BITMASK;
+                               e->bitmask = MyConf->ReadInteger("dnsbl", "bitmask", i, false);
+                       }
+                       else
+                       {
+                               memset(e->records, 0, 256);
+                               e->type = DNSBLConfEntry::A_RECORD;
+                               irc::portparser portrange(MyConf->ReadValue("dnsbl", "records", i), false);
+                               long item = -1;
+                               while ((item = portrange.GetToken()))
+                                       e->records[item] = 1;
+                       }
+
                        e->banaction = str2banaction(MyConf->ReadValue("dnsbl", "action", i));
                        e->duration = ServerInstance->Duration(MyConf->ReadValue("dnsbl", "duration", i));
-                       e->bitmask = MyConf->ReadInteger("dnsbl", "bitmask", i, false);
+                       
+                       /* Use portparser for record replies */
 
                        /* yeah, logic here is a little messy */
                        if (e->bitmask <= 0)
@@ -263,12 +290,12 @@ class ModuleDNSBL : public Module
                delete MyConf;
        }
 
-       virtual void OnRehash(userrec* user, const std::string &parameter)
+       virtual void OnRehash(User* user, const std::string &parameter)
        {
                ReadConf();
        }
 
-       virtual int OnUserRegister(userrec* user)
+       virtual int OnUserRegister(User* user)
        {
                /* only do lookups on local users */
                if (IS_LOCAL(user))
@@ -327,7 +354,7 @@ class ModuleDNSBL : public Module
                return 0;
        }
        
-       virtual int OnStats(char symbol, userrec* user, string_list &results)
+       virtual int OnStats(char symbol, User* user, string_list &results)
        {
                if (symbol != 'd')
                        return 0;