Replace large if/else blocks for target.type with switches (#1668).

diff --git a/src/modules/m_deaf.cpp b/src/modules/m_deaf.cpp
index 90412c5c1201d67e0256836e542ed0010f6504bf..e360e2a2e6a117cb320423e57dc3f22ebf4eb78c 100644 (file)
--- a/src/modules/m_deaf.cpp
+++ b/src/modules/m_deaf.cpp
@@ -89,50 +89,58 @@ class ModuleDeaf : public Module
 
        ModResult OnUserPreMessage(User* user, const MessageTarget& target, MessageDetails& details) CXX11_OVERRIDE
        {
-               if (target.type == MessageTarget::TYPE_CHANNEL)
+               switch (target.type)
                {
-                       Channel* chan = target.Get<Channel>();
-                       bool is_bypasschar = (deaf_bypasschars.find(details.text[0]) != std::string::npos);
-                       bool is_bypasschar_uline = (deaf_bypasschars_uline.find(details.text[0]) != std::string::npos);
-
-                       // If we have no bypasschars_uline in config, and this is a bypasschar (regular)
-                       // Then it is obviously going to get through +d, no exemption list required
-                       if (deaf_bypasschars_uline.empty() && is_bypasschar)
-                               return MOD_RES_PASSTHRU;
-                       // If it matches both bypasschar and bypasschar_uline, it will get through.
-                       if (is_bypasschar && is_bypasschar_uline)
-                               return MOD_RES_PASSTHRU;
-
-                       const Channel::MemberMap& ulist = chan->GetUsers();
-                       for (Channel::MemberMap::const_iterator i = ulist.begin(); i != ulist.end(); ++i)
+                       case MessageTarget::TYPE_CHANNEL:
                        {
-                               // not +d
-                               if (!i->first->IsModeSet(deafmode))
-                                       continue;
-
-                               bool is_a_uline = i->first->server->IsULine();
-                               // matched a U-line only bypass
-                               if (is_bypasschar_uline && is_a_uline)
-                                       continue;
-                               // matched a regular bypass
-                               if (is_bypasschar && !is_a_uline)
-                                       continue;
-
-                               // don't deliver message!
-                               details.exemptions.insert(i->first);
+                               Channel* chan = target.Get<Channel>();
+                               bool is_bypasschar = (deaf_bypasschars.find(details.text[0]) != std::string::npos);
+                               bool is_bypasschar_uline = (deaf_bypasschars_uline.find(details.text[0]) != std::string::npos);
+
+                               // If we have no bypasschars_uline in config, and this is a bypasschar (regular)
+                               // Then it is obviously going to get through +d, no exemption list required
+                               if (deaf_bypasschars_uline.empty() && is_bypasschar)
+                                       return MOD_RES_PASSTHRU;
+                               // If it matches both bypasschar and bypasschar_uline, it will get through.
+                               if (is_bypasschar && is_bypasschar_uline)
+                                       return MOD_RES_PASSTHRU;
+
+                               const Channel::MemberMap& ulist = chan->GetUsers();
+                               for (Channel::MemberMap::const_iterator i = ulist.begin(); i != ulist.end(); ++i)
+                               {
+                                       // not +d
+                                       if (!i->first->IsModeSet(deafmode))
+                                               continue;
+
+                                       bool is_a_uline = i->first->server->IsULine();
+                                       // matched a U-line only bypass
+                                       if (is_bypasschar_uline && is_a_uline)
+                                               continue;
+                                       // matched a regular bypass
+                                       if (is_bypasschar && !is_a_uline)
+                                               continue;
+
+                                       // don't deliver message!
+                                       details.exemptions.insert(i->first);
+                               }
+                               break;
                        }
-               }
-               else if (target.type == MessageTarget::TYPE_USER)
-               {
-                       User* targ = target.Get<User>();
-                       if (!targ->IsModeSet(privdeafmode))
-                               return MOD_RES_PASSTHRU;
+                       case MessageTarget::TYPE_USER:
+                       {
+                               User* targ = target.Get<User>();
+                               if (!targ->IsModeSet(privdeafmode))
+                                       return MOD_RES_PASSTHRU;
 
-                       if (!privdeafuline && user->server->IsULine())
-                               return MOD_RES_DENY;
+                               if (!privdeafuline && user->server->IsULine())
+                                       return MOD_RES_DENY;
 
-                       if (!user->HasPrivPermission("users/ignore-privdeaf"))
-                               return MOD_RES_DENY;
+                               if (!user->HasPrivPermission("users/ignore-privdeaf"))
+                                       return MOD_RES_DENY;
+
+                               break;
+                       }
+                       case MessageTarget::TYPE_SERVER:
+                               break;
                }
 
                return MOD_RES_PASSTHRU;

diff --git a/src/modules/m_filter.cpp b/src/modules/m_filter.cpp
index 8e51fd6835922b497a61513186747bcb49efb7d8..e7aab2eeb9dad4ba6d0d2f48073bcc6d9da3c850 100644 (file)
--- a/src/modules/m_filter.cpp
+++ b/src/modules/m_filter.cpp
@@ -372,25 +372,32 @@ ModResult ModuleFilter::OnUserPreMessage(User* user, const MessageTarget& msgtar
        {
                bool is_selfmsg = false;
                std::string target;
-               if (msgtarget.type == MessageTarget::TYPE_USER)
+               switch (msgtarget.type)
                {
-                       User* t = msgtarget.Get<User>();
-                       // Check if the target nick is exempted, if yes, ignore this message
-                       if (exemptednicks.count(t->nick))
-                               return MOD_RES_PASSTHRU;
+                       case MessageTarget::TYPE_USER:
+                       {
+                               User* t = msgtarget.Get<User>();
+                               // Check if the target nick is exempted, if yes, ignore this message
+                               if (exemptednicks.count(t->nick))
+                                       return MOD_RES_PASSTHRU;
 
-                       if (user == t)
-                               is_selfmsg = true;
+                               if (user == t)
+                                       is_selfmsg = true;
 
-                       target = t->nick;
-               }
-               else if (msgtarget.type == MessageTarget::TYPE_CHANNEL)
-               {
-                       Channel* t = msgtarget.Get<Channel>();
-                       if (exemptedchans.count(t->name))
-                               return MOD_RES_PASSTHRU;
+                               target = t->nick;
+                               break;
+                       }
+                       case MessageTarget::TYPE_CHANNEL:
+                       {
+                               Channel* t = msgtarget.Get<Channel>();
+                               if (exemptedchans.count(t->name))
+                                       return MOD_RES_PASSTHRU;
 
-                       target = t->name;
+                               target = t->name;
+                               break;
+                       }
+                       case MessageTarget::TYPE_SERVER:
+                               break;
                }
 
                if (is_selfmsg && warnonselfmsg)

diff --git a/src/modules/m_ircv3_echomessage.cpp b/src/modules/m_ircv3_echomessage.cpp
index 3ec534e916725dd7359009e8abe992d49368754a..8f281da709342f64e8426574caeb5ad6e5e4e91d 100644 (file)
--- a/src/modules/m_ircv3_echomessage.cpp
+++ b/src/modules/m_ircv3_echomessage.cpp
@@ -48,26 +48,32 @@ class ModuleIRCv3EchoMessage
 
                const std::string& text = details.echo_original ? details.original_text : details.text;
                const ClientProtocol::TagMap& tags = details.echo_original ? details.tags_in : details.tags_out;
-               if (target.type == MessageTarget::TYPE_USER)
+               switch (target.type)
                {
-                       User* destuser = target.Get<User>();
-                       ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, destuser, text, details.type);
-                       privmsg.AddTags(tags);
-                       localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg);
-               }
-               else if (target.type == MessageTarget::TYPE_CHANNEL)
-               {
-                       Channel* chan = target.Get<Channel>();
-                       ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, chan, text, details.type, target.status);
-                       privmsg.AddTags(tags);
-                       localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg);
-               }
-               else
-               {
-                       const std::string* servername = target.Get<std::string>();
-                       ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, *servername, text, details.type);
-                       privmsg.AddTags(tags);
-                       localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg);
+                       case MessageTarget::TYPE_USER:
+                       {
+                               User* destuser = target.Get<User>();
+                               ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, destuser, text, details.type);
+                               privmsg.AddTags(tags);
+                               localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg);
+                               break;
+                       }
+                       case MessageTarget::TYPE_CHANNEL:
+                       {
+                               Channel* chan = target.Get<Channel>();
+                               ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, chan, text, details.type, target.status);
+                               privmsg.AddTags(tags);
+                               localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg);
+                               break;
+                       }
+                       case MessageTarget::TYPE_SERVER:
+                       {
+                               const std::string* servername = target.Get<std::string>();
+                               ClientProtocol::Messages::Privmsg privmsg(ClientProtocol::Messages::Privmsg::nocopy, user, *servername, text, details.type);
+                               privmsg.AddTags(tags);
+                               localuser->Send(ServerInstance->GetRFCEvents().privmsg, privmsg);
+                               break;
+                       }
                }
        }
 
