src/mode.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 /* $Core: libIRCDmode */
  15 /* $ExtraDeps: $(RELCPPFILES) */
  16 /* $ExtraObjects: modes/modeclasses.a */
  17 /* $ExtraBuild: ${MAKE} -C "modes" DIRNAME="src/modes" CC="$(CC)" $(MAKEARGS) CPPFILES="$(CPPFILES)" */
  18
  19 #include "inspircd.h"
  20 #include "inspstring.h"
  21
  22 /* +s (secret) */
  23 #include "modes/cmode_s.h"
  24 /* +p (private) */
  25 #include "modes/cmode_p.h"
  26 /* +b (bans) */
  27 #include "modes/cmode_b.h"
  28 /* +m (moderated) */
  29 #include "modes/cmode_m.h"
  30 /* +t (only (half) ops can change topic) */
  31 #include "modes/cmode_t.h"
  32 /* +n (no external messages) */
  33 #include "modes/cmode_n.h"
  34 /* +i (invite only) */
  35 #include "modes/cmode_i.h"
  36 /* +k (keyed channel) */
  37 #include "modes/cmode_k.h"
  38 /* +l (channel user limit) */
  39 #include "modes/cmode_l.h"
  40 /* +o (channel op) */
  41 #include "modes/cmode_o.h"
  42 /* +h (channel halfop) */
  43 #include "modes/cmode_h.h"
  44 /* +v (channel voice) */
  45 #include "modes/cmode_v.h"
  46 /* +s (server notices) */
  47 #include "modes/umode_s.h"
  48 /* +w (see wallops) */
  49 #include "modes/umode_w.h"
  50 /* +i (invisible) */
  51 #include "modes/umode_i.h"
  52 /* +o (operator) */
  53 #include "modes/umode_o.h"
  54 /* +n (notice mask - our implementation of snomasks) */
  55 #include "modes/umode_n.h"
  56
  57 ModeHandler::ModeHandler(InspIRCd* Instance, char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly, char mprefix)
  58         : ServerInstance(Instance), mode(modeletter), n_params_on(parameters_on), n_params_off(parameters_off), list(listmode), m_type(type), oper(operonly), prefix(mprefix), count(0)
  59 {
  60 }
  61
  62 ModeHandler::~ModeHandler()
  63 {
  64 }
  65
  66 bool ModeHandler::IsListMode()
  67 {
  68         return list;
  69 }
  70
  71 unsigned int ModeHandler::GetPrefixRank()
  72 {
  73         return 0;
  74 }
  75
  76 unsigned int ModeHandler::GetCount()
  77 {
  78         return 0;
  79 }
  80
  81 void ModeHandler::ChangeCount(int modifier)
  82 {
  83         count += modifier;
  84         ServerInstance->Log(DEBUG,"Change count for mode %c is now %d", mode, count);
  85 }
  86
  87 ModeType ModeHandler::GetModeType()
  88 {
  89         return m_type;
  90 }
  91
  92 bool ModeHandler::NeedsOper()
  93 {
  94         return oper;
  95 }
  96
  97 char ModeHandler::GetPrefix()
  98 {
  99         return prefix;
 100 }
 101
 102 int ModeHandler::GetNumParams(bool adding)
 103 {
 104         return adding ? n_params_on : n_params_off;
 105 }
 106
 107 char ModeHandler::GetModeChar()
 108 {
 109         return mode;
 110 }
 111
 112 ModeAction ModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
 113 {
 114         return MODEACTION_DENY;
 115 }
 116
 117 ModePair ModeHandler::ModeSet(User* source, User* dest, Channel* channel, const std::string &parameter)
 118 {
 119         if (dest)
 120         {
 121                 return std::make_pair(dest->IsModeSet(this->mode), "");
 122         }
 123         else
 124         {
 125                 return std::make_pair(channel->IsModeSet(this->mode), "");
 126         }
 127 }
 128
 129 void ModeHandler::DisplayList(User* user, Channel* channel)
 130 {
 131 }
 132
 133 void ModeHandler::DisplayEmptyList(User* user, Channel* channel)
 134 {
 135 }
 136
 137 bool ModeHandler::CheckTimeStamp(time_t theirs, time_t ours, const std::string &their_param, const std::string &our_param, Channel* channel)
 138 {
 139         return (ours < theirs);
 140 }
 141
 142 ModeWatcher::ModeWatcher(InspIRCd* Instance, char modeletter, ModeType type) : ServerInstance(Instance), mode(modeletter), m_type(type)
 143 {
 144 }
 145
 146 ModeWatcher::~ModeWatcher()
 147 {
 148 }
 149
 150 char ModeWatcher::GetModeChar()
 151 {
 152         return mode;
 153 }
 154
 155 ModeType ModeWatcher::GetModeType()
 156 {
 157         return m_type;
 158 }
 159
 160 bool ModeWatcher::BeforeMode(User* source, User* dest, Channel* channel, std::string &parameter, bool adding, ModeType type)
 161 {
 162         return true;
 163 }
 164
 165 void ModeWatcher::AfterMode(User* source, User* dest, Channel* channel, const std::string &parameter, bool adding, ModeType type)
 166 {
 167 }
 168
 169 User* ModeParser::SanityChecks(User *user,const char *dest,Channel *chan,int status)
 170 {
 171         User *d;
 172         if ((!user) || (!dest) || (!chan) || (!*dest))
 173         {
 174                 return NULL;
 175         }
 176         d = ServerInstance->FindNick(dest);
 177         if (!d)
 178         {
 179                 user->WriteServ("401 %s %s :No such nick/channel",user->nick, dest);
 180                 return NULL;
 181         }
 182         return d;
 183 }
 184
 185 const char* ModeParser::Grant(User *d,Channel *chan,int MASK)
 186 {
 187         if (!chan)
 188                 return "";
 189
 190         UCListIter n = d->chans.find(chan);
 191         if (n != d->chans.end())
 192         {
 193                 if (n->second & MASK)
 194                 {
 195                         return "";
 196                 }
 197                 n->second = n->second | MASK;
 198                 switch (MASK)
 199                 {
 200                         case UCMODE_OP:
 201                                 n->first->AddOppedUser(d);
 202                         break;
 203                         case UCMODE_HOP:
 204                                 n->first->AddHalfoppedUser(d);
 205                         break;
 206                         case UCMODE_VOICE:
 207                                 n->first->AddVoicedUser(d);
 208                         break;
 209                 }
 210                 return d->nick;
 211         }
 212         return "";
 213 }
 214
 215 const char* ModeParser::Revoke(User *d,Channel *chan,int MASK)
 216 {
 217         if (!chan)
 218                 return "";
 219
 220         UCListIter n = d->chans.find(chan);
 221         if (n != d->chans.end())
 222         {
 223                 if ((n->second & MASK) == 0)
 224                 {
 225                         return "";
 226                 }
 227                 n->second ^= MASK;
 228                 switch (MASK)
 229                 {
 230                         case UCMODE_OP:
 231                                 n->first->DelOppedUser(d);
 232                         break;
 233                         case UCMODE_HOP:
 234                                 n->first->DelHalfoppedUser(d);
 235                         break;
 236                         case UCMODE_VOICE:
 237                                 n->first->DelVoicedUser(d);
 238                         break;
 239                 }
 240                 return d->nick;
 241         }
 242         return "";
 243 }
 244
 245 void ModeParser::DisplayCurrentModes(User *user, User* targetuser, Channel* targetchannel, const char* text)
 246 {
 247         if (targetchannel)
 248         {
 249                 /* Display channel's current mode string */
 250                 user->WriteServ("324 %s %s +%s",user->nick, targetchannel->name, targetchannel->ChanModes(targetchannel->HasUser(user)));
 251                 user->WriteServ("329 %s %s %lu", user->nick, targetchannel->name, (unsigned long)targetchannel->age);
 252                 return;
 253         }
 254         else if (targetuser)
 255         {
 256                 if (targetuser->Visibility && !targetuser->Visibility->VisibleTo(user))
 257                 {
 258                         user->WriteServ("401 %s %s :No such nick/channel",user->nick, text);
 259                         return;
 260                 }
 261
 262                 if ((targetuser == user) || (IS_OPER(user)))
 263                 {
 264                         /* Display user's current mode string */
 265                         user->WriteServ("221 %s :+%s",targetuser->nick,targetuser->FormatModes());
 266                         if (IS_OPER(targetuser))
 267                                 user->WriteServ("008 %s +%s :Server notice mask", targetuser->nick, targetuser->FormatNoticeMasks());
 268                         return;
 269                 }
 270                 else
 271                 {
 272                         user->WriteServ("502 %s :Can't change mode for other users", user->nick);
 273                         return;
 274                 }
 275         }
 276
 277         /* No such nick/channel */
 278         user->WriteServ("401 %s %s :No such nick/channel",user->nick, text);
 279         return;
 280 }
 281
 282 void ModeParser::Process(const char** parameters, int pcnt, User *user, bool servermode)
 283 {
 284         std::string target = parameters[0];
 285         ModeType type = MODETYPE_USER;
 286         unsigned char mask = 0;
 287         Channel* targetchannel = ServerInstance->FindChan(parameters[0]);
 288         User* targetuser  = ServerInstance->FindNick(parameters[0]);
 289
 290         LastParse.clear();
 291
 292         /* Special case for displaying the list for listmodes,
 293          * e.g. MODE #chan b, or MODE #chan +b without a parameter
 294          */
 295         if ((targetchannel) && (pcnt == 2))
 296         {
 297                 const char* mode = parameters[1];
 298                 int nonlistmodes_found = 0;
 299                 bool sent[256];
 300
 301                 mask = MASK_CHANNEL;
 302
 303                 memset(&sent, 0, 256);
 304
 305                 while (mode && *mode)
 306                 {
 307                         unsigned char mletter = *mode;
 308
 309                         if (*mode == '+')
 310                         {
 311                                 mode++;
 312                                 continue;
 313                         }
 314
 315                         /* Ensure the user doesnt request the same mode twice,
 316                          * so they cant flood themselves off out of idiocy.
 317                          */
 318                         if (!sent[mletter])
 319                         {
 320                                 sent[mletter] = true;
 321                         }
 322                         else
 323                         {
 324                                 mode++;
 325                                 continue;
 326                         }
 327
 328                         ModeHandler *mh = this->FindMode(*mode, MODETYPE_CHANNEL);
 329                         bool display = true;
 330
 331                         if ((mh) && (mh->IsListMode()))
 332                         {
 333                                 if (ServerInstance->Config->HideModeLists[mletter] && (targetchannel->GetStatus(user) < STATUS_HOP))
 334                                 {
 335                                         user->WriteServ("482 %s %s :Only half-operators and above may view the +%c list",user->nick, targetchannel->name, *mode++);
 336                                         mh->DisplayEmptyList(user, targetchannel);
 337                                         continue;
 338                                 }
 339
 340                                 /** See below for a description of what craq this is :D
 341                                  */
 342                                 unsigned char handler_id = (*mode - 65) | mask;
 343
 344                                 for(ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
 345                                 {
 346                                         std::string dummyparam;
 347
 348                                         if (!((*watchers)->BeforeMode(user, NULL, targetchannel, dummyparam, true, MODETYPE_CHANNEL)))
 349                                                 display = false;
 350                                 }
 351
 352                                 if (display)
 353                                         mh->DisplayList(user, targetchannel);
 354                         }
 355                         else
 356                                 nonlistmodes_found++;
 357
 358                         mode++;
 359                 }
 360
 361                 /* We didnt have any modes that were non-list, we can return here */
 362                 if (!nonlistmodes_found)
 363                         return;
 364         }
 365
 366         if (pcnt == 1)
 367         {
 368                 this->DisplayCurrentModes(user, targetuser, targetchannel, parameters[0]);
 369         }
 370         else if (pcnt > 1)
 371         {
 372                 if (targetchannel)
 373                 {
 374                         type = MODETYPE_CHANNEL;
 375                         mask = MASK_CHANNEL;
 376
 377                         /* Extra security checks on channel modes
 378                          * (e.g. are they a (half)op?
 379                          */
 380
 381                         if ((IS_LOCAL(user)) && (targetchannel->GetStatus(user) < STATUS_HOP))
 382                         {
 383                                 /* We don't have halfop */
 384                                 int MOD_RESULT = 0;
 385                                 FOREACH_RESULT(I_OnAccessCheck,OnAccessCheck(user, NULL, targetchannel, AC_GENERAL_MODE));
 386                                 if (MOD_RESULT == ACR_DENY)
 387                                         return;
 388
 389                                 if (MOD_RESULT == ACR_DEFAULT)
 390                                 {
 391                                         /* Are we a uline or is it a servermode? */
 392                                         if ((!ServerInstance->ULine(user->server)) && (!servermode))
 393                                         {
 394                                                 /* Not enough permission:
 395                                                  * NOT a uline and NOT a servermode,
 396                                                  * OR, NOT halfop or above.
 397                                                  */
 398                                                 user->WriteServ("482 %s %s :You're not a channel (half)operator",user->nick, targetchannel->name);
 399                                                 return;
 400                                         }
 401                                 }
 402                         }
 403                 }
 404                 else if (targetuser)
 405                 {
 406                         type = MODETYPE_USER;
 407                         mask = MASK_USER;
 408                         if ((user != targetuser) && (!ServerInstance->ULine(user->server)))
 409                         {
 410                                 user->WriteServ("502 %s :Can't change mode for other users", user->nick);
 411                                 return;
 412                         }
 413                 }
 414                 else
 415                 {
 416                         /* No such nick/channel */
 417                         user->WriteServ("401 %s %s :No such nick/channel",user->nick, parameters[0]);
 418                         return;
 419                 }
 420
 421                 std::string mode_sequence = parameters[1];
 422                 std::string parameter;
 423                 std::ostringstream parameter_list;
 424                 std::string output_sequence;
 425                 bool adding = true, state_change = false;
 426                 unsigned char handler_id = 0;
 427                 int parameter_counter = 2; /* Index of first parameter */
 428                 int parameter_count = 0;
 429                 bool last_successful_state_change = false;
 430
 431                 /* A mode sequence that doesnt start with + or -. Assume +. - Thanks for the suggestion spike (bug#132) */
 432                 if ((*mode_sequence.begin() != '+') && (*mode_sequence.begin() != '-'))
 433                         mode_sequence.insert(0, "+");
 434
 435                 for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
 436                 {
 437                         unsigned char modechar = *letter;
 438
 439                         switch (modechar)
 440                         {
 441                                 /* NB:
 442                                  * For + and - mode characters, we don't just stick the character into the output sequence.
 443                                  * This is because the user may do something dumb, like: +-+ooo or +oo-+. To prevent this
 444                                  * appearing in the output sequence, we store a flag which says there was a state change,
 445                                  * which is set on any + or -, however, the + or - that we finish on is only appended to
 446                                  * the output stream in the event it is followed by a non "+ or -" character, such as o or v.
 447                                  */
 448                                 case '+':
 449                                         /* The following expression prevents: +o+o nick nick, compressing it to +oo nick nick,
 450                                          * however, will allow the + if it is the first item in the sequence, regardless.
 451                                          */
 452                                         if ((!adding) || (!output_sequence.length()))
 453                                                 state_change = true;
 454                                         adding = true;
 455                                         if (!output_sequence.length())
 456                                                 last_successful_state_change = false;
 457                                         continue;
 458                                 break;
 459                                 case '-':
 460                                         if ((adding) || (!output_sequence.length()))
 461                                                 state_change = true;
 462                                         adding = false;
 463                                         if (!output_sequence.length())
 464                                                 last_successful_state_change = true;
 465                                         continue;
 466                                 break;
 467                                 default:
 468
 469                                         /**
 470                                          * Watch carefully for the sleight of hand trick.
 471                                          * 65 is the ascii value of 'A'. We take this from
 472                                          * the char we're looking at to get a number between
 473                                          * 1 and 127. We then logic-or it to get the hashed
 474                                          * position, dependent on wether its a channel or
 475                                          * a user mode. This is a little stranger, but a lot
 476                                          * faster, than using a map of pairs.
 477                                          */
 478                                         handler_id = (modechar - 65) | mask;
 479
 480                                         if (modehandlers[handler_id])
 481                                         {
 482                                                 bool abort = false;
 483
 484                                                 if (modehandlers[handler_id]->GetModeType() == type)
 485                                                 {
 486                                                         if (modehandlers[handler_id]->GetNumParams(adding))
 487                                                         {
 488                                                                 /* This mode expects a parameter, do we have any parameters left in our list to use? */
 489                                                                 if (parameter_counter < pcnt)
 490                                                                 {
 491                                                                         parameter = parameters[parameter_counter++];
 492
 493                                                                         /* Yerk, invalid! */
 494                                                                         if ((parameter.find(':') == 0) || (parameter.rfind(' ') != std::string::npos))
 495                                                                                 parameter.clear();
 496                                                                 }
 497                                                                 else
 498                                                                 {
 499                                                                         /* No parameter, continue to the next mode */
 500                                                                         continue;
 501                                                                 }
 502
 503                                                                 bool had_parameter = !parameter.empty();
 504
 505                                                                 for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
 506                                                                 {
 507                                                                         if ((*watchers)->BeforeMode(user, targetuser, targetchannel, parameter, adding, type) == false)
 508                                                                         {
 509                                                                                 abort = true;
 510                                                                                 break;
 511                                                                         }
 512                                                                         /* A module whacked the parameter completely, and there was one. abort. */
 513                                                                         if ((had_parameter) && (parameter.empty()))
 514                                                                         {
 515                                                                                 abort = true;
 516                                                                                 break;
 517                                                                         }
 518                                                                 }
 519
 520                                                                 if (abort)
 521                                                                         continue;
 522                                                         }
 523                                                         else
 524                                                         {
 525                                                                 /* Fix by brain: mode watchers not being called for parameterless modes */
 526                                                                 for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
 527                                                                 {
 528                                                                         if ((*watchers)->BeforeMode(user, targetuser, targetchannel, parameter, adding, type) == false)
 529                                                                         {
 530                                                                                 abort = true;
 531                                                                                 break;
 532                                                                         }
 533                                                                 }
 534
 535                                                                 if (abort)
 536                                                                         continue;
 537                                                         }
 538
 539                                                         /* It's an oper only mode, check if theyre an oper. If they arent,
 540                                                          * eat any parameter that  came with the mode, and continue to next
 541                                                          */
 542                                                         if ((IS_LOCAL(user)) && (modehandlers[handler_id]->NeedsOper()) && (!IS_OPER(user)))
 543                                                         {
 544                                                                 user->WriteServ("481 %s :Permission Denied - Only IRC operators may %sset %s mode %c", user->nick,
 545                                                                                 adding ? "" : "un", type == MODETYPE_CHANNEL ? "channel" : "user",
 546                                                                                 modehandlers[handler_id]->GetModeChar());
 547                                                                 continue;
 548                                                         }
 549
 550                                                         /* Call the handler for the mode */
 551                                                         ModeAction ma = modehandlers[handler_id]->OnModeChange(user, targetuser, targetchannel, parameter, adding);
 552
 553                                                         if ((modehandlers[handler_id]->GetNumParams(adding)) && (parameter.empty()))
 554                                                         {
 555                                                                 /* The handler nuked the parameter and they are supposed to have one.
 556                                                                  * We CANT continue now, even if they actually returned MODEACTION_ALLOW,
 557                                                                  * so we bail to the next mode character.
 558                                                                  */
 559                                                                 continue;
 560                                                         }
 561
 562                                                         if (ma == MODEACTION_ALLOW)
 563                                                         {
 564                                                                 /* We're about to output a valid mode letter - was there previously a pending state-change? */
 565                                                                 if (state_change)
 566                                                                 {
 567                                                                         if (adding != last_successful_state_change)
 568                                                                                 output_sequence.append(adding ? "+" : "-");
 569                                                                         last_successful_state_change = adding;
 570                                                                 }
 571
 572                                                                 /* Add the mode letter */
 573                                                                 output_sequence.push_back(modechar);
 574
 575                                                                 modehandlers[handler_id]->ChangeCount(adding ? 1 : -1);
 576
 577                                                                 /* Is there a valid parameter for this mode? If so add it to the parameter list */
 578                                                                 if ((modehandlers[handler_id]->GetNumParams(adding)) && (!parameter.empty()))
 579                                                                 {
 580                                                                         parameter_list << " " << parameter;
 581                                                                         parameter_count++;
 582                                                                         /* Does this mode have a prefix? */
 583                                                                         if (modehandlers[handler_id]->GetPrefix() && targetchannel)
 584                                                                         {
 585                                                                                 User* user_to_prefix = ServerInstance->FindNick(parameter);
 586                                                                                 if (user_to_prefix)
 587                                                                                         targetchannel->SetPrefix(user_to_prefix, modehandlers[handler_id]->GetPrefix(),
 588                                                                                                         modehandlers[handler_id]->GetPrefixRank(), adding);
 589                                                                         }
 590                                                                 }
 591
 592                                                                 /* Call all the AfterMode events in the mode watchers for this mode */
 593                                                                 for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
 594                                                                         (*watchers)->AfterMode(user, targetuser, targetchannel, parameter, adding, type);
 595
 596                                                                 /* Reset the state change flag */
 597                                                                 state_change = false;
 598
 599                                                                 if ((output_sequence.length() + parameter_list.str().length() > 450) || (output_sequence.length() > 100)
 600                                                                                 || (parameter_count > MAXMODES))
 601                                                                 {
 602                                                                         /* We cant have a mode sequence this long */
 603                                                                         letter = mode_sequence.end() - 1;
 604                                                                         continue;
 605                                                                 }
 606                                                         }
 607                                                 }
 608                                         }
 609                                         else
 610                                         {
 611                                                 /* No mode handler? Unknown mode character then. */
 612                                                 user->WriteServ("%d %s %c :is unknown mode char to me", type == MODETYPE_CHANNEL ? 472 : 501, user->nick, modechar);
 613                                         }
 614                                 break;
 615                         }
 616                 }
 617
 618                 /* Was there at least one valid mode in the sequence? */
 619                 if (!output_sequence.empty())
 620                 {
 621                         if (servermode)
 622                         {
 623                                 if (type == MODETYPE_CHANNEL)
 624                                 {
 625                                         targetchannel->WriteChannelWithServ(ServerInstance->Config->ServerName, "MODE %s %s%s", targetchannel->name, output_sequence.c_str(), parameter_list.str().c_str());
 626                                         this->LastParse = targetchannel->name;
 627                                 }
 628                                 else
 629                                 {
 630                                         targetuser->WriteServ("MODE %s %s%s",targetuser->nick,output_sequence.c_str(), parameter_list.str().c_str());
 631                                         this->LastParse = targetuser->nick;
 632                                 }
 633                         }
 634                         else
 635                         {
 636                                 if (type == MODETYPE_CHANNEL)
 637                                 {
 638                                         targetchannel->WriteChannel(user,"MODE %s %s%s",targetchannel->name,output_sequence.c_str(),parameter_list.str().c_str());
 639                                         FOREACH_MOD(I_OnMode,OnMode(user, targetchannel, TYPE_CHANNEL, output_sequence + parameter_list.str()));
 640                                         this->LastParse = targetchannel->name;
 641                                 }
 642                                 else
 643                                 {
 644                                         user->WriteTo(targetuser,"MODE %s %s%s",targetuser->nick,output_sequence.c_str(), parameter_list.str().c_str());
 645                                         FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, output_sequence + parameter_list.str()));
 646                                         this->LastParse = targetuser->nick;
 647                                 }
 648                         }
 649
 650                         LastParse.append(" ");
 651                         LastParse.append(output_sequence);
 652                         LastParse.append(parameter_list.str());
 653                 }
 654         }
 655 }
 656
 657 const std::string& ModeParser::GetLastParse()
 658 {
 659         return LastParse;
 660 }
 661
 662 void ModeParser::CleanMask(std::string &mask)
 663 {
 664         std::string::size_type pos_of_pling = mask.find_first_of('!');
 665         std::string::size_type pos_of_at = mask.find_first_of('@');
 666         std::string::size_type pos_of_dot = mask.find_first_of('.');
 667         std::string::size_type pos_of_colon = mask.find_first_of(':'); /* Because ipv6 addresses are colon delimited */
 668
 669         if ((pos_of_pling == std::string::npos) && (pos_of_at == std::string::npos))
 670         {
 671                 /* Just a nick, or just a host */
 672                 if ((pos_of_dot == std::string::npos) && (pos_of_colon == std::string::npos))
 673                 {
 674                         /* It has no '.' in it, it must be a nick. */
 675                         mask.append("!*@*");
 676                 }
 677                 else
 678                 {
 679                         /* Got a dot in it? Has to be a host */
 680                         mask = "*!*@" + mask;
 681                 }
 682         }
 683         else if ((pos_of_pling == std::string::npos) && (pos_of_at != std::string::npos))
 684         {
 685                 /* Has an @ but no !, its a user@host */
 686                  mask = "*!" + mask;
 687         }
 688         else if ((pos_of_pling != std::string::npos) && (pos_of_at == std::string::npos))
 689         {
 690                 /* Has a ! but no @, it must be a nick!ident */
 691                 mask.append("@*");
 692         }
 693 }
 694
 695 bool ModeParser::AddMode(ModeHandler* mh, unsigned const char modeletter)
 696 {
 697         unsigned char mask = 0;
 698         unsigned char pos = 0;
 699
 700         /* Yes, i know, this might let people declare modes like '_' or '^'.
 701          * If they do that, thats their problem, and if i ever EVER see an
 702          * official InspIRCd developer do that, i'll beat them with a paddle!
 703          */
 704         if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z') || (mh->GetPrefix() > 126))
 705                 return false;
 706
 707         /* A mode prefix of ',' is not acceptable, it would fuck up server to server.
 708          * A mode prefix of ':' will fuck up both server to server, and client to server.
 709          * A mode prefix of '#' will mess up /whois and /privmsg
 710          */
 711         if ((mh->GetPrefix() == ',') || (mh->GetPrefix() == ':') || (mh->GetPrefix() == '#'))
 712                 return false;
 713
 714         mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 715         pos = (mh->GetModeChar()-65) | mask;
 716
 717         if (modehandlers[pos])
 718                 return false;
 719
 720         modehandlers[pos] = mh;
 721         return true;
 722 }
 723
 724 bool ModeParser::DelMode(ModeHandler* mh)
 725 {
 726         unsigned char mask = 0;
 727         unsigned char pos = 0;
 728
 729         if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z'))
 730                 return false;
 731
 732         mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 733         pos = (mh->GetModeChar()-65) | mask;
 734
 735         if (!modehandlers[pos])
 736                 return false;
 737
 738         switch (mh->GetModeType())
 739         {
 740                 case MODETYPE_USER:
 741                         for (user_hash::iterator i = ServerInstance->clientlist->begin(); i != ServerInstance->clientlist->end(); i++)
 742                         {
 743                                 mh->RemoveMode(i->second);
 744                         }
 745                 break;
 746                 case MODETYPE_CHANNEL:
 747                         for (chan_hash::iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); i++)
 748                         {
 749                                 mh->RemoveMode(i->second);
 750                         }
 751                 break;
 752         }
 753
 754         modehandlers[pos] = NULL;
 755
 756         return true;
 757 }
 758
 759 ModeHandler* ModeParser::FindMode(unsigned const char modeletter, ModeType mt)
 760 {
 761         unsigned char mask = 0;
 762         unsigned char pos = 0;
 763
 764         if ((modeletter < 'A') || (modeletter > 'z'))
 765                 return NULL;
 766
 767         mt == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 768         pos = (modeletter-65) | mask;
 769
 770         return modehandlers[pos];
 771 }
 772
 773 std::string ModeParser::UserModeList()
 774 {
 775         char modestr[256];
 776         int pointer = 0;
 777
 778         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 779         {
 780                 unsigned char pos = (mode-65) | MASK_USER;
 781
 782                 if (modehandlers[pos])
 783                         modestr[pointer++] = mode;
 784         }
 785         modestr[pointer++] = 0;
 786         return modestr;
 787 }
 788
 789 std::string ModeParser::ChannelModeList()
 790 {
 791         char modestr[256];
 792         int pointer = 0;
 793
 794         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 795         {
 796                 if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
 797                         continue;
 798
 799                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 800
 801                 if (modehandlers[pos])
 802                         modestr[pointer++] = mode;
 803         }
 804         modestr[pointer++] = 0;
 805         return modestr;
 806 }
 807
 808 std::string ModeParser::ParaModeList()
 809 {
 810         char modestr[256];
 811         int pointer = 0;
 812
 813         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 814         {
 815                 if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
 816                         continue;
 817
 818                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 819
 820                 if ((modehandlers[pos]) && (modehandlers[pos]->GetNumParams(true)))
 821                         modestr[pointer++] = mode;
 822         }
 823         modestr[pointer++] = 0;
 824         return modestr;
 825 }
 826
 827 ModeHandler* ModeParser::FindPrefix(unsigned const char pfxletter)
 828 {
 829         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 830         {
 831                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 832
 833                 if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix() == pfxletter))
 834                 {
 835                         return modehandlers[pos];
 836                 }
 837         }
 838         return NULL;
 839 }
 840
 841 std::string ModeParser::ModeString(User* user, Channel* channel)
 842 {
 843         std::string types;
 844         std::string pars;
 845
 846         if (!channel || !user)
 847                 return "";
 848
 849         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 850         {
 851                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 852                 ModeHandler* mh = modehandlers[pos];
 853                 if ((mh) && (mh->GetNumParams(true)) && (mh->GetNumParams(false)))
 854                 {
 855                         ModePair ret;
 856                         ret = mh->ModeSet(NULL, user, channel, user->nick);
 857                         if ((ret.first) && (ret.second == user->nick))
 858                         {
 859                                 pars.append(" ");
 860                                 pars.append(user->nick);
 861                                 types.push_back(mh->GetModeChar());
 862                         }
 863                 }
 864         }
 865
 866         return types+pars;
 867 }
 868
 869 std::string ModeParser::ChanModes()
 870 {
 871         std::string type1;      /* Listmodes EXCEPT those with a prefix */
 872         std::string type2;      /* Modes that take a param when adding or removing */
 873         std::string type3;      /* Modes that only take a param when adding */
 874         std::string type4;      /* Modes that dont take a param */
 875
 876         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 877         {
 878                 if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
 879                         continue;
 880
 881                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 882                  /* One parameter when adding */
 883                 if (modehandlers[pos])
 884                 {
 885                         if (modehandlers[pos]->GetNumParams(true))
 886                         {
 887                                 if ((modehandlers[pos]->IsListMode()) && (!modehandlers[pos]->GetPrefix()))
 888                                 {
 889                                         type1 += modehandlers[pos]->GetModeChar();
 890                                 }
 891                                 else
 892                                 {
 893                                         /* ... and one parameter when removing */
 894                                         if (modehandlers[pos]->GetNumParams(false))
 895                                         {
 896                                                 /* But not a list mode */
 897                                                 if (!modehandlers[pos]->GetPrefix())
 898                                                 {
 899                                                         type2 += modehandlers[pos]->GetModeChar();
 900                                                 }
 901                                         }
 902                                         else
 903                                         {
 904                                                 /* No parameters when removing */
 905                                                 type3 += modehandlers[pos]->GetModeChar();
 906                                         }
 907                                 }
 908                         }
 909                         else
 910                         {
 911                                 type4 += modehandlers[pos]->GetModeChar();
 912                         }
 913                 }
 914
 915         }
 916
 917         return type1 + "," + type2 + "," + type3 + "," + type4;
 918 }
 919
 920 bool ModeParser::PrefixComparison(prefixtype one, prefixtype two)
 921 {
 922         return one.second > two.second;
 923 }
 924
 925 std::string ModeParser::BuildPrefixes()
 926 {
 927         std::string mletters;
 928         std::string mprefixes;
 929         pfxcontainer pfx;
 930         std::map<char,char> prefix_to_mode;
 931
 932         for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 933         {
 934                 if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
 935                         continue;
 936
 937                 unsigned char pos = (mode-65) | MASK_CHANNEL;
 938
 939                 if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix()))
 940                 {
 941                         pfx.push_back(std::make_pair<char,unsigned int>(modehandlers[pos]->GetPrefix(), modehandlers[pos]->GetPrefixRank()));
 942                         prefix_to_mode[modehandlers[pos]->GetPrefix()] = modehandlers[pos]->GetModeChar();
 943                 }
 944         }
 945
 946         sort(pfx.begin(), pfx.end(), ModeParser::PrefixComparison);
 947
 948         for (pfxcontainer::iterator n = pfx.begin(); n != pfx.end(); n++)
 949         {
 950                 mletters = mletters + n->first;
 951                 mprefixes = mprefixes + prefix_to_mode.find(n->first)->second;
 952         }
 953
 954         return "(" + mprefixes + ")" + mletters;
 955 }
 956
 957 bool ModeParser::AddModeWatcher(ModeWatcher* mw)
 958 {
 959         unsigned char mask = 0;
 960         unsigned char pos = 0;
 961
 962         if (!mw)
 963                 return false;
 964
 965         if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z'))
 966                 return false;
 967
 968         mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 969         pos = (mw->GetModeChar()-65) | mask;
 970
 971         modewatchers[pos].push_back(mw);
 972
 973         return true;
 974 }
 975
 976 bool ModeParser::DelModeWatcher(ModeWatcher* mw)
 977 {
 978         unsigned char mask = 0;
 979         unsigned char pos = 0;
 980
 981         if (!mw)
 982                 return false;
 983
 984         if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z'))
 985                 return false;
 986
 987         mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
 988         pos = (mw->GetModeChar()-65) | mask;
 989
 990         ModeWatchIter a = find(modewatchers[pos].begin(),modewatchers[pos].end(),mw);
 991
 992         if (a == modewatchers[pos].end())
 993         {
 994                 return false;
 995         }
 996
 997         modewatchers[pos].erase(a);
 998
 999         return true;
1000 }
1001
1002 /** This default implementation can remove simple user modes
1003  */
1004 void ModeHandler::RemoveMode(User* user)
1005 {
1006         char moderemove[MAXBUF];
1007         const char* parameters[] = { user->nick, moderemove };
1008
1009         if (user->IsModeSet(this->GetModeChar()))
1010         {
1011                 sprintf(moderemove,"-%c",this->GetModeChar());
1012                 ServerInstance->Parser->CallHandler("MODE", parameters, 2, user);
1013         }
1014 }
1015
1016 /** This default implementation can remove simple channel modes
1017  * (no parameters)
1018  */
1019 void ModeHandler::RemoveMode(Channel* channel)
1020 {
1021         char moderemove[MAXBUF];
1022         const char* parameters[] = { channel->name, moderemove };
1023
1024         if (channel->IsModeSet(this->GetModeChar()))
1025         {
1026                 sprintf(moderemove,"-%c",this->GetModeChar());
1027                 ServerInstance->SendMode(parameters, 2, ServerInstance->FakeClient);
1028         }
1029 }
1030
1031 ModeParser::ModeParser(InspIRCd* Instance) : ServerInstance(Instance)
1032 {
1033         struct Initializer
1034         {
1035                 char modechar;
1036                 ModeHandler* handler;
1037         };
1038
1039         Initializer modes[] = {
1040                 { 's', new ModeChannelSecret(Instance) },
1041                 { 'p', new ModeChannelPrivate(Instance) },
1042                 { 'm', new ModeChannelModerated(Instance) },
1043                 { 't', new ModeChannelTopicOps(Instance) },
1044                 { 'n', new ModeChannelNoExternal(Instance) },
1045                 { 'i', new ModeChannelInviteOnly(Instance) },
1046                 { 'k', new ModeChannelKey(Instance) },
1047                 { 'l', new ModeChannelLimit(Instance) },
1048                 { 'b', new ModeChannelBan(Instance) },
1049                 { 'o', new ModeChannelOp(Instance) },
1050                 { 'h', new ModeChannelHalfOp(Instance) },
1051                 { 'v', new ModeChannelVoice(Instance) },
1052                 { 's', new ModeUserServerNotice(Instance) },
1053                 { 'w', new ModeUserWallops(Instance) },
1054                 { 'i', new ModeUserInvisible(Instance) },
1055                 { 'o', new ModeUserOperator(Instance) },
1056                 { 'n', new ModeUserServerNoticeMask(Instance) },
1057                 { 0, NULL }
1058         };
1059
1060         /* Clear mode list */
1061         memset(modehandlers, 0, sizeof(modehandlers));
1062         memset(modewatchers, 0, sizeof(modewatchers));
1063
1064         /* Last parse string */
1065         LastParse.clear();
1066
1067         /* Initialise the RFC mode letters */
1068         for (int index = 0; modes[index].modechar; index++)
1069                 this->AddMode(modes[index].handler, modes[index].modechar);
1070 }