/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2011 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
#include "inspircd.h"
#include "builtin-modes.h"
ModeHandler::ModeHandler(Module* Creator, const std::string& Name, char modeletter, ParamSpec Params, ModeType type)
: ServiceProvider(Creator, Name, SERVICE_MODE), m_paramtype(TR_TEXT), parameters_taken(Params),
m_type(type), levelrequired(HALFOP_VALUE), mode(modeletter), prefix(0), oper(false),
fixed_letter(true), list(false), disabled(false)
{
}
CullResult ModeHandler::cull()
{
if (ServerInstance->Modes)
ServerInstance->Modes->DelMode(this);
return classbase::cull();
}
ModeHandler::~ModeHandler()
{
if (ServerInstance && ServerInstance->Modes && ServerInstance->Modes->FindMode(mode, m_type) == this)
ServerInstance->Logs->Log("MODE", DEFAULT, "ERROR: Destructor for mode %c called while still registered", mode);
}
bool ModeHandler::IsListMode()
{
return list;
}
unsigned int ModeHandler::GetPrefixRank()
{
return 0;
}
void ModeHandler::AdjustModeChar(char proposed_letter)
{
if (fixed_letter)
return;
mode = proposed_letter;
}
int ModeHandler::GetNumParams(bool adding)
{
switch (parameters_taken)
{
case PARAM_ALWAYS:
return 1;
case PARAM_SETONLY:
return adding ? 1 : 0;
case PARAM_NONE:
break;
}
return 0;
}
std::string ModeHandler::GetUserParameter(User* user)
{
return "";
}
void ModeHandler::AccessCheck(ModePermissionData&)
{
}
void ModeHandler::DisplayList(User*, Channel*)
{
}
void ModeHandler::DisplayEmptyList(User*, Channel*)
{
}
void ModeHandler::OnParameterMissing(User* user, User* dest, Channel* channel, std::string& param)
{
}
bool ModeHandler::ParamOrder(const std::string& theirs, const std::string& ours)
{
return (theirs < ours);
}
ModeAction SimpleUserModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
if (adding)
{
if (!dest->IsModeSet(this->GetModeChar()))
{
dest->SetMode(this->GetModeChar(),true);
return MODEACTION_ALLOW;
}
}
else
{
if (dest->IsModeSet(this->GetModeChar()))
{
dest->SetMode(this->GetModeChar(),false);
return MODEACTION_ALLOW;
}
}
return MODEACTION_DENY;
}
ModeAction SimpleChannelModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
if (adding)
{
if (!channel->IsModeSet(this))
{
channel->SetMode(this,true);
return MODEACTION_ALLOW;
}
}
else
{
if (channel->IsModeSet(this))
{
channel->SetMode(this,false);
return MODEACTION_ALLOW;
}
}
return MODEACTION_DENY;
}
ModeAction ParamChannelModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
if (adding)
{
std::string now = channel->GetModeParameter(this);
if (parameter == now)
return MODEACTION_DENY;
if (!ParamValidate(parameter))
return MODEACTION_DENY;
channel->SetModeParam(this, parameter);
}
else
channel->SetModeParam(this, "");
return MODEACTION_ALLOW;
}
bool ParamChannelModeHandler::ParamValidate(std::string& parameter)
{
return true;
}
ModeWatcher::ModeWatcher(Module* Creator, char modeletter, ModeType type)
: mode(modeletter), m_type(type), creator(Creator)
{
}
ModeWatcher::~ModeWatcher()
{
}
char ModeWatcher::GetModeChar()
{
return mode;
}
ModeType ModeWatcher::GetModeType()
{
return m_type;
}
bool ModeWatcher::BeforeMode(User*, User*, Channel*, std::string&, bool, ModeType)
{
return true;
}
void ModeWatcher::AfterMode(User*, User*, Channel*, const std::string&, bool, ModeType)
{
}
irc::modechange::modechange(const std::string& name, const std::string& param, bool add)
: adding(add), value(param)
{
ModeHandler* mh = ServerInstance->Modes->FindMode(name);
if (mh)
mode = mh->id;
}
irc::modechange::modechange(char modechar, ModeType type, const std::string& param, bool add)
: adding(add), value(param)
{
ModeHandler* mh = ServerInstance->Modes->FindMode(modechar, type);
if (mh)
mode = mh->id;
}
std::string irc::modestacker::popModeLine(SerializeFormat format, int maxlen, int maxmodes)
{
char pm_now = '\0';
std::string modeline;
std::stringstream params;
int nmodes = 0, linelen = 0;
if (maxmodes == 0)
maxmodes = ServerInstance->Config->Limits.MaxModes;
std::vector<modechange>::iterator iter = sequence.begin();
for(; iter != sequence.end() && nmodes < maxmodes; ++iter)
{
char pm = iter->adding ? '+' : '-';
ModeHandler* mh = ServerInstance->Modes->FindMode(iter->mode);
if (!mh)
continue;
char modechar = mh->GetModeChar();
std::string value = iter->value;
if (mh->GetTranslateType() == TR_NICK)
{
User* u = ServerInstance->FindNick(value);
if (u && format == FORMAT_USER)
value = u->nick;
else if (u && (format == FORMAT_NETWORK || format == FORMAT_INTERNAL))
value = u->uuid;
else
value.clear();
}
else if (mh->GetTranslateType() == TR_CUSTOM)
{
mh->TranslateMode(value, iter->adding, format);
}
if (mh->GetNumParams(iter->adding) && value.empty())
{
// value is empty when we want a param - failed conversion?
continue;
}
if (format == FORMAT_PERSIST || !modechar)
{
// this will only happen if we already allowed NameOnlyModes, no need to check
modechar = 'Z';
if (mh->GetNumParams(iter->adding))
value = mh->name + "=" + value;
else
value = mh->name;
}
else if (!mh->GetNumParams(iter->adding))
value.clear();
int mylen = (pm == pm_now) ? 1 : 2;
if (!value.empty())
mylen += 1 + value.length();
if (mylen + linelen > maxlen)
break;
linelen += mylen;
if (pm != pm_now)
{
modeline.push_back(pm);
pm_now = pm;
}
modeline.push_back(modechar);
if (!value.empty())
params << " " << value;
}
sequence.erase(sequence.begin(), iter);
if (format == FORMAT_PERSIST)
{
std::string rv = params.str();
if (rv.empty())
return rv;
// drop the initial space
return rv.substr(1);
}
if (modeline.empty())
return "+";
return modeline + params.str();
}
void ModeParser::DisplayCurrentModes(User *user, User* targetuser, Channel* targetchannel, const char* text)
{
if (targetchannel)
{
irc::modestacker ms;
targetchannel->ChanModes(ms, targetchannel->HasUser(user) ? MODELIST_SHORT : MODELIST_PUBLIC);
/* Display channel's current mode string */
user->WriteNumeric(RPL_CHANNELMODEIS, "%s %s %s", user->nick.c_str(),
targetchannel->name.c_str(), ms.popModeLine(FORMAT_USER, 400, INT_MAX).c_str());
user->WriteNumeric(RPL_CHANNELCREATED, "%s %s %lu", user->nick.c_str(), targetchannel->name.c_str(), (unsigned long)targetchannel->age);
return;
}
else
{
if (targetuser == user || user->HasPrivPermission("users/auspex"))
{
/* Display user's current mode string */
user->WriteNumeric(RPL_UMODEIS, "%s :+%s",targetuser->nick.c_str(),targetuser->FormatModes());
if (IS_OPER(targetuser))
user->WriteNumeric(RPL_SNOMASKIS, "%s +%s :Server notice mask", targetuser->nick.c_str(), targetuser->FormatNoticeMasks());
return;
}
else
{
user->WriteNumeric(ERR_USERSDONTMATCH, "%s :Can't view modes for other users", user->nick.c_str());
return;
}
}
}
ModeAction ModeParser::TryMode(User* user, User* targetuser, Channel* chan, irc::modechange& mc, bool SkipACL)
{
bool adding = mc.adding;
ModeID modeid = mc.mode;
ModeType type = chan ? MODETYPE_CHANNEL : MODETYPE_USER;
ModeHandler *mh = FindMode(modeid);
int pcnt = mh->GetNumParams(adding);
// crop mode parameter size to 250 characters
if (mc.value.length() > 250)
mc.value = mc.value.substr(0, 250);
ModResult MOD_RESULT;
FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, mc));
if (IS_LOCAL(user) && (MOD_RESULT == MOD_RES_DENY))
return MODEACTION_DENY;
if (chan && !SkipACL && (MOD_RESULT != MOD_RES_ALLOW))
{
User* targ = (mh->GetTranslateType() == TR_NICK) ? ServerInstance->FindNick(mc.value) : NULL;
ModePermissionData perm(user, "mode/" + mh->name, chan, targ, mc);
mh->AccessCheck(perm);
FOR_EACH_MOD(OnPermissionCheck, (perm));
perm.DoRankCheck();
if (perm.result == MOD_RES_DENY)
{
if (!perm.reason.empty())
user->SendText(perm.reason);
return MODEACTION_DENY;
}
}
std::pair<ModeWatcherMap::iterator,ModeWatcherMap::iterator> watchers = modewatchers.equal_range(modeid);
for (ModeWatcherMap::iterator watcher = watchers.first; watcher != watchers.second; watcher++)
{
if (watcher->second->BeforeMode(user, targetuser, chan, mc.value, adding, type) == false)
return MODEACTION_DENY;
/* A module whacked the parameter completely, and there was one. abort. */
if (pcnt && mc.value.empty())
return MODEACTION_DENY;
}
if (!SkipACL && (mh->disabled || (adding && mh->NeedsOper())) && !user->HasModePermission(mh->id))
{
/* It's an oper only mode, and they don't have access to it. */
if (IS_OPER(user))
{
user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - Oper type %s does not have access to set the %s mode",
user->nick.c_str(), user->oper->NameStr(), mh->name.c_str());
}
else if (mh->disabled)
{
user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - mode %s has been locked by the administrator",
user->nick.c_str(), mh->name.c_str());
}
else
{
user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - Only operators may set the %s mode",
user->nick.c_str(), mh->name.c_str());
}
return MODEACTION_DENY;
}
if (mh->GetTranslateType() == TR_NICK)
{
User* targ = ServerInstance->FindNick(mc.value);
if(!targ)
{
user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel", user->nick.c_str(), mc.value.c_str());
return MODEACTION_DENY;
}
else
mc.value = targ->uuid;
}
if (mh->GetPrefixRank() && chan)
{
User* user_to_prefix = ServerInstance->FindNick(mc.value);
if (!user_to_prefix)
return MODEACTION_DENY;
if (!chan->SetPrefix(user_to_prefix, mh->GetModeChar(), adding))
return MODEACTION_DENY;
}
/* Call the handler for the mode */
ModeAction ma = mh->OnModeChange(user, targetuser, chan, mc.value, adding);
if (pcnt && mc.value.empty())
return MODEACTION_DENY;
if (ma != MODEACTION_ALLOW)
return ma;
for (ModeWatcherMap::iterator watcher = watchers.first; watcher != watchers.second; watcher++)
watcher->second->AfterMode(user, targetuser, chan, mc.value, adding, type);
return MODEACTION_ALLOW;
}
void ModeParser::Parse(const std::vector<std::string>& parameters, User *user, Extensible*& target, irc::modestacker& modes)
{
std::string targetstr = parameters[0];
Channel* targetchannel = ServerInstance->FindChan(targetstr);
User* targetuser = ServerInstance->FindNick(targetstr);
target = targetuser ? (Extensible*)targetuser : targetchannel;
ModeType type = targetchannel ? MODETYPE_CHANNEL : MODETYPE_USER;
if (!targetchannel && !targetuser)
{
user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel",user->nick.c_str(),targetstr.c_str());
return;
}
if (parameters.size() == 1)
{
this->DisplayCurrentModes(user, targetuser, targetchannel, targetstr.c_str());
return;
}
if (targetchannel && parameters.size() == 2)
{
/* Special case for displaying the list for listmodes,
* e.g. MODE #chan b, or MODE #chan +b without a parameter
*/
this->DisplayListModes(user, targetchannel, parameters[1]);
}
unsigned int param_at = 2;
bool adding = true;
bool listednamedmodes = false;
for (std::string::const_iterator letter = parameters[1].begin(); letter != parameters[1].end(); letter++)
{
unsigned char modechar = *letter;
// skip s2s mode-merge indicator
if (modechar == '=')
continue;
if (modechar == '+' || modechar == '-')
{
adding = (modechar == '+');
continue;
}
if (modechar == 'Z' && ServerInstance->Config->NameOnlyModes)
{
// special case: Z is the named mode change interface
std::string name, value;
if (param_at == parameters.size())
{
/* Ensure the user doesnt request the same mode twice,
* so they cant flood themselves off out of idiocy.
*/
if (listednamedmodes)
continue;
listednamedmodes = true;
for(ModeIDIter id; id; id++)
{
ModeHandler* mh = ServerInstance->Modes->FindMode(id);
if (!mh || mh->IsListMode() || mh->GetModeType() != type)
continue;
if (targetchannel && !targetchannel->IsModeSet(mh))
continue;
if (targetuser && !targetuser->IsModeSet(mh->GetModeChar()))
continue;
if (mh->GetNumParams(true))
user->WriteNumeric(963, "%s %s %s=%s", user->nick.c_str(), targetchannel->name.c_str(), mh->name.c_str(), targetchannel->GetModeParameter(mh).c_str());
else
{
if(targetchannel)
user->WriteNumeric(963, "%s %s %s", user->nick.c_str(), targetchannel->name.c_str(), mh->name.c_str());
else
user->WriteNumeric(963, "%s %s %s", user->nick.c_str(), targetuser->nick.c_str(), mh->name.c_str());
}
}
if(targetchannel)
user->WriteNumeric(962, "%s :End of Mode List", targetchannel->name.c_str());
else
user->WriteNumeric(962, "%s :End of Mode List", targetuser->nick.c_str());
continue;
}
name = parameters[param_at++];
std::string::size_type eq = name.find('=');
if (eq != std::string::npos)
{
value = name.substr(eq + 1);
name = name.substr(0, eq);
}
ModeHandler *mh = FindMode(name);
if (mh && mh->GetModeType() == type)
{
if (mh->GetNumParams(adding) && value.empty())
{
if (mh->IsListMode() && targetchannel && adding)
{
/* Special case for displaying the list for listmodes,
* e.g. MODE #chan +Z ban, or MODE #chan +Z ban=
*/
mh->DisplayList(user, targetchannel);
continue;
}
/* No parameter, continue to the next mode unless OnParameterMissing fills one in */
mh->OnParameterMissing(user, targetuser, targetchannel, value);
if (value.empty())
continue;
}
modes.push(irc::modechange(mh->id, value, adding));
}
else
{
user->WriteServ("%d %s %s :is unknown mode string to me", type == MODETYPE_CHANNEL ? 472 : 501, user->nick.c_str(), name.c_str());
}
continue;
}
ModeHandler *mh = this->FindMode(modechar, type);
if (!mh)
{
/* No mode handler? Unknown mode character then. */
user->WriteServ("%d %s %c :is unknown mode char to me", type == MODETYPE_CHANNEL ? 472 : 501, user->nick.c_str(), modechar);
continue;
}
std::string parameter = "";
int pcnt = mh->GetNumParams(adding);
if (pcnt && param_at == parameters.size())
{
/* No parameter, continue to the next mode unless OnParameterMissing fills one in */
mh->OnParameterMissing(user, targetuser, targetchannel, parameter);
if (parameter.empty())
continue;
}
else if (pcnt)
{
parameter = parameters[param_at++];
}
modes.push(irc::modechange(mh->id, parameter, adding));
}
}
void ModeParser::Send(User *src, Extensible* target, irc::modestacker modes)
{
Channel* targetchannel = IS_CHANNEL(target);
User* targetuser = IS_USER(target);
if (targetchannel)
{
while (!modes.empty())
targetchannel->WriteChannel(src, "MODE %s %s", targetchannel->name.c_str(), modes.popModeLine(FORMAT_USER).c_str());
}
else if (targetuser)
{
while (!modes.empty())
targetuser->WriteFrom(src, "MODE %s %s", targetuser->nick.c_str(), modes.popModeLine(FORMAT_USER).c_str());
}
}
void ModeParser::Process(User *src, Extensible* target, irc::modestacker& modes, bool merge, bool SkipAccessChecks)
{
Channel* targetchannel = IS_CHANNEL(target);
User* targetuser = IS_USER(target);
if (!targetuser && !targetchannel)
return;
ModResult MOD_RESULT;
FIRST_MOD_RESULT(OnPreMode, MOD_RESULT, (src, target, modes));
if (!IS_LOCAL(src) || MOD_RESULT == MOD_RES_ALLOW)
SkipAccessChecks = true;
else if (MOD_RESULT == MOD_RES_DENY)
return;
if (targetuser && src != targetuser && !SkipAccessChecks)
{
src->WriteNumeric(ERR_USERSDONTMATCH, "%s :Can't change mode for other users", src->nick.c_str());
return;
}
std::vector<irc::modechange>::iterator mc = modes.sequence.begin();
while (mc != modes.sequence.end())
{
ModeHandler* mh = FindMode(mc->mode);
if (!mh)
throw CoreException("Invalid mode sequence passed to ModeParser::Process!");
if (mc->value.c_str()[0] == ':' || mc->value.find(' ') != std::string::npos)
{
// you can't do that in a mode value, sorry
mc = modes.sequence.erase(mc);
continue;
}
if (merge && targetchannel && targetchannel->IsModeSet(mh) && mc->adding && !mh->IsListMode())
{
std::string ours = targetchannel->GetModeParameter(mh);
if (mc->value == ours || !mh->ParamOrder(mc->value, ours))
{
/* local side won the mode merge, don't apply this mode */
mc = modes.sequence.erase(mc);
continue;
}
}
ModeAction ma = TryMode(src, targetuser, targetchannel, *mc, SkipAccessChecks);
if (ma == MODEACTION_ALLOW)
{
mc++;
}
else
{
/* mode change was denied */
mc = modes.sequence.erase(mc);
continue;
}
}
FOREACH_MOD(I_OnMode, OnMode(src, target, modes));
}
void ModeParser::DisplayListModes(User* user, Channel* chan, const std::string &mode_sequence)
{
std::bitset<MODE_ID_MAX> sent;
for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
{
unsigned char mletter = *letter;
if (mletter == '+')
continue;
ModeHandler *mh = this->FindMode(mletter, MODETYPE_CHANNEL);
if (!mh || !mh->IsListMode())
return;
/* Ensure the user doesnt request the same mode twice,
* so they cant flood themselves off out of idiocy.
*/
if (sent[mh->id.GetID()])
continue;
sent[mh->id.GetID()] = true;
irc::modechange mc(mh->id);
ModResult MOD_RESULT;
FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, mc));
if (MOD_RESULT == MOD_RES_DENY)
continue;
bool display = true;
if (!user->HasPrivPermission("channels/auspex") && ServerInstance->Config->HideModeLists[mletter] && (chan->GetAccessRank(user) < HALFOP_VALUE))
{
user->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You do not have access to view the +%c list",
user->nick.c_str(), chan->name.c_str(), mletter);
display = false;
}
std::pair<ModeWatcherMap::iterator,ModeWatcherMap::iterator> watchers = modewatchers.equal_range(mh->id);
for(ModeWatcherMap::iterator watcher = watchers.first; watcher != watchers.second; watcher++)
{
std::string dummyparam;
if (!watcher->second->BeforeMode(user, NULL, chan, dummyparam, true, MODETYPE_CHANNEL))
display = false;
}
if (display)
mh->DisplayList(user, chan);
else
mh->DisplayEmptyList(user, chan);
}
}
void ModeParser::CleanMask(std::string &mask)
{
std::string::size_type pos_of_pling = mask.find_first_of('!');
std::string::size_type pos_of_at = mask.find_first_of('@');
std::string::size_type pos_of_dot = mask.find_first_of('.');
std::string::size_type pos_of_colons = mask.find("::"); /* Because ipv6 addresses are colon delimited -- double so it treats extban as nick */
if (mask.length() >= 2 && mask[1] == ':')
return; // if it's an extban, don't even try guess how it needs to be formed.
if ((pos_of_pling == std::string::npos) && (pos_of_at == std::string::npos))
{
/* Just a nick, or just a host - or clearly ipv6 (starting with :) */
if ((pos_of_dot == std::string::npos) && (pos_of_colons == std::string::npos) && mask[0] != ':')
{
/* It has no '.' in it, it must be a nick. */
mask.append("!*@*");
}
else
{
/* Got a dot in it? Has to be a host */
mask = "*!*@" + mask;
}
}
else if ((pos_of_pling == std::string::npos) && (pos_of_at != std::string::npos))
{
/* Has an @ but no !, its a user@host */
mask = "*!" + mask;
}
else if ((pos_of_pling != std::string::npos) && (pos_of_at == std::string::npos))
{
/* Has a ! but no @, it must be a nick!ident */
mask.append("@*");
}
}
void ModeParser::AddMode(ModeHandler* mh)
{
/* A mode prefix of ',' is not acceptable, it would fuck up server to server.
* A mode prefix of ':' will fuck up both server to server, and client to server.
* A mode prefix of '#' will mess up /whois and /privmsg
*/
if ((mh->GetPrefix() == ',') || (mh->GetPrefix() == ':') || (mh->GetPrefix() == '#'))
throw ModuleException("Invalid prefix defined in mode");
std::string myletter = ServerInstance->Config->GetTag("modeletters")->getString(mh->name, std::string(1,mh->GetModeChar()));
mh->AdjustModeChar(myletter.c_str()[0]);
if (FindMode(mh->name))
throw ModuleException("Duplicate mode name found");
// prefixes can't be duplicated
if (mh->GetPrefix() && FindPrefix(mh->GetPrefix()))
throw ModuleException("Duplicate channel prefix found");
char mc = mh->GetModeChar();
// user modes have to be alpha (can't be null either)
if (mh->GetModeType() == MODETYPE_USER && !isalpha(mc))
throw ModuleException("Invalid mode character");
// all modes have to be alphanumeric or null
if (mc && !isalnum(mc))
throw ModuleException("Invalid mode character");
if (mh->GetPrefixRank() && !mc)
throw ModuleException("Prefix modes must define a mode character");
if (mc && FindMode(mc, mh->GetModeType()))
throw ModuleException("Duplicate mode character '" + std::string(1, mc) + "' found");
if (!mc && !ServerInstance->Config->NameOnlyModes)
throw ModuleException("<options:nameonlymodes> must be enabled to clear a mode character");
// find a free ID, and add it
for(int id = 1; id < MODE_ID_MAX; id++)
{
if (handlers[id])
continue;
mh->id.SetID(id);
handlers[id] = mh;
return;
}
// whoops, you need to increase MODE_ID_MAX
throw ModuleException("Out of Mode IDs!");
}
bool ModeParser::DelMode(ModeHandler* mh)
{
if (handlers[mh->id.GetID()] != mh)
return false;
/* Note: We can't stack here, as we have modes potentially being removed across many different channels.
* To stack here we have to make the algorithm slower. Discuss.
*/
switch (mh->GetModeType())
{
case MODETYPE_USER:
for (user_hash::iterator i = ServerInstance->Users->clientlist->begin(); i != ServerInstance->Users->clientlist->end();)
{
mh->RemoveMode(i++->second);
}
break;
case MODETYPE_CHANNEL:
for (chan_hash::iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end();)
{
mh->RemoveMode(i++->second);
}
break;
}
handlers[mh->id.GetID()] = NULL;
mh->id.SetID(0);
return true;
}
ModeHandler* ModeParser::FindMode(const std::string& name)
{
for(int id = 1; id < MODE_ID_MAX; id++)
{
if (handlers[id] && handlers[id]->name == name)
return handlers[id];
}
return NULL;
}
ModeHandler* ModeParser::FindMode(unsigned const char modeletter, ModeType mt)
{
for(int id = 1; id < MODE_ID_MAX; id++)
{
if (handlers[id] && handlers[id]->GetModeChar() == modeletter && handlers[id]->GetModeType() == mt)
return handlers[id];
}
return NULL;
}
std::string ModeParser::UserModeList()
{
char modestr[256];
int pointer = 0;
for(ModeIDIter id; id; id++)
{
ModeHandler* mh = FindMode(id);
if(mh && mh->GetModeType() == MODETYPE_USER && mh->GetModeChar())
modestr[pointer++] = mh->GetModeChar();
}
std::sort(modestr, modestr + pointer);
modestr[pointer++] = 0;
return modestr;
}
std::string ModeParser::ChannelModeList()
{
char modestr[256];
int pointer = 0;
for(ModeIDIter id; id; id++)
{
ModeHandler* mh = FindMode(id);
if (mh && mh->GetModeType() == MODETYPE_CHANNEL && mh->GetModeChar())
modestr[pointer++] = mh->GetModeChar();
}
if (ServerInstance->Config->NameOnlyModes)
modestr[pointer++] = 'Z';
modestr[pointer] = 0;
std::sort(modestr, modestr + pointer);
return modestr;
}
std::string ModeParser::ParaModeList()
{
char modestr[256];
int pointer = 0;
for(ModeIDIter id; id; id++)
{
ModeHandler* mh = FindMode(id);
if (mh && mh->GetModeType() == MODETYPE_CHANNEL && mh->GetNumParams(true) && mh->GetModeChar())
modestr[pointer++] = mh->GetModeChar();
}
if (ServerInstance->Config->NameOnlyModes)
modestr[pointer++] = 'Z';
modestr[pointer] = 0;
std::sort(modestr, modestr + pointer);
return modestr;
}
ModeHandler* ModeParser::FindPrefix(unsigned const char pfxletter)
{
for(ModeIDIter id; id; id++)
{
ModeHandler* mh = FindMode(id);
if (mh && mh->GetPrefix() == pfxletter)
return mh;
}
return NULL;
}
std::string ModeParser::GiveModeList(ModeType m)
{
std::string type1; /* Listmodes EXCEPT those with a prefix */
std::string type2; /* Modes that take a param when adding or removing */
std::string type3; /* Modes that only take a param when adding */
std::string type4; /* Modes that dont take a param */
if (m == MODETYPE_CHANNEL && ServerInstance->Config->NameOnlyModes)
type1.push_back('Z');
for(ModeIDIter id; id; id++)
{
ModeHandler* mh = FindMode(id);
if (mh && mh->GetModeType() == m && mh->GetModeChar())
{
if (mh->GetNumParams(true))
{
if ((mh->IsListMode()) && (!mh->GetPrefix()))
{
type1 += mh->GetModeChar();
}
else
{
/* ... and one parameter when removing */
if (mh->GetNumParams(false))
{
/* But not a list mode */
if (!mh->GetPrefix())
{
type2 += mh->GetModeChar();
}
}
else
{
/* No parameters when removing */
type3 += mh->GetModeChar();
}
}
}
else
{
type4 += mh->GetModeChar();
}
}
}
std::sort(type1.begin(), type1.end());
std::sort(type2.begin(), type2.end());
std::sort(type3.begin(), type3.end());
std::sort(type4.begin(), type4.end());
return type1 + "," + type2 + "," + type3 + "," + type4;
}
std::string ModeParser::BuildPrefixes(bool lettersAndModes)
{
std::string mletters;
std::string mprefixes;
std::map<int,std::pair<char,char> > prefixes;
for(ModeIDIter id; id; id++)
{
ModeHandler* mh = FindMode(id);
if (mh && mh->GetPrefix())
{
prefixes[mh->GetPrefixRank()] = std::make_pair(mh->GetPrefix(), mh->GetModeChar());
}
}
for(std::map<int,std::pair<char,char> >::reverse_iterator n = prefixes.rbegin(); n != prefixes.rend(); n++)
{
mletters = mletters + n->second.first;
mprefixes = mprefixes + n->second.second;
}
return lettersAndModes ? "(" + mprefixes + ")" + mletters : mletters;
}
bool ModeParser::AddModeWatcher(ModeWatcher* mw)
{
if (!mw)
return false;
ModeHandler* mh = FindMode(mw->GetModeChar(), mw->GetModeType());
if (!mh)
return false;
modewatchers.insert(std::make_pair(mh->id,mw));
return true;
}
bool ModeParser::DelModeWatcher(ModeWatcher* mw)
{
if (!mw)
return false;
ModeHandler* mh = FindMode(mw->GetModeChar(), mw->GetModeType());
if (!mh)
return false;
std::pair<ModeWatcherMap::iterator,ModeWatcherMap::iterator> watchers = modewatchers.equal_range(mh->id);
while (watchers.first != watchers.second)
{
if (watchers.first->second == mw)
{
modewatchers.erase(watchers.first);
return true;
}
watchers.first++;
}
return false;
}
/** This default implementation can remove simple user modes
*/
void ModeHandler::RemoveMode(User* user, irc::modestacker* stack)
{
if (user->IsModeSet(this->GetModeChar()))
{
irc::modechange mc(id, "", false);
if (stack)
{
stack->push(mc);
}
else
{
irc::modestacker tmp;
tmp.push(mc);
ServerInstance->SendMode(ServerInstance->FakeClient, user, tmp, false);
}
}
}
/** This default implementation can remove non-list modes
*/
void ModeHandler::RemoveMode(Channel* channel, irc::modestacker* stack)
{
if (channel->IsModeSet(this))
{
irc::modechange mc(id, channel->GetModeParameter(this), false);
if (stack)
{
stack->push(mc);
}
else
{
irc::modestacker ms;
ms.push(mc);
ServerInstance->SendMode(ServerInstance->FakeClient, channel, ms, false);
}
}
}
void PrefixModeHandler::RemoveMode(Channel* channel, irc::modestacker* stack)
{
irc::modestacker loc_ms;
if (!stack)
stack = &loc_ms;
for (UserMembIter i = channel->userlist.begin(); i != channel->userlist.end(); i++)
{
Membership* memb = i->second;
if (memb->hasMode(mode))
stack->push(irc::modechange(id, i->first->nick, false));
}
if (stack == &loc_ms)
ServerInstance->SendMode(ServerInstance->FakeClient, channel, loc_ms, false);
}
void PrefixModeHandler::RemoveMode(User*, irc::modestacker*)
{
}
void ModeHandler::PopulateChanModes(Channel* channel, irc::modestacker& stack)
{
irc::modechange mc(id, channel->GetModeParameter(this), true);
if (channel->IsModeSet(this))
stack.push(mc);
}
void ListExtItem::free(void* item)
{
modelist* ml = static_cast<modelist*>(item);
delete ml;
}
void ListModeBase::DisplayList(User* user, Channel* channel)
{
modelist* el = extItem.get(channel);
if (el)
{
for (modelist::reverse_iterator it = el->rbegin(); it != el->rend(); ++it)
{
user->WriteNumeric(listnumeric, "%s %s %s %s %ld", user->nick.c_str(), channel->name.c_str(), it->mask.c_str(), it->setter.c_str(), (long)it->time);
}
}
user->WriteNumeric(endoflistnumeric, "%s %s :%s", user->nick.c_str(), channel->name.c_str(), endofliststring.c_str());
}
const modelist* ListModeBase::GetList(Channel* channel)
{
return extItem.get(channel);
}
void ListModeBase::PopulateChanModes(Channel* channel, irc::modestacker& stack)
{
modelist* ml = extItem.get(channel);
if (!ml)
return;
for(modelist::const_iterator i = ml->begin(); i != ml->end(); i++)
{
stack.push(irc::modechange(id, i->mask, true));
}
}
void ListModeBase::RemoveMode(Channel* channel, irc::modestacker* stack)
{
modelist* el = extItem.get(channel);
if (el)
{
irc::modestacker modestack;
for (modelist::iterator it = el->begin(); it != el->end(); it++)
{
if (stack)
stack->push(irc::modechange(id, it->mask, false));
else
modestack.push(irc::modechange(id, it->mask, false));
}
if (stack)
return;
ServerInstance->SendMode(ServerInstance->FakeClient, channel, modestack, false);
}
}
void ListModeBase::RemoveMode(User*, irc::modestacker* stack)
{
// listmodes don't get set on users
}
void ListModeBase::DoRehash()
{
ConfigTagList tags = ServerInstance->Config->GetTags(configtag);
chanlimits.clear();
for (ConfigIter i = tags.first; i != tags.second; i++)
{
// For each <banlist> tag
ConfigTag* c = i->second;
ListLimit limit;
limit.mask = c->getString("chan");
limit.limit = c->getInt("limit");
if (limit.mask.size() && limit.limit > 0)
chanlimits.push_back(limit);
}
if (chanlimits.size() == 0)
{
ListLimit limit;
limit.mask = "*";
limit.limit = 64;
chanlimits.push_back(limit);
}
}
ModeAction ListModeBase::OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding)
{
// Try and grab the list
modelist* el = extItem.get(channel);
if (adding)
{
// If there was no list, make one
if (!el)
el = extItem.make(channel);
// Clean the mask up
if (this->tidy)
ModeParser::CleanMask(parameter);
// Check if the item already exists in the list
for (modelist::iterator it = el->begin(); it != el->end(); it++)
{
if (parameter == it->mask)
{
/* Give a subclass a chance to error about this */
TellAlreadyOnList(source, channel, parameter);
// it does, deny the change
return MODEACTION_DENY;
}
}
unsigned int maxsize = 0;
for (limitlist::iterator it = chanlimits.begin(); it != chanlimits.end(); it++)
{
if (InspIRCd::Match(channel->name, it->mask))
{
// We have a pattern matching the channel...
maxsize = el->size();
if (!IS_LOCAL(source) || (maxsize < it->limit))
{
/* Ok, it *could* be allowed, now give someone subclassing us
* a chance to validate the parameter.
* The param is passed by reference, so they can both modify it
* and tell us if we allow it or not.
*
* eg, the subclass could:
* 1) allow
* 2) 'fix' parameter and then allow
* 3) deny
*/
if (ValidateParam(source, channel, parameter))
{
// And now add the mask onto the list...
BanItem e;
e.mask = parameter;
e.setter = source->nick;
e.time = ServerInstance->Time();
el->push_back(e);
return MODEACTION_ALLOW;
}
else
{
/* If they deny it they have the job of giving an error message */
return MODEACTION_DENY;
}
}
}
}
/* List is full, give subclass a chance to send a custom message */
if (!TellListTooLong(source, channel, parameter))
{
source->WriteNumeric(478, "%s %s %s :Channel ban/ignore list is full", source->nick.c_str(), channel->name.c_str(), parameter.c_str());
}
parameter = "";
return MODEACTION_DENY;
}
else
{
// We're taking the mode off
if (el)
{
for (modelist::iterator it = el->begin(); it != el->end(); it++)
{
if (parameter == it->mask)
{
el->erase(it);
if (el->size() == 0)
{
extItem.unset(channel);
}
return MODEACTION_ALLOW;
}
}
/* Tried to remove something that wasn't set */
TellNotSet(source, channel, parameter);
parameter = "";
return MODEACTION_DENY;
}
else
{
/* Hmm, taking an exception off a non-existant list, DIE */
TellNotSet(source, channel, parameter);
parameter = "";
return MODEACTION_DENY;
}
}
return MODEACTION_DENY;
}
struct builtin_modes
{
ModeChannelSecret s;
ModeChannelPrivate p;
ModeChannelModerated m;
ModeChannelTopicOps t;
ModeChannelNoExternal n;
ModeChannelInviteOnly i;
ModeChannelKey k;
ModeChannelLimit l;
ModeChannelBan b;
ModeChannelOp o;
ModeChannelVoice v;
ModeUserWallops uw;
ModeUserInvisible ui;
ModeUserOperator uo;
ModeUserServerNoticeMask us;
void init(ModeParser* modes)
{
b.init();
modes->AddMode(&s);
modes->AddMode(&p);
modes->AddMode(&m);
modes->AddMode(&t);
modes->AddMode(&n);
modes->AddMode(&i);
modes->AddMode(&k);
modes->AddMode(&l);
modes->AddMode(&b);
modes->AddMode(&o);
modes->AddMode(&v);
modes->AddMode(&uw);
modes->AddMode(&ui);
modes->AddMode(&uo);
modes->AddMode(&us);
}
};
static builtin_modes static_modes;
ModeParser::ModeParser()
{
/* Clear mode handler list */
memset(handlers, 0, sizeof(handlers));
static_modes.init(this);
}
ModeParser::~ModeParser()
{
}