@@ -80,23 +86,29 @@ class ModuleIRCv3EchoMessage
                LocalUser* const localuser = static_cast<LocalUser*>(user);
 
                const ClientProtocol::TagMap& tags = details.echo_original ? details.tags_in : details.tags_out;
-               if (target.type == MessageTarget::TYPE_USER)
-               {
-                       User* destuser = target.Get<User>();
-                       CTCTags::TagMessage message(user, destuser, tags);
-                       localuser->Send(tagmsgprov, message);
-               }
-               else if (target.type == MessageTarget::TYPE_CHANNEL)
-               {
-                       Channel* chan = target.Get<Channel>();
-                       CTCTags::TagMessage message(user, chan, tags);
-                       localuser->Send(tagmsgprov, message);
-               }
-               else
+               switch (target.type)
                {
-                       const std::string* servername = target.Get<std::string>();
-                       CTCTags::TagMessage message(user, servername->c_str(), tags);
-                       localuser->Send(tagmsgprov, message);
+                       case MessageTarget::TYPE_USER:
+                       {
+                               User* destuser = target.Get<User>();
+                               CTCTags::TagMessage message(user, destuser, tags);
+                               localuser->Send(tagmsgprov, message);
+                               break;
+                       }
+                       case MessageTarget::TYPE_CHANNEL:
+                       {
+                               Channel* chan = target.Get<Channel>();
+                               CTCTags::TagMessage message(user, chan, tags);
+                               localuser->Send(tagmsgprov, message);
+                               break;
+                       }
+                       case MessageTarget::TYPE_SERVER:
+                       {
+                               const std::string* servername = target.Get<std::string>();
+                               CTCTags::TagMessage message(user, servername->c_str(), tags);
+                               localuser->Send(tagmsgprov, message);
+                               break;
+                       }
                }
        }
 

