#include "inspircd.h"
#include "core_channel.h"
#include "invite.h"
+#include "listmode.h"
class CoreModChannel : public Module, public CheckExemption::EventListener
{
CommandKick cmdkick;
CommandNames cmdnames;
CommandTopic cmdtopic;
+
+ ModeChannelBan banmode;
+ SimpleChannelModeHandler inviteonlymode;
+ ModeChannelKey keymode;
+ ModeChannelLimit limitmode;
+ SimpleChannelModeHandler moderatedmode;
+ SimpleChannelModeHandler noextmsgmode;
+ ModeChannelOp opmode;
+ SimpleChannelModeHandler privatemode;
+ SimpleChannelModeHandler secretmode;
+ SimpleChannelModeHandler topiclockmode;
+ ModeChannelVoice voicemode;
+
insp::flat_map<std::string, char> exemptions;
ModResult IsInvited(User* user, Channel* chan)
, cmdkick(this)
, cmdnames(this)
, cmdtopic(this)
+ , banmode(this)
+ , inviteonlymode(this, "inviteonly", 'i')
+ , keymode(this)
+ , limitmode(this)
+ , moderatedmode(this, "moderated", 'm')
+ , noextmsgmode(this, "noextmsg", 'n')
+ , opmode(this)
+ , privatemode(this, "private", 'p')
+ , secretmode(this, "secret", 's')
+ , topiclockmode(this, "topiclock", 't')
+ , voicemode(this)
{
}
exempts[restriction] = prefix;
}
exemptions.swap(exempts);
+
+ // In 2.0 we allowed limits of 0 to be set. This is non-standard behaviour
+ // and will be removed in the next major release.
+ limitmode.minlimit = optionstag->getBool("allowzerolimit", true) ? 0 : 1;
+
+ banmode.DoRehash();
+ }
+
+ void On005Numeric(std::map<std::string, std::string>& tokens) CXX11_OVERRIDE
+ {
+ tokens["KEYLEN"] = ConvToStr(ModeChannelKey::maxkeylen);
+
+ // Build a map of limits to their mode character.
+ insp::flat_map<int, std::string> limits;
+ const ModeParser::ListModeList& listmodes = ServerInstance->Modes->GetListModes();
+ for (ModeParser::ListModeList::const_iterator iter = listmodes.begin(); iter != listmodes.end(); ++iter)
+ {
+ const unsigned int limit = (*iter)->GetLowerLimit();
+ limits[limit].push_back((*iter)->GetModeChar());
+ }
+
+ // Generate the MAXLIST token from the limits map.
+ std::string& buffer = tokens["MAXLIST"];
+ for (insp::flat_map<int, std::string>::const_iterator iter = limits.begin(); iter != limits.end(); ++iter)
+ {
+ if (!buffer.empty())
+ buffer.push_back(',');
+
+ buffer.append(iter->second);
+ buffer.push_back(':');
+ buffer.append(ConvToStr(iter->first));
+ }
+ }
+
+ ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string&, std::string&, const std::string& keygiven) CXX11_OVERRIDE
+ {
+ if (!chan)
+ return MOD_RES_PASSTHRU;
+
+ // Check whether the channel key is correct.
+ const std::string ckey = chan->GetModeParameter(&keymode);
+ if (!ckey.empty())
+ {
+ ModResult MOD_RESULT;
+ FIRST_MOD_RESULT(OnCheckKey, MOD_RESULT, (user, chan, keygiven));
+ if (!MOD_RESULT.check(InspIRCd::TimingSafeCompare(ckey, keygiven)))
+ {
+ // If no key provided, or key is not the right one, and can't bypass +k (not invited or option not enabled)
+ user->WriteNumeric(ERR_BADCHANNELKEY, chan->name, "Cannot join channel (Incorrect channel key)");
+ return MOD_RES_DENY;
+ }
+ }
+
+ // Check whether the invite only mode is set.
+ if (chan->IsModeSet(inviteonlymode))
+ {
+ ModResult MOD_RESULT;
+ FIRST_MOD_RESULT(OnCheckInvite, MOD_RESULT, (user, chan));
+ if (MOD_RESULT != MOD_RES_ALLOW)
+ {
+ user->WriteNumeric(ERR_INVITEONLYCHAN, chan->name, "Cannot join channel (Invite only)");
+ return MOD_RES_DENY;
+ }
+ }
+
+ // Check whether the limit would be exceeded by this user joining.
+ if (chan->IsModeSet(limitmode))
+ {
+ ModResult MOD_RESULT;
+ FIRST_MOD_RESULT(OnCheckLimit, MOD_RESULT, (user, chan));
+ if (!MOD_RESULT.check(chan->GetUserCounter() < static_cast<size_t>(limitmode.ext.get(chan))))
+ {
+ user->WriteNumeric(ERR_CHANNELISFULL, chan->name, "Cannot join channel (Channel is full)");
+ return MOD_RES_DENY;
+ }
+ }
+
+ // Everything looks okay.
+ return MOD_RES_PASSTHRU;
}
void OnPostJoin(Membership* memb) CXX11_OVERRIDE
// Remove existing invite, if any
invapi.Remove(localuser, chan);
- if (chan->topicset)
+ if (chan->topic.length())
Topic::ShowTopic(localuser, chan);
// Show all members of the channel, including invisible (+i) users