CmdResult cmd_rehash::Handle (const char** parameters, int pcnt, userrec *user)
{
user->WriteServ("382 %s %s :Rehashing",user->nick,ServerConfig::CleanFilename(ServerInstance->ConfigFileName));
std::string parameter;
std::string old_disabled = ServerInstance->Config->DisabledCommands;
if (pcnt)
{
parameter = parameters[0];
}
else
{
ServerInstance->WriteOpers("*** %s is rehashing config file %s",user->nick,ServerConfig::CleanFilename(ServerInstance->ConfigFileName));
ServerInstance->CloseLog();
ServerInstance->OpenLog(ServerInstance->Config->argv, ServerInstance->Config->argc);
ServerInstance->RehashUsersAndChans();
FOREACH_MOD(I_OnGarbageCollect, OnGarbageCollect());
ServerInstance->Config->Read(false,user);
ServerInstance->Res->Rehash();
ServerInstance->ResetMaxBans();
}
if (old_disabled != ServerInstance->Config->DisabledCommands)
InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance);
FOREACH_MOD(I_OnRehash,OnRehash(user, parameter));
ServerInstance->BuildISupport();
return CMD_SUCCESS;
}
void Tick(time_t)
{
if (!Config->CSExpire || noexpire || readonly)
return;
for (registered_channel_map::const_iterator it = RegisteredChannelList.begin(), it_end = RegisteredChannelList.end(); it != it_end; )
{
ChannelInfo *ci = it->second;
++it;
bool expire = false;
if (!ci->c && Config->CSExpire && Anope::CurTime - ci->last_used >= Config->CSExpire)
expire = true;
if (ci->HasFlag(CI_NO_EXPIRE))
expire = false;
FOREACH_MOD(I_OnPreChanExpire, OnPreChanExpire(ci, expire));
if (expire)
{
Anope::string extra;
if (ci->HasFlag(CI_SUSPENDED))
extra = "suspended ";
Log(LOG_NORMAL, "chanserv/expire") << "Expiring " << extra << "channel " << ci->name << " (founder: " << (ci->GetFounder() ? ci->GetFounder()->display : "(none)") << ")";
FOREACH_MOD(I_OnChanExpire, OnChanExpire(ci));
delete ci;
}
}
}
bool TreeSocket::Away(const std::string &prefix, parameterlist ¶ms)
{
User* u = ServerInstance->FindNick(prefix);
if ((!u) || (IS_SERVER(u)))
return true;
if (params.size())
{
FOREACH_MOD(I_OnSetAway, OnSetAway(u, params[params.size() - 1]));
if (params.size() > 1)
u->awaytime = atoi(params[0].c_str());
else
u->awaytime = ServerInstance->Time();
u->awaymsg = params[params.size() - 1];
params[params.size() - 1] = ":" + params[params.size() - 1];
}
else
{
FOREACH_MOD(I_OnSetAway, OnSetAway(u, ""));
u->awaymsg.clear();
}
Utils->DoOneToAllButSender(prefix,"AWAY",params,u->server);
return true;
}
ModResult DoMsg(User *user, void *dest, int target_type, std::string &text, char status, CUList &exempt_list, bool privmsg)
{
if (!IS_LOCAL(user) || target_type != TYPE_CHANNEL || status)
return MOD_RES_PASSTHRU;
Channel* chan = static_cast<Channel*>(dest);
ModResult res = ServerInstance->OnCheckExemption(user,chan,"opmoderated");
if (res == MOD_RES_ALLOW)
return MOD_RES_PASSTHRU;
if (!chan->GetExtBanStatus(user, 'u').check(!chan->IsModeSet(&mh)) && chan->GetPrefixValue(user) < VOICE_VALUE)
{
FOREACH_MOD(I_OnText,OnText(user,chan,TYPE_CHANNEL,text,status,exempt_list));
chan->WriteAllExcept(user, false, '@', exempt_list, "%s @%s :%s",
privmsg ? "PRIVMSG" : "NOTICE", chan->name.c_str(), text.c_str());
if (privmsg)
{
FOREACH_MOD(I_OnUserMessage,OnUserMessage(user,chan,TYPE_CHANNEL,text,'@',exempt_list));
}
else
FOREACH_MOD(I_OnUserNotice,OnUserNotice(user,chan,TYPE_CHANNEL,text,'@',exempt_list));
return MOD_RES_DENY;
}
return MOD_RES_PASSTHRU;
}
CmdResult cmd_zline::Handle (const char** parameters, int pcnt, userrec *user)
{
if (pcnt >= 3)
{
if (strchr(parameters[0],'@') || strchr(parameters[0],'!'))
{
user->WriteServ("NOTICE %s :*** You cannot include a username or nickname in a zline, a zline must ban only an IP mask",user->nick);
return CMD_FAILURE;
}
if (ServerInstance->IPMatchesEveryone(parameters[0],user))
return CMD_FAILURE;
long duration = ServerInstance->Duration(parameters[1]);
if (ServerInstance->XLines->add_zline(duration,user->nick,parameters[2],parameters[0]))
{
int to_apply = APPLY_ZLINES;
FOREACH_MOD(I_OnAddZLine,OnAddZLine(duration, user, parameters[2], parameters[0]));
if (!duration)
{
to_apply |= APPLY_PERM_ONLY;
ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent Z-line for %s.",user->nick,parameters[0]);
}
else
{
time_t c_requires_crap = duration + ServerInstance->Time();
ServerInstance->SNO->WriteToSnoMask('x',"%s added timed Z-line for %s, expires on %s",user->nick,parameters[0],
ServerInstance->TimeString(c_requires_crap).c_str());
}
ServerInstance->XLines->apply_lines(to_apply);
}
else
{
user->WriteServ("NOTICE %s :*** Z-Line for %s already exists",user->nick,parameters[0]);
}
}
else
{
if (ServerInstance->XLines->del_zline(parameters[0]))
{
FOREACH_MOD(I_OnDelZLine,OnDelZLine(user, parameters[0]));
ServerInstance->SNO->WriteToSnoMask('x',"%s Removed Z-line on %s.",user->nick,parameters[0]);
}
else
{
user->WriteServ("NOTICE %s :*** Z-Line %s not found in list, try /stats Z.",user->nick,parameters[0]);
return CMD_FAILURE;
}
}
return CMD_SUCCESS;
}
void UserManager::QuitUser(User* user, const std::string& quitreason, const std::string* operreason)
{
if (user->quitting)
{
ServerInstance->Logs->Log("USERS", LOG_DEFAULT, "ERROR: Tried to quit quitting user: "******"USERS", LOG_DEFAULT, "ERROR: Tried to quit server user: "******"USERS", LOG_DEBUG, "QuitUser: %s=%s '%s'", user->uuid.c_str(), user->nick.c_str(), quitreason.c_str());
user->Write("ERROR :Closing link: (%s@%s) [%s]", user->ident.c_str(), user->host.c_str(), operreason ? operreason->c_str() : quitreason.c_str());
std::string reason;
reason.assign(quitreason, 0, ServerInstance->Config->Limits.MaxQuit);
if (!operreason)
operreason = &reason;
ServerInstance->GlobalCulls.AddItem(user);
if (user->registered == REG_ALL)
{
FOREACH_MOD(OnUserQuit, (user, reason, *operreason));
user->WriteCommonQuit(reason, *operreason);
}
else
unregistered_count--;
if (IS_LOCAL(user))
{
LocalUser* lu = IS_LOCAL(user);
FOREACH_MOD(OnUserDisconnect, (lu));
lu->eh.Close();
if (lu->registered == REG_ALL)
ServerInstance->SNO->WriteToSnoMask('q',"Client exiting: %s (%s) [%s]", user->GetFullRealHost().c_str(), user->GetIPString().c_str(), operreason->c_str());
}
user_hash::iterator iter = this->clientlist->find(user->nick);
if (iter != this->clientlist->end())
this->clientlist->erase(iter);
else
ServerInstance->Logs->Log("USERS", LOG_DEFAULT, "ERROR: Nick not found in clientlist, cannot remove: " + user->nick);
uuidlist->erase(user->uuid);
}
CmdResult cmd_qline::Handle (const char** parameters, int pcnt, userrec *user)
{
if (pcnt >= 3)
{
if (ServerInstance->NickMatchesEveryone(parameters[0],user))
return CMD_FAILURE;
if (strchr(parameters[0],'@') || strchr(parameters[0],'!') || strchr(parameters[0],'.'))
{
user->WriteServ("NOTICE %s :*** A Q-Line only bans a nick pattern, not a nick!user@host pattern.",user->nick);
return CMD_FAILURE;
}
long duration = ServerInstance->Duration(parameters[1]);
if (ServerInstance->XLines->add_qline(duration,user->nick,parameters[2],parameters[0]))
{
int to_apply = APPLY_QLINES;
FOREACH_MOD(I_OnAddQLine,OnAddQLine(duration, user, parameters[2], parameters[0]));
if (!duration)
{
to_apply |= APPLY_PERM_ONLY;
ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent Q-line for %s.",user->nick,parameters[0]);
}
else
{
time_t c_requires_crap = duration + ServerInstance->Time();
ServerInstance->SNO->WriteToSnoMask('x',"%s added timed Q-line for %s, expires on %s",user->nick,parameters[0],
ServerInstance->TimeString(c_requires_crap).c_str());
}
ServerInstance->XLines->apply_lines(to_apply);
}
else
{
user->WriteServ("NOTICE %s :*** Q-Line for %s already exists",user->nick,parameters[0]);
}
}
else
{
if (ServerInstance->XLines->del_qline(parameters[0]))
{
FOREACH_MOD(I_OnDelQLine,OnDelQLine(user, parameters[0]));
ServerInstance->SNO->WriteToSnoMask('x',"%s Removed Q-line on %s.",user->nick,parameters[0]);
}
else
{
user->WriteServ("NOTICE %s :*** Q-Line %s not found in list, try /stats q.",user->nick,parameters[0]);
return CMD_FAILURE;
}
}
return CMD_SUCCESS;
}
CmdResult CommandMetadata::Handle(const std::vector<std::string>& params, User *srcuser)
{
if (params[0] == "*")
{
std::string value = params.size() < 3 ? "" : params[2];
FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(NULL,params[1],value));
return CMD_SUCCESS;
}
if (params[0][0] == '#')
{
// Channel METADATA has an additional parameter: the channel TS
// :22D METADATA #channel 12345 extname :extdata
if (params.size() < 3)
return CMD_INVALID;
Channel* c = ServerInstance->FindChan(params[0]);
if (!c)
return CMD_FAILURE;
time_t ChanTS = ConvToInt(params[1]);
if (!ChanTS)
return CMD_INVALID;
if (c->age < ChanTS)
// Their TS is newer than ours, discard this command and do not propagate
return CMD_FAILURE;
std::string value = params.size() < 4 ? "" : params[3];
ExtensionItem* item = ServerInstance->Extensions.GetItem(params[2]);
if (item)
item->unserialize(FORMAT_NETWORK, c, value);
FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(c,params[2],value));
}
else
{
User* u = ServerInstance->FindUUID(params[0]);
if ((u) && (!IS_SERVER(u)))
{
ExtensionItem* item = ServerInstance->Extensions.GetItem(params[1]);
std::string value = params.size() < 3 ? "" : params[2];
if (item)
item->unserialize(FORMAT_NETWORK, u, value);
FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(u,params[1],value));
}
}
return CMD_SUCCESS;
}
/** Handle /AWAY
*/
CmdResult cmd_away::Handle (const char** parameters, int pcnt, userrec *user)
{
if ((pcnt) && (*parameters[0]))
{
strlcpy(user->awaymsg,parameters[0],MAXAWAY);
user->WriteServ("306 %s :You have been marked as being away",user->nick);
FOREACH_MOD(I_OnSetAway,OnSetAway(user));
}
else
{
*user->awaymsg = 0;
user->WriteServ("305 %s :You are no longer marked as being away",user->nick);
FOREACH_MOD(I_OnCancelAway,OnCancelAway(user));
}
return CMD_SUCCESS;
}
void Snomask::Flush()
{
if (Count > 1)
{
std::string desc = this->Description;
std::string mesg = "(last message repeated "+ConvToStr(Count)+" times)";
char mysnomask = MySnomask;
ServerInstance->Logs->Log("snomask", DEFAULT, "%s: %s", desc.c_str(), mesg.c_str());
FOREACH_MOD(I_OnSendSnotice, OnSendSnotice(mysnomask, desc, mesg));
if (!LastBlocked)
{
/* Only opers can receive snotices, so we iterate the oper list */
std::list<User*>::iterator i = ServerInstance->Users->all_opers.begin();
while (i != ServerInstance->Users->all_opers.end())
{
User* a = *i;
if (IS_LOCAL(a) && a->IsModeSet('s') && a->IsNoticeMaskSet(mysnomask) && !a->quitting)
{
a->WriteServ("NOTICE %s :*** %s: %s", a->nick.c_str(), desc.c_str(), mesg.c_str());
}
i++;
}
}
}
LastMessage = "";
LastBlocked = false;
Count = 0;
}
void Server::Delete(const Anope::string &reason)
{
this->quit_reason = reason;
this->quitting = true;
FOREACH_MOD(OnServerQuit, (this));
delete this;
}
NickAlias::~NickAlias()
{
UnsetExtensibles();
FOREACH_MOD(OnDelNick, (this));
/* Accept nicks that have no core, because of database load functions */
if (this->nc)
{
/* Next: see if our core is still useful. */
std::vector<NickAlias *>::iterator it = std::find(this->nc->aliases->begin(), this->nc->aliases->end(), this);
if (it != this->nc->aliases->end())
this->nc->aliases->erase(it);
if (this->nc->aliases->empty())
{
delete this->nc;
this->nc = NULL;
}
else
{
/* Display updating stuff */
if (this->nick.equals_ci(this->nc->display))
this->nc->SetDisplay(this->nc->aliases->front());
}
}
/* Remove us from the aliases list */
NickAliasList->erase(this->nick);
}
/** This function is called when we want to send a netburst to a local
* server. There is a set order we must do this, because for example
* users require their servers to exist, and channels require their
* users to exist. You get the idea.
*/
void TreeSocket::DoBurst(TreeServer* s)
{
ServerInstance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s%s).",
s->GetName().c_str(),
capab->auth_fingerprint ? "SSL Fingerprint and " : "",
capab->auth_challenge ? "challenge-response" : "plaintext password");
this->CleanNegotiationInfo();
this->WriteLine(":" + ServerInstance->Config->GetSID() + " BURST " + ConvToStr(ServerInstance->Time()));
/* send our version string */
this->WriteLine(":" + ServerInstance->Config->GetSID() + " VERSION :"+ServerInstance->GetVersionString());
/* Send server tree */
this->SendServers(Utils->TreeRoot, s);
BurstState bs(this);
/* Send users and their oper status */
this->SendUsers(bs);
for (chan_hash::const_iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); ++i)
SyncChannel(i->second, bs);
this->SendXLines();
FOREACH_MOD(OnSyncNetwork, (bs.server));
this->WriteLine(":" + ServerInstance->Config->GetSID() + " ENDBURST");
ServerInstance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+ s->GetName()+"\2.");
}
/** send all users and their oper state/modes */
void TreeSocket::SendUsers(BurstState& bs)
{
ProtocolInterface::Server& piserver = bs.server;
for (user_hash::iterator u = ServerInstance->Users->clientlist->begin(); u != ServerInstance->Users->clientlist->end(); u++)
{
User* user = u->second;
if (user->registered != REG_ALL)
continue;
this->WriteLine(CommandUID::Builder(user));
if (user->IsOper())
this->WriteLine(CommandOpertype::Builder(user));
if (user->IsAway())
this->WriteLine(CommandAway::Builder(user));
const Extensible::ExtensibleStore& exts = user->GetExtList();
for (Extensible::ExtensibleStore::const_iterator i = exts.begin(); i != exts.end(); ++i)
{
ExtensionItem* item = i->first;
std::string value = item->serialize(FORMAT_NETWORK, u->second, i->second);
if (!value.empty())
this->WriteLine(CommandMetadata::Builder(user, item->name, value));
}
FOREACH_MOD(OnSyncUser, (user, piserver));
}
}
void do_whois(InspIRCd* ServerInstance, userrec* user, userrec* dest,unsigned long signon, unsigned long idle, const char* nick)
{
// bug found by phidjit - were able to whois an incomplete connection if it had sent a NICK or USER
if (dest->registered == REG_ALL)
{
user->WriteServ("311 %s %s %s %s * :%s",user->nick, dest->nick, dest->ident, dest->dhost, dest->fullname);
if ((user == dest) || (*user->oper))
{
user->WriteServ("378 %s %s :is connecting from *@%s %s",user->nick, dest->nick, dest->host, dest->GetIPString());
}
std::string cl = dest->ChannelList(user);
if (cl.length())
{
if (cl.length() > 400)
{
user->SplitChanList(dest,cl);
}
else
{
user->WriteServ("319 %s %s :%s",user->nick, dest->nick, cl.c_str());
}
}
if (*ServerInstance->Config->HideWhoisServer && !(*user->oper))
{
user->WriteServ("312 %s %s %s :%s",user->nick, dest->nick, ServerInstance->Config->HideWhoisServer, ServerInstance->Config->Network);
}
else
{
user->WriteServ("312 %s %s %s :%s",user->nick, dest->nick, dest->server, ServerInstance->GetServerDescription(dest->server).c_str());
}
if (*dest->awaymsg)
{
user->WriteServ("301 %s %s :%s",user->nick, dest->nick, dest->awaymsg);
}
if (*dest->oper)
{
user->WriteServ("313 %s %s :is %s %s on %s",user->nick, dest->nick, (strchr("AEIOUaeiou",*dest->oper) ? "an" : "a"),Spacify(dest->oper), ServerInstance->Config->Network);
}
if ((!signon) && (!idle))
{
FOREACH_MOD(I_OnWhois,OnWhois(user,dest));
}
if (!strcasecmp(user->server,dest->server))
{
// idle time and signon line can only be sent if youre on the same server (according to RFC)
user->WriteServ("317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, abs((dest->idle_lastmsg)-ServerInstance->Time()), dest->signon);
}
else
{
if ((idle) || (signon))
user->WriteServ("317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, idle, signon);
}
user->WriteServ("318 %s %s :End of /WHOIS list.",user->nick, dest->nick);
}
else
{
user->WriteServ("401 %s %s :No such nick/channel",user->nick, *nick ? nick : "*");
user->WriteServ("318 %s %s :End of /WHOIS list.",user->nick, *nick ? nick : "*");
}
}
bool XLineManager::DelLine(const char* hostmask, const std::string &type, User* user, bool simulate)
{
ContainerIter x = lookup_lines.find(type);
if (x == lookup_lines.end())
return false;
LookupIter y = x->second.find(hostmask);
if (y == x->second.end())
return false;
if (simulate)
return true;
ServerInstance->BanCache->RemoveEntries(y->second->type, true);
FOREACH_MOD(I_OnDelLine,OnDelLine(user, y->second));
y->second->Unset();
std::vector<XLine*>::iterator pptr = std::find(pending_lines.begin(), pending_lines.end(), y->second);
if (pptr != pending_lines.end())
pending_lines.erase(pptr);
delete y->second;
x->second.erase(y);
return true;
}
bool XLineManager::AddLine(XLine* line, User* user)
{
ServerInstance->BanCache->RemoveEntries(line->type, false); // XXX perhaps remove ELines here?
if (line->duration && ServerInstance->Time() > line->expiry)
return false; // Don't apply expired XLines.
/* Don't apply duplicate xlines */
ContainerIter x = lookup_lines.find(line->type);
if (x != lookup_lines.end())
{
LookupIter i = x->second.find(line->Displayable());
if (i != x->second.end())
{
return false;
}
}
/*ELine* item = new ELine(ServerInstance, ServerInstance->Time(), duration, source, reason, ih.first.c_str(), ih.second.c_str());*/
XLineFactory* xlf = GetFactory(line->type);
if (!xlf)
return false;
if (xlf->AutoApplyToUserList(line))
pending_lines.push_back(line);
lookup_lines[line->type][line->Displayable()] = line;
line->OnAdd();
FOREACH_MOD(I_OnAddLine,OnAddLine(user, line));
return true;
}
NickCore::~NickCore()
{
UnsetExtensibles();
FOREACH_MOD(OnDelCore, (this));
if (!this->chanaccess->empty())
Log(LOG_DEBUG) << "Non-empty chanaccess list in destructor!";
for (std::list<User *>::iterator it = this->users.begin(); it != this->users.end();)
{
User *user = *it++;
user->Logout();
}
this->users.clear();
NickCoreList->erase(this->display);
this->ClearAccess();
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();
}
}
bool IRCdMessage::OnSQuit(const Anope::string &source, const std::vector<Anope::string> ¶ms)
{
const Anope::string &server = params[0];
Server *s = Server::Find(server);
if (!s)
{
Log() << "SQUIT for nonexistent server " << server;
return true;
}
FOREACH_MOD(I_OnServerQuit, OnServerQuit(s));
Anope::string buf = s->GetName() + " " + s->GetUplink()->GetName();
if (s->GetUplink() == Me && Capab.count("UNCONNECT") > 0)
{
Log(LOG_DEBUG) << "Sending UNCONNECT SQUIT for " << s->GetName();
/* need to fix */
ircdproto->SendSquit(s, buf);
}
s->Delete(buf);
return true;
}
bool User::ChangeDisplayedHost(const char* shost)
{
if (dhost == shost)
return true;
if (IS_LOCAL(this))
{
ModResult MOD_RESULT;
FIRST_MOD_RESULT(OnChangeLocalUserHost, MOD_RESULT, (IS_LOCAL(this),shost));
if (MOD_RESULT == MOD_RES_DENY)
return false;
}
FOREACH_MOD(I_OnChangeHost, OnChangeHost(this,shost));
std::string quitstr = ":" + GetFullHost() + " QUIT :Changing host";
/* Fix by Om: User::dhost is 65 long, this was truncating some long hosts */
this->dhost.assign(shost, 0, 64);
this->InvalidateCache();
this->DoHostCycle(quitstr);
if (IS_LOCAL(this))
this->WriteNumeric(RPL_YOURDISPLAYEDHOST, "%s %s :is now your displayed host",this->nick.c_str(),this->dhost.c_str());
return true;
}
CullResult cull()
{
/*
* DelMode can't remove the +P mode on empty channels, or it will break
* merging modes with remote servers. Remove the empty channels now as
* we know this is not the case.
*/
chan_hash::iterator iter = ServerInstance->chanlist->begin();
while (iter != ServerInstance->chanlist->end())
{
Channel* c = iter->second;
if (c->GetUserCounter() == 0)
{
chan_hash::iterator at = iter;
iter++;
FOREACH_MOD(OnChannelDelete, (c));
ServerInstance->chanlist->erase(at);
ServerInstance->GlobalCulls.AddItem(c);
}
else
iter++;
}
ServerInstance->Modes->DelMode(&p);
return Module::cull();
}
bool ModeManager::AddUserMode(UserMode *um)
{
if (ModeManager::FindUserModeByChar(um->mchar) != NULL)
return false;
if (ModeManager::FindUserModeByName(um->name) != NULL)
return false;
if (um->name.empty())
{
um->name = stringify(++GenericUserModes);
Log() << "ModeManager: Added generic support for user mode " << um->mchar;
}
unsigned want = um->mchar;
if (want >= UserModesIdx.size())
UserModesIdx.resize(want + 1);
UserModesIdx[want] = um;
UserModesByName[um->name] = um;
UserModes.push_back(um);
FOREACH_MOD(OnUserModeAdd, (um));
return true;
}
void Server::Sync(bool sync_links)
{
if (this->IsSynced())
return;
syncing = false;
Log(this, "sync") << "is done syncing";
FOREACH_MOD(OnServerSync, (this));
if (sync_links && !this->links.empty())
{
for (unsigned i = 0, j = this->links.size(); i < j; ++i)
this->links[i]->Sync(true);
}
bool me = this->GetUplink() && this->GetUplink() == Me;
if (me)
{
FOREACH_MOD(OnPreUplinkSync, (this));
}
for (channel_map::const_iterator it = ChannelList.begin(), it_end = ChannelList.end(); it != it_end;)
{
Channel *c = it->second;
++it;
if (c->syncing)
c->Sync();
}
if (me)
{
IRCD->SendEOB();
Me->Sync(false);
FOREACH_MOD(OnUplinkSync, (this));
if (!Anope::NoFork && Anope::AtTerm())
{
Log(LOG_TERMINAL) << "Successfully linked, launching into background...";
Anope::Fork();
}
}
}
/**
* \fn bool ModuleHandler::Unload(Module *m)
* \brief Unloads the Module safely and announces the Module unload event
* \param Module the Module to be unloaded
*/
bool ModuleHandler::Unload(Module *m)
{
if(!m || m->GetPermanent())
return false;
FOREACH_MOD(OnModuleUnload, m);
return DeleteModule(m);
}
static void DoDel(CommandSource &source, unsigned index)
{
Exception *e = session_service->GetExceptions()[index];
FOREACH_MOD(I_OnExceptionDel, OnExceptionDel(source.u, e));
session_service->DelException(e);
delete e;
}
void ISupportManager::Build()
{
/**
* This is currently the neatest way we can build the initial ISUPPORT map. In
* the future we can use an initializer list here.
*/
std::map<std::string, std::string> tokens;
std::vector<std::string> lines;
int token_count = 0;
std::string line;
tokens["AWAYLEN"] = ConvToStr(ServerInstance->Config->Limits.MaxAway);
tokens["CASEMAPPING"] = "rfc1459";
tokens["CHANMODES"] = ConvToStr(ServerInstance->Modes->GiveModeList(MASK_CHANNEL));
tokens["CHANNELLEN"] = ConvToStr(ServerInstance->Config->Limits.ChanMax);
tokens["CHANTYPES"] = "#";
tokens["CHARSET"] = "ascii";
tokens["ELIST"] = "MU";
tokens["KICKLEN"] = ConvToStr(ServerInstance->Config->Limits.MaxKick);
tokens["MAXBANS"] = "64"; // TODO: make this a config setting.
tokens["MAXCHANNELS"] = ConvToStr(ServerInstance->Config->MaxChans);
tokens["MAXPARA"] = ConvToStr(MAXPARAMETERS);
tokens["MAXTARGETS"] = ConvToStr(ServerInstance->Config->MaxTargets);
tokens["MODES"] = ConvToStr(ServerInstance->Config->Limits.MaxModes);
tokens["NETWORK"] = ConvToStr(ServerInstance->Config->Network);
tokens["NICKLEN"] = ConvToStr(ServerInstance->Config->Limits.NickMax);
tokens["PREFIX"] = ServerInstance->Modes->BuildPrefixes();
tokens["STATUSMSG"] = ServerInstance->Modes->BuildPrefixes(false);
tokens["TOPICLEN"] = ConvToStr(ServerInstance->Config->Limits.MaxTopic);
tokens["FNC"] = tokens["MAP"] = tokens["VBANLIST"] =
tokens["WALLCHOPS"] = tokens["WALLVOICES"];
FOREACH_MOD(I_On005Numeric, On005Numeric(tokens));
// EXTBAN is a special case as we need to sort it and prepend a comma.
std::map<std::string, std::string>::iterator extban = tokens.find("EXTBAN");
if (extban != tokens.end())
{
sort(extban->second.begin(), extban->second.end());
extban->second.insert(0, ",");
}
for (std::map<std::string, std::string>::iterator it = tokens.begin(); it != tokens.end(); it++)
{
line.append(it->first + (it->second.empty() ? " " : "=" + it->second + " "));
token_count++;
if (token_count % 13 == 12 || it == --tokens.end())
{
line.append(":are supported by this server");
lines.push_back(line);
line.clear();
}
}
this->Lines = lines;
}
HttpServerSocket(int newfd, const std::string& IP, ListenSocket* via, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server)
: BufferedSocket(newfd), ip(IP), postsize(0)
{
InternalState = HTTP_SERVE_WAIT_REQUEST;
FOREACH_MOD(OnHookIO, (this, via));
if (GetIOHook())
GetIOHook()->OnStreamSocketAccept(this, client, server);
}
bool IRCdMessage::OnAway(const Anope::string &source, const std::vector<Anope::string> ¶ms)
{
User *u = finduser(source);
if (u)
{
FOREACH_MOD(I_OnUserAway, OnUserAway(u, params.empty() ? "" : params[0]));
}
return true;
}
ModuleReturn ModuleManager::UnloadModule(Module *m, User *u)
{
if (!m)
return MOD_ERR_PARAMS;
FOREACH_MOD(I_OnModuleUnload, OnModuleUnload(u, m));
return DeleteModule(m);
}
void Channel::SetTopic(User* u, const std::string& ntopic)
{
this->topic.assign(ntopic, 0, ServerInstance->Config->Limits.MaxTopic);
this->setby.assign(ServerInstance->Config->FullHostInTopic ? u->GetFullHost() : u->nick, 0, 128);
this->WriteChannel(u, "TOPIC %s :%s", this->name.c_str(), this->topic.c_str());
this->topicset = ServerInstance->Time();
FOREACH_MOD(OnPostTopicChange, (u, this, this->topic));
}