diff --git a/src/modules/m_noctcp.cpp b/src/modules/m_noctcp.cpp
index c73f8308e08005e1fbb25010d065f942a4263ae7..f288820b8b12f3b1e238274a9db550f32b2cfb22 100644 (file)
--- a/src/modules/m_noctcp.cpp
+++ b/src/modules/m_noctcp.cpp
@@ -61,33 +61,40 @@ class ModuleNoCTCP : public Module
                if (!details.IsCTCP(ctcpname) || irc::equals(ctcpname, "ACTION"))
                        return MOD_RES_PASSTHRU;
 
-               if (target.type == MessageTarget::TYPE_CHANNEL)
+               switch (target.type)
                {
-                       if (user->HasPrivPermission("channels/ignore-noctcp"))
-                               return MOD_RES_PASSTHRU;
+                       case MessageTarget::TYPE_CHANNEL:
+                       {
+                               if (user->HasPrivPermission("channels/ignore-noctcp"))
+                                       return MOD_RES_PASSTHRU;
 
-                       Channel* c = target.Get<Channel>();
-                       ModResult res = CheckExemption::Call(exemptionprov, user, c, "noctcp");
-                       if (res == MOD_RES_ALLOW)
-                               return MOD_RES_PASSTHRU;
+                               Channel* c = target.Get<Channel>();
+                               ModResult res = CheckExemption::Call(exemptionprov, user, c, "noctcp");
+                               if (res == MOD_RES_ALLOW)
+                                       return MOD_RES_PASSTHRU;
 
-                       if (!c->GetExtBanStatus(user, 'C').check(!c->IsModeSet(nc)))
-                       {
-                               user->WriteNumeric(ERR_CANNOTSENDTOCHAN, c->name, "Can't send CTCP to channel (+C is set)");
-                               return MOD_RES_DENY;
+                               if (!c->GetExtBanStatus(user, 'C').check(!c->IsModeSet(nc)))
+                               {
+                                       user->WriteNumeric(ERR_CANNOTSENDTOCHAN, c->name, "Can't send CTCP to channel (+C is set)");
+                                       return MOD_RES_DENY;
+                               }
+                               break;
                        }
-               }
-               else if (target.type == MessageTarget::TYPE_USER)
-               {
-                       if (user->HasPrivPermission("users/ignore-noctcp"))
-                               return MOD_RES_PASSTHRU;
-
-                       User* u = target.Get<User>();
-                       if (u->IsModeSet(ncu))
+                       case MessageTarget::TYPE_USER:
                        {
-                               user->WriteNumeric(ERR_CANTSENDTOUSER, u->nick, "Can't send CTCP to user (+T is set)");
-                               return MOD_RES_DENY;
+                               if (user->HasPrivPermission("users/ignore-noctcp"))
+                                       return MOD_RES_PASSTHRU;
+
+                               User* u = target.Get<User>();
+                               if (u->IsModeSet(ncu))
+                               {
+                                       user->WriteNumeric(ERR_CANTSENDTOUSER, u->nick, "Can't send CTCP to user (+T is set)");
+                                       return MOD_RES_DENY;
+                               }
+                               break;
                        }
+                       case MessageTarget::TYPE_SERVER:
+                               break;
                }
                return MOD_RES_PASSTHRU;
        }

