InspSocket -> BufferedSocket. Paves the way for a SimpleSocket class which ident...

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

diff --git a/src/mode.cpp b/src/mode.cpp
index db120cfe587a59be26b676815fbc44f4002b8f90..1f6cc08b9c5bb28e47665dfa56da72f07a4ee62b 100644 (file)
--- a/src/mode.cpp
+++ b/src/mode.cpp
@@ -12,10 +12,7 @@
  */
 
 #include "inspircd.h"
-#include "users.h"
-#include "modules.h"
 #include "inspstring.h"
-#include "mode.h"
 
 /* +s (secret) */
 #include "modes/cmode_s.h"
@@ -79,6 +76,7 @@ unsigned int ModeHandler::GetCount()
 void ModeHandler::ChangeCount(int modifier)
 {
        count += modifier;
+       ServerInstance->Log(DEBUG,"Change count for mode %c is now %d", mode, count);
 }
 
 ModeType ModeHandler::GetModeType()
@@ -106,12 +104,12 @@ char ModeHandler::GetModeChar()
        return mode;
 }
 
-ModeAction ModeHandler::OnModeChange(userrec* source, userrec* dest, chanrec* channel, std::string &parameter, bool adding)
+ModeAction ModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
 {
        return MODEACTION_DENY;
 }
 
-ModePair ModeHandler::ModeSet(userrec* source, userrec* dest, chanrec* channel, const std::string &parameter)
+ModePair ModeHandler::ModeSet(User* source, User* dest, Channel* channel, const std::string &parameter)
 {
        if (dest)
        {
@@ -123,11 +121,15 @@ ModePair ModeHandler::ModeSet(userrec* source, userrec* dest, chanrec* channel,
        }
 }
 
-void ModeHandler::DisplayList(userrec* user, chanrec* channel)
+void ModeHandler::DisplayList(User* user, Channel* channel)
 {
 }
 
-bool ModeHandler::CheckTimeStamp(time_t theirs, time_t ours, const std::string &their_param, const std::string &our_param, chanrec* channel)
+void ModeHandler::DisplayEmptyList(User* user, Channel* channel)
+{
+}
+
+bool ModeHandler::CheckTimeStamp(time_t theirs, time_t ours, const std::string &their_param, const std::string &our_param, Channel* channel)
 {
        return (ours < theirs);
 }
@@ -150,18 +152,18 @@ ModeType ModeWatcher::GetModeType()
        return m_type;
 }
 
-bool ModeWatcher::BeforeMode(userrec* source, userrec* dest, chanrec* channel, std::string &parameter, bool adding, ModeType type)
+bool ModeWatcher::BeforeMode(User* source, User* dest, Channel* channel, std::string &parameter, bool adding, ModeType type)
 {
        return true;
 }
 
-void ModeWatcher::AfterMode(userrec* source, userrec* dest, chanrec* channel, const std::string &parameter, bool adding, ModeType type)
+void ModeWatcher::AfterMode(User* source, User* dest, Channel* channel, const std::string &parameter, bool adding, ModeType type)
 {
 }
 
