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)); }