diff --git a/src/modules/m_services_account.cpp b/src/modules/m_services_account.cpp
index 6e15aa8bf7dd138bc466ac9507b250350c4f0889..72cd925abea7037d39662cfde8d987fa49600b94 100644 (file)
--- a/src/modules/m_services_account.cpp
+++ b/src/modules/m_services_account.cpp
@@ -207,32 +207,39 @@ class ModuleServicesAccount
                std::string *account = accountname.get(user);
                bool is_registered = account && !account->empty();
 
-               if (target.type == MessageTarget::TYPE_CHANNEL)
+               switch (target.type)
                {
-                       Channel* targchan = target.Get<Channel>();
+                       case MessageTarget::TYPE_CHANNEL:
+                       {
+                               Channel* targchan = target.Get<Channel>();
 
-                       if (!targchan->IsModeSet(m2) || is_registered)
-                               return MOD_RES_PASSTHRU;
+                               if (!targchan->IsModeSet(m2) || is_registered)
+                                       return MOD_RES_PASSTHRU;
 
-                       if (CheckExemption::Call(exemptionprov, user, targchan, "regmoderated") == MOD_RES_ALLOW)
-                               return MOD_RES_PASSTHRU;
+                               if (CheckExemption::Call(exemptionprov, user, targchan, "regmoderated") == MOD_RES_ALLOW)
+                                       return MOD_RES_PASSTHRU;
 
-                       // User is messaging a +M channel and is not registered or exempt.
-                       user->WriteNumeric(ERR_NEEDREGGEDNICK, targchan->name, "You need to be identified to a registered account to message this channel");
-                       return MOD_RES_DENY;
-               }
-               else if (target.type == MessageTarget::TYPE_USER)
-               {
-                       User* targuser = target.Get<User>();
-                       if (!targuser->IsModeSet(m3)  || is_registered)
-                               return MOD_RES_PASSTHRU;
+                               // User is messaging a +M channel and is not registered or exempt.
+                               user->WriteNumeric(ERR_NEEDREGGEDNICK, targchan->name, "You need to be identified to a registered account to message this channel");
+                               return MOD_RES_DENY;
+                               break;
+                       }
+                       case MessageTarget::TYPE_USER:
+                       {
+                               User* targuser = target.Get<User>();
+                               if (!targuser->IsModeSet(m3)  || is_registered)
+                                       return MOD_RES_PASSTHRU;
 
-                       if (calleridapi && calleridapi->IsOnAcceptList(user, targuser))
-                               return MOD_RES_PASSTHRU;
+                               if (calleridapi && calleridapi->IsOnAcceptList(user, targuser))
+                                       return MOD_RES_PASSTHRU;
 
-                       // User is messaging a +R user and is not registered or on an accept list.
-                       user->WriteNumeric(ERR_NEEDREGGEDNICK, targuser->nick, "You need to be identified to a registered account to message this user");
-                       return MOD_RES_DENY;
+                               // User is messaging a +R user and is not registered or on an accept list.
+                               user->WriteNumeric(ERR_NEEDREGGEDNICK, targuser->nick, "You need to be identified to a registered account to message this user");
+                               return MOD_RES_DENY;
+                               break;
+                       }
+                       case MessageTarget::TYPE_SERVER:
+                               break;
                }
                return MOD_RES_PASSTHRU;
        }

