2 * InspIRCd -- Internet Relay Chat Daemon
4 * Copyright (C) 2012 Shawn Smith <shawn@inspircd.org>
5 * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
6 * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org>
7 * Copyright (C) 2006-2008 Robin Burchell <robin+git@viroteck.net>
8 * Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
9 * Copyright (C) 2004-2008 Craig Edwards <craigedwards@brainbox.cc>
10 * Copyright (C) 2006 Oliver Lupton <oliverlupton@gmail.com>
12 * This file is part of InspIRCd. InspIRCd is free software: you can
13 * redistribute it and/or modify it under the terms of the GNU General Public
14 * License as published by the Free Software Foundation, version 2.
16 * This program is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21 * You should have received a copy of the GNU General Public License
22 * along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include "inspstring.h"
30 #include "modes/cmode_s.h"
32 #include "modes/cmode_p.h"
34 #include "modes/cmode_b.h"
36 #include "modes/cmode_m.h"
37 /* +t (only (half) ops can change topic) */
38 #include "modes/cmode_t.h"
39 /* +n (no external messages) */
40 #include "modes/cmode_n.h"
41 /* +i (invite only) */
42 #include "modes/cmode_i.h"
43 /* +k (keyed channel) */
44 #include "modes/cmode_k.h"
45 /* +l (channel user limit) */
46 #include "modes/cmode_l.h"
48 #include "modes/cmode_o.h"
49 /* +v (channel voice) */
50 #include "modes/cmode_v.h"
51 /* +w (see wallops) */
52 #include "modes/umode_w.h"
54 #include "modes/umode_i.h"
56 #include "modes/umode_o.h"
57 /* +s (server notice masks) */
58 #include "modes/umode_s.h"
60 ModeHandler::ModeHandler(Module* Creator, const std::string& Name, char modeletter, ParamSpec Params, ModeType type)
61 : ServiceProvider(Creator, Name, SERVICE_MODE), m_paramtype(TR_TEXT),
62 parameters_taken(Params), mode(modeletter), prefix(0), oper(false),
63 list(false), m_type(type), levelrequired(HALFOP_VALUE)
67 CullResult ModeHandler::cull()
69 if (ServerInstance->Modes)
70 ServerInstance->Modes->DelMode(this);
71 return classbase::cull();
74 ModeHandler::~ModeHandler()
78 bool ModeHandler::IsListMode()
83 unsigned int ModeHandler::GetPrefixRank()
88 int ModeHandler::GetNumParams(bool adding)
90 switch (parameters_taken)
95 return adding ? 1 : 0;
102 std::string ModeHandler::GetUserParameter(User* user)
107 ModResult ModeHandler::AccessCheck(User*, Channel*, std::string &, bool)
109 return MOD_RES_PASSTHRU;
112 ModeAction ModeHandler::OnModeChange(User*, User*, Channel*, std::string&, bool)
114 return MODEACTION_DENY;
117 void ModeHandler::DisplayList(User*, Channel*)
121 void ModeHandler::DisplayEmptyList(User*, Channel*)
125 void ModeHandler::OnParameterMissing(User* user, User* dest, Channel* channel)
129 bool ModeHandler::ResolveModeConflict(std::string& theirs, const std::string& ours, Channel*)
131 return (theirs < ours);
134 ModeAction SimpleUserModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
136 /* We're either trying to add a mode we already have or
137 remove a mode we don't have, deny. */
138 if (dest->IsModeSet(this->GetModeChar()) == adding)
139 return MODEACTION_DENY;
141 /* adding will be either true or false, depending on if we
142 are adding or removing the mode, since we already checked
143 to make sure we aren't adding a mode we have or that we
144 aren't removing a mode we don't have, we don't have to do any
145 other checks here to see if it's true or false, just add or
147 dest->SetMode(this->GetModeChar(), adding);
149 return MODEACTION_ALLOW;
153 ModeAction SimpleChannelModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
155 /* We're either trying to add a mode we already have or
156 remove a mode we don't have, deny. */
157 if (channel->IsModeSet(this->GetModeChar()) == adding)
158 return MODEACTION_DENY;
160 /* adding will be either true or false, depending on if we
161 are adding or removing the mode, since we already checked
162 to make sure we aren't adding a mode we have or that we
163 aren't removing a mode we don't have, we don't have to do any
164 other checks here to see if it's true or false, just add or
166 channel->SetMode(this->GetModeChar(), adding);
168 return MODEACTION_ALLOW;
171 ModeAction ParamChannelModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
173 if (adding && !ParamValidate(parameter))
174 return MODEACTION_DENY;
175 std::string now = channel->GetModeParameter(this);
176 if (parameter == now)
177 return MODEACTION_DENY;
179 channel->SetModeParam(this, parameter);
181 channel->SetModeParam(this, "");
182 return MODEACTION_ALLOW;
185 bool ParamChannelModeHandler::ParamValidate(std::string& parameter)
190 ModeWatcher::ModeWatcher(Module* Creator, char modeletter, ModeType type)
191 : mode(modeletter), m_type(type), creator(Creator)
195 ModeWatcher::~ModeWatcher()
199 char ModeWatcher::GetModeChar()
204 ModeType ModeWatcher::GetModeType()
209 bool ModeWatcher::BeforeMode(User*, User*, Channel*, std::string&, bool, ModeType)
214 void ModeWatcher::AfterMode(User*, User*, Channel*, const std::string&, bool, ModeType)
218 User* ModeParser::SanityChecks(User *user, const char *dest, Channel *chan, int)
221 if ((!user) || (!dest) || (!chan) || (!*dest))
225 d = ServerInstance->FindNick(dest);
228 user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel",user->nick.c_str(), dest);
234 void ModeParser::DisplayCurrentModes(User *user, User* targetuser, Channel* targetchannel, const char* text)
238 /* Display channel's current mode string */
239 user->WriteNumeric(RPL_CHANNELMODEIS, "%s %s +%s",user->nick.c_str(), targetchannel->name.c_str(), targetchannel->ChanModes(targetchannel->HasUser(user)));
240 user->WriteNumeric(RPL_CHANNELCREATED, "%s %s %lu", user->nick.c_str(), targetchannel->name.c_str(), (unsigned long)targetchannel->age);
245 if (targetuser == user || user->HasPrivPermission("users/auspex"))
247 /* Display user's current mode string */
248 user->WriteNumeric(RPL_UMODEIS, "%s :+%s",targetuser->nick.c_str(),targetuser->FormatModes());
249 if (IS_OPER(targetuser))
250 user->WriteNumeric(RPL_SNOMASKIS, "%s +%s :Server notice mask", targetuser->nick.c_str(), targetuser->FormatNoticeMasks());
255 user->WriteNumeric(ERR_USERSDONTMATCH, "%s :Can't view modes for other users", user->nick.c_str());
261 ModeAction ModeParser::TryMode(User* user, User* targetuser, Channel* chan, bool adding, const unsigned char modechar,
262 std::string ¶meter, bool SkipACL)
264 ModeType type = chan ? MODETYPE_CHANNEL : MODETYPE_USER;
265 unsigned char mask = chan ? MASK_CHANNEL : MASK_USER;
267 ModeHandler *mh = FindMode(modechar, type);
268 int pcnt = mh->GetNumParams(adding);
270 // crop mode parameter size to 250 characters
271 if (parameter.length() > 250 && adding)
272 parameter = parameter.substr(0, 250);
274 ModResult MOD_RESULT;
275 FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, modechar, parameter, adding, pcnt));
277 if (IS_LOCAL(user) && (MOD_RESULT == MOD_RES_DENY))
278 return MODEACTION_DENY;
280 if (chan && !SkipACL && (MOD_RESULT != MOD_RES_ALLOW))
282 MOD_RESULT = mh->AccessCheck(user, chan, parameter, adding);
284 if (MOD_RESULT == MOD_RES_DENY)
285 return MODEACTION_DENY;
286 if (MOD_RESULT == MOD_RES_PASSTHRU)
288 unsigned int neededrank = mh->GetLevelRequired();
289 /* Compare our rank on the channel against the rank of the required prefix,
290 * allow if >= ours. Because mIRC and xchat throw a tizz if the modes shown
291 * in NAMES(X) are not in rank order, we know the most powerful mode is listed
292 * first, so we don't need to iterate, we just look up the first instead.
294 unsigned int ourrank = chan->GetPrefixValue(user);
295 if (ourrank < neededrank)
297 ModeHandler* neededmh = NULL;
298 for(char c='A'; c <= 'z'; c++)
300 ModeHandler *privmh = FindMode(c, MODETYPE_CHANNEL);
301 if (privmh && privmh->GetPrefixRank() >= neededrank)
303 // this mode is sufficient to allow this action
304 if (!neededmh || privmh->GetPrefixRank() < neededmh->GetPrefixRank())
309 user->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You must have channel %s access or above to %sset channel mode %c",
310 user->nick.c_str(), chan->name.c_str(), neededmh->name.c_str(), adding ? "" : "un", modechar);
312 user->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You cannot %sset channel mode %c",
313 user->nick.c_str(), chan->name.c_str(), adding ? "" : "un", modechar);
314 return MODEACTION_DENY;
319 unsigned char handler_id = (modechar - 'A') | mask;
321 for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
323 if ((*watchers)->BeforeMode(user, targetuser, chan, parameter, adding, type) == false)
324 return MODEACTION_DENY;
325 /* A module whacked the parameter completely, and there was one. abort. */
326 if (pcnt && parameter.empty())
327 return MODEACTION_DENY;
330 if (IS_LOCAL(user) && !IS_OPER(user))
332 char* disabled = (type == MODETYPE_CHANNEL) ? ServerInstance->Config->DisabledCModes : ServerInstance->Config->DisabledUModes;
333 if (disabled[modechar - 'A'])
335 user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - %s mode %c has been locked by the administrator",
336 user->nick.c_str(), type == MODETYPE_CHANNEL ? "channel" : "user", modechar);
337 return MODEACTION_DENY;
341 if (adding && IS_LOCAL(user) && mh->NeedsOper() && !user->HasModePermission(modechar, type))
343 /* It's an oper only mode, and they don't have access to it. */
346 user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - Oper type %s does not have access to set %s mode %c",
347 user->nick.c_str(), user->oper->NameStr(), type == MODETYPE_CHANNEL ? "channel" : "user", modechar);
351 user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - Only operators may set %s mode %c",
352 user->nick.c_str(), type == MODETYPE_CHANNEL ? "channel" : "user", modechar);
354 return MODEACTION_DENY;
357 if (mh->GetTranslateType() == TR_NICK && !ServerInstance->FindNick(parameter))
359 user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel", user->nick.c_str(), parameter.c_str());
360 return MODEACTION_DENY;
363 if (mh->GetPrefixRank() && chan)
365 User* user_to_prefix = ServerInstance->FindNick(parameter);
367 return MODEACTION_DENY;
368 if (!chan->SetPrefix(user_to_prefix, modechar, adding))
369 return MODEACTION_DENY;
372 /* Call the handler for the mode */
373 ModeAction ma = mh->OnModeChange(user, targetuser, chan, parameter, adding);
375 if (pcnt && parameter.empty())
376 return MODEACTION_DENY;
378 if (ma != MODEACTION_ALLOW)
381 for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
382 (*watchers)->AfterMode(user, targetuser, chan, parameter, adding, type);
384 return MODEACTION_ALLOW;
387 void ModeParser::Process(const std::vector<std::string>& parameters, User *user, bool merge)
389 std::string target = parameters[0];
390 Channel* targetchannel = ServerInstance->FindChan(target);
391 User* targetuser = ServerInstance->FindNick(target);
392 ModeType type = targetchannel ? MODETYPE_CHANNEL : MODETYPE_USER;
395 LastParseParams.clear();
396 LastParseTranslate.clear();
398 if (!targetchannel && !targetuser)
400 user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel",user->nick.c_str(),target.c_str());
403 if (parameters.size() == 1)
405 this->DisplayCurrentModes(user, targetuser, targetchannel, target.c_str());
409 ModResult MOD_RESULT;
410 FIRST_MOD_RESULT(OnPreMode, MOD_RESULT, (user, targetuser, targetchannel, parameters));
412 bool SkipAccessChecks = false;
414 if (!IS_LOCAL(user) || ServerInstance->ULine(user->server) || MOD_RESULT == MOD_RES_ALLOW)
415 SkipAccessChecks = true;
416 else if (MOD_RESULT == MOD_RES_DENY)
419 if (targetuser && !SkipAccessChecks && user != targetuser)
421 user->WriteNumeric(ERR_USERSDONTMATCH, "%s :Can't change mode for other users", user->nick.c_str());
425 std::string mode_sequence = parameters[1];
427 std::string output_mode;
428 std::ostringstream output_parameters;
429 LastParseParams.push_back(output_mode);
430 LastParseTranslate.push_back(TR_TEXT);
433 char output_pm = '\0'; // current output state, '+' or '-'
434 unsigned int param_at = 2;
436 for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
438 unsigned char modechar = *letter;
439 if (modechar == '+' || modechar == '-')
441 adding = (modechar == '+');
445 ModeHandler *mh = this->FindMode(modechar, type);
448 /* No mode handler? Unknown mode character then. */
449 user->WriteServ("%d %s %c :is unknown mode char to me", type == MODETYPE_CHANNEL ? 472 : 501, user->nick.c_str(), modechar);
453 std::string parameter = "";
454 int pcnt = mh->GetNumParams(adding);
455 if (pcnt && param_at == parameters.size())
457 /* No parameter, continue to the next mode */
458 mh->OnParameterMissing(user, targetuser, targetchannel);
463 parameter = parameters[param_at++];
464 /* Make sure the user isn't trying to slip in an invalid parameter */
465 if ((parameter.find(':') == 0) || (parameter.rfind(' ') != std::string::npos))
467 if (merge && targetchannel && targetchannel->IsModeSet(modechar) && !mh->IsListMode())
469 std::string ours = targetchannel->GetModeParameter(modechar);
470 if (!mh->ResolveModeConflict(parameter, ours, targetchannel))
471 /* we won the mode merge, don't apply this mode */
476 ModeAction ma = TryMode(user, targetuser, targetchannel, adding, modechar, parameter, SkipAccessChecks);
478 if (ma != MODEACTION_ALLOW)
481 char needed_pm = adding ? '+' : '-';
482 if (needed_pm != output_pm)
484 output_pm = needed_pm;
485 output_mode.append(1, output_pm);
487 output_mode.append(1, modechar);
491 TranslateType tt = mh->GetTranslateType();
494 User* u = ServerInstance->FindNick(parameter);
498 output_parameters << " " << parameter;
499 LastParseParams.push_back(parameter);
500 LastParseTranslate.push_back(tt);
503 if ( (output_mode.length() + output_parameters.str().length() > 450)
504 || (output_mode.length() > 100)
505 || (LastParseParams.size() > ServerInstance->Config->Limits.MaxModes))
507 /* mode sequence is getting too long */
512 LastParseParams[0] = output_mode;
514 if (!output_mode.empty())
516 LastParse = targetchannel ? targetchannel->name : targetuser->nick;
517 LastParse.append(" ");
518 LastParse.append(output_mode);
519 LastParse.append(output_parameters.str());
523 targetchannel->WriteChannel(user, "MODE %s", LastParse.c_str());
524 FOREACH_MOD(I_OnMode,OnMode(user, targetchannel, TYPE_CHANNEL, LastParseParams, LastParseTranslate));
528 targetuser->WriteFrom(user, "MODE %s", LastParse.c_str());
529 FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, LastParseParams, LastParseTranslate));
532 else if (targetchannel && parameters.size() == 2)
534 /* Special case for displaying the list for listmodes,
535 * e.g. MODE #chan b, or MODE #chan +b without a parameter
537 this->DisplayListModes(user, targetchannel, mode_sequence);
541 void ModeParser::DisplayListModes(User* user, Channel* chan, std::string &mode_sequence)
545 for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
547 unsigned char mletter = *letter;
551 /* Ensure the user doesnt request the same mode twice,
552 * so they cant flood themselves off out of idiocy.
554 if (sent[mletter] == seq)
559 ModeHandler *mh = this->FindMode(mletter, MODETYPE_CHANNEL);
561 if (!mh || !mh->IsListMode())
564 ModResult MOD_RESULT;
565 FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, mletter, "", true, 0));
566 if (MOD_RESULT == MOD_RES_DENY)
570 if (!user->HasPrivPermission("channels/auspex") && ServerInstance->Config->HideModeLists[mletter] && (chan->GetPrefixValue(user) < HALFOP_VALUE))
572 user->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You do not have access to view the +%c list",
573 user->nick.c_str(), chan->name.c_str(), mletter);
577 unsigned char handler_id = (mletter - 'A') | MASK_CHANNEL;
579 for(ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
581 std::string dummyparam;
583 if (!((*watchers)->BeforeMode(user, NULL, chan, dummyparam, true, MODETYPE_CHANNEL)))
587 mh->DisplayList(user, chan);
589 mh->DisplayEmptyList(user, chan);
593 const std::string& ModeParser::GetLastParse()
598 void ModeParser::CleanMask(std::string &mask)
600 std::string::size_type pos_of_pling = mask.find_first_of('!');
601 std::string::size_type pos_of_at = mask.find_first_of('@');
602 std::string::size_type pos_of_dot = mask.find_first_of('.');
603 std::string::size_type pos_of_colons = mask.find("::"); /* Because ipv6 addresses are colon delimited -- double so it treats extban as nick */
605 if (mask.length() >= 2 && mask[1] == ':')
606 return; // if it's an extban, don't even try guess how it needs to be formed.
608 if ((pos_of_pling == std::string::npos) && (pos_of_at == std::string::npos))
610 /* Just a nick, or just a host - or clearly ipv6 (starting with :) */
611 if ((pos_of_dot == std::string::npos) && (pos_of_colons == std::string::npos) && mask[0] != ':')
613 /* It has no '.' in it, it must be a nick. */
618 /* Got a dot in it? Has to be a host */
619 mask = "*!*@" + mask;
622 else if ((pos_of_pling == std::string::npos) && (pos_of_at != std::string::npos))
624 /* Has an @ but no !, its a user@host */
627 else if ((pos_of_pling != std::string::npos) && (pos_of_at == std::string::npos))
629 /* Has a ! but no @, it must be a nick!ident */
634 bool ModeParser::AddMode(ModeHandler* mh)
636 unsigned char mask = 0;
637 unsigned char pos = 0;
639 /* Yes, i know, this might let people declare modes like '_' or '^'.
640 * If they do that, thats their problem, and if i ever EVER see an
641 * official InspIRCd developer do that, i'll beat them with a paddle!
643 if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z') || (mh->GetPrefix() > 126))
646 /* A mode prefix of ',' is not acceptable, it would fuck up server to server.
647 * A mode prefix of ':' will fuck up both server to server, and client to server.
648 * A mode prefix of '#' will mess up /whois and /privmsg
650 if ((mh->GetPrefix() == ',') || (mh->GetPrefix() == ':') || (mh->GetPrefix() == '#'))
653 if (mh->GetPrefix() && FindPrefix(mh->GetPrefix()))
656 mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
657 pos = (mh->GetModeChar()-65) | mask;
659 if (modehandlers[pos])
662 modehandlers[pos] = mh;
666 bool ModeParser::DelMode(ModeHandler* mh)
668 unsigned char mask = 0;
669 unsigned char pos = 0;
671 if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z'))
674 mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
675 pos = (mh->GetModeChar()-65) | mask;
677 if (modehandlers[pos] != mh)
680 /* Note: We can't stack here, as we have modes potentially being removed across many different channels.
681 * To stack here we have to make the algorithm slower. Discuss.
683 switch (mh->GetModeType())
686 for (user_hash::iterator i = ServerInstance->Users->clientlist->begin(); i != ServerInstance->Users->clientlist->end(); i++)
688 mh->RemoveMode(i->second);
691 case MODETYPE_CHANNEL:
692 for (chan_hash::iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); i++)
694 mh->RemoveMode(i->second);
699 modehandlers[pos] = NULL;
704 ModeHandler* ModeParser::FindMode(unsigned const char modeletter, ModeType mt)
706 unsigned char mask = 0;
707 unsigned char pos = 0;
709 if ((modeletter < 'A') || (modeletter > 'z'))
712 mt == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
713 pos = (modeletter-65) | mask;
715 return modehandlers[pos];
718 std::string ModeParser::UserModeList()
723 for (unsigned char mode = 'A'; mode <= 'z'; mode++)
725 unsigned char pos = (mode-65) | MASK_USER;
727 if (modehandlers[pos])
728 modestr[pointer++] = mode;
730 modestr[pointer++] = 0;
734 std::string ModeParser::ChannelModeList()
739 for (unsigned char mode = 'A'; mode <= 'z'; mode++)
741 unsigned char pos = (mode-65) | MASK_CHANNEL;
743 if (modehandlers[pos])
744 modestr[pointer++] = mode;
746 modestr[pointer++] = 0;
750 std::string ModeParser::ParaModeList()
755 for (unsigned char mode = 'A'; mode <= 'z'; mode++)
757 unsigned char pos = (mode-65) | MASK_CHANNEL;
759 if ((modehandlers[pos]) && (modehandlers[pos]->GetNumParams(true)))
760 modestr[pointer++] = mode;
762 modestr[pointer++] = 0;
766 ModeHandler* ModeParser::FindPrefix(unsigned const char pfxletter)
768 for (unsigned char mode = 'A'; mode <= 'z'; mode++)
770 unsigned char pos = (mode-65) | MASK_CHANNEL;
772 if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix() == pfxletter))
774 return modehandlers[pos];
780 std::string ModeParser::GiveModeList(ModeMasks m)
782 std::string type1; /* Listmodes EXCEPT those with a prefix */
783 std::string type2; /* Modes that take a param when adding or removing */
784 std::string type3; /* Modes that only take a param when adding */
785 std::string type4; /* Modes that dont take a param */
787 for (unsigned char mode = 'A'; mode <= 'z'; mode++)
789 unsigned char pos = (mode-65) | m;
790 /* One parameter when adding */
791 if (modehandlers[pos])
793 if (modehandlers[pos]->GetNumParams(true))
795 if ((modehandlers[pos]->IsListMode()) && (!modehandlers[pos]->GetPrefix()))
797 type1 += modehandlers[pos]->GetModeChar();
801 /* ... and one parameter when removing */
802 if (modehandlers[pos]->GetNumParams(false))
804 /* But not a list mode */
805 if (!modehandlers[pos]->GetPrefix())
807 type2 += modehandlers[pos]->GetModeChar();
812 /* No parameters when removing */
813 type3 += modehandlers[pos]->GetModeChar();
819 type4 += modehandlers[pos]->GetModeChar();
824 return type1 + "," + type2 + "," + type3 + "," + type4;
827 std::string ModeParser::BuildPrefixes(bool lettersAndModes)
829 std::string mletters;
830 std::string mprefixes;
831 std::map<int,std::pair<char,char> > prefixes;
833 for (unsigned char mode = 'A'; mode <= 'z'; mode++)
835 unsigned char pos = (mode-65) | MASK_CHANNEL;
837 if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix()))
839 prefixes[modehandlers[pos]->GetPrefixRank()] = std::make_pair(
840 modehandlers[pos]->GetPrefix(), modehandlers[pos]->GetModeChar());
844 for(std::map<int,std::pair<char,char> >::reverse_iterator n = prefixes.rbegin(); n != prefixes.rend(); n++)
846 mletters = mletters + n->second.first;
847 mprefixes = mprefixes + n->second.second;
850 return lettersAndModes ? "(" + mprefixes + ")" + mletters : mletters;
853 bool ModeParser::AddModeWatcher(ModeWatcher* mw)
855 unsigned char mask = 0;
856 unsigned char pos = 0;
861 if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z'))
864 mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
865 pos = (mw->GetModeChar()-65) | mask;
867 modewatchers[pos].push_back(mw);
872 bool ModeParser::DelModeWatcher(ModeWatcher* mw)
874 unsigned char mask = 0;
875 unsigned char pos = 0;
880 if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z'))
883 mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
884 pos = (mw->GetModeChar()-65) | mask;
886 ModeWatchIter a = find(modewatchers[pos].begin(),modewatchers[pos].end(),mw);
888 if (a == modewatchers[pos].end())
893 modewatchers[pos].erase(a);
898 /** This default implementation can remove simple user modes
900 void ModeHandler::RemoveMode(User* user, irc::modestacker* stack)
902 char moderemove[MAXBUF];
903 std::vector<std::string> parameters;
905 if (user->IsModeSet(this->GetModeChar()))
909 stack->Push(this->GetModeChar());
913 sprintf(moderemove,"-%c",this->GetModeChar());
914 parameters.push_back(user->nick);
915 parameters.push_back(moderemove);
916 ServerInstance->Modes->Process(parameters, ServerInstance->FakeClient);
921 /** This default implementation can remove simple channel modes
924 void ModeHandler::RemoveMode(Channel* channel, irc::modestacker* stack)
926 char moderemove[MAXBUF];
927 std::vector<std::string> parameters;
929 if (channel->IsModeSet(this->GetModeChar()))
933 stack->Push(this->GetModeChar());
937 sprintf(moderemove,"-%c",this->GetModeChar());
938 parameters.push_back(channel->name);
939 parameters.push_back(moderemove);
940 ServerInstance->SendMode(parameters, ServerInstance->FakeClient);
948 ModeChannelPrivate p;
949 ModeChannelModerated m;
950 ModeChannelTopicOps t;
952 ModeChannelNoExternal n;
953 ModeChannelInviteOnly i;
962 ModeUserInvisible ui;
964 ModeUserServerNoticeMask us;
966 void init(ModeParser* modes)
986 static builtin_modes static_modes;
988 ModeParser::ModeParser()
990 /* Clear mode handler list */
991 memset(modehandlers, 0, sizeof(modehandlers));
993 /* Last parse string */
997 memset(&sent, 0, sizeof(sent));
999 static_modes.init(this);
1002 ModeParser::~ModeParser()