src/mode.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   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>
  11  *
  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.
  15  *
  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
  19  * details.
  20  *
  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/>.
  23  */
  24
  25
  26 #include "inspircd.h"
  27 #include "builtinmodes.h"
  28
  29 ModeHandler::ModeHandler(Module* Creator, const std::string& Name, char modeletter, ParamSpec Params, ModeType type)
  30         : ServiceProvider(Creator, Name, SERVICE_MODE), m_paramtype(TR_TEXT),
  31         parameters_taken(Params), mode(modeletter), prefix(0), oper(false),
  32         list(false), m_type(type), levelrequired(HALFOP_VALUE)
  33 {
  34 }
  35
  36 CullResult ModeHandler::cull()
  37 {
  38         if (ServerInstance->Modes)
  39                 ServerInstance->Modes->DelMode(this);
  40         return classbase::cull();
  41 }
  42
  43 ModeHandler::~ModeHandler()
  44 {
  45 }
  46
  47 bool ModeHandler::IsListMode()
  48 {
  49         return list;
  50 }
  51
  52 unsigned int ModeHandler::GetPrefixRank()
  53 {
  54         return 0;
  55 }
  56
  57 int ModeHandler::GetNumParams(bool adding)
  58 {
  59         switch (parameters_taken)
  60         {
  61                 case PARAM_ALWAYS:
  62                         return 1;
  63                 case PARAM_SETONLY:
  64                         return adding ? 1 : 0;
  65                 case PARAM_NONE:
  66                         break;
  67         }
  68         return 0;
  69 }
  70
  71 std::string ModeHandler::GetUserParameter(User* user)
  72 {
  73         return "";
  74 }
  75
  76 ModResult ModeHandler::AccessCheck(User*, Channel*, std::string &, bool)
  77 {
  78         return MOD_RES_PASSTHRU;
  79 }
  80
  81 ModeAction ModeHandler::OnModeChange(User*, User*, Channel*, std::string&, bool)
  82 {
  83         return MODEACTION_DENY;
  84 }
  85
  86 void ModeHandler::DisplayList(User*, Channel*)
  87 {
  88 }
  89
  90 void ModeHandler::DisplayEmptyList(User*, Channel*)
  91 {
  92 }
  93
  94 void ModeHandler::OnParameterMissing(User* user, User* dest, Channel* channel)
  95 {
  96 }
  97
  98 bool ModeHandler::ResolveModeConflict(std::string& theirs, const std::string& ours, Channel*)
  99 {
 100         return (theirs < ours);
 101 }
 102
 103 ModeAction SimpleUserModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
 104 {
 105         /* We're either trying to add a mode we already have or
 106                 remove a mode we don't have, deny. */
 107         if (dest->IsModeSet(this->GetModeChar()) == adding)
 108                 return MODEACTION_DENY;
 109
 110         /* adding will be either true or false, depending on if we
 111                 are adding or removing the mode, since we already checked
 112                 to make sure we aren't adding a mode we have or that we
 113                 aren't removing a mode we don't have, we don't have to do any
 114                 other checks here to see if it's true or false, just add or
 115                 remove the mode */
 116         dest->SetMode(this->GetModeChar(), adding);
 117
 118         return MODEACTION_ALLOW;
 119 }
 120
 121
 122 ModeAction SimpleChannelModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
 123 {
 124         /* We're either trying to add a mode we already have or
 125                 remove a mode we don't have, deny. */
 126         if (channel->IsModeSet(this->GetModeChar()) == adding)
 127                 return MODEACTION_DENY;
 128
 129         /* adding will be either true or false, depending on if we
 130                 are adding or removing the mode, since we already checked
 131                 to make sure we aren't adding a mode we have or that we
 132                 aren't removing a mode we don't have, we don't have to do any
 133                 other checks here to see if it's true or false, just add or
 134                 remove the mode */
 135         channel->SetMode(this->GetModeChar(), adding);
 136
 137         return MODEACTION_ALLOW;
 138 }
 139
 140 ModeAction ParamChannelModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
 141 {
 142         if (adding && !ParamValidate(parameter))
 143                 return MODEACTION_DENY;
 144         std::string now = channel->GetModeParameter(this);
 145         if (parameter == now)
 146                 return MODEACTION_DENY;
 147         if (adding)
 148                 channel->SetModeParam(this, parameter);
 149         else
 150                 channel->SetModeParam(this, "");
 151         return MODEACTION_ALLOW;
 152 }
 153
 154 bool ParamChannelModeHandler::ParamValidate(std::string& parameter)
 155 {
 156         return true;
 157 }
 158
 159 ModeWatcher::ModeWatcher(Module* Creator, char modeletter, ModeType type)
 160         : mode(modeletter), m_type(type), creator(Creator)
 161 {
 162 }
 163
 164 ModeWatcher::~ModeWatcher()
 165 {
 166 }
 167
 168 char ModeWatcher::GetModeChar()
 169 {
 170         return mode;
 171 }
 172
 173 ModeType ModeWatcher::GetModeType()
 174 {
 175         return m_type;
 176 }
 177
 178 bool ModeWatcher::BeforeMode(User*, User*, Channel*, std::string&, bool, ModeType)
 179 {
 180         return true;
 181 }
 182
 183 void ModeWatcher::AfterMode(User*, User*, Channel*, const std::string&, bool, ModeType)
 184 {
 185 }
 186
 187 User* ModeParser::SanityChecks(User *user, const char *dest, Channel *chan, int)
 188 {
 189         User *d;
 190         if ((!user) || (!dest) || (!chan) || (!*dest))
 191         {
 192                 return NULL;
 193         }
 194         d = ServerInstance->FindNick(dest);
 195         if (!d)
 196         {
 197                 user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel",user->nick.c_str(), dest);
 198                 return NULL;
 199         }
 200         return d;
 201 }
 202
 203 void ModeParser::DisplayCurrentModes(User *user, User* targetuser, Channel* targetchannel, const char* text)
 204 {
 205         if (targetchannel)
 206         {
 207                 /* Display channel's current mode string */
 208                 user->WriteNumeric(RPL_CHANNELMODEIS, "%s %s +%s",user->nick.c_str(), targetchannel->name.c_str(), targetchannel->ChanModes(targetchannel->HasUser(user)));
 209                 user->WriteNumeric(RPL_CHANNELCREATED, "%s %s %lu", user->nick.c_str(), targetchannel->name.c_str(), (unsigned long)targetchannel->age);
 210                 return;
 211         }
 212         else
 213         {
 214                 if (targetuser == user || user->HasPrivPermission("users/auspex"))
 215                 {
 216                         /* Display user's current mode string */
 217                         user->WriteNumeric(RPL_UMODEIS, "%s :+%s",targetuser->nick.c_str(),targetuser->FormatModes());
 218                         if ((targetuser->IsOper()))
 219                                 user->WriteNumeric(RPL_SNOMASKIS, "%s +%s :Server notice mask", targetuser->nick.c_str(), targetuser->FormatNoticeMasks());
 220                         return;
 221                 }
 222                 else
 223                 {
 224                         user->WriteNumeric(ERR_USERSDONTMATCH, "%s :Can't view modes for other users", user->nick.c_str());
 225                         return;
 226                 }
 227         }
 228 }
 229
 230 ModeAction ModeParser::TryMode(User* user, User* targetuser, Channel* chan, bool adding, const unsigned char modechar,
 231                 std::string &parameter, bool SkipACL)
 232 {
 233         ModeType type = chan ? MODETYPE_CHANNEL : MODETYPE_USER;
 234         unsigned char mask = chan ? MASK_CHANNEL : MASK_USER;
 235
 236         ModeHandler *mh = FindMode(modechar, type);
 237         int pcnt = mh->GetNumParams(adding);
 238
 239         // crop mode parameter size to 250 characters
 240         if (parameter.length() > 250 && adding)
 241                 parameter = parameter.substr(0, 250);
 242
 243         ModResult MOD_RESULT;
 244         FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, modechar, parameter, adding, pcnt));
 245
 246         if (IS_LOCAL(user) && (MOD_RESULT == MOD_RES_DENY))
 247                 return MODEACTION_DENY;
 248
 249         if (chan && !SkipACL && (MOD_RESULT != MOD_RES_ALLOW))
 250         {
 251                 MOD_RESULT = mh->AccessCheck(user, chan, parameter, adding);
 252
 253                 if (MOD_RESULT == MOD_RES_DENY)
 254                         return MODEACTION_DENY;
 255                 if (MOD_RESULT == MOD_RES_PASSTHRU)
 256                 {
 257                         unsigned int neededrank = mh->GetLevelRequired();
 258                         /* Compare our rank on the channel against the rank of the required prefix,
 259                          * allow if >= ours. Because mIRC and xchat throw a tizz if the modes shown
 260                          * in NAMES(X) are not in rank order, we know the most powerful mode is listed
 261                          * first, so we don't need to iterate, we just look up the first instead.
 262                          */
 263                         unsigned int ourrank = chan->GetPrefixValue(user);
 264                         if (ourrank < neededrank)
 265                         {
 266                                 ModeHandler* neededmh = NULL;
 267                                 for(char c='A'; c <= 'z'; c++)
 268                                 {
 269                                         ModeHandler *privmh = FindMode(c, MODETYPE_CHANNEL);
 270                                         if (privmh && privmh->GetPrefixRank() >= neededrank)
 271                                         {
 272                                                 // this mode is sufficient to allow this action
 273                                                 if (!neededmh || privmh->GetPrefixRank() < neededmh->GetPrefixRank())
 274                                                         neededmh = privmh;
 275                                         }
 276                                 }
 277                                 if (neededmh)
 278                                         user->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You must have channel %s access or above to %sset channel mode %c",
 279                                                 user->nick.c_str(), chan->name.c_str(), neededmh->name.c_str(), adding ? "" : "un", modechar);
 280                                 else
 281                                         user->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You cannot %sset channel mode %c",
 282                                                 user->nick.c_str(), chan->name.c_str(), adding ? "" : "un", modechar);
 283                                 return MODEACTION_DENY;
 284                         }
 285                 }
 286         }
 287
 288         unsigned char handler_id = (modechar - 'A') | mask;
 289
 290         for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
 291         {
 292                 if ((*watchers)->BeforeMode(user, targetuser, chan, parameter, adding, type) == false)
 293                         return MODEACTION_DENY;
 294                 /* A module whacked the parameter completely, and there was one. abort. */
 295                 if (pcnt && parameter.empty())
 296                         return MODEACTION_DENY;
 297         }
 298
 299         if (IS_LOCAL(user) && !user->IsOper())
 300         {
 301                 char* disabled = (type == MODETYPE_CHANNEL) ? ServerInstance->Config->DisabledCModes : ServerInstance->Config->DisabledUModes;
 302                 if (disabled[modechar - 'A'])
 303                 {
 304                         user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - %s mode %c has been locked by the administrator",
 305                                 user->nick.c_str(), type == MODETYPE_CHANNEL ? "channel" : "user", modechar);
 306                         return MODEACTION_DENY;
 307                 }
 308         }
 309
 310         if (adding && IS_LOCAL(user) && mh->NeedsOper() && !user->HasModePermission(modechar, type))
 311         {
 312                 /* It's an oper only mode, and they don't have access to it. */
 313                 if (user->IsOper())
 314                 {
 315                         user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - Oper type %s does not have access to set %s mode %c",
 316                                         user->nick.c_str(), user->oper->name.c_str(), type == MODETYPE_CHANNEL ? "channel" : "user", modechar);
 317                 }
 318                 else
 319                 {
 320                         user->WriteNumeric(ERR_NOPRIVILEGES, "%s :Permission Denied - Only operators may set %s mode %c",
 321                                         user->nick.c_str(), type == MODETYPE_CHANNEL ? "channel" : "user", modechar);
 322                 }
 323                 return MODEACTION_DENY;
 324         }
 325
 326         if (mh->GetTranslateType() == TR_NICK && !ServerInstance->FindNick(parameter))
 327         {
 328                 user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel", user->nick.c_str(), parameter.c_str());
 329                 return MODEACTION_DENY;
 330         }
 331
 332         if (mh->GetPrefixRank() && chan)
 333         {
 334                 User* user_to_prefix = ServerInstance->FindNick(parameter);
 335                 if (!user_to_prefix)
 336                         return MODEACTION_DENY;
 337                 if (!chan->SetPrefix(user_to_prefix, modechar, adding))
 338                         return MODEACTION_DENY;
 339         }
 340
 341         /* Call the handler for the mode */
 342         ModeAction ma = mh->OnModeChange(user, targetuser, chan, parameter, adding);
 343
 344         if (pcnt && parameter.empty())
 345                 return MODEACTION_DENY;
 346
 347         if (ma != MODEACTION_ALLOW)
 348                 return ma;
 349
 350         for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
 351                 (*watchers)->AfterMode(user, targetuser, chan, parameter, adding, type);
 352
 353         return MODEACTION_ALLOW;
 354 }
 355
 356 void ModeParser::Process(const std::vector<std::string>& parameters, User *user, bool merge)
 357 {
 358         std::string target = parameters[0];
 359         Channel* targetchannel = ServerInstance->FindChan(target);
 360         User* targetuser  = ServerInstance->FindNick(target);
 361         ModeType type = targetchannel ? MODETYPE_CHANNEL : MODETYPE_USER;
 362
 363         LastParse.clear();
 364         LastParseParams.clear();
 365         LastParseTranslate.clear();
 366
 367         if ((!targetchannel) && ((!targetuser) || (IS_SERVER(targetuser))))
 368         {
 369                 user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel",user->nick.c_str(),target.c_str());
 370                 return;
 371         }
 372         if (parameters.size() == 1)
 373         {
 374                 this->DisplayCurrentModes(user, targetuser, targetchannel, target.c_str());
 375                 return;
 376         }
 377
 378         ModResult MOD_RESULT;
 379         FIRST_MOD_RESULT(OnPreMode, MOD_RESULT, (user, targetuser, targetchannel, parameters));
 380
 381         bool SkipAccessChecks = false;
 382
 383         if (!IS_LOCAL(user) || ServerInstance->ULine(user->server) || MOD_RESULT == MOD_RES_ALLOW)
 384                 SkipAccessChecks = true;
 385         else if (MOD_RESULT == MOD_RES_DENY)
 386                 return;
 387
 388         if (targetuser && !SkipAccessChecks && user != targetuser)
 389         {
 390                 user->WriteNumeric(ERR_USERSDONTMATCH, "%s :Can't change mode for other users", user->nick.c_str());
 391                 return;
 392         }
 393
 394         std::string mode_sequence = parameters[1];
 395
 396         std::string output_mode;
 397         std::ostringstream output_parameters;
 398         LastParseParams.push_back(output_mode);
 399         LastParseTranslate.push_back(TR_TEXT);
 400
 401         bool adding = true;
 402         char output_pm = '\0'; // current output state, '+' or '-'
 403         unsigned int param_at = 2;
 404
 405         for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
 406         {
 407                 unsigned char modechar = *letter;
 408                 if (modechar == '+' || modechar == '-')
 409                 {
 410                         adding = (modechar == '+');
 411                         continue;
 412                 }
 413
 414                 ModeHandler *mh = this->FindMode(modechar, type);
 415                 if (!mh)
 416                 {
 417                         /* No mode handler? Unknown mode character then. */
 418                         user->WriteServ("%d %s %c :is unknown mode char to me", type == MODETYPE_CHANNEL ? 472 : 501, user->nick.c_str(), modechar);
 419                         continue;
 420                 }
 421
 422                 std::string parameter;
 423                 int pcnt = mh->GetNumParams(adding);
 424                 if (pcnt && param_at == parameters.size())
 425                 {
 426                         /* No parameter, continue to the next mode */
 427                         mh->OnParameterMissing(user, targetuser, targetchannel);
 428                         continue;
 429                 }
 430                 else if (pcnt)
 431                 {
 432                         parameter = parameters[param_at++];
 433                         /* Make sure the user isn't trying to slip in an invalid parameter */
 434                         if ((parameter.find(':') == 0) || (parameter.rfind(' ') != std::string::npos))
 435                                 continue;
 436                         if (merge && targetchannel && targetchannel->IsModeSet(modechar) && !mh->IsListMode())
 437                         {
 438                                 std::string ours = targetchannel->GetModeParameter(modechar);
 439                                 if (!mh->ResolveModeConflict(parameter, ours, targetchannel))
 440                                         /* we won the mode merge, don't apply this mode */
 441                                         continue;
 442                         }
 443                 }
 444
 445                 ModeAction ma = TryMode(user, targetuser, targetchannel, adding, modechar, parameter, SkipAccessChecks);
 446
 447                 if (ma != MODEACTION_ALLOW)
 448                         continue;
 449
 450                 char needed_pm = adding ? '+' : '-';
 451                 if (needed_pm != output_pm)
 452                 {
 453                         output_pm = needed_pm;
 454                         output_mode.append(1, output_pm);
 455                 }
 456                 output_mode.append(1, modechar);
 457
 458                 if (pcnt)
 459                 {
 460                         TranslateType tt = mh->GetTranslateType();
 461                         if (tt == TR_NICK)
 462                         {
 463                                 User* u = ServerInstance->FindNick(parameter);
 464                                 if (u)
 465                                         parameter = u->nick;
 466                         }
 467                         output_parameters << " " << parameter;
 468                         LastParseParams.push_back(parameter);
 469                         LastParseTranslate.push_back(tt);
 470                 }
 471
 472                 if ( (output_mode.length() + output_parameters.str().length() > 450)
 473                                 || (output_mode.length() > 100)
 474                                 || (LastParseParams.size() > ServerInstance->Config->Limits.MaxModes))
 475                 {
 476                         /* mode sequence is getting too long */
 477                         break;
 478                 }
 479         }
 480
 481         LastParseParams[0] = output_mode;
 482
 483         if (!output_mode.empty())
 484         {
 485                 LastParse = targetchannel ? targetchannel->name : targetuser->nick;
 486                 LastParse.append(" ");
 487                 LastParse.append(output_mode);
 488                 LastParse.append(output_parameters.str());
 489
 490                 if (targetchannel)
 491                 {
 492                         targetchannel->WriteChannel(user, "MODE %s", LastParse.c_str());
 493                         FOREACH_MOD(I_OnMode,OnMode(user, targetchannel, TYPE_CHANNEL, LastParseParams, LastParseTranslate));
 494                 }
 495                 else
 496                 {
 497                         targetuser->WriteFrom(user, "MODE %s", LastParse.c_str());
 498                         FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, LastParseParams, LastParseTranslate));
 499                 }
 500         }
 501         else if (targetchannel && parameters.size() == 2)
 502         {
 503                 /* Special case for displaying the list for listmodes,
 504                  * e.g. MODE #chan b, or MODE #chan +b without a parameter
 505                  */
 506                 this->DisplayListModes(user, targetchannel, mode_sequence);
 507         }
 508 }
 509
 510 void ModeParser::DisplayListModes(User* user, Channel* chan, std::string &mode_sequence)
 511 {
 512         seq++;
 513
 514         for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
 515         {
 516                 unsigned char mletter = *letter;
 517                 if (mletter == '+')
 518                         continue;
 519
 520                 /* Ensure the user doesnt request the same mode twice,
 521                  * so they cant flood themselves off out of idiocy.
 522                  */
 523                 if (sent[mletter] == seq)
 524                         continue;
 525
 526                 sent[mletter] = seq;
 527
 528                 ModeHandler *mh = this->FindMode(mletter, MODETYPE_CHANNEL);
 529
 530                 if (!mh || !mh->IsListMode())
 531                         return;
 532
 533                 ModResult MOD_RESULT;
 534                 FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, mletter, "", true, 0));
 535                 if (MOD_RESULT == MOD_RES_DENY)
 536                         continue;
 537
 538                 bool display = true;
 539                 if (!user->HasPrivPermission("channels/auspex") && ServerInstance->Config->HideModeLists[mletter] && (chan->GetPrefixValue(user) < HALFOP_VALUE))
 540                 {
 541                         user->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You do not have access to view the +%c list",
 542                                 user->nick.c_str(), chan->name.c_str(), mletter);
 543                         display = false;
 544                 }
 545
 546                 unsigned char handler_id = (mletter - 'A') | MASK_CHANNEL;
 547
 548                 for(ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
 549                 {
 550                         std::string dummyparam;
 551
 552                         if (!((*watchers)->BeforeMode(user, NULL, chan, dummyparam, true, MODETYPE_CHANNEL)))
 553                                 display = false;
 554                 }
 555                 if (display)
 556                         mh->DisplayList(user, chan);
 557                 else
 558                         mh->DisplayEmptyList(user, chan);
 559         }
 560 }
 561
 562 const std::string& ModeParser::GetLastParse()
 563 {
 564         return LastParse;
 565 }
 566
 567 void ModeParser::CleanMask(std::string &mask)
 568 {
 569         std::string::size_type pos_of_pling = mask.find_first_of('!');
 570         std::string::size_type pos_of_at = mask.find_first_of('@');
 571         std::string::size_type pos_of_dot = mask.find_first_of('.');
 572         std::string::size_type pos_of_colons = mask.find("::"); /* Because ipv6 addresses are colon delimited -- double so it treats extban as nick */
 573
 574         if (mask.length() >= 2 && mask[1] == ':')
 575                 return; // if it's an extban, don't even try guess how it needs to be formed.
 576
 577         if ((pos_of_pling == std::string::npos) && (pos_of_at == std::string::npos))
 578         {
 579                 /* Just a nick, or just a host - or clearly ipv6 (starting with :) */
 580                 if ((pos_of_dot == std::string::npos) && (pos_of_colons == std::string::npos) && mask[0] != ':')
 581                 {
 582                         /* It has no '.' in it, it must be a nick. */
 583                         mask.append("!*@*");
 584                 }
 585                 else
 586                 {
 587                         /* Got a dot in it? Has to be a host */
 588                         mask = "*!*@" + mask;
 589                 }
 590         }
 591         else if ((pos_of_pling == std::string::npos) && (pos_of_at != std::string::npos))
 592         {
 593                 /* Has an @ but no !, its a user@host */
 594                  mask = "*!" + mask;
 595         }
 596         else if ((pos_of_pling != std::string::npos) && (pos_of_at == std::string::npos))
 597         {
 598                 /* Has a ! but no @, it must be a nick!ident */
 599                 mask.append("@*");
 600         }
 601 }
 602
 603 bool ModeParser::AddMode(ModeHandler* mh)
 604 {
 605         unsigned char mask = 0;
 606         unsigned char pos = 0;
 607
 608         /* Yes, i know, this might let people declare modes like '_' or '^'.
 609          * If they do that, thats their problem, and if i ever EVER see an
 610          * official InspIRCd developer do that, i'll beat them with a paddle!
 611          */
 612         if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z') || (mh->GetPrefix() > 126))
 613                 return false;
 614
 615         /* A mode prefix of ',' is not acceptable, it would fuck up server to server.
 616          * A mode prefix of ':' will fuck up both server to server, and client to server.
 617          * A mode prefix of '#' will mess up /whois and /privmsg
 618          */
 619         if ((mh->GetPrefix() == ',') || (mh->GetPrefix() == ':') || (mh->GetPrefix() == '#'))
 620                 return false;
 621
 622         if (mh->GetPrefix() && FindPrefix(mh->GetPrefix()))
 623                 return false;
 624
 625         mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 626         pos = (mh->GetModeChar()-65) | mask;
 627
 628         if (modehandlers[pos])
 629                 return false;
 630
 631         modehandlers[pos] = mh;
 632         return true;
 633 }
 634
 635 bool ModeParser::DelMode(ModeHandler* mh)
 636 {
 637         unsigned char mask = 0;
 638         unsigned char pos = 0;
 639
 640         if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z'))
 641                 return false;
 642
 643         mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 644         pos = (mh->GetModeChar()-65) | mask;
 645
 646         if (modehandlers[pos] != mh)
 647                 return false;
 648
 649         /* Note: We can't stack here, as we have modes potentially being removed across many different channels.
 650          * To stack here we have to make the algorithm slower. Discuss.
 651          */
 652         switch (mh->GetModeType())
 653         {
 654                 case MODETYPE_USER:
 655                         for (user_hash::iterator i = ServerInstance->Users->clientlist->begin(); i != ServerInstance->Users->clientlist->end(); )
 656                         {
 657                                 User* user = i->second;
 658                                 ++i;
 659                                 mh->RemoveMode(user);
 660                         }
 661                 break;
 662                 case MODETYPE_CHANNEL:
 663                         for (chan_hash::iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); )
 664                         {
 665                                 // The channel may not be in the hash after RemoveMode(), see m_permchannels
 666                                 Channel* chan = i->second;
 667                                 ++i;
 668                                 mh->RemoveMode(chan);
 669                         }
 670                 break;
 671         }
 672
 673         modehandlers[pos] = NULL;
 674
 675         return true;
 676 }
 677
 678 ModeHandler* ModeParser::FindMode(unsigned const char modeletter, ModeType mt)
 679 {
 680         unsigned char mask = 0;
 681         unsigned char pos = 0;
 682
 683         if ((modeletter < 'A') || (modeletter > 'z'))
 684                 return NULL;
 685
 686         mt == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 687         pos = (modeletter-65) | mask;
 688
 689         return modehandlers[pos];
 690 }
 691
 692 std::string ModeParser::UserModeList()
 693 {
 694         char modestr[256];
 695         int pointer = 0;
 696
 697         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 698         {
 699                 unsigned char pos = (mode-65) | MASK_USER;
 700
 701                 if (modehandlers[pos])
 702                         modestr[pointer++] = mode;
 703         }
 704         modestr[pointer++] = 0;
 705         return modestr;
 706 }
 707
 708 std::string ModeParser::ChannelModeList()
 709 {
 710         char modestr[256];
 711         int pointer = 0;
 712
 713         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 714         {
 715                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 716
 717                 if (modehandlers[pos])
 718                         modestr[pointer++] = mode;
 719         }
 720         modestr[pointer++] = 0;
 721         return modestr;
 722 }
 723
 724 std::string ModeParser::ParaModeList()
 725 {
 726         char modestr[256];
 727         int pointer = 0;
 728
 729         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 730         {
 731                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 732
 733                 if ((modehandlers[pos]) && (modehandlers[pos]->GetNumParams(true)))
 734                         modestr[pointer++] = mode;
 735         }
 736         modestr[pointer++] = 0;
 737         return modestr;
 738 }
 739
 740 ModeHandler* ModeParser::FindPrefix(unsigned const char pfxletter)
 741 {
 742         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 743         {
 744                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 745
 746                 if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix() == pfxletter))
 747                 {
 748                         return modehandlers[pos];
 749                 }
 750         }
 751         return NULL;
 752 }
 753
 754 std::string ModeParser::GiveModeList(ModeMasks m)
 755 {
 756         std::string type1;      /* Listmodes EXCEPT those with a prefix */
 757         std::string type2;      /* Modes that take a param when adding or removing */
 758         std::string type3;      /* Modes that only take a param when adding */
 759         std::string type4;      /* Modes that dont take a param */
 760
 761         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 762         {
 763                 unsigned char pos = (mode-65) | m;
 764                  /* One parameter when adding */
 765                 if (modehandlers[pos])
 766                 {
 767                         if (modehandlers[pos]->GetNumParams(true))
 768                         {
 769                                 if ((modehandlers[pos]->IsListMode()) && (!modehandlers[pos]->GetPrefix()))
 770                                 {
 771                                         type1 += modehandlers[pos]->GetModeChar();
 772                                 }
 773                                 else
 774                                 {
 775                                         /* ... and one parameter when removing */
 776                                         if (modehandlers[pos]->GetNumParams(false))
 777                                         {
 778                                                 /* But not a list mode */
 779                                                 if (!modehandlers[pos]->GetPrefix())
 780                                                 {
 781                                                         type2 += modehandlers[pos]->GetModeChar();
 782                                                 }
 783                                         }
 784                                         else
 785                                         {
 786                                                 /* No parameters when removing */
 787                                                 type3 += modehandlers[pos]->GetModeChar();
 788                                         }
 789                                 }
 790                         }
 791                         else
 792                         {
 793                                 type4 += modehandlers[pos]->GetModeChar();
 794                         }
 795                 }
 796         }
 797
 798         return type1 + "," + type2 + "," + type3 + "," + type4;
 799 }
 800
 801 std::string ModeParser::BuildPrefixes(bool lettersAndModes)
 802 {
 803         std::string mletters;
 804         std::string mprefixes;
 805         std::map<int,std::pair<char,char> > prefixes;
 806
 807         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 808         {
 809                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 810
 811                 if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix()))
 812                 {
 813                         prefixes[modehandlers[pos]->GetPrefixRank()] = std::make_pair(
 814                                 modehandlers[pos]->GetPrefix(), modehandlers[pos]->GetModeChar());
 815                 }
 816         }
 817
 818         for(std::map<int,std::pair<char,char> >::reverse_iterator n = prefixes.rbegin(); n != prefixes.rend(); n++)
 819         {
 820                 mletters = mletters + n->second.first;
 821                 mprefixes = mprefixes + n->second.second;
 822         }
 823
 824         return lettersAndModes ? "(" + mprefixes + ")" + mletters : mletters;
 825 }
 826
 827 bool ModeParser::AddModeWatcher(ModeWatcher* mw)
 828 {
 829         unsigned char mask = 0;
 830         unsigned char pos = 0;
 831
 832         if (!mw)
 833                 return false;
 834
 835         if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z'))
 836                 return false;
 837
 838         mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 839         pos = (mw->GetModeChar()-65) | mask;
 840
 841         modewatchers[pos].push_back(mw);
 842
 843         return true;
 844 }
 845
 846 bool ModeParser::DelModeWatcher(ModeWatcher* mw)
 847 {
 848         unsigned char mask = 0;
 849         unsigned char pos = 0;
 850
 851         if (!mw)
 852                 return false;
 853
 854         if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z'))
 855                 return false;
 856
 857         mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 858         pos = (mw->GetModeChar()-65) | mask;
 859
 860         ModeWatchIter a = find(modewatchers[pos].begin(),modewatchers[pos].end(),mw);
 861
 862         if (a == modewatchers[pos].end())
 863         {
 864                 return false;
 865         }
 866
 867         modewatchers[pos].erase(a);
 868
 869         return true;
 870 }
 871
 872 /** This default implementation can remove simple user modes
 873  */
 874 void ModeHandler::RemoveMode(User* user, irc::modestacker* stack)
 875 {
 876         if (user->IsModeSet(this->GetModeChar()))
 877         {
 878                 if (stack)
 879                 {
 880                         stack->Push(this->GetModeChar());
 881                 }
 882                 else
 883                 {
 884                         std::vector<std::string> parameters;
 885                         parameters.push_back(user->nick);
 886                         parameters.push_back("-");
 887                         parameters[1].push_back(this->GetModeChar());
 888                         ServerInstance->Modes->Process(parameters, ServerInstance->FakeClient);
 889                 }
 890         }
 891 }
 892
 893 /** This default implementation can remove simple channel modes
 894  * (no parameters)
 895  */
 896 void ModeHandler::RemoveMode(Channel* channel, irc::modestacker* stack)
 897 {
 898         if (channel->IsModeSet(this->GetModeChar()))
 899         {
 900                 if (stack)
 901                 {
 902                         stack->Push(this->GetModeChar());
 903                 }
 904                 else
 905                 {
 906                         std::vector<std::string> parameters;
 907                         parameters.push_back(channel->name);
 908                         parameters.push_back("-");
 909                         parameters[1].push_back(this->GetModeChar());
 910                         ServerInstance->SendMode(parameters, ServerInstance->FakeClient);
 911                 }
 912         }
 913 }
 914
 915 struct builtin_modes
 916 {
 917         ModeChannelSecret s;
 918         ModeChannelPrivate p;
 919         ModeChannelModerated m;
 920         ModeChannelTopicOps t;
 921
 922         ModeChannelNoExternal n;
 923         ModeChannelInviteOnly i;
 924         ModeChannelKey k;
 925         ModeChannelLimit l;
 926
 927         ModeChannelBan b;
 928         ModeChannelOp o;
 929         ModeChannelVoice v;
 930
 931         ModeUserWallops uw;
 932         ModeUserInvisible ui;
 933         ModeUserOperator uo;
 934         ModeUserServerNoticeMask us;
 935
 936         void init()
 937         {
 938                 ServiceProvider* modes[] = { &s, &p, &m, &t, &n, &i, &k, &l, &b, &o, &v,
 939                                                                          &uw, &ui, &uo, &us };
 940                 ServerInstance->Modules->AddServices(modes, sizeof(modes)/sizeof(ServiceProvider*));
 941         }
 942 };
 943
 944 static builtin_modes static_modes;
 945
 946 void ModeParser::InitBuiltinModes()
 947 {
 948         static_modes.init();
 949         static_modes.b.DoRehash();
 950 }
 951
 952 ModeParser::ModeParser()
 953 {
 954         /* Clear mode handler list */
 955         memset(modehandlers, 0, sizeof(modehandlers));
 956
 957         /* Last parse string */
 958         LastParse.clear();
 959
 960         seq = 0;
 961         memset(&sent, 0, sizeof(sent));
 962 }
 963
 964 ModeParser::~ModeParser()
 965 {
 966 }