Port bindings for gnutls now bind via ip:port, rather than on all ports for that...

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

diff --git a/src/users.cpp b/src/users.cpp
index 5724e9eab44e27b0db30a9b3d1014f96b8c67628..f8a95af49a195197042218fb16176f955030c39d 100644 (file)
--- a/src/users.cpp
+++ b/src/users.cpp
@@ -193,6 +193,9 @@ User::User(InspIRCd* Instance, const std::string &uid) : ServerInstance(Instance
        Visibility = NULL;
        ip = NULL;
        MyClass = NULL;
+       io = NULL;
+       AllowedUserModes = NULL;
+       AllowedChanModes = NULL;
        AllowedOperCommands = NULL;
        chans.clear();
        invites.clear();
@@ -229,6 +232,18 @@ User::~User()
                AllowedOperCommands = NULL;
        }
 
+       if (this->AllowedUserModes)
+       {
+               delete[] AllowedUserModes;
+               AllowedUserModes = NULL;
+       }
+
+       if (this->AllowedChanModes)
+       {
+               delete[] AllowedChanModes;
+               AllowedChanModes = NULL;
+       }
+
        this->InvalidateCache();
        this->DecrementModes();
 
@@ -437,6 +452,21 @@ void User::RemoveInvite(const irc::string &channel)
        }
 }
 
+bool User::HasModePermission(unsigned char mode, ModeType type)
+{
+       if (!IS_LOCAL(this))
+               return true;
+
+       if (!IS_OPER(this))
+               return false;
+
+       if (!AllowedUserModes || !AllowedChanModes)
+               return false;
+
+       return ((type == MODETYPE_USER ? AllowedUserModes : AllowedChanModes))[(mode - 'A')];
+       
+}
+
 bool User::HasPermission(const std::string &command)
 {
        /*
@@ -669,6 +699,15 @@ void User::Oper(const std::string &opertype, const std::string &opername)
                        else
                                AllowedOperCommands = new std::map<std::string, bool>;
 
+                       if (!AllowedChanModes)
+                               AllowedChanModes = new bool[64];
+
+                       if (!AllowedUserModes)
+                               AllowedUserModes = new bool[64];
+
+                       memset(AllowedUserModes, 0, 64);
+                       memset(AllowedChanModes, 0, 64);
+
                        char* Classes = strdup(iter_opertype->second);
                        char* myclass = strtok_r(Classes," ",&savept);
                        while (myclass)
@@ -676,7 +715,7 @@ void User::Oper(const std::string &opertype, const std::string &opername)
                                operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass);
                                if (iter_operclass != ServerInstance->Config->operclass.end())
                                {
-                                       char* CommandList = strdup(iter_operclass->second);
+                                       char* CommandList = strdup(iter_operclass->second.commandlist);
                                        mycmd = strtok_r(CommandList," ",&savept2);
                                        while (mycmd)
                                        {
@@ -684,6 +723,29 @@ void User::Oper(const std::string &opertype, const std::string &opername)
                                                mycmd = strtok_r(NULL," ",&savept2);
                                        }
                                        free(CommandList);
+                                       this->AllowedUserModes['o' - 'A'] = true; // Call me paranoid if you want.
+                                       for (unsigned char* c = (unsigned char*)iter_operclass->second.umodelist; *c; ++c)
+                                       {
+                                               if (*c == '*')
+                                               {
+                                                       memset(this->AllowedUserModes, (int)(true), 64);
+                                               }
+                                               else
+                                               {
+                                                       this->AllowedUserModes[*c - 'A'] = true;
+                                               }
+                                       }
+                                       for (unsigned char* c = (unsigned char*)iter_operclass->second.cmodelist; *c; ++c)
+                                       {
+                                               if (*c == '*')
+                                               {
+                                                       memset(this->AllowedChanModes, (int)(true), 64);
+                                               }
+                                               else
+                                               {
+                                                       this->AllowedChanModes[*c - 'A'] = true;
+                                               }
+                                       }
                                }
                                myclass = strtok_r(NULL," ",&savept);
                        }
@@ -731,6 +793,17 @@ void User::UnOper()
                        delete AllowedOperCommands;
                        AllowedOperCommands = NULL;
                }
+               if (AllowedUserModes)
+               {
+                       delete[] AllowedUserModes;
+                       AllowedUserModes = NULL;
+               }
+               if (AllowedChanModes)
+               {
+                       delete[] AllowedChanModes;
+                       AllowedChanModes = NULL;
+               }
+
        }
 }
 
@@ -1093,14 +1166,14 @@ void User::Write(std::string text)
                return;
        }
 
-       if (ServerInstance->Config->GetIOHook(this->GetPort()))
+       if (this->io)
        {
                /* XXX: The lack of buffering here is NOT a bug, modules implementing this interface have to
                 * implement their own buffering mechanisms
                 */
                try
                {
-                       ServerInstance->Config->GetIOHook(this->GetPort())->OnRawSocketWrite(this->fd, text.data(), text.length());
+                       this->io->OnRawSocketWrite(this->fd, text.data(), text.length());
                }
                catch (CoreException& modexcept)
                {