-userrec* ModeParser::SanityChecks(userrec *user,const char *dest,chanrec *chan,int status)
+User* ModeParser::SanityChecks(User *user,const char *dest,Channel *chan,int status)
 {
-       userrec *d;
+       User *d;
        if ((!user) || (!dest) || (!chan) || (!*dest))
        {
                return NULL;
@@ -175,7 +177,7 @@ userrec* ModeParser::SanityChecks(userrec *user,const char *dest,chanrec *chan,i
        return d;
 }
 
-const char* ModeParser::Grant(userrec *d,chanrec *chan,int MASK)
+const char* ModeParser::Grant(User *d,Channel *chan,int MASK)
 {
        if (!chan)
                return "";
@@ -205,7 +207,7 @@ const char* ModeParser::Grant(userrec *d,chanrec *chan,int MASK)
        return "";
 }
 
-const char* ModeParser::Revoke(userrec *d,chanrec *chan,int MASK)
+const char* ModeParser::Revoke(User *d,Channel *chan,int MASK)
 {
        if (!chan)
                return "";
@@ -235,7 +237,7 @@ const char* ModeParser::Revoke(userrec *d,chanrec *chan,int MASK)
        return "";
 }
 
-void ModeParser::DisplayCurrentModes(userrec *user, userrec* targetuser, chanrec* targetchannel, const char* text)
+void ModeParser::DisplayCurrentModes(User *user, User* targetuser, Channel* targetchannel, const char* text)
 {
        if (targetchannel)
        {
@@ -272,13 +274,13 @@ void ModeParser::DisplayCurrentModes(userrec *user, userrec* targetuser, chanrec
        return;
 }
 
-void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool servermode)
+void ModeParser::Process(const char** parameters, int pcnt, User *user, bool servermode)
 {
        std::string target = parameters[0];
        ModeType type = MODETYPE_USER;
        unsigned char mask = 0;
-       chanrec* targetchannel = ServerInstance->FindChan(parameters[0]);
-       userrec* targetuser  = ServerInstance->FindNick(parameters[0]);
+       Channel* targetchannel = ServerInstance->FindChan(parameters[0]);
+       User* targetuser  = ServerInstance->FindNick(parameters[0]);
 
        LastParse.clear();
 
@@ -326,6 +328,7 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
                                if (ServerInstance->Config->HideModeLists[mletter] && (targetchannel->GetStatus(user) < STATUS_HOP))
                                {
                                        user->WriteServ("482 %s %s :Only half-operators and above may view the +%c list",user->nick, targetchannel->name, *mode++);
+                                       mh->DisplayEmptyList(user, targetchannel);
                                        continue;
                                }
 
@@ -564,6 +567,8 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
                                                                /* Add the mode letter */
                                                                output_sequence.push_back(modechar);
 
+                                                               modehandlers[handler_id]->ChangeCount(adding ? 1 : -1);
+
                                                                /* Is there a valid parameter for this mode? If so add it to the parameter list */
                                                                if ((modehandlers[handler_id]->GetNumParams(adding)) && (!parameter.empty()))
                                                                {
@@ -572,7 +577,7 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
                                                                        /* Does this mode have a prefix? */
                                                                        if (modehandlers[handler_id]->GetPrefix() && targetchannel)
                                                                        {
-                                                                               userrec* user_to_prefix = ServerInstance->FindNick(parameter);
+                                                                               User* user_to_prefix = ServerInstance->FindNick(parameter);
                                                                                if (user_to_prefix)
                                                                                        targetchannel->SetPrefix(user_to_prefix, modehandlers[handler_id]->GetPrefix(),
                                                                                                        modehandlers[handler_id]->GetPrefixRank(), adding);
@@ -599,7 +604,7 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
                                        else
                                        {
                                                /* No mode handler? Unknown mode character then. */
-                                               user->WriteServ("472 %s %c :is unknown mode char to me",user->nick, modechar);
+                                               user->WriteServ("%d %s %c :is unknown mode char to me", type == MODETYPE_CHANNEL ? 472 : 501, user->nick, modechar);
                                        }
                                break;
                        }
@@ -828,7 +833,7 @@ ModeHandler* ModeParser::FindPrefix(unsigned const char pfxletter)
        return NULL;
 }
 
-std::string ModeParser::ModeString(userrec* user, chanrec* channel)
+std::string ModeParser::ModeString(User* user, Channel* channel)
 {
        std::string types;
        std::string pars;
@@ -991,7 +996,7 @@ bool ModeParser::DelModeWatcher(ModeWatcher* mw)
 
 /** This default implementation can remove simple user modes
  */
-void ModeHandler::RemoveMode(userrec* user)
+void ModeHandler::RemoveMode(User* user)
 {
        char moderemove[MAXBUF];
        const char* parameters[] = { user->nick, moderemove };
@@ -1006,21 +1011,15 @@ void ModeHandler::RemoveMode(userrec* user)
 /** This default implementation can remove simple channel modes
  * (no parameters)
  */
-void ModeHandler::RemoveMode(chanrec* channel)
+void ModeHandler::RemoveMode(Channel* channel)
 {
        char moderemove[MAXBUF];
        const char* parameters[] = { channel->name, moderemove };
 
        if (channel->IsModeSet(this->GetModeChar()))
        {
-               userrec* n = new userrec(ServerInstance);
-
                sprintf(moderemove,"-%c",this->GetModeChar());
-               n->SetFd(FD_MAGIC_NUMBER);
-
-               ServerInstance->SendMode(parameters, 2, n);
-
-               delete n;
+               ServerInstance->SendMode(parameters, 2, ServerInstance->FakeClient);
        }
 }