X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fchannels.cpp;h=9ef1180c6fb0599dc308dfea5515d7a1dbf3afa0;hb=6d64862fb556c43568efdf6b4f65de3fbd33c576;hp=4a110bdb25b08d72018c4e5516c416ba0c3c76f5;hpb=715dab175374ee11609f013b103c1b0f579192bc;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/channels.cpp b/src/channels.cpp index 4a110bdb2..0b24aa4b7 100644 --- a/src/channels.cpp +++ b/src/channels.cpp @@ -2,582 +2,1196 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. - * E-mail: - * - * - * - * Written by Craig Edwards, Craig McLure, and others. + * InspIRCd: (C) 2002-2008 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ -using namespace std; +/* $Core */ -#include "inspircd_config.h" #include "inspircd.h" -#include "inspircd_io.h" -#include -#include -#include -#include -#include -#include -#ifdef GCC3 -#include -#else -#include -#endif -#include -#include -#include -#include -#include "users.h" -#include "ctables.h" -#include "globals.h" -#include "modules.h" -#include "dynamic.h" -#include "commands.h" +#include #include "wildcard.h" -#include "message.h" #include "mode.h" -#include "xline.h" -#include "inspstring.h" -#include "helperfuncs.h" -#include "typedefs.h" -#ifdef GCC3 -#define nspace __gnu_cxx -#else -#define nspace std -#endif +Channel::Channel(InspIRCd* Instance, const std::string &cname, time_t ts) : ServerInstance(Instance) +{ + chan_hash::iterator findchan = ServerInstance->chanlist->find(cname); + if (findchan != Instance->chanlist->end()) + throw CoreException("Cannot create duplicate channel " + cname); + + (*(ServerInstance->chanlist))[cname.c_str()] = this; + this->name.assign(cname, 0, ServerInstance->Config->Limits.ChanMax); + this->created = ts ? ts : ServerInstance->Time(); + this->age = this->created; -extern ServerConfig* Config; + maxbans = topicset = 0; + modes.reset(); +} + +void Channel::SetMode(char mode,bool mode_on) +{ + modes[mode-65] = mode_on; + if (!mode_on) + this->SetModeParam(mode,"",false); +} -extern int MODCOUNT; -extern std::vector modules; -extern std::vector factory; -extern int WHOWAS_STALE; -extern int WHOWAS_MAX; -extern time_t TIME; -extern chan_hash chanlist; -using namespace std; +void Channel::SetModeParam(char mode,const char* parameter,bool mode_on) +{ + CustomModeList::iterator n = custom_mode_params.find(mode); -std::vector custom_mode_params; + if (mode_on) + { + if (n == custom_mode_params.end()) + custom_mode_params[mode] = strdup(parameter); + } + else + { + if (n != custom_mode_params.end()) + { + free(n->second); + custom_mode_params.erase(n); + } + } +} -chanrec* ForceChan(chanrec* Ptr,ucrec &a,userrec* user, int created); +bool Channel::IsModeSet(char mode) +{ + return modes[mode-65]; +} -chanrec::chanrec() +std::string Channel::GetModeParameter(char mode) { - *name = *custom_modes = *topic = *setby = *key = 0; - created = topicset = limit = binarymodes = 0; - internal_userlist.clear(); + CustomModeList::iterator n = custom_mode_params.find(mode); + if (n != custom_mode_params.end()) + return n->second; + return ""; } -void chanrec::SetCustomMode(char mode,bool mode_on) +int Channel::SetTopic(User *u, std::string &ntopic, bool forceset) { - if (mode_on) { - static char m[3]; - m[0] = mode; - m[1] = '\0'; - if (!strchr(this->custom_modes,mode)) + if (IS_LOCAL(u)) + { + if(!forceset) { - strlcat(custom_modes,m,MAXMODES); + int MOD_RESULT = 0; + /* 0: check status, 1: don't, -1: disallow change silently */ + + FOREACH_RESULT(I_OnLocalTopicChange,OnLocalTopicChange(u,this,ntopic)); + + if (MOD_RESULT == 1) + return CMD_FAILURE; + else if (MOD_RESULT == 0) + { + if (!this->HasUser(u)) + { + u->WriteNumeric(442, "%s %s :You're not on that channel!",u->nick.c_str(), this->name.c_str()); + return CMD_FAILURE; + } + if ((this->IsModeSet('t')) && (this->GetStatus(u) < STATUS_HOP)) + { + u->WriteNumeric(482, "%s %s :You must be at least a half-operator to change the topic on this channel", u->nick.c_str(), this->name.c_str()); + return CMD_FAILURE; + } + } } - log(DEBUG,"Custom mode %c set",mode); } - else { - std::string a = this->custom_modes; - int pos = a.find(mode); - a.erase(pos,1); - strlcpy(this->custom_modes,a.c_str(),MAXMODES); + this->topic.assign(ntopic, 0, ServerInstance->Config->Limits.MaxTopic); + this->setby.assign(ServerInstance->Config->FullHostInTopic ? u->GetFullHost() : u->nick, 0, 128); + this->topicset = ServerInstance->Time(); + this->WriteChannel(u, "TOPIC %s :%s", this->name.c_str(), this->topic.c_str()); - log(DEBUG,"Custom mode %c removed: modelist='%s'",mode,this->custom_modes); - this->SetCustomModeParam(mode,"",false); + if (IS_LOCAL(u)) + { + FOREACH_MOD(I_OnPostLocalTopicChange,OnPostLocalTopicChange(u, this, this->topic)); } + + return CMD_SUCCESS; } +long Channel::GetUserCounter() +{ + return (this->internal_userlist.size()); +} -void chanrec::SetCustomModeParam(char mode,char* parameter,bool mode_on) +void Channel::AddUser(User* user) { + internal_userlist[user] = user->nick; +} - log(DEBUG,"SetCustomModeParam called"); - ModeParameter M; - M.mode = mode; - strlcpy(M.channel,this->name,CHANMAX); - strlcpy(M.parameter,parameter,MAXBUF); - if (mode_on) +unsigned long Channel::DelUser(User* user) +{ + CUListIter a = internal_userlist.find(user); + + if (a != internal_userlist.end()) + { + internal_userlist.erase(a); + /* And tidy any others... */ + DelOppedUser(user); + DelHalfoppedUser(user); + DelVoicedUser(user); + } + + return internal_userlist.size(); +} + +bool Channel::HasUser(User* user) +{ + return (internal_userlist.find(user) != internal_userlist.end()); +} + +void Channel::AddOppedUser(User* user) +{ + internal_op_userlist[user] = user->nick; +} + +void Channel::DelOppedUser(User* user) +{ + CUListIter a = internal_op_userlist.find(user); + if (a != internal_op_userlist.end()) + { + internal_op_userlist.erase(a); + return; + } +} + +void Channel::AddHalfoppedUser(User* user) +{ + internal_halfop_userlist[user] = user->nick; +} + +void Channel::DelHalfoppedUser(User* user) +{ + CUListIter a = internal_halfop_userlist.find(user); + + if (a != internal_halfop_userlist.end()) + { + internal_halfop_userlist.erase(a); + } +} + +void Channel::AddVoicedUser(User* user) +{ + internal_voice_userlist[user] = user->nick; +} + +void Channel::DelVoicedUser(User* user) +{ + CUListIter a = internal_voice_userlist.find(user); + + if (a != internal_voice_userlist.end()) { - log(DEBUG,"Custom mode parameter %c %s added",mode,parameter); - custom_mode_params.push_back(M); + internal_voice_userlist.erase(a); + } +} + +CUList* Channel::GetUsers() +{ + return &internal_userlist; +} + +CUList* Channel::GetOppedUsers() +{ + return &internal_op_userlist; +} + +CUList* Channel::GetHalfoppedUsers() +{ + return &internal_halfop_userlist; +} + +CUList* Channel::GetVoicedUsers() +{ + return &internal_voice_userlist; +} + +void Channel::SetDefaultModes() +{ + ServerInstance->Logs->Log("CHANNELS", DEBUG, "SetDefaultModes %s", ServerInstance->Config->DefaultModes); + irc::spacesepstream list(ServerInstance->Config->DefaultModes); + std::string modeseq; + std::string parameter; + + list.GetToken(modeseq); + + for (std::string::iterator n = modeseq.begin(); n != modeseq.end(); ++n) + { + ModeHandler* mode = ServerInstance->Modes->FindMode(*n, MODETYPE_CHANNEL); + if (mode) + { + if (mode->GetNumParams(true)) + list.GetToken(parameter); + else + parameter.clear(); + + mode->OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, this, parameter, true); + } + } +} + +/* + * add a channel to a user, creating the record for it if needed and linking + * it to the user record + */ +Channel* Channel::JoinUser(InspIRCd* Instance, User *user, const char* cn, bool override, const char* key, bool bursting, time_t TS) +{ + if (!user || !cn) + return NULL; + + char cname[MAXBUF]; + int MOD_RESULT = 0; + std::string privs; + Channel *Ptr; + + /* + * We don't restrict the number of channels that remote users or users that are override-joining may be in. + * We restrict local users to MaxChans channels. + * We restrict local operators to OperMaxChans channels. + * This is a lot more logical than how it was formerly. -- w00t + */ + if (IS_LOCAL(user) && !override) + { + // Checking MyClass exists because we *may* get here with NULL, not 100% sure. + if (user->MyClass && user->MyClass->GetMaxChans()) + { + if (user->chans.size() >= user->MyClass->GetMaxChans()) + { + user->WriteNumeric(ERR_TOOMANYCHANNELS, "%s %s :You are on too many channels",user->nick.c_str(), cn); + return NULL; + } + } + else + { + if (IS_OPER(user)) + { + if (user->chans.size() >= Instance->Config->OperMaxChans) + { + user->WriteNumeric(ERR_TOOMANYCHANNELS, "%s %s :You are on too many channels",user->nick.c_str(), cn); + return NULL; + } + } + else + { + if (user->chans.size() >= Instance->Config->MaxChans) + { + user->WriteNumeric(ERR_TOOMANYCHANNELS, "%s %s :You are on too many channels",user->nick.c_str(), cn); + return NULL; + } + } + } + } + + strlcpy(cname, cn, Instance->Config->Limits.ChanMax); + Ptr = Instance->FindChan(cname); + + if (!Ptr) + { + /* + * Fix: desync bug was here, don't set @ on remote users - spanningtree handles their permissions. bug #358. -- w00t + */ + if (!IS_LOCAL(user)) + { + if (!TS) + Instance->Logs->Log("CHANNEL",DEBUG,"*** BUG *** Channel::JoinUser called for REMOTE user '%s' on channel '%s' but no TS given!", user->nick.c_str(), cn); + } + else + { + privs = "@"; + } + + if (IS_LOCAL(user) && override == false) + { + MOD_RESULT = 0; + FOREACH_RESULT_I(Instance,I_OnUserPreJoin, OnUserPreJoin(user, NULL, cname, privs, key ? key : "")); + if (MOD_RESULT == 1) + return NULL; + } + + Ptr = new Channel(Instance, cname, TS); } else { - if (custom_mode_params.size()) + /* Already on the channel */ + if (Ptr->HasUser(user)) + return NULL; + + /* + * remote users are allowed us to bypass channel modes + * and bans (used by servers) + */ + if (IS_LOCAL(user) && override == false) { - for (vector::iterator i = custom_mode_params.begin(); i < custom_mode_params.end(); i++) + MOD_RESULT = 0; + FOREACH_RESULT_I(Instance,I_OnUserPreJoin, OnUserPreJoin(user, Ptr, cname, privs, key ? key : "")); + if (MOD_RESULT == 1) { - if ((i->mode == mode) && (!strcasecmp(this->name,i->channel))) + return NULL; + } + else if (MOD_RESULT == 0) + { + std::string ckey = Ptr->GetModeParameter('k'); + bool invited = user->IsInvited(Ptr->name.c_str()); + bool can_bypass = Instance->Config->InvBypassModes && invited; + + if (!ckey.empty()) { - log(DEBUG,"Custom mode parameter %c %s removed",mode,parameter); - custom_mode_params.erase(i); - return; + MOD_RESULT = 0; + FOREACH_RESULT_I(Instance, I_OnCheckKey, OnCheckKey(user, Ptr, key ? key : "")); + if (!MOD_RESULT) + { + // If no key provided, or key is not the right one, and can't bypass +k (not invited or option not enabled) + if ((!key || ckey != key) && !can_bypass) + { + user->WriteNumeric(ERR_BADCHANNELKEY, "%s %s :Cannot join channel (Incorrect channel key)",user->nick.c_str(), Ptr->name.c_str()); + return NULL; + } + } + } + + if (Ptr->IsModeSet('i')) + { + MOD_RESULT = 0; + FOREACH_RESULT_I(Instance,I_OnCheckInvite,OnCheckInvite(user, Ptr)); + if (!MOD_RESULT) + { + if (!invited) + { + user->WriteNumeric(ERR_INVITEONLYCHAN, "%s %s :Cannot join channel (Invite only)",user->nick.c_str(), Ptr->name.c_str()); + return NULL; + } + } + } + + std::string limit = Ptr->GetModeParameter('l'); + if (!limit.empty()) + { + MOD_RESULT = 0; + FOREACH_RESULT_I(Instance, I_OnCheckLimit, OnCheckLimit(user, Ptr)); + if (!MOD_RESULT) + { + long llimit = atol(limit.c_str()); + if (Ptr->GetUserCounter() >= llimit && !can_bypass) + { + user->WriteNumeric(ERR_CHANNELISFULL, "%s %s :Cannot join channel (Channel is full)",user->nick.c_str(), Ptr->name.c_str()); + return NULL; + } + } + } + + if (Ptr->bans.size()) + { + if (Ptr->IsBanned(user) && !can_bypass) + { + user->WriteNumeric(ERR_BANNEDFROMCHAN, "%s %s :Cannot join channel (You're banned)",user->nick.c_str(), Ptr->name.c_str()); + return NULL; + } + } + + /* + * If the user has invites for this channel, remove them now + * after a successful join so they don't build up. + */ + if (invited) + { + user->RemoveInvite(Ptr->name.c_str()); } } } - log(DEBUG,"*** BUG *** Attempt to remove non-existent mode parameter!"); } + + /* As spotted by jilles, dont bother to set this on remote users */ + if (IS_LOCAL(user) && Ptr->GetUserCounter() == 0) + Ptr->SetDefaultModes(); + + return Channel::ForceChan(Instance, Ptr, user, privs, bursting); } -bool chanrec::IsCustomModeSet(char mode) -{ - return (strchr(this->custom_modes,mode)); +Channel* Channel::ForceChan(InspIRCd* Instance, Channel* Ptr, User* user, const std::string &privs, bool bursting) +{ + std::string nick = user->nick; + bool silent = false; + + Ptr->AddUser(user); + + /* Just in case they have no permissions */ + user->chans[Ptr] = 0; + + for (std::string::const_iterator x = privs.begin(); x != privs.end(); x++) + { + const char status = *x; + ModeHandler* mh = Instance->Modes->FindPrefix(status); + if (mh) + { + /* Set, and make sure that the mode handler knows this mode was now set */ + Ptr->SetPrefix(user, status, mh->GetPrefixRank(), true); + mh->OnModeChange(Instance->FakeClient, Instance->FakeClient, Ptr, nick, true); + + switch (mh->GetPrefix()) + { + /* These logic ops are SAFE IN THIS CASE because if the entry doesnt exist, + * addressing operator[] creates it. If they do exist, it points to it. + * At all other times where we dont want to create an item if it doesnt exist, we + * must stick to ::find(). + */ + case '@': + user->chans[Ptr] |= UCMODE_OP; + break; + case '%': + user->chans[Ptr] |= UCMODE_HOP; + break; + case '+': + user->chans[Ptr] |= UCMODE_VOICE; + break; + } + } + } + + FOREACH_MOD_I(Instance,I_OnUserJoin,OnUserJoin(user, Ptr, bursting, silent)); + + if (!silent) + Ptr->WriteChannel(user,"JOIN :%s",Ptr->name.c_str()); + + /* Theyre not the first ones in here, make sure everyone else sees the modes we gave the user */ + std::string ms = Instance->Modes->ModeString(user, Ptr); + if ((Ptr->GetUserCounter() > 1) && (ms.length())) + Ptr->WriteAllExceptSender(user, true, 0, "MODE %s +%s", Ptr->name.c_str(), ms.c_str()); + + /* Major improvement by Brain - we dont need to be calculating all this pointlessly for remote users */ + if (IS_LOCAL(user)) + { + if (Ptr->topicset) + { + user->WriteNumeric(RPL_TOPIC, "%s %s :%s", user->nick.c_str(), Ptr->name.c_str(), Ptr->topic.c_str()); + user->WriteNumeric(RPL_TOPICTIME, "%s %s %s %lu", user->nick.c_str(), Ptr->name.c_str(), Ptr->setby.c_str(), (unsigned long)Ptr->topicset); + } + Ptr->UserList(user); + } + FOREACH_MOD_I(Instance,I_OnPostJoin,OnPostJoin(user, Ptr)); + return Ptr; } -std::string chanrec::GetModeParameter(char mode) +bool Channel::IsBanned(User* user) { - if (custom_mode_params.size()) + char mask[MAXBUF]; + int MOD_RESULT = 0; + FOREACH_RESULT(I_OnCheckBan,OnCheckBan(user, this)); + + if (MOD_RESULT == -1) + return true; + else if (MOD_RESULT == 0) { - for (vector::iterator i = custom_mode_params.begin(); i < custom_mode_params.end(); i++) + snprintf(mask, MAXBUF, "%s!%s@%s", user->nick.c_str(), user->ident.c_str(), user->GetIPString()); + for (BanList::iterator i = this->bans.begin(); i != this->bans.end(); i++) { - if ((i->mode == mode) && (!strcasecmp(this->name,i->channel))) + /* This allows CIDR ban matching + * + * Full masked host Full unmasked host IP with/without CIDR + */ + if ((match(user->GetFullHost(),i->data)) || (match(user->GetFullRealHost(),i->data)) || (match(mask, i->data, true))) { - return i->parameter; + return true; } } } - return ""; + return false; } -long chanrec::GetUserCounter() +bool Channel::IsExtBanned(const std::string &str, char type) { - return (this->internal_userlist.size()); + int MOD_RESULT = 0; + FOREACH_RESULT(I_OnCheckStringExtBan, OnCheckStringExtBan(str, this, type)); + + if (MOD_RESULT == -1) + return true; + else if (MOD_RESULT == 0) + { + for (BanList::iterator i = this->bans.begin(); i != this->bans.end(); i++) + { + if (i->data[0] != type || i->data[1] != ':') + continue; + + // Iterate past char and : to get to the mask without doing a data copy(!) + std::string maskptr = i->data.substr(2); + ServerInstance->Logs->Log("EXTBANS", DEBUG, "Checking %s against %s, type is %c", str.c_str(), maskptr.c_str(), type); + + if (match(str, maskptr)) + return true; + } + } + + return false; } -void chanrec::AddUser(char* castuser) +bool Channel::IsExtBanned(User *user, char type) { - internal_userlist[castuser] = castuser; - log(DEBUG,"Added casted user to channel's internal list"); + int MOD_RESULT = 0; + FOREACH_RESULT(I_OnCheckExtBan, OnCheckExtBan(user, this, type)); + + if (MOD_RESULT == -1) + return true; + else if (MOD_RESULT == 0) + { + char mask[MAXBUF]; + snprintf(mask, MAXBUF, "%s!%s@%s", user->nick.c_str(), user->ident.c_str(), user->GetIPString()); + + // XXX: we should probably hook cloaked hosts in here somehow too.. + if (this->IsExtBanned(mask, type)) + return true; + + if (this->IsExtBanned(user->GetFullHost(), type)) + return true; + + if (this->IsExtBanned(user->GetFullRealHost(), type)) + return true; + } + + return false; } -void chanrec::DelUser(char* castuser) +/* Channel::PartUser + * remove a channel from a users record, and return the number of users left. + * Therefore, if this function returns 0 the caller should delete the Channel. + * + * XXX: bleh, string copy of reason, fixme! -- w00t + */ +long Channel::PartUser(User *user, std::string &reason) { - std::map::iterator a = internal_userlist.find(castuser); - if (a != internal_userlist.end()) + bool silent = false; + + if (!user) + return this->GetUserCounter(); + + UCListIter i = user->chans.find(this); + if (i != user->chans.end()) { - log(DEBUG,"Removed casted user from channel's internal list"); - internal_userlist.erase(a); + FOREACH_MOD(I_OnUserPart,OnUserPart(user, this, reason, silent)); + + if (!silent) + this->WriteChannel(user, "PART %s%s%s", this->name.c_str(), reason.empty() ? "" : " :", reason.c_str()); + + user->chans.erase(i); + this->RemoveAllPrefixes(user); + } + + if (!this->DelUser(user)) /* if there are no users left on the channel... */ + { + chan_hash::iterator iter = ServerInstance->chanlist->find(this->name); + /* kill the record */ + if (iter != ServerInstance->chanlist->end()) + { + int MOD_RESULT = 0; + FOREACH_RESULT_I(ServerInstance,I_OnChannelPreDelete, OnChannelPreDelete(this)); + if (MOD_RESULT == 1) + return 1; // delete halted by module + FOREACH_MOD(I_OnChannelDelete, OnChannelDelete(this)); + ServerInstance->chanlist->erase(iter); + } + return 0; + } + + return this->GetUserCounter(); +} + +long Channel::ServerKickUser(User* user, const char* reason, bool triggerevents, const char* servername) +{ + bool silent = false; + + if (!user || !reason) + return this->GetUserCounter(); + + if (IS_LOCAL(user)) + { + if (!this->HasUser(user)) + { + /* Not on channel */ + return this->GetUserCounter(); + } + } + + if (servername == NULL || *ServerInstance->Config->HideWhoisServer) + servername = ServerInstance->Config->ServerName; + + if (triggerevents) + { + FOREACH_MOD(I_OnUserKick,OnUserKick(NULL, user, this, reason, silent)); + } + + UCListIter i = user->chans.find(this); + if (i != user->chans.end()) + { + if (!silent) + this->WriteChannelWithServ(servername, "KICK %s %s :%s", this->name.c_str(), user->nick.c_str(), reason); + + user->chans.erase(i); + this->RemoveAllPrefixes(user); + } + + if (!this->DelUser(user)) + { + chan_hash::iterator iter = ServerInstance->chanlist->find(this->name); + /* kill the record */ + if (iter != ServerInstance->chanlist->end()) + { + int MOD_RESULT = 0; + FOREACH_RESULT_I(ServerInstance,I_OnChannelPreDelete, OnChannelPreDelete(this)); + if (MOD_RESULT == 1) + return 1; // delete halted by module + FOREACH_MOD(I_OnChannelDelete, OnChannelDelete(this)); + ServerInstance->chanlist->erase(iter); + } + return 0; + } + + return this->GetUserCounter(); +} + +long Channel::KickUser(User *src, User *user, const char* reason) +{ + bool silent = false; + + if (!src || !user || !reason) + return this->GetUserCounter(); + + if (IS_LOCAL(src)) + { + if (!this->HasUser(user)) + { + src->WriteNumeric(ERR_USERNOTINCHANNEL, "%s %s %s :They are not on that channel",src->nick.c_str(), user->nick.c_str(), this->name.c_str()); + return this->GetUserCounter(); + } + if ((ServerInstance->ULine(user->server)) && (!ServerInstance->ULine(src->server))) + { + src->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :Only a u-line may kick a u-line from a channel.",src->nick.c_str(), this->name.c_str()); + return this->GetUserCounter(); + } + int MOD_RESULT = 0; + + if (!ServerInstance->ULine(src->server)) + { + MOD_RESULT = 0; + FOREACH_RESULT(I_OnUserPreKick,OnUserPreKick(src,user,this,reason)); + if (MOD_RESULT == 1) + return this->GetUserCounter(); + } + /* Set to -1 by OnUserPreKick if explicit allow was set */ + if (MOD_RESULT != -1) + { + FOREACH_RESULT(I_OnAccessCheck,OnAccessCheck(src,user,this,AC_KICK)); + if ((MOD_RESULT == ACR_DENY) && (!ServerInstance->ULine(src->server))) + return this->GetUserCounter(); + + if ((MOD_RESULT == ACR_DEFAULT) || (!ServerInstance->ULine(src->server))) + { + int them = this->GetStatus(src); + int us = this->GetStatus(user); + if ((them < STATUS_HOP) || (them < us)) + { + src->WriteNumeric(ERR_CHANOPRIVSNEEDED, "%s %s :You must be a channel %soperator",src->nick.c_str(), this->name.c_str(), them == STATUS_HOP ? "" : "half-"); + return this->GetUserCounter(); + } + } + } + } + + FOREACH_MOD(I_OnUserKick,OnUserKick(src, user, this, reason, silent)); + + UCListIter i = user->chans.find(this); + if (i != user->chans.end()) + { + /* zap it from the channel list of the user */ + if (!silent) + this->WriteChannel(src, "KICK %s %s :%s", this->name.c_str(), user->nick.c_str(), reason); + + user->chans.erase(i); + this->RemoveAllPrefixes(user); + } + + if (!this->DelUser(user)) + /* if there are no users left on the channel */ + { + chan_hash::iterator iter = ServerInstance->chanlist->find(this->name.c_str()); + + /* kill the record */ + if (iter != ServerInstance->chanlist->end()) + { + int MOD_RESULT = 0; + FOREACH_RESULT_I(ServerInstance,I_OnChannelPreDelete, OnChannelPreDelete(this)); + if (MOD_RESULT == 1) + return 1; // delete halted by module + FOREACH_MOD(I_OnChannelDelete, OnChannelDelete(this)); + ServerInstance->chanlist->erase(iter); + } + return 0; + } + + return this->GetUserCounter(); +} + +void Channel::WriteChannel(User* user, const char* text, ...) +{ + char textbuffer[MAXBUF]; + va_list argsPtr; + + if (!user || !text) return; + + va_start(argsPtr, text); + vsnprintf(textbuffer, MAXBUF, text, argsPtr); + va_end(argsPtr); + + this->WriteChannel(user, std::string(textbuffer)); +} + +void Channel::WriteChannel(User* user, const std::string &text) +{ + CUList *ulist = this->GetUsers(); + char tb[MAXBUF]; + + if (!user) + return; + + snprintf(tb,MAXBUF,":%s %s", user->GetFullHost().c_str(), text.c_str()); + std::string out = tb; + + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + { + if (IS_LOCAL(i->first)) + i->first->Write(out); } - log(DEBUG,"BUG BUG BUG! Attempt to remove an uncasted user from the internal list of %s!",name); } -std::map *chanrec::GetUsers() +void Channel::WriteChannelWithServ(const char* ServName, const char* text, ...) { - return &internal_userlist; + char textbuffer[MAXBUF]; + va_list argsPtr; + + if (!text) + return; + + va_start(argsPtr, text); + vsnprintf(textbuffer, MAXBUF, text, argsPtr); + va_end(argsPtr); + + this->WriteChannelWithServ(ServName, std::string(textbuffer)); } -/* add a channel to a user, creating the record for it if needed and linking - * it to the user record */ - -chanrec* add_channel(userrec *user, const char* cn, const char* key, bool override) -{ - if ((!user) || (!cn)) - { - log(DEFAULT,"*** BUG *** add_channel was given an invalid parameter"); - return 0; - } - - int created = 0; - char cname[MAXBUF]; - int MOD_RESULT = 0; - strlcpy(cname,cn,CHANMAX); - log(DEBUG,"cname='%s' cn='%s'",cname,cn); - - log(DEBUG,"add_channel: %s %s",user->nick,cname); - - chanrec* Ptr = FindChan(cname); - - if (!Ptr) - { - if (user->fd > -1) - { - MOD_RESULT = 0; - FOREACH_RESULT(I_OnUserPreJoin,OnUserPreJoin(user,NULL,cname)); - if (MOD_RESULT == 1) - return NULL; - } - /* create a new one */ - chanlist[cname] = new chanrec(); - strlcpy(chanlist[cname]->name, cname,CHANMAX); - chanlist[cname]->binarymodes = CM_TOPICLOCK | CM_NOEXTERNAL; - chanlist[cname]->created = TIME; - *chanlist[cname]->topic = 0; - strlcpy(chanlist[cname]->setby, user->nick,NICKMAX); - chanlist[cname]->topicset = 0; - Ptr = chanlist[cname]; - log(DEBUG,"add_channel: created: %s",cname); - /* set created to 2 to indicate user - * is the first in the channel - * and should be given ops */ - created = 2; - } - else - { - /* Already on the channel */ - if (has_channel(user,Ptr)) - return NULL; - - // remote users are allowed us to bypass channel modes - // and bans (used by servers) - if (user->fd > -1) - { - MOD_RESULT = 0; - FOREACH_RESULT(I_OnUserPreJoin,OnUserPreJoin(user,Ptr,cname)); - if (MOD_RESULT == 1) - { - return NULL; - } - else if (MOD_RESULT == 0) - { - if (*Ptr->key) - { - MOD_RESULT = 0; - FOREACH_RESULT(I_OnCheckKey,OnCheckKey(user, Ptr, key ? key : "")); - if (!MOD_RESULT) - { - if (!key) - { - log(DEBUG,"add_channel: no key given in JOIN"); - WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name); - return NULL; - } - else - { - if (strcasecmp(key,Ptr->key)) - { - log(DEBUG,"add_channel: bad key given in JOIN"); - WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name); - return NULL; - } - } - } - } - if (Ptr->binarymodes & CM_INVITEONLY) - { - MOD_RESULT = 0; - irc::string xname(Ptr->name); - FOREACH_RESULT(I_OnCheckInvite,OnCheckInvite(user, Ptr)); - if (!MOD_RESULT) - { - log(DEBUG,"add_channel: channel is +i"); - if (user->IsInvited(xname)) - { - /* user was invited to channel */ - /* there may be an optional channel NOTICE here */ - } - else - { - WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name); - return NULL; - } - } - user->RemoveInvite(xname); - } - if (Ptr->limit) - { - MOD_RESULT = 0; - FOREACH_RESULT(I_OnCheckLimit,OnCheckLimit(user, Ptr)); - if (!MOD_RESULT) - { - if (usercount(Ptr) >= Ptr->limit) - { - WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name); - return NULL; - } - } - } - if (Ptr->bans.size()) - { - log(DEBUG,"add_channel: about to walk banlist"); - MOD_RESULT = 0; - FOREACH_RESULT(I_OnCheckBan,OnCheckBan(user, Ptr)); - if (!MOD_RESULT) - { - for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++) - { - if (match(user->GetFullHost(),i->data)) - { - WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name); - return NULL; - } - } - } - } - } - } - else - { - log(DEBUG,"Overridden checks"); - } - created = 1; - } - - log(DEBUG,"Passed channel checks"); - - for (unsigned int index =0; index < user->chans.size(); index++) - { - if (user->chans[index].channel == NULL) - { - return ForceChan(Ptr,user->chans[index],user,created); - } - } - /* XXX: If the user is an oper here, we can just extend their user->chans vector by one - * and put the channel in here. Same for remote users which are not bound by - * the channel limits. Otherwise, nope, youre boned. - */ - if (user->fd < 0) - { - ucrec a; - chanrec* c = ForceChan(Ptr,a,user,created); - user->chans.push_back(a); - return c; - } - else if (strchr(user->modes,'o')) - { - /* Oper allows extension up to the OPERMAXCHANS value */ - if (user->chans.size() < OPERMAXCHANS) - { - ucrec a; - chanrec* c = ForceChan(Ptr,a,user,created); - user->chans.push_back(a); - return c; - } - } - log(DEBUG,"add_channel: user channel max exceeded: %s %s",user->nick,cname); - WriteServ(user->fd,"405 %s %s :You are on too many channels",user->nick, cname); - return NULL; -} - -chanrec* ForceChan(chanrec* Ptr,ucrec &a,userrec* user, int created) -{ - if (created == 2) - { - /* first user in is given ops */ - a.uc_modes = UCMODE_OP; - } - else - { - a.uc_modes = 0; - } - a.channel = Ptr; - Ptr->AddUser((char*)user); - WriteChannel(Ptr,user,"JOIN :%s",Ptr->name); - log(DEBUG,"Sent JOIN to client"); - if (Ptr->topicset) - { - WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic); - WriteServ(user->fd,"333 %s %s %s %lu", user->nick, Ptr->name, Ptr->setby, (unsigned long)Ptr->topicset); - } - userlist(user,Ptr); - WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, Ptr->name); - FOREACH_MOD(I_OnUserJoin,OnUserJoin(user,Ptr)); - return Ptr; -} - -/* remove a channel from a users record, and remove the record from memory - * if the channel has become empty */ - -chanrec* del_channel(userrec *user, const char* cname, const char* reason, bool local) -{ - if ((!user) || (!cname)) - { - log(DEFAULT,"*** BUG *** del_channel was given an invalid parameter"); - return NULL; - } - - chanrec* Ptr = FindChan(cname); - - if (!Ptr) - return NULL; - - log(DEBUG,"del_channel: removing: %s %s",user->nick,Ptr->name); - - for (unsigned int i =0; i < user->chans.size(); i++) - { - /* zap it from the channel list of the user */ - if (user->chans[i].channel == Ptr) - { - if (reason) - { - FOREACH_MOD(I_OnUserPart,OnUserPart(user,Ptr,reason)); - WriteChannel(Ptr,user,"PART %s :%s",Ptr->name, reason); - } - else - { - FOREACH_MOD(I_OnUserPart,OnUserPart(user,Ptr,"")); - WriteChannel(Ptr,user,"PART :%s",Ptr->name); - } - user->chans[i].uc_modes = 0; - user->chans[i].channel = NULL; - log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name); - break; - } - } - - Ptr->DelUser((char*)user); - - /* if there are no users left on the channel */ - if (!usercount(Ptr)) - { - chan_hash::iterator iter = chanlist.find(Ptr->name); - - log(DEBUG,"del_channel: destroying channel: %s",Ptr->name); - - /* kill the record */ - if (iter != chanlist.end()) - { - log(DEBUG,"del_channel: destroyed: %s",Ptr->name); - FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(Ptr)); - delete Ptr; - chanlist.erase(iter); - } - } - - return NULL; -} - -void server_kick_channel(userrec* user, chanrec* Ptr, char* reason, bool triggerevents) -{ - if ((!user) || (!Ptr) || (!reason)) +void Channel::WriteChannelWithServ(const char* ServName, const std::string &text) +{ + CUList *ulist = this->GetUsers(); + char tb[MAXBUF]; + + snprintf(tb,MAXBUF,":%s %s", ServName ? ServName : ServerInstance->Config->ServerName, text.c_str()); + std::string out = tb; + + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { + if (IS_LOCAL(i->first)) + i->first->Write(out); + } +} + +/* write formatted text from a source user to all users on a channel except + * for the sender (for privmsg etc) */ +void Channel::WriteAllExceptSender(User* user, bool serversource, char status, const char* text, ...) +{ + char textbuffer[MAXBUF]; + va_list argsPtr; + + if (!text) return; + + va_start(argsPtr, text); + vsnprintf(textbuffer, MAXBUF, text, argsPtr); + va_end(argsPtr); + + this->WriteAllExceptSender(user, serversource, status, std::string(textbuffer)); +} + +void Channel::WriteAllExcept(User* user, bool serversource, char status, CUList &except_list, const char* text, ...) +{ + char textbuffer[MAXBUF]; + va_list argsPtr; + + if (!text) + return; + + va_start(argsPtr, text); + vsnprintf(textbuffer, MAXBUF, text, argsPtr); + va_end(argsPtr); + + this->WriteAllExcept(user, serversource, status, except_list, std::string(textbuffer)); +} + +void Channel::WriteAllExcept(User* user, bool serversource, char status, CUList &except_list, const std::string &text) +{ + CUList *ulist = this->GetUsers(); + char tb[MAXBUF]; + + snprintf(tb,MAXBUF,":%s %s", user->GetFullHost().c_str(), text.c_str()); + std::string out = tb; + + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + { + if ((IS_LOCAL(i->first)) && (except_list.find(i->first) == except_list.end())) + { + /* User doesnt have the status we're after */ + if (status && !strchr(this->GetAllPrefixChars(i->first), status)) + continue; + + if (serversource) + i->first->WriteServ(text); + else + i->first->Write(out); + } } +} - if (!has_channel(user,Ptr)) +void Channel::WriteAllExceptSender(User* user, bool serversource, char status, const std::string& text) +{ + CUList except_list; + except_list[user] = user->nick; + this->WriteAllExcept(user, serversource, status, except_list, std::string(text)); +} + +/* + * return a count of the users on a specific channel accounting for + * invisible users who won't increase the count. e.g. for /LIST + */ +int Channel::CountInvisible() +{ + int count = 0; + CUList *ulist= this->GetUsers(); + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { - /* Not on channel */ + if (!(i->first->IsModeSet('i'))) + count++; + } + + return count; +} + +char* Channel::ChanModes(bool showkey) +{ + static char scratch[MAXBUF]; + static char sparam[MAXBUF]; + char* offset = scratch; + std::string extparam; + + *scratch = '\0'; + *sparam = '\0'; + + /* This was still iterating up to 190, Channel::modes is only 64 elements -- Om */ + for(int n = 0; n < 64; n++) + { + if(this->modes[n]) + { + *offset++ = n + 65; + extparam.clear(); + switch (n) + { + case CM_KEY: + // Unfortunately this must be special-cased, as we definitely don't want to always display key. + if (showkey) + { + extparam = this->GetModeParameter('k'); + } + else + { + extparam = ""; + } + break; + case CM_NOEXTERNAL: + case CM_TOPICLOCK: + case CM_INVITEONLY: + case CM_MODERATED: + case CM_SECRET: + case CM_PRIVATE: + /* We know these have no parameters */ + break; + default: + extparam = this->GetModeParameter(n + 65); + break; + } + if (!extparam.empty()) + { + charlcat(sparam,' ',MAXBUF); + strlcat(sparam,extparam.c_str(),MAXBUF); + } + } + } + + /* Null terminate scratch */ + *offset = '\0'; + strlcat(scratch,sparam,MAXBUF); + return scratch; +} + +/* compile a userlist of a channel into a string, each nick seperated by + * spaces and op, voice etc status shown as @ and +, and send it to 'user' + */ +void Channel::UserList(User *user, CUList *ulist) +{ + char list[MAXBUF]; + size_t dlen, curlen; + int MOD_RESULT = 0; + bool call_modules = true; + + if (!IS_LOCAL(user)) return; + + FOREACH_RESULT(I_OnUserList,OnUserList(user, this, ulist)); + if (MOD_RESULT == 1) + call_modules = false; + + if (MOD_RESULT != -1) + { + if ((this->IsModeSet('s')) && (!this->HasUser(user))) + { + user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel",user->nick.c_str(), this->name.c_str()); + return; + } } - if (triggerevents) + dlen = curlen = snprintf(list,MAXBUF,"%s %c %s :", user->nick.c_str(), this->IsModeSet('s') ? '@' : this->IsModeSet('p') ? '*' : '=', this->name.c_str()); + + int numusers = 0; + char* ptr = list + dlen; + + if (!ulist) + ulist = this->GetUsers(); + + /* Improvement by Brain - this doesnt change in value, so why was it inside + * the loop? + */ + bool has_user = this->HasUser(user); + + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { - FOREACH_MOD(I_OnUserKick,OnUserKick(NULL,user,Ptr,reason)); - } - - for (unsigned int i =0; i < user->chans.size(); i++) - { - if (user->chans[i].channel) - if (!strcasecmp(user->chans[i].channel->name,Ptr->name)) - { - WriteChannelWithServ(Config->ServerName,Ptr,"KICK %s %s :%s",Ptr->name, user->nick, reason); - user->chans[i].uc_modes = 0; - user->chans[i].channel = NULL; - break; - } - } - - Ptr->DelUser((char*)user); - - if (!usercount(Ptr)) - { - chan_hash::iterator iter = chanlist.find(Ptr->name); - log(DEBUG,"del_channel: destroying channel: %s",Ptr->name); - /* kill the record */ - if (iter != chanlist.end()) - { - log(DEBUG,"del_channel: destroyed: %s",Ptr->name); - FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(Ptr)); - delete Ptr; - chanlist.erase(iter); - } - } -} - -void kick_channel(userrec *src,userrec *user, chanrec *Ptr, char* reason) -{ - if ((!src) || (!user) || (!Ptr) || (!reason)) - { - log(DEFAULT,"*** BUG *** kick_channel was given an invalid parameter"); - return; - } - - log(DEBUG,"kick_channel: removing: %s %s %s",user->nick,Ptr->name,src->nick); - - if (!has_channel(user,Ptr)) - { - WriteServ(src->fd,"441 %s %s %s :They are not on that channel",src->nick, user->nick, Ptr->name); - return; - } - - int MOD_RESULT = 0; - FOREACH_RESULT(I_OnAccessCheck,OnAccessCheck(src,user,Ptr,AC_KICK)); - if ((MOD_RESULT == ACR_DENY) && (!is_uline(src->server))) - return; - - if ((MOD_RESULT == ACR_DEFAULT) || (!is_uline(src->server))) - { - if ((cstatus(src,Ptr) < STATUS_HOP) || (cstatus(src,Ptr) < cstatus(user,Ptr))) - { - if (cstatus(src,Ptr) == STATUS_HOP) - { - WriteServ(src->fd,"482 %s %s :You must be a channel operator",src->nick, Ptr->name); - } - else - { - WriteServ(src->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",src->nick, Ptr->name); - } - - return; - } - } - - if (!is_uline(src->server)) - { - MOD_RESULT = 0; - FOREACH_RESULT(I_OnUserPreKick,OnUserPreKick(src,user,Ptr,reason)); - if (MOD_RESULT) - return; - } - - FOREACH_MOD(I_OnUserKick,OnUserKick(src,user,Ptr,reason)); - - for (unsigned int i =0; i < user->chans.size(); i++) - { - /* zap it from the channel list of the user */ - if (user->chans[i].channel) - if (!strcasecmp(user->chans[i].channel->name,Ptr->name)) - { - WriteChannel(Ptr,src,"KICK %s %s :%s",Ptr->name, user->nick, reason); - user->chans[i].uc_modes = 0; - user->chans[i].channel = NULL; - log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name); - break; - } - } - - Ptr->DelUser((char*)user); - - /* if there are no users left on the channel */ - if (!usercount(Ptr)) - { - chan_hash::iterator iter = chanlist.find(Ptr->name); - - log(DEBUG,"del_channel: destroying channel: %s",Ptr->name); - - /* kill the record */ - if (iter != chanlist.end()) - { - log(DEBUG,"del_channel: destroyed: %s",Ptr->name); - FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(Ptr)); - delete Ptr; - chanlist.erase(iter); - } - } + if ((!has_user) && (i->first->IsModeSet('i'))) + { + /* + * user is +i, and source not on the channel, does not show + * nick in NAMES list + */ + continue; + } + + if (i->first->Visibility && !i->first->Visibility->VisibleTo(user)) + continue; + + std::string prefixlist = this->GetPrefixChar(i->first); + std::string nick = i->first->nick; + + if (call_modules) + { + FOREACH_MOD(I_OnNamesListItem, OnNamesListItem(user, i->first, this, prefixlist, nick)); + + /* Nick was nuked, a module wants us to skip it */ + if (nick.empty()) + continue; + } + + size_t ptrlen = 0; + + if (curlen + prefixlist.length() + nick.length() + 1 > 480) + { + /* list overflowed into multiple numerics */ + user->WriteServ(std::string(list)); + + /* reset our lengths */ + dlen = curlen = snprintf(list,MAXBUF,"%s %c %s :", user->nick.c_str(), this->IsModeSet('s') ? '@' : this->IsModeSet('p') ? '*' : '=', this->name.c_str()); + ptr = list + dlen; + + ptrlen = 0; + numusers = 0; + } + + ptrlen = snprintf(ptr, MAXBUF, "%s%s ", prefixlist.c_str(), nick.c_str()); + + curlen += ptrlen; + ptr += ptrlen; + + numusers++; + } + + /* if whats left in the list isnt empty, send it */ + if (numusers) + { + user->WriteNumeric(RPL_NAMREPLY, std::string(list)); + } + + user->WriteNumeric(RPL_ENDOFNAMES, "%s %s :End of /NAMES list.", user->nick.c_str(), this->name.c_str()); } +long Channel::GetMaxBans() +{ + /* Return the cached value if there is one */ + if (this->maxbans) + return this->maxbans; + + /* If there isnt one, we have to do some O(n) hax to find it the first time. (ick) */ + for (std::map::iterator n = ServerInstance->Config->maxbans.begin(); n != ServerInstance->Config->maxbans.end(); n++) + { + if (match(this->name,n->first)) + { + this->maxbans = n->second; + return n->second; + } + } + + /* Screw it, just return the default of 64 */ + this->maxbans = 64; + return this->maxbans; +} + +void Channel::ResetMaxBans() +{ + this->maxbans = 0; +} + +/* returns the status character for a given user on a channel, e.g. @ for op, + * % for halfop etc. If the user has several modes set, the highest mode + * the user has must be returned. + */ +const char* Channel::GetPrefixChar(User *user) +{ + static char pf[2] = {0, 0}; + + prefixlist::iterator n = prefixes.find(user); + if (n != prefixes.end()) + { + if (n->second.size()) + { + /* If the user has any prefixes, their highest prefix + * will always be at the head of the list, as the list is + * sorted in rank order highest first (see SetPrefix() + * for reasons why) + */ + *pf = n->second.begin()->first; + return pf; + } + } + + *pf = 0; + return pf; +} + + +const char* Channel::GetAllPrefixChars(User* user) +{ + static char prefix[MAXBUF]; + int ctr = 0; + *prefix = 0; + + prefixlist::iterator n = prefixes.find(user); + if (n != prefixes.end()) + { + for (std::vector::iterator x = n->second.begin(); x != n->second.end(); x++) + { + prefix[ctr++] = x->first; + } + } + + prefix[ctr] = 0; + + return prefix; +} + +unsigned int Channel::GetPrefixValue(User* user) +{ + prefixlist::iterator n = prefixes.find(user); + if (n != prefixes.end()) + { + if (n->second.size()) + return n->second.begin()->second; + } + return 0; +} + +int Channel::GetStatusFlags(User *user) +{ + UCListIter i = user->chans.find(this); + if (i != user->chans.end()) + { + return i->second; + } + return 0; +} + +int Channel::GetStatus(User *user) +{ + if (ServerInstance->ULine(user->server)) + return STATUS_OP; + + UCListIter i = user->chans.find(this); + if (i != user->chans.end()) + { + if ((i->second & UCMODE_OP) > 0) + { + return STATUS_OP; + } + if ((i->second & UCMODE_HOP) > 0) + { + return STATUS_HOP; + } + if ((i->second & UCMODE_VOICE) > 0) + { + return STATUS_VOICE; + } + return STATUS_NORMAL; + } + return STATUS_NORMAL; +} + +void Channel::SetPrefix(User* user, char prefix, unsigned int prefix_value, bool adding) +{ + prefixlist::iterator n = prefixes.find(user); + prefixtype pfx = std::make_pair(prefix,prefix_value); + if (adding) + { + if (n != prefixes.end()) + { + if (std::find(n->second.begin(), n->second.end(), pfx) == n->second.end()) + { + n->second.push_back(pfx); + /* We must keep prefixes in rank order, largest first. + * This is for two reasons, firstly because x-chat *ass-u-me's* this + * state, and secondly it turns out to be a benefit to us later. + * See above in GetPrefix(). + */ + std::sort(n->second.begin(), n->second.end(), ModeParser::PrefixComparison); + } + } + else + { + pfxcontainer one; + one.push_back(pfx); + prefixes.insert(std::make_pair(user, one)); + } + } + else + { + if (n != prefixes.end()) + { + pfxcontainer::iterator x = std::find(n->second.begin(), n->second.end(), pfx); + if (x != n->second.end()) + n->second.erase(x); + } + } +} + +void Channel::RemoveAllPrefixes(User* user) +{ + prefixlist::iterator n = prefixes.find(user); + if (n != prefixes.end()) + { + prefixes.erase(n); + } +}