Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

ModeParser Class Reference

The mode parser handles routing of modes and handling of mode strings. More...

#include <mode.h>

Inheritance diagram for ModeParser:

[legend]Collaboration diagram for ModeParser:

[legend]List of all members.

Public Member Functions
	ModeParser (InspIRCd *Instance)
	The constructor initializes all the RFC basic modes by using ModeParserAddMode().
userrec *	SanityChecks (userrec *user, const char *dest, chanrec *chan, int status)
	Used to check if user 'd' should be allowed to do operation 'MASK' on channel 'chan'.
const char *	Grant (userrec *d, chanrec *chan, int MASK)
	Grant a built in privilage (e.g.
const char *	Revoke (userrec *d, chanrec *chan, int MASK)
	Revoke a built in privilage (e.g.
const std::string &	GetLastParse ()
	Get the last string to be processed, as it was sent to the user or channel.
bool	AddMode (ModeHandler *mh, unsigned const char modeletter)
	Add a mode to the mode parser.
bool	DelMode (ModeHandler *mh)
	Delete a mode from the mode parser.
bool	AddModeWatcher (ModeWatcher *mw)
	Add a mode watcher.
bool	DelModeWatcher (ModeWatcher *mw)
	Delete a mode watcher.
void	Process (const char **parameters, int pcnt, userrec *user, bool servermode)
	Process a set of mode changes from a server or user.
ModeHandler *	FindMode (unsigned const char modeletter, ModeType mt)
	Find the mode handler for a given mode and type.
ModeHandler *	FindPrefix (unsigned const char pfxletter)
	Find a mode handler by its prefix.
std::string	UserModeList ()
	Returns a list of mode characters which are usermodes.
std::string	ChannelModeList ()
	Returns a list of channel mode characters which are listmodes.
std::string	ParaModeList ()
	Returns a list of channel mode characters which take parameters.
std::string	ChanModes ()
	Generates the CHANMODES= 005 sequence.
std::string	BuildPrefixes ()
	This returns the PREFIX=(ohv)%+ section of the 005 numeric.
std::string	ModeString (userrec *user, chanrec *channel)
	This returns the privilages of a user upon a channel, in the format of a mode change.
Static Public Member Functions
static void	CleanMask (std::string &mask)
	Tidy a banmask.
static bool	PrefixComparison (prefixtype one, prefixtype two)
	Used by this class internally during std::sort and 005 generation.
Private Member Functions
void	DisplayCurrentModes (userrec *user, userrec *targetuser, chanrec *targetchannel, const char *text)
	Displays the current modes of a channel or user.
Private Attributes
InspIRCd *	ServerInstance
	Creator/owner pointer.
ModeHandler *	modehandlers [256]
	Mode handlers for each mode, to access a handler subtract 65 from the ascii value of the mode letter.
std::vector< ModeWatcher * >	modewatchers [256]
	Mode watcher classes arranged in the same way as the mode handlers, except for instead of having 256 of them we have 256 lists of them.
std::string	LastParse
	The string representing the last set of modes to be parsed.

---

Detailed Description

The mode parser handles routing of modes and handling of mode strings.

It marshalls, controls and maintains both ModeWatcher and ModeHandler classes, parses client to server MODE strings for user and channel modes, and performs processing for the 004 mode list numeric, amongst other things.

Definition at line 369 of file mode.h.

---

Constructor & Destructor Documentation

ModeParser::ModeParser (  InspIRCd *  Instance  )

The constructor initializes all the RFC basic modes by using ModeParserAddMode(). Definition at line 1036 of file mode.cpp. References AddMode(), LastParse, modehandlers, and modewatchers. : ServerInstance(Instance) { struct Initializer { char modechar; ModeHandler* handler; }; Initializer modes[] = { { 's', new ModeChannelSecret(Instance) }, { 'p', new ModeChannelPrivate(Instance) }, { 'm', new ModeChannelModerated(Instance) }, { 't', new ModeChannelTopicOps(Instance) }, { 'n', new ModeChannelNoExternal(Instance) }, { 'i', new ModeChannelInviteOnly(Instance) }, { 'k', new ModeChannelKey(Instance) }, { 'l', new ModeChannelLimit(Instance) }, { 'b', new ModeChannelBan(Instance) }, { 'o', new ModeChannelOp(Instance) }, { 'h', new ModeChannelHalfOp(Instance) }, { 'v', new ModeChannelVoice(Instance) }, { 's', new ModeUserServerNotice(Instance) }, { 'w', new ModeUserWallops(Instance) }, { 'i', new ModeUserInvisible(Instance) }, { 'o', new ModeUserOperator(Instance) }, { 'n', new ModeUserServerNoticeMask(Instance) }, { 0, NULL } }; /* Clear mode list */ memset(modehandlers, 0, sizeof(modehandlers)); memset(modewatchers, 0, sizeof(modewatchers)); /* Last parse string */ LastParse.clear(); /* Initialise the RFC mode letters */ for (int index = 0; modes[index].modechar; index++) this->AddMode(modes[index].handler, modes[index].modechar); }

---

Member Function Documentation

bool ModeParser::AddMode (  ModeHandler *  mh, unsigned const char  modeletter )

Add a mode to the mode parser. The modeletter parameter is purely to save on doing a lookup in the function, as strictly it could be obtained via ModeHandler::GetModeChar(). Returns: True if the mode was successfully added. Definition at line 694 of file mode.cpp. References ModeHandler::GetModeChar(), ModeHandler::GetModeType(), ModeHandler::GetPrefix(), MASK_CHANNEL, MASK_USER, modehandlers, and MODETYPE_USER. Referenced by InspIRCd::AddMode(), and ModeParser(). { unsigned char mask = 0; unsigned char pos = 0; /* Yes, i know, this might let people declare modes like '_' or '^'. * If they do that, thats their problem, and if i ever EVER see an * official InspIRCd developer do that, i'll beat them with a paddle! */ if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z') || (mh->GetPrefix() > 126)) return false; /* 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() == '#')) return false; mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL; pos = (mh->GetModeChar()-65) | mask; if (modehandlers[pos]) return false; modehandlers[pos] = mh; return true; }

bool ModeParser::AddModeWatcher (  ModeWatcher *  mw  )

Add a mode watcher. A mode watcher is triggered before and after a mode handler is triggered. See the documentation of class ModeWatcher for more information. Parameters: mw  The ModeWatcher you want to add Returns: True if the ModeWatcher was added correctly Definition at line 956 of file mode.cpp. References ModeWatcher::GetModeChar(), ModeWatcher::GetModeType(), MASK_CHANNEL, MASK_USER, MODETYPE_USER, and modewatchers. Referenced by InspIRCd::AddModeWatcher(). { unsigned char mask = 0; unsigned char pos = 0; if (!mw) return false; if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z')) return false; mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL; pos = (mw->GetModeChar()-65) | mask; modewatchers[pos].push_back(mw); return true; }

std::string ModeParser::BuildPrefixes (   )

This returns the PREFIX=(ohv)%+ section of the 005 numeric. Definition at line 924 of file mode.cpp. References ServerConfig::AllowHalfop, InspIRCd::Config, ModeHandler::GetPrefix(), MASK_CHANNEL, modehandlers, PrefixComparison(), and ServerInstance. Referenced by InspIRCd::BuildISupport(), TreeSocket::Capab(), and TreeSocket::SendCapabilities(). { std::string mletters; std::string mprefixes; pfxcontainer pfx; std::map<char,char> prefix_to_mode; for (unsigned char mode = 'A'; mode <= 'z'; mode++) { if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h')) continue; unsigned char pos = (mode-65) | MASK_CHANNEL; if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix())) { pfx.push_back(std::make_pair<char,unsigned int>(modehandlers[pos]->GetPrefix(), modehandlers[pos]->GetPrefixRank())); prefix_to_mode[modehandlers[pos]->GetPrefix()] = modehandlers[pos]->GetModeChar(); } } sort(pfx.begin(), pfx.end(), ModeParser::PrefixComparison); for (pfxcontainer::iterator n = pfx.begin(); n != pfx.end(); n++) { mletters = mletters + n->first; mprefixes = mprefixes + prefix_to_mode.find(n->first)->second; } return "(" + mprefixes + ")" + mletters; }

std::string ModeParser::ChanModes (   )

Generates the CHANMODES= 005 sequence. Definition at line 868 of file mode.cpp. References ServerConfig::AllowHalfop, InspIRCd::Config, ModeHandler::GetModeChar(), MASK_CHANNEL, modehandlers, and ServerInstance. Referenced by InspIRCd::BuildISupport(), and TreeSocket::SendCapabilities(). { 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 */ for (unsigned char mode = 'A'; mode <= 'z'; mode++) { if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h')) continue; unsigned char pos = (mode-65) | MASK_CHANNEL; /* One parameter when adding */ if (modehandlers[pos]) { if (modehandlers[pos]->GetNumParams(true)) { if ((modehandlers[pos]->IsListMode()) && (!modehandlers[pos]->GetPrefix())) { type1 += modehandlers[pos]->GetModeChar(); } else { /* ... and one parameter when removing */ if (modehandlers[pos]->GetNumParams(false)) { /* But not a list mode */ if (!modehandlers[pos]->GetPrefix()) { type2 += modehandlers[pos]->GetModeChar(); } } else { /* No parameters when removing */ type3 += modehandlers[pos]->GetModeChar(); } } } else { type4 += modehandlers[pos]->GetModeChar(); } } } return type1 + "," + type2 + "," + type3 + "," + type4; }

std::string ModeParser::ChannelModeList (   )

Returns a list of channel mode characters which are listmodes. This is used in the 004 numeric when users connect. Definition at line 788 of file mode.cpp. References ServerConfig::AllowHalfop, InspIRCd::Config, MASK_CHANNEL, modehandlers, and ServerInstance. Referenced by userrec::FullConnect(). { char modestr[256]; int pointer = 0; for (unsigned char mode = 'A'; mode <= 'z'; mode++) { if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h')) continue; unsigned char pos = (mode-65) | MASK_CHANNEL; if (modehandlers[pos]) modestr[pointer++] = mode; } modestr[pointer++] = 0; return modestr; }

void ModeParser::CleanMask (  std::string &  mask  )  [static]

Tidy a banmask. This makes a banmask 'acceptable' if fields are left out. E.g. nick -> nick!*@* nick!ident -> nick!ident@* host.name -> *!*.name ident@host.name -> *!ident.name This method can be used on both IPV4 and IPV6 user masks. Definition at line 661 of file mode.cpp. Referenced by cmd_silence::Handle(), and ListModeBase::OnModeChange(). { 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_colon = mask.find_first_of(':'); /* Because ipv6 addresses are colon delimited */ if ((pos_of_pling == std::string::npos) && (pos_of_at == std::string::npos)) { /* Just a nick, or just a host */ if ((pos_of_dot == std::string::npos) && (pos_of_colon == std::string::npos)) { /* 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("@*"); } }

bool ModeParser::DelMode (  ModeHandler *  mh  )

Delete a mode from the mode parser. When a mode is deleted, the mode handler will be called for every user (if it is a user mode) or for every channel (if it is a channel mode) to unset the mode on all objects. This prevents modes staying in the system which no longer exist. Parameters: mh  The mode handler to remove Returns: True if the mode was successfully removed. Definition at line 723 of file mode.cpp. References InspIRCd::chanlist, InspIRCd::clientlist, ModeHandler::GetModeChar(), ModeHandler::GetModeType(), MASK_CHANNEL, MASK_USER, modehandlers, MODETYPE_CHANNEL, MODETYPE_USER, ModeHandler::RemoveMode(), and ServerInstance. Referenced by ModuleChanProtect::OnRehash(), ModuleAuditorium::~ModuleAuditorium(), ModuleBanException::~ModuleBanException(), ModuleBlockCAPS::~ModuleBlockCAPS(), ModuleBlockColour::~ModuleBlockColour(), ModuleBotMode::~ModuleBotMode(), ModuleCensor::~ModuleCensor(), ModuleChanFilter::~ModuleChanFilter(), ModuleChanProtect::~ModuleChanProtect(), ModuleCloaking::~ModuleCloaking(), ModuleDeaf::~ModuleDeaf(), ModuleHelpop::~ModuleHelpop(), ModuleHideChans::~ModuleHideChans(), ModuleHideOper::~ModuleHideOper(), ModuleInvisible::~ModuleInvisible(), ModuleInviteException::~ModuleInviteException(), ModuleJoinFlood::~ModuleJoinFlood(), ModuleKickNoRejoin::~ModuleKickNoRejoin(), ModuleKnock::~ModuleKnock(), ModuleMsgFlood::~ModuleMsgFlood(), ModuleNickFlood::~ModuleNickFlood(), ModuleNoCTCP::~ModuleNoCTCP(), ModuleNoInvite::~ModuleNoInvite(), ModuleNoKicks::~ModuleNoKicks(), ModuleNoNickChange::~ModuleNoNickChange(), ModuleNoNotice::~ModuleNoNotice(), ModuleOperChans::~ModuleOperChans(), ModulePrivacyMode::~ModulePrivacyMode(), ModuleRedirect::~ModuleRedirect(), ModuleServices::~ModuleServices(), ModuleServicesAccount::~ModuleServicesAccount(), ModuleShowwhois::~ModuleShowwhois(), ModuleSSLModes::~ModuleSSLModes(), and ModuleStripColor::~ModuleStripColor(). { unsigned char mask = 0; unsigned char pos = 0; if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z')) return false; mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL; pos = (mh->GetModeChar()-65) | mask; if (!modehandlers[pos]) return false; switch (mh->GetModeType()) { case MODETYPE_USER: for (user_hash::iterator i = ServerInstance->clientlist->begin(); i != ServerInstance->clientlist->end(); i++) { mh->RemoveMode(i->second); } break; case MODETYPE_CHANNEL: for (chan_hash::iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); i++) { mh->RemoveMode(i->second); } break; } modehandlers[pos] = NULL; return true; }

bool ModeParser::DelModeWatcher (  ModeWatcher *  mw  )

Delete a mode watcher. A mode watcher is triggered before and after a mode handler is triggered. See the documentation of class ModeWatcher for more information. Parameters: mw  The ModeWatcher you want to delete Returns: True if the ModeWatcher was deleted correctly Definition at line 975 of file mode.cpp. References ModeWatcher::GetModeChar(), ModeWatcher::GetModeType(), MASK_CHANNEL, MASK_USER, MODETYPE_USER, and modewatchers. Referenced by InspIRCd::DelModeWatcher(), ModuleBanRedirect::~ModuleBanRedirect(), and ModuleInvisible::~ModuleInvisible(). { unsigned char mask = 0; unsigned char pos = 0; if (!mw) return false; if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z')) return false; mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL; pos = (mw->GetModeChar()-65) | mask; ModeWatchIter a = find(modewatchers[pos].begin(),modewatchers[pos].end(),mw); if (a == modewatchers[pos].end()) { return false; } modewatchers[pos].erase(a); return true; }

void ModeParser::DisplayCurrentModes (  userrec *  user, userrec *  targetuser, chanrec *  targetchannel, const char *  text )  [private]

Displays the current modes of a channel or user. Used by ModeParser::Process. Definition at line 243 of file mode.cpp. References classbase::age, chanrec::ChanModes(), userrec::FormatModes(), userrec::FormatNoticeMasks(), chanrec::HasUser(), IS_OPER, chanrec::name, userrec::nick, userrec::Visibility, VisData::VisibleTo(), and userrec::WriteServ(). Referenced by Process(). { if (targetchannel) { /* Display channel's current mode string */ user->WriteServ("324 %s %s +%s",user->nick, targetchannel->name, targetchannel->ChanModes(targetchannel->HasUser(user))); user->WriteServ("329 %s %s %lu", user->nick, targetchannel->name, (unsigned long)targetchannel->age); return; } else if (targetuser) { if (targetuser->Visibility && !targetuser->Visibility->VisibleTo(user)) { user->WriteServ("401 %s %s :No such nick/channel",user->nick, text); return; } if ((targetuser == user) || (IS_OPER(user))) { /* Display user's current mode string */ user->WriteServ("221 %s :+%s",targetuser->nick,targetuser->FormatModes()); if (IS_OPER(targetuser)) user->WriteServ("008 %s +%s :Server notice mask", targetuser->nick, targetuser->FormatNoticeMasks()); return; } else { user->WriteServ("502 %s :Can't change mode for other users", user->nick); return; } } /* No such nick/channel */ user->WriteServ("401 %s %s :No such nick/channel",user->nick, text); return; }

ModeHandler * ModeParser::FindMode (  unsigned const char  modeletter, ModeType  mt )

Find the mode handler for a given mode and type. Parameters: modeletter  mode letter to search for type  of mode to search for, user or channel Returns: a pointer to a ModeHandler class, or NULL of there isnt a handler for the given mode Definition at line 758 of file mode.cpp. References MASK_CHANNEL, MASK_USER, modehandlers, and MODETYPE_USER. Referenced by userrec::DecrementModes(), TreeSocket::IntroduceClient(), InspIRCd::ModeCount(), Process(), TreeSocket::RemoveStatus(), and chanrec::SetDefaultModes(). { unsigned char mask = 0; unsigned char pos = 0; if ((modeletter < 'A') || (modeletter > 'z')) return NULL; mt == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL; pos = (modeletter-65) | mask; return modehandlers[pos]; }

ModeHandler * ModeParser::FindPrefix (  unsigned const char  pfxletter  )

Find a mode handler by its prefix. If there is no mode handler with the given prefix, NULL will be returned. Parameters: pfxletter  The prefix to find, e.g. '@' Returns: The mode handler which handles this prefix, or NULL if there is none. Definition at line 826 of file mode.cpp. References MASK_CHANNEL, and modehandlers. Referenced by chanrec::ForceChan(), and TreeSocket::ForceJoin(). { for (unsigned char mode = 'A'; mode <= 'z'; mode++) { unsigned char pos = (mode-65) | MASK_CHANNEL; if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix() == pfxletter)) { return modehandlers[pos]; } } return NULL; }

const std::string & ModeParser::GetLastParse (   )

Get the last string to be processed, as it was sent to the user or channel. Use this to display a string you just sent to be parsed, as the actual output may be different to what you sent after it has been 'cleaned up' by the parser. Returns: Last parsed string, as seen by users. Definition at line 656 of file mode.cpp. References LastParse. Referenced by cmd_samode::Handle(), ModuleTimedBans::OnBackgroundTimer(), and ModuleOverride::OnPostCommand(). { return LastParse; }

const char * ModeParser::Grant (  userrec *  d, chanrec *  chan, int  MASK )

Grant a built in privilage (e.g. ops, halfops, voice) to a user on a channel Definition at line 183 of file mode.cpp. References userrec::chans, userrec::nick, UCMODE_HOP, UCMODE_OP, and UCMODE_VOICE. { if (!chan) return ""; UCListIter n = d->chans.find(chan); if (n != d->chans.end()) { if (n->second & MASK) { return ""; } n->second = n->second | MASK; switch (MASK) { case UCMODE_OP: n->first->AddOppedUser(d); break; case UCMODE_HOP: n->first->AddHalfoppedUser(d); break; case UCMODE_VOICE: n->first->AddVoicedUser(d); break; } return d->nick; } return ""; }

std::string ModeParser::ModeString (  userrec *  user, chanrec *  channel )

This returns the privilages of a user upon a channel, in the format of a mode change. For example, if a user has privilages +avh, this will return the string "avh nick nick nick". This is used by the core when cycling a user to refresh their hostname. You may use it for similar purposes. Parameters: user  The username to look up channel  The channel name to look up the privilages of the user for Returns: The mode string. Definition at line 840 of file mode.cpp. References ModeHandler::GetModeChar(), ModeHandler::GetNumParams(), MASK_CHANNEL, modehandlers, ModeHandler::ModeSet(), and userrec::nick. Referenced by userrec::ChangeDisplayedHost(), userrec::ChangeIdent(), chanrec::ForceChan(), and InvisibleMode::OnModeChange(). { std::string types; std::string pars; if (!channel || !user) return ""; for (unsigned char mode = 'A'; mode <= 'z'; mode++) { unsigned char pos = (mode-65) | MASK_CHANNEL; ModeHandler* mh = modehandlers[pos]; if ((mh) && (mh->GetNumParams(true)) && (mh->GetNumParams(false))) { ModePair ret; ret = mh->ModeSet(NULL, user, channel, user->nick); if ((ret.first) && (ret.second == user->nick)) { pars.append(" "); pars.append(user->nick); types.push_back(mh->GetModeChar()); } } } return types+pars; }

std::string ModeParser::ParaModeList (   )

Returns a list of channel mode characters which take parameters. This is used in the 004 numeric when users connect. Definition at line 807 of file mode.cpp. References ServerConfig::AllowHalfop, InspIRCd::Config, MASK_CHANNEL, modehandlers, and ServerInstance. Referenced by userrec::FullConnect(). { char modestr[256]; int pointer = 0; for (unsigned char mode = 'A'; mode <= 'z'; mode++) { if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h')) continue; unsigned char pos = (mode-65) | MASK_CHANNEL; if ((modehandlers[pos]) && (modehandlers[pos]->GetNumParams(true))) modestr[pointer++] = mode; } modestr[pointer++] = 0; return modestr; }

bool ModeParser::PrefixComparison (  prefixtype  one, prefixtype  two )  [static]

Used by this class internally during std::sort and 005 generation. Definition at line 919 of file mode.cpp. Referenced by BuildPrefixes(), and chanrec::SetPrefix(). { return one.second > two.second; }

void ModeParser::Process (  const char **  parameters, int  pcnt, userrec *  user, bool  servermode )

Process a set of mode changes from a server or user. Parameters: parameters  The parameters of the mode change, in the format they would be from a MODE command. pcnt  The number of items in the parameters array user  The user setting or removing the modes. When the modes are set by a server, an 'uninitialized' userrec is used, where *usernick == NULL and *user->server == NULL. servermode  True if a server is setting the mode. Definition at line 280 of file mode.cpp. References AC_GENERAL_MODE, ACR_DEFAULT, ACR_DENY, ServerConfig::AllowHalfop, ModeHandler::ChangeCount(), InspIRCd::Config, DisplayCurrentModes(), ModeHandler::DisplayEmptyList(), ModeHandler::DisplayList(), InspIRCd::FindChan(), FindMode(), InspIRCd::FindNick(), FOREACH_MOD, FOREACH_RESULT, ModeHandler::GetModeChar(), chanrec::GetStatus(), ServerConfig::HideModeLists, I_OnAccessCheck, I_OnMode, IS_LOCAL, IS_OPER, ModeHandler::IsListMode(), LastParse, MASK_CHANNEL, MASK_USER, MAXMODES, MODEACTION_ALLOW, modehandlers, MODETYPE_CHANNEL, MODETYPE_USER, modewatchers, chanrec::name, userrec::nick, ModeHandler::OnModeChange(), userrec::server, ServerInstance, ServerConfig::ServerName, chanrec::SetPrefix(), STATUS_HOP, TYPE_CHANNEL, TYPE_USER, InspIRCd::ULine(), chanrec::WriteChannel(), chanrec::WriteChannelWithServ(), userrec::WriteServ(), and userrec::WriteTo(). Referenced by InvisibleDeOper::BeforeMode(), cmd_mode::Handle(), and InspIRCd::SendMode(). { 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]); LastParse.clear(); /* Special case for displaying the list for listmodes, * e.g. MODE #chan b, or MODE #chan +b without a parameter */ if ((targetchannel) && (pcnt == 2)) { const char* mode = parameters[1]; int nonlistmodes_found = 0; bool sent[256]; mask = MASK_CHANNEL; memset(&sent, 0, 256); while (mode && *mode) { unsigned char mletter = *mode; if (*mode == '+') { mode++; continue; } /* Ensure the user doesnt request the same mode twice, * so they cant flood themselves off out of idiocy. */ if (!sent[mletter]) { sent[mletter] = true; } else { mode++; continue; } ModeHandler *mh = this->FindMode(*mode, MODETYPE_CHANNEL); bool display = true; if ((mh) && (mh->IsListMode())) { 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; } unsigned char handler_id = (*mode - 65) | mask; for(ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++) { std::string dummyparam; if (!((*watchers)->BeforeMode(user, NULL, targetchannel, dummyparam, true, MODETYPE_CHANNEL))) display = false; } if (display) mh->DisplayList(user, targetchannel); } else nonlistmodes_found++; mode++; } /* We didnt have any modes that were non-list, we can return here */ if (!nonlistmodes_found) return; } if (pcnt == 1) { this->DisplayCurrentModes(user, targetuser, targetchannel, parameters[0]); } else if (pcnt > 1) { if (targetchannel) { type = MODETYPE_CHANNEL; mask = MASK_CHANNEL; /* Extra security checks on channel modes * (e.g. are they a (half)op? */ if ((IS_LOCAL(user)) && (targetchannel->GetStatus(user) < STATUS_HOP)) { /* We don't have halfop */ int MOD_RESULT = 0; FOREACH_RESULT(I_OnAccessCheck,OnAccessCheck(user, NULL, targetchannel, AC_GENERAL_MODE)); if (MOD_RESULT == ACR_DENY) return; if (MOD_RESULT == ACR_DEFAULT) { /* Are we a uline or is it a servermode? */ if ((!ServerInstance->ULine(user->server)) && (!servermode)) { /* Not enough permission: * NOT a uline and NOT a servermode, * OR, NOT halfop or above. */ user->WriteServ("482 %s %s :You're not a channel %soperator",user->nick, targetchannel->name, ServerInstance->Config->AllowHalfop ? "(half)" : ""); return; } } } } else if (targetuser) { type = MODETYPE_USER; mask = MASK_USER; if ((user != targetuser) && (!ServerInstance->ULine(user->server))) { user->WriteServ("502 %s :Can't change mode for other users", user->nick); return; } } else { /* No such nick/channel */ user->WriteServ("401 %s %s :No such nick/channel",user->nick, parameters[0]); return; } std::string mode_sequence = parameters[1]; std::string parameter; std::ostringstream parameter_list; std::string output_sequence; bool adding = true, state_change = false; unsigned char handler_id = 0; int parameter_counter = 2; /* Index of first parameter */ int parameter_count = 0; bool last_successful_state_change = false; /* A mode sequence that doesnt start with + or -. Assume +. - Thanks for the suggestion spike (bug#132) */ if ((*mode_sequence.begin() != '+') && (*mode_sequence.begin() != '-')) mode_sequence.insert(0, "+"); for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++) { unsigned char modechar = *letter; switch (modechar) { /* NB: * For + and - mode characters, we don't just stick the character into the output sequence. * This is because the user may do something dumb, like: +-+ooo or +oo-+. To prevent this * appearing in the output sequence, we store a flag which says there was a state change, * which is set on any + or -, however, the + or - that we finish on is only appended to * the output stream in the event it is followed by a non "+ or -" character, such as o or v. */ case '+': /* The following expression prevents: +o+o nick nick, compressing it to +oo nick nick, * however, will allow the + if it is the first item in the sequence, regardless. */ if ((!adding) || (!output_sequence.length())) state_change = true; adding = true; if (!output_sequence.length()) last_successful_state_change = false; continue; break; case '-': if ((adding) || (!output_sequence.length())) state_change = true; adding = false; if (!output_sequence.length()) last_successful_state_change = true; continue; break; default: handler_id = (modechar - 65) | mask; if (modehandlers[handler_id]) { bool abort = false; if (modehandlers[handler_id]->GetModeType() == type) { if (modehandlers[handler_id]->GetNumParams(adding)) { /* This mode expects a parameter, do we have any parameters left in our list to use? */ if (parameter_counter < pcnt) { parameter = parameters[parameter_counter++]; /* Yerk, invalid! */ if ((parameter.find(':') == 0) || (parameter.rfind(' ') != std::string::npos)) parameter.clear(); } else { /* No parameter, continue to the next mode */ continue; } bool had_parameter = !parameter.empty(); for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++) { if ((*watchers)->BeforeMode(user, targetuser, targetchannel, parameter, adding, type) == false) { abort = true; break; } /* A module whacked the parameter completely, and there was one. abort. */ if ((had_parameter) && (parameter.empty())) { abort = true; break; } } if (abort) continue; } else { /* Fix by brain: mode watchers not being called for parameterless modes */ for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++) { if ((*watchers)->BeforeMode(user, targetuser, targetchannel, parameter, adding, type) == false) { abort = true; break; } } if (abort) continue; } /* It's an oper only mode, check if theyre an oper. If they arent, * eat any parameter that came with the mode, and continue to next */ if ((IS_LOCAL(user)) && (modehandlers[handler_id]->NeedsOper()) && (!IS_OPER(user))) { user->WriteServ("481 %s :Permission Denied - Only IRC operators may %sset %s mode %c", user->nick, adding ? "" : "un", type == MODETYPE_CHANNEL ? "channel" : "user", modehandlers[handler_id]->GetModeChar()); continue; } /* Call the handler for the mode */ ModeAction ma = modehandlers[handler_id]->OnModeChange(user, targetuser, targetchannel, parameter, adding); if ((modehandlers[handler_id]->GetNumParams(adding)) && (parameter.empty())) { /* The handler nuked the parameter and they are supposed to have one. * We CANT continue now, even if they actually returned MODEACTION_ALLOW, * so we bail to the next mode character. */ continue; } if (ma == MODEACTION_ALLOW) { /* We're about to output a valid mode letter - was there previously a pending state-change? */ if (state_change) { if (adding != last_successful_state_change) output_sequence.append(adding ? "+" : "-"); last_successful_state_change = adding; } /* 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())) { parameter_list << " " << parameter; parameter_count++; /* Does this mode have a prefix? */ if (modehandlers[handler_id]->GetPrefix() && targetchannel) { userrec* user_to_prefix = ServerInstance->FindNick(parameter); if (user_to_prefix) targetchannel->SetPrefix(user_to_prefix, modehandlers[handler_id]->GetPrefix(), modehandlers[handler_id]->GetPrefixRank(), adding); } } /* Call all the AfterMode events in the mode watchers for this mode */ for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++) (*watchers)->AfterMode(user, targetuser, targetchannel, parameter, adding, type); /* Reset the state change flag */ state_change = false; if ((output_sequence.length() + parameter_list.str().length() > 450) || (output_sequence.length() > 100) || (parameter_count > MAXMODES)) { /* We cant have a mode sequence this long */ letter = mode_sequence.end() - 1; continue; } } } } else { /* 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, modechar); } break; } } /* Was there at least one valid mode in the sequence? */ if (!output_sequence.empty()) { if (servermode) { if (type == MODETYPE_CHANNEL) { targetchannel->WriteChannelWithServ(ServerInstance->Config->ServerName, "MODE %s %s%s", targetchannel->name, output_sequence.c_str(), parameter_list.str().c_str()); this->LastParse = targetchannel->name; } else { targetuser->WriteServ("MODE %s %s%s",targetuser->nick,output_sequence.c_str(), parameter_list.str().c_str()); this->LastParse = targetuser->nick; } } else { if (type == MODETYPE_CHANNEL) { targetchannel->WriteChannel(user,"MODE %s %s%s",targetchannel->name,output_sequence.c_str(),parameter_list.str().c_str()); FOREACH_MOD(I_OnMode,OnMode(user, targetchannel, TYPE_CHANNEL, output_sequence + parameter_list.str())); this->LastParse = targetchannel->name; } else { user->WriteTo(targetuser,"MODE %s %s%s",targetuser->nick,output_sequence.c_str(), parameter_list.str().c_str()); FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, output_sequence + parameter_list.str())); this->LastParse = targetuser->nick; } } LastParse.append(" "); LastParse.append(output_sequence); LastParse.append(parameter_list.str()); } } }

const char * ModeParser::Revoke (  userrec *  d, chanrec *  chan, int  MASK )

Revoke a built in privilage (e.g. ops, halfops, voice) to a user on a channel Definition at line 213 of file mode.cpp. References userrec::chans, userrec::nick, UCMODE_HOP, UCMODE_OP, and UCMODE_VOICE. { if (!chan) return ""; UCListIter n = d->chans.find(chan); if (n != d->chans.end()) { if ((n->second & MASK) == 0) { return ""; } n->second ^= MASK; switch (MASK) { case UCMODE_OP: n->first->DelOppedUser(d); break; case UCMODE_HOP: n->first->DelHalfoppedUser(d); break; case UCMODE_VOICE: n->first->DelVoicedUser(d); break; } return d->nick; } return ""; }

userrec * ModeParser::SanityChecks (  userrec *  user, const char *  dest, chanrec *  chan, int  status )

Used to check if user 'd' should be allowed to do operation 'MASK' on channel 'chan'. for example, should 'user A' be able to 'op' on 'channel B'. Definition at line 167 of file mode.cpp. References InspIRCd::FindNick(), userrec::nick, ServerInstance, and userrec::WriteServ(). { userrec *d; if ((!user) || (!dest) || (!chan) || (!*dest)) { return NULL; } d = ServerInstance->FindNick(dest); if (!d) { user->WriteServ("401 %s %s :No such nick/channel",user->nick, dest); return NULL; } return d; }

std::string ModeParser::UserModeList (   )

Returns a list of mode characters which are usermodes. This is used in the 004 numeric when users connect. Definition at line 772 of file mode.cpp. References MASK_USER, and modehandlers. Referenced by userrec::FullConnect(). { char modestr[256]; int pointer = 0; for (unsigned char mode = 'A'; mode <= 'z'; mode++) { unsigned char pos = (mode-65) | MASK_USER; if (modehandlers[pos]) modestr[pointer++] = mode; } modestr[pointer++] = 0; return modestr; }

---

Member Data Documentation

std::string ModeParser::LastParse [private]

The string representing the last set of modes to be parsed. Use GetLastParse() to get this value, to be used for display purposes. Definition at line 395 of file mode.h. Referenced by GetLastParse(), ModeParser(), and Process().

ModeHandler* ModeParser::modehandlers[256] [private]

Mode handlers for each mode, to access a handler subtract 65 from the ascii value of the mode letter. The upper bit of the value indicates if its a usermode or a channel mode, so we have 256 of them not 64. Definition at line 381 of file mode.h. Referenced by AddMode(), BuildPrefixes(), ChanModes(), ChannelModeList(), DelMode(), FindMode(), FindPrefix(), ModeParser(), ModeString(), ParaModeList(), Process(), and UserModeList().

std::vector<ModeWatcher*> ModeParser::modewatchers[256] [private]

Mode watcher classes arranged in the same way as the mode handlers, except for instead of having 256 of them we have 256 lists of them. Definition at line 386 of file mode.h. Referenced by AddModeWatcher(), DelModeWatcher(), ModeParser(), and Process().

InspIRCd* ModeParser::ServerInstance [private]

Creator/owner pointer. Definition at line 375 of file mode.h. Referenced by BuildPrefixes(), ChanModes(), ChannelModeList(), DelMode(), ParaModeList(), Process(), and SanityChecks().

---

The documentation for this class was generated from the following files:

• mode.h
• mode.cpp