diff --git a/src/modules/m_silence.cpp b/src/modules/m_silence.cpp
index 87b70dfa46451d6922f5b4397876ed0d2541d839..1e73bda27569b82cdf350d066d5f25a39892c4c8 100644 (file)
--- a/src/modules/m_silence.cpp
+++ b/src/modules/m_silence.cpp
@@ -384,32 +384,38 @@ class ModuleSilence
                bool is_ctcp = details.IsCTCP(ctcpname) && !irc::equals(ctcpname, "ACTION");
 
                SilenceEntry::SilenceFlags flag = SilenceEntry::SF_NONE;
-               if (target.type == MessageTarget::TYPE_CHANNEL)
-               {
-                       if (is_ctcp)
-                               flag = SilenceEntry::SF_CTCP_CHANNEL;
-                       else if (details.type == MSG_NOTICE)
-                               flag = SilenceEntry::SF_NOTICE_CHANNEL;
-                       else if (details.type == MSG_PRIVMSG)
-                               flag = SilenceEntry::SF_PRIVMSG_CHANNEL;
-
-                       return BuildChannelExempts(user, target.Get<Channel>(), flag, details.exemptions);
-               }
-
-               if (target.type == MessageTarget::TYPE_USER)
+               switch (target.type)
                {
-                       if (is_ctcp)
-                               flag = SilenceEntry::SF_CTCP_USER;
-                       else if (details.type == MSG_NOTICE)
-                               flag = SilenceEntry::SF_NOTICE_USER;
-                       else if (details.type == MSG_PRIVMSG)
-                               flag = SilenceEntry::SF_PRIVMSG_USER;
-
-                       if (!CanReceiveMessage(user, target.Get<User>(), flag))
+                       case MessageTarget::TYPE_CHANNEL:
+                       {
+                               if (is_ctcp)
+                                       flag = SilenceEntry::SF_CTCP_CHANNEL;
+                               else if (details.type == MSG_NOTICE)
+                                       flag = SilenceEntry::SF_NOTICE_CHANNEL;
+                               else if (details.type == MSG_PRIVMSG)
+                                       flag = SilenceEntry::SF_PRIVMSG_CHANNEL;
+
+                               return BuildChannelExempts(user, target.Get<Channel>(), flag, details.exemptions);
+                               break;
+                       }
+                       case MessageTarget::TYPE_USER:
                        {
-                               details.echo_original = true;
-                               return MOD_RES_DENY;
+                               if (is_ctcp)
+                                       flag = SilenceEntry::SF_CTCP_USER;
+                               else if (details.type == MSG_NOTICE)
+                                       flag = SilenceEntry::SF_NOTICE_USER;
+                               else if (details.type == MSG_PRIVMSG)
+                                       flag = SilenceEntry::SF_PRIVMSG_USER;
+
+                               if (!CanReceiveMessage(user, target.Get<User>(), flag))
+                               {
+                                       details.echo_original = true;
+                                       return MOD_RES_DENY;
+                               }
+                               break;
                        }
+                       case MessageTarget::TYPE_SERVER:
+                               break;
                }
 
                return MOD_RES_PASSTHRU;

diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp
index db526534425ec398e84aa3a69aa529828183473c..1a51955d160619d1d43066ab8c56920eba862180 100644 (file)
--- a/src/modules/m_spanningtree/main.cpp
+++ b/src/modules/m_spanningtree/main.cpp
@@ -392,30 +392,36 @@ void ModuleSpanningTree::OnUserPostMessage(User* user, const MessageTarget& targ
                return;
 
        const char* message_type = (details.type == MSG_PRIVMSG ? "PRIVMSG" : "NOTICE");
-       if (target.type == MessageTarget::TYPE_USER)
+       switch (target.type)
        {
-               User* d = target.Get<User>();
-               if (!IS_LOCAL(d))
+               case MessageTarget::TYPE_USER:
                {
-                       CmdBuilder params(user, message_type);
-                       params.push_tags(details.tags_out);
-                       params.push_back(d->uuid);
-                       params.push_last(details.text);
-                       params.Unicast(d);
+                       User* d = target.Get<User>();
+                       if (!IS_LOCAL(d))
+                       {
+                               CmdBuilder params(user, message_type);
+                               params.push_tags(details.tags_out);
+                               params.push_back(d->uuid);
+                               params.push_last(details.text);
+                               params.Unicast(d);
+                       }
+                       break;
+               }
+               case MessageTarget::TYPE_CHANNEL:
+               {
+                       Utils->SendChannelMessage(user->uuid, target.Get<Channel>(), details.text, target.status, details.tags_out, details.exemptions, message_type);
+                       break;
+               }
+               case MessageTarget::TYPE_SERVER:
+               {
+                       const std::string* serverglob = target.Get<std::string>();
+                       CmdBuilder par(user, message_type);
+                       par.push_tags(details.tags_out);
+                       par.push_back(*serverglob);
+                       par.push_last(details.text);
+                       par.Broadcast();
+                       break;
                }
-       }
-       else if (target.type == MessageTarget::TYPE_CHANNEL)
-       {
-               Utils->SendChannelMessage(user->uuid, target.Get<Channel>(), details.text, target.status, details.tags_out, details.exemptions, message_type);
-       }
-       else if (target.type == MessageTarget::TYPE_SERVER)
-       {
-               const std::string* serverglob = target.Get<std::string>();
-               CmdBuilder par(user, message_type);
-               par.push_tags(details.tags_out);
-               par.push_back(*serverglob);
-               par.push_last(details.text);
-               par.Broadcast();
        }
 }
 

diff --git a/src/modules/m_stripcolor.cpp b/src/modules/m_stripcolor.cpp
index 6ea279422e4f9b237d606e5c4640a5a3f5cc978f..a309492eb54250fbbf441c806751e35ee69ab9eb 100644 (file)
--- a/src/modules/m_stripcolor.cpp
+++ b/src/modules/m_stripcolor.cpp
@@ -47,20 +47,27 @@ class ModuleStripColor : public Module
                        return MOD_RES_PASSTHRU;
 
                bool active = false;
-               if (target.type == MessageTarget::TYPE_USER)
+               switch (target.type)
                {
-                       User* t = target.Get<User>();
-                       active = t->IsModeSet(usc);
-               }
-               else if (target.type == MessageTarget::TYPE_CHANNEL)
-               {
-                       Channel* t = target.Get<Channel>();
-                       ModResult res = CheckExemption::Call(exemptionprov, user, t, "stripcolor");
-
-                       if (res == MOD_RES_ALLOW)
-                               return MOD_RES_PASSTHRU;
-
-                       active = !t->GetExtBanStatus(user, 'S').check(!t->IsModeSet(csc));
+                       case MessageTarget::TYPE_USER:
+                       {
+                               User* t = target.Get<User>();
+                               active = t->IsModeSet(usc);
+                               break;
+                       }
+                       case MessageTarget::TYPE_CHANNEL:
+                       {
+                               Channel* t = target.Get<Channel>();
+                               ModResult res = CheckExemption::Call(exemptionprov, user, t, "stripcolor");
+
+                               if (res == MOD_RES_ALLOW)
+                                       return MOD_RES_PASSTHRU;
+
+                               active = !t->GetExtBanStatus(user, 'S').check(!t->IsModeSet(csc));
+                               break;
+                       }
+                       case MessageTarget::TYPE_SERVER:
+                               break;
                }
 
                if (active)