mirror of git://git.acid.vegas/anope.git
695 lines
15 KiB
C++
695 lines
15 KiB
C++
|
/* Registered channel functions
|
||
|
*
|
||
|
* (C) 2003-2022 Anope Team
|
||
|
* Contact us at team@anope.org
|
||
|
*
|
||
|
* Please read COPYING and README for further details.
|
||
|
*
|
||
|
* Based on the original code of Epona by Lara.
|
||
|
* Based on the original code of Services by Andy Church.
|
||
|
*/
|
||
|
|
||
|
#include "services.h"
|
||
|
#include "modules.h"
|
||
|
#include "regchannel.h"
|
||
|
#include "account.h"
|
||
|
#include "access.h"
|
||
|
#include "channels.h"
|
||
|
#include "config.h"
|
||
|
#include "bots.h"
|
||
|
#include "servers.h"
|
||
|
|
||
|
Serialize::Checker<registered_channel_map> RegisteredChannelList("ChannelInfo");
|
||
|
|
||
|
AutoKick::AutoKick() : Serializable("AutoKick")
|
||
|
{
|
||
|
}
|
||
|
|
||
|
AutoKick::~AutoKick()
|
||
|
{
|
||
|
if (this->ci)
|
||
|
{
|
||
|
std::vector<AutoKick *>::iterator it = std::find(this->ci->akick->begin(), this->ci->akick->end(), this);
|
||
|
if (it != this->ci->akick->end())
|
||
|
this->ci->akick->erase(it);
|
||
|
|
||
|
if (nc)
|
||
|
nc->RemoveChannelReference(this->ci);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void AutoKick::Serialize(Serialize::Data &data) const
|
||
|
{
|
||
|
data["ci"] << this->ci->name;
|
||
|
if (this->nc)
|
||
|
data["nc"] << this->nc->display;
|
||
|
else
|
||
|
data["mask"] << this->mask;
|
||
|
data["reason"] << this->reason;
|
||
|
data["creator"] << this->creator;
|
||
|
data.SetType("addtime", Serialize::Data::DT_INT); data["addtime"] << this->addtime;
|
||
|
data.SetType("last_used", Serialize::Data::DT_INT); data["last_used"] << this->last_used;
|
||
|
}
|
||
|
|
||
|
Serializable* AutoKick::Unserialize(Serializable *obj, Serialize::Data &data)
|
||
|
{
|
||
|
Anope::string sci, snc;
|
||
|
|
||
|
data["ci"] >> sci;
|
||
|
data["nc"] >> snc;
|
||
|
|
||
|
ChannelInfo *ci = ChannelInfo::Find(sci);
|
||
|
if (!ci)
|
||
|
return NULL;
|
||
|
|
||
|
AutoKick *ak;
|
||
|
NickCore *nc = NickCore::Find(snc);
|
||
|
if (obj)
|
||
|
{
|
||
|
ak = anope_dynamic_static_cast<AutoKick *>(obj);
|
||
|
data["creator"] >> ak->creator;
|
||
|
data["reason"] >> ak->reason;
|
||
|
ak->nc = NickCore::Find(snc);
|
||
|
data["mask"] >> ak->mask;
|
||
|
data["addtime"] >> ak->addtime;
|
||
|
data["last_used"] >> ak->last_used;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
time_t addtime, lastused;
|
||
|
data["addtime"] >> addtime;
|
||
|
data["last_used"] >> lastused;
|
||
|
|
||
|
Anope::string screator, sreason, smask;
|
||
|
|
||
|
data["creator"] >> screator;
|
||
|
data["reason"] >> sreason;
|
||
|
data["mask"] >> smask;
|
||
|
|
||
|
if (nc)
|
||
|
ak = ci->AddAkick(screator, nc, sreason, addtime, lastused);
|
||
|
else
|
||
|
ak = ci->AddAkick(screator, smask, sreason, addtime, lastused);
|
||
|
}
|
||
|
|
||
|
return ak;
|
||
|
}
|
||
|
|
||
|
ChannelInfo::ChannelInfo(const Anope::string &chname) : Serializable("ChannelInfo"),
|
||
|
access("ChanAccess"), akick("AutoKick")
|
||
|
{
|
||
|
if (chname.empty())
|
||
|
throw CoreException("Empty channel passed to ChannelInfo constructor");
|
||
|
|
||
|
this->founder = NULL;
|
||
|
this->successor = NULL;
|
||
|
this->c = Channel::Find(chname);
|
||
|
if (this->c)
|
||
|
this->c->ci = this;
|
||
|
this->banexpire = 0;
|
||
|
this->bi = NULL;
|
||
|
this->last_topic_time = 0;
|
||
|
|
||
|
this->name = chname;
|
||
|
|
||
|
this->bantype = 2;
|
||
|
this->memos.memomax = 0;
|
||
|
this->last_used = this->time_registered = Anope::CurTime;
|
||
|
|
||
|
size_t old = RegisteredChannelList->size();
|
||
|
(*RegisteredChannelList)[this->name] = this;
|
||
|
if (old == RegisteredChannelList->size())
|
||
|
Log(LOG_DEBUG) << "Duplicate channel " << this->name << " in registered channel table?";
|
||
|
|
||
|
FOREACH_MOD(OnCreateChan, (this));
|
||
|
}
|
||
|
|
||
|
ChannelInfo::ChannelInfo(const ChannelInfo &ci) : Serializable("ChannelInfo"),
|
||
|
access("ChanAccess"), akick("AutoKick")
|
||
|
{
|
||
|
*this = ci;
|
||
|
|
||
|
if (this->founder)
|
||
|
++this->founder->channelcount;
|
||
|
|
||
|
this->access->clear();
|
||
|
this->akick->clear();
|
||
|
|
||
|
FOREACH_MOD(OnCreateChan, (this));
|
||
|
}
|
||
|
|
||
|
ChannelInfo::~ChannelInfo()
|
||
|
{
|
||
|
FOREACH_MOD(OnDelChan, (this));
|
||
|
|
||
|
UnsetExtensibles();
|
||
|
|
||
|
Log(LOG_DEBUG) << "Deleting channel " << this->name;
|
||
|
|
||
|
if (this->c)
|
||
|
{
|
||
|
if (this->bi && this->c->FindUser(this->bi))
|
||
|
this->bi->Part(this->c);
|
||
|
|
||
|
/* Parting the service bot can cause the channel to go away */
|
||
|
|
||
|
if (this->c)
|
||
|
{
|
||
|
if (this->c && this->c->CheckDelete())
|
||
|
this->c->QueueForDeletion();
|
||
|
|
||
|
this->c = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
RegisteredChannelList->erase(this->name);
|
||
|
|
||
|
this->SetFounder(NULL);
|
||
|
this->SetSuccessor(NULL);
|
||
|
|
||
|
this->ClearAccess();
|
||
|
this->ClearAkick();
|
||
|
|
||
|
if (!this->memos.memos->empty())
|
||
|
{
|
||
|
for (unsigned i = 0, end = this->memos.memos->size(); i < end; ++i)
|
||
|
delete this->memos.GetMemo(i);
|
||
|
this->memos.memos->clear();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::Serialize(Serialize::Data &data) const
|
||
|
{
|
||
|
data["name"] << this->name;
|
||
|
if (this->founder)
|
||
|
data["founder"] << this->founder->display;
|
||
|
if (this->successor)
|
||
|
data["successor"] << this->successor->display;
|
||
|
data["description"] << this->desc;
|
||
|
data.SetType("time_registered", Serialize::Data::DT_INT); data["time_registered"] << this->time_registered;
|
||
|
data.SetType("last_used", Serialize::Data::DT_INT); data["last_used"] << this->last_used;
|
||
|
data["last_topic"] << this->last_topic;
|
||
|
data["last_topic_setter"] << this->last_topic_setter;
|
||
|
data.SetType("last_topic_time", Serialize::Data::DT_INT); data["last_topic_time"] << this->last_topic_time;
|
||
|
data.SetType("bantype", Serialize::Data::DT_INT); data["bantype"] << this->bantype;
|
||
|
{
|
||
|
Anope::string levels_buffer;
|
||
|
for (Anope::map<int16_t>::const_iterator it = this->levels.begin(), it_end = this->levels.end(); it != it_end; ++it)
|
||
|
levels_buffer += it->first + " " + stringify(it->second) + " ";
|
||
|
data["levels"] << levels_buffer;
|
||
|
}
|
||
|
if (this->bi)
|
||
|
data["bi"] << this->bi->nick;
|
||
|
data.SetType("banexpire", Serialize::Data::DT_INT); data["banexpire"] << this->banexpire;
|
||
|
data["memomax"] << this->memos.memomax;
|
||
|
for (unsigned i = 0; i < this->memos.ignores.size(); ++i)
|
||
|
data["memoignores"] << this->memos.ignores[i] << " ";
|
||
|
|
||
|
Extensible::ExtensibleSerialize(this, this, data);
|
||
|
}
|
||
|
|
||
|
Serializable* ChannelInfo::Unserialize(Serializable *obj, Serialize::Data &data)
|
||
|
{
|
||
|
Anope::string sname, sfounder, ssuccessor, slevels, sbi;
|
||
|
|
||
|
data["name"] >> sname;
|
||
|
data["founder"] >> sfounder;
|
||
|
data["successor"] >> ssuccessor;
|
||
|
data["levels"] >> slevels;
|
||
|
data["bi"] >> sbi;
|
||
|
|
||
|
ChannelInfo *ci;
|
||
|
if (obj)
|
||
|
ci = anope_dynamic_static_cast<ChannelInfo *>(obj);
|
||
|
else
|
||
|
ci = new ChannelInfo(sname);
|
||
|
|
||
|
ci->SetFounder(NickCore::Find(sfounder));
|
||
|
ci->SetSuccessor(NickCore::Find(ssuccessor));
|
||
|
|
||
|
data["description"] >> ci->desc;
|
||
|
data["time_registered"] >> ci->time_registered;
|
||
|
data["last_used"] >> ci->last_used;
|
||
|
data["last_topic"] >> ci->last_topic;
|
||
|
data["last_topic_setter"] >> ci->last_topic_setter;
|
||
|
data["last_topic_time"] >> ci->last_topic_time;
|
||
|
data["bantype"] >> ci->bantype;
|
||
|
{
|
||
|
std::vector<Anope::string> v;
|
||
|
spacesepstream(slevels).GetTokens(v);
|
||
|
for (unsigned i = 0; i + 1 < v.size(); i += 2)
|
||
|
try
|
||
|
{
|
||
|
ci->levels[v[i]] = convertTo<int16_t>(v[i + 1]);
|
||
|
}
|
||
|
catch (const ConvertException &) { }
|
||
|
}
|
||
|
BotInfo *bi = BotInfo::Find(sbi, true);
|
||
|
if (*ci->bi != bi)
|
||
|
{
|
||
|
if (bi)
|
||
|
bi->Assign(NULL, ci);
|
||
|
else if (ci->bi)
|
||
|
ci->bi->UnAssign(NULL, ci);
|
||
|
}
|
||
|
data["banexpire"] >> ci->banexpire;
|
||
|
data["memomax"] >> ci->memos.memomax;
|
||
|
{
|
||
|
Anope::string buf;
|
||
|
data["memoignores"] >> buf;
|
||
|
spacesepstream sep(buf);
|
||
|
ci->memos.ignores.clear();
|
||
|
while (sep.GetToken(buf))
|
||
|
ci->memos.ignores.push_back(buf);
|
||
|
}
|
||
|
|
||
|
Extensible::ExtensibleUnserialize(ci, ci, data);
|
||
|
|
||
|
/* compat */
|
||
|
bool b;
|
||
|
b = false;
|
||
|
data["extensible:SECURE"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("CS_SECURE");
|
||
|
b = false;
|
||
|
data["extensible:PRIVATE"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("CS_PRIVATE");
|
||
|
b = false;
|
||
|
data["extensible:NO_EXPIRE"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("CS_NO_EXPIRE");
|
||
|
b = false;
|
||
|
data["extensible:FANTASY"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("BS_FANTASY");
|
||
|
b = false;
|
||
|
data["extensible:GREET"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("BS_GREET");
|
||
|
b = false;
|
||
|
data["extensible:PEACE"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("PEACE");
|
||
|
b = false;
|
||
|
data["extensible:SECUREFOUNDER"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("SECUREFOUNDER");
|
||
|
b = false;
|
||
|
data["extensible:RESTRICTED"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("RESTRICTED");
|
||
|
b = false;
|
||
|
data["extensible:KEEPTOPIC"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("KEEPTOPIC");
|
||
|
b = false;
|
||
|
data["extensible:SIGNKICK"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("SIGNKICK");
|
||
|
b = false;
|
||
|
data["extensible:SIGNKICK_LEVEL"] >> b;
|
||
|
if (b)
|
||
|
ci->Extend<bool>("SIGNKICK_LEVEL");
|
||
|
/* end compat */
|
||
|
|
||
|
return ci;
|
||
|
}
|
||
|
|
||
|
|
||
|
void ChannelInfo::SetFounder(NickCore *nc)
|
||
|
{
|
||
|
if (this->founder)
|
||
|
{
|
||
|
--this->founder->channelcount;
|
||
|
this->founder->RemoveChannelReference(this);
|
||
|
}
|
||
|
|
||
|
this->founder = nc;
|
||
|
|
||
|
if (this->founder)
|
||
|
{
|
||
|
++this->founder->channelcount;
|
||
|
this->founder->AddChannelReference(this);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
NickCore *ChannelInfo::GetFounder() const
|
||
|
{
|
||
|
return this->founder;
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::SetSuccessor(NickCore *nc)
|
||
|
{
|
||
|
if (this->successor)
|
||
|
this->successor->RemoveChannelReference(this);
|
||
|
this->successor = nc;
|
||
|
if (this->successor)
|
||
|
this->successor->AddChannelReference(this);
|
||
|
}
|
||
|
|
||
|
NickCore *ChannelInfo::GetSuccessor() const
|
||
|
{
|
||
|
return this->successor;
|
||
|
}
|
||
|
|
||
|
BotInfo *ChannelInfo::WhoSends() const
|
||
|
{
|
||
|
if (this && this->bi)
|
||
|
return this->bi;
|
||
|
|
||
|
BotInfo *ChanServ = Config->GetClient("ChanServ");
|
||
|
if (ChanServ)
|
||
|
return ChanServ;
|
||
|
|
||
|
if (!BotListByNick->empty())
|
||
|
return BotListByNick->begin()->second;
|
||
|
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::AddAccess(ChanAccess *taccess)
|
||
|
{
|
||
|
this->access->push_back(taccess);
|
||
|
}
|
||
|
|
||
|
ChanAccess *ChannelInfo::GetAccess(unsigned index) const
|
||
|
{
|
||
|
if (this->access->empty() || index >= this->access->size())
|
||
|
return NULL;
|
||
|
|
||
|
ChanAccess *acc = (*this->access)[index];
|
||
|
acc->QueueUpdate();
|
||
|
return acc;
|
||
|
}
|
||
|
|
||
|
static void FindMatchesRecurse(ChannelInfo *ci, const User *u, const NickCore *account, unsigned int depth, std::vector<ChanAccess::Path> &paths, ChanAccess::Path &path)
|
||
|
{
|
||
|
if (depth > ChanAccess::MAX_DEPTH)
|
||
|
return;
|
||
|
|
||
|
for (unsigned int i = 0; i < ci->GetAccessCount(); ++i)
|
||
|
{
|
||
|
ChanAccess *a = ci->GetAccess(i);
|
||
|
ChannelInfo *next = NULL;
|
||
|
|
||
|
if (a->Matches(u, account, next))
|
||
|
{
|
||
|
ChanAccess::Path next_path = path;
|
||
|
next_path.push_back(a);
|
||
|
|
||
|
paths.push_back(next_path);
|
||
|
}
|
||
|
else if (next)
|
||
|
{
|
||
|
ChanAccess::Path next_path = path;
|
||
|
next_path.push_back(a);
|
||
|
|
||
|
FindMatchesRecurse(next, u, account, depth + 1, paths, next_path);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void FindMatches(AccessGroup &group, ChannelInfo *ci, const User *u, const NickCore *account)
|
||
|
{
|
||
|
ChanAccess::Path path;
|
||
|
FindMatchesRecurse(ci, u, account, 0, group.paths, path);
|
||
|
}
|
||
|
|
||
|
AccessGroup ChannelInfo::AccessFor(const User *u, bool updateLastUsed)
|
||
|
{
|
||
|
AccessGroup group;
|
||
|
|
||
|
if (u == NULL)
|
||
|
return group;
|
||
|
|
||
|
const NickCore *nc = u->Account();
|
||
|
if (nc == NULL && !this->HasExt("NS_SECURE") && u->IsRecognized())
|
||
|
{
|
||
|
const NickAlias *na = NickAlias::Find(u->nick);
|
||
|
if (na != NULL)
|
||
|
nc = na->nc;
|
||
|
}
|
||
|
|
||
|
group.super_admin = u->super_admin;
|
||
|
group.founder = IsFounder(u, this);
|
||
|
group.ci = this;
|
||
|
group.nc = nc;
|
||
|
|
||
|
FindMatches(group, this, u, u->Account());
|
||
|
|
||
|
if (group.founder || !group.paths.empty())
|
||
|
{
|
||
|
if (updateLastUsed)
|
||
|
this->last_used = Anope::CurTime;
|
||
|
|
||
|
for (unsigned i = 0; i < group.paths.size(); ++i)
|
||
|
{
|
||
|
ChanAccess::Path &p = group.paths[i];
|
||
|
|
||
|
for (unsigned int j = 0; j < p.size(); ++j)
|
||
|
p[j]->last_seen = Anope::CurTime;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return group;
|
||
|
}
|
||
|
|
||
|
AccessGroup ChannelInfo::AccessFor(const NickCore *nc, bool updateLastUsed)
|
||
|
{
|
||
|
AccessGroup group;
|
||
|
|
||
|
group.founder = (this->founder && this->founder == nc);
|
||
|
group.ci = this;
|
||
|
group.nc = nc;
|
||
|
|
||
|
FindMatches(group, this, NULL, nc);
|
||
|
|
||
|
if (group.founder || !group.paths.empty())
|
||
|
if (updateLastUsed)
|
||
|
this->last_used = Anope::CurTime;
|
||
|
|
||
|
/* don't update access last seen here, this isn't the user requesting access */
|
||
|
|
||
|
return group;
|
||
|
}
|
||
|
|
||
|
unsigned ChannelInfo::GetAccessCount() const
|
||
|
{
|
||
|
return this->access->size();
|
||
|
}
|
||
|
|
||
|
static unsigned int GetDeepAccessCount(const ChannelInfo *ci, std::set<const ChannelInfo *> &seen, unsigned int depth)
|
||
|
{
|
||
|
if (depth > ChanAccess::MAX_DEPTH || seen.count(ci))
|
||
|
return 0;
|
||
|
seen.insert(ci);
|
||
|
|
||
|
unsigned int total = 0;
|
||
|
|
||
|
for (unsigned int i = 0; i < ci->GetAccessCount(); ++i)
|
||
|
{
|
||
|
ChanAccess::Path path;
|
||
|
ChanAccess *a = ci->GetAccess(i);
|
||
|
ChannelInfo *next = NULL;
|
||
|
|
||
|
a->Matches(NULL, NULL, next);
|
||
|
++total;
|
||
|
|
||
|
if (next)
|
||
|
total += GetDeepAccessCount(ci, seen, depth + 1);
|
||
|
}
|
||
|
|
||
|
return total;
|
||
|
}
|
||
|
|
||
|
unsigned ChannelInfo::GetDeepAccessCount() const
|
||
|
{
|
||
|
std::set<const ChannelInfo *> seen;
|
||
|
return ::GetDeepAccessCount(this, seen, 0);
|
||
|
}
|
||
|
|
||
|
ChanAccess *ChannelInfo::EraseAccess(unsigned index)
|
||
|
{
|
||
|
if (this->access->empty() || index >= this->access->size())
|
||
|
return NULL;
|
||
|
|
||
|
ChanAccess *ca = this->access->at(index);
|
||
|
this->access->erase(this->access->begin() + index);
|
||
|
return ca;
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::ClearAccess()
|
||
|
{
|
||
|
for (unsigned i = this->access->size(); i > 0; --i)
|
||
|
delete this->GetAccess(i - 1);
|
||
|
}
|
||
|
|
||
|
AutoKick *ChannelInfo::AddAkick(const Anope::string &user, NickCore *akicknc, const Anope::string &reason, time_t t, time_t lu)
|
||
|
{
|
||
|
AutoKick *autokick = new AutoKick();
|
||
|
autokick->ci = this;
|
||
|
autokick->nc = akicknc;
|
||
|
autokick->reason = reason;
|
||
|
autokick->creator = user;
|
||
|
autokick->addtime = t;
|
||
|
autokick->last_used = lu;
|
||
|
|
||
|
this->akick->push_back(autokick);
|
||
|
|
||
|
akicknc->AddChannelReference(this);
|
||
|
|
||
|
return autokick;
|
||
|
}
|
||
|
|
||
|
AutoKick *ChannelInfo::AddAkick(const Anope::string &user, const Anope::string &mask, const Anope::string &reason, time_t t, time_t lu)
|
||
|
{
|
||
|
AutoKick *autokick = new AutoKick();
|
||
|
autokick->ci = this;
|
||
|
autokick->mask = mask;
|
||
|
autokick->nc = NULL;
|
||
|
autokick->reason = reason;
|
||
|
autokick->creator = user;
|
||
|
autokick->addtime = t;
|
||
|
autokick->last_used = lu;
|
||
|
|
||
|
this->akick->push_back(autokick);
|
||
|
|
||
|
return autokick;
|
||
|
}
|
||
|
|
||
|
AutoKick *ChannelInfo::GetAkick(unsigned index) const
|
||
|
{
|
||
|
if (this->akick->empty() || index >= this->akick->size())
|
||
|
return NULL;
|
||
|
|
||
|
AutoKick *ak = (*this->akick)[index];
|
||
|
ak->QueueUpdate();
|
||
|
return ak;
|
||
|
}
|
||
|
|
||
|
unsigned ChannelInfo::GetAkickCount() const
|
||
|
{
|
||
|
return this->akick->size();
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::EraseAkick(unsigned index)
|
||
|
{
|
||
|
if (this->akick->empty() || index >= this->akick->size())
|
||
|
return;
|
||
|
|
||
|
delete this->GetAkick(index);
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::ClearAkick()
|
||
|
{
|
||
|
while (!this->akick->empty())
|
||
|
delete this->akick->back();
|
||
|
}
|
||
|
|
||
|
const Anope::map<int16_t> &ChannelInfo::GetLevelEntries()
|
||
|
{
|
||
|
return this->levels;
|
||
|
}
|
||
|
|
||
|
int16_t ChannelInfo::GetLevel(const Anope::string &priv) const
|
||
|
{
|
||
|
if (PrivilegeManager::FindPrivilege(priv) == NULL)
|
||
|
{
|
||
|
Log(LOG_DEBUG) << "Unknown privilege " + priv;
|
||
|
return ACCESS_INVALID;
|
||
|
}
|
||
|
|
||
|
Anope::map<int16_t>::const_iterator it = this->levels.find(priv);
|
||
|
if (it == this->levels.end())
|
||
|
return 0;
|
||
|
return it->second;
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::SetLevel(const Anope::string &priv, int16_t level)
|
||
|
{
|
||
|
if (PrivilegeManager::FindPrivilege(priv) == NULL)
|
||
|
{
|
||
|
Log(LOG_DEBUG) << "Unknown privilege " + priv;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
this->levels[priv] = level;
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::RemoveLevel(const Anope::string &priv)
|
||
|
{
|
||
|
this->levels.erase(priv);
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::ClearLevels()
|
||
|
{
|
||
|
this->levels.clear();
|
||
|
}
|
||
|
|
||
|
Anope::string ChannelInfo::GetIdealBan(User *u) const
|
||
|
{
|
||
|
int bt = this ? this->bantype : -1;
|
||
|
switch (bt)
|
||
|
{
|
||
|
case 0:
|
||
|
return "*!" + u->GetVIdent() + "@" + u->GetDisplayedHost();
|
||
|
case 1:
|
||
|
if (u->GetVIdent()[0] == '~')
|
||
|
return "*!*" + u->GetVIdent() + "@" + u->GetDisplayedHost();
|
||
|
else
|
||
|
return "*!" + u->GetVIdent() + "@" + u->GetDisplayedHost();
|
||
|
case 3:
|
||
|
return "*!" + u->Mask();
|
||
|
case 2:
|
||
|
default:
|
||
|
return "*!*@" + u->GetDisplayedHost();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
ChannelInfo* ChannelInfo::Find(const Anope::string &name)
|
||
|
{
|
||
|
registered_channel_map::const_iterator it = RegisteredChannelList->find(name);
|
||
|
if (it != RegisteredChannelList->end())
|
||
|
{
|
||
|
it->second->QueueUpdate();
|
||
|
return it->second;
|
||
|
}
|
||
|
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
bool IsFounder(const User *user, const ChannelInfo *ci)
|
||
|
{
|
||
|
if (!user || !ci)
|
||
|
return false;
|
||
|
|
||
|
if (user->super_admin)
|
||
|
return true;
|
||
|
|
||
|
if (user->Account() && user->Account() == ci->GetFounder())
|
||
|
return true;
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
void ChannelInfo::AddChannelReference(const Anope::string &what)
|
||
|
{
|
||
|
++references[what];
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::RemoveChannelReference(const Anope::string &what)
|
||
|
{
|
||
|
int &i = references[what];
|
||
|
if (--i <= 0)
|
||
|
references.erase(what);
|
||
|
}
|
||
|
|
||
|
void ChannelInfo::GetChannelReferences(std::deque<Anope::string> &chans)
|
||
|
{
|
||
|
chans.clear();
|
||
|
for (Anope::map<int>::iterator it = references.begin(); it != references.end(); ++it)
|
||
|
chans.push_back(it->first);
|
||
|
}
|