X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fcoremods%2Fcore_whowas.cpp;h=02bcdf5d4ccada7362fafb699bdc756472e681a5;hb=d494fa6e094e85cd29235e995fb2b447d6e1f168;hp=801f1186e0baac5942ee9fc881ef7a271dbb1656;hpb=93786820aad505e00d5c1c07228ef7aa6c3f22b8;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/coremods/core_whowas.cpp b/src/coremods/core_whowas.cpp index 801f1186e..02bcdf5d4 100644 --- a/src/coremods/core_whowas.cpp +++ b/src/coremods/core_whowas.cpp @@ -1,10 +1,14 @@ /* * InspIRCd -- Internet Relay Chat Daemon * + * Copyright (C) 2013, 2017-2018, 2020 Sadie Powell + * Copyright (C) 2012-2016 Attila Molnar + * Copyright (C) 2012, 2019 Robby + * Copyright (C) 2010 Craig Edwards + * Copyright (C) 2009 Uli Schlachter * Copyright (C) 2009 Daniel De Graaf - * Copyright (C) 2008 Thomas Stagner - * Copyright (C) 2008 Craig Edwards * Copyright (C) 2007-2008 Robin Burchell + * Copyright (C) 2006-2007 Dennis Friis * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public @@ -21,226 +25,417 @@ #include "inspircd.h" -#include "commands/cmd_whowas.h" +#include "modules/stats.h" + +enum +{ + // From RFC 1459. + RPL_WHOWASUSER = 314, + RPL_ENDOFWHOWAS = 369, + + // InspIRCd-specific. + RPL_WHOWASIP = 652 +}; + +namespace WhoWas +{ + /** One entry for a nick. There may be multiple entries for a nick. */ + struct Entry + { + /** Real host */ + const std::string host; + + /** Displayed host */ + const std::string dhost; + + /** Ident */ + const std::string ident; + + /** Server name */ + const std::string server; + + /** Real name */ + const std::string real; + + /** Signon time */ + const time_t signon; + + /** Initialize this Entry with a user */ + Entry(User* user); + }; + + /** Everything known about one nick */ + struct Nick : public insp::intrusive_list_node + { + /** A group of users related by nickname */ + typedef std::deque List; + + /** Container where each element has information about one occurrence of this nick */ + List entries; + + /** Time this nick was added to the database */ + const time_t addtime; + + /** Nickname whose information is stored in this class */ + const std::string nick; + + /** Constructor to initialize fields */ + Nick(const std::string& nickname); + + /** Destructor, deallocates all elements in the entries container */ + ~Nick(); + }; + + class Manager + { + public: + struct Stats + { + /** Number of currently existing WhoWas::Entry objects */ + size_t entrycount; + }; + + /** Add a user to the whowas database. Called when a user quits. + * @param user The user to add to the database + */ + void Add(User* user); + + /** Retrieves statistics about the whowas database + * @return Whowas statistics as a WhoWas::Manager::Stats struct + */ + Stats GetStats() const; + + /** Expires old entries */ + void Maintain(); + + /** Updates the current configuration which may result in the database being pruned if the + * new values are lower than the current ones. + * @param NewGroupSize Maximum number of nicks allowed in the database. In case there are this many nicks + * in the database and one more is added, the oldest one is removed (FIFO). + * @param NewMaxGroups Maximum number of entries per nick + * @param NewMaxKeep Seconds how long each nick should be kept + */ + void UpdateConfig(unsigned int NewGroupSize, unsigned int NewMaxGroups, unsigned int NewMaxKeep); + + /** Retrieves all data known about a given nick + * @param nick Nickname to find, case insensitive (IRC casemapping) + * @return A pointer to a WhoWas::Nick if the nick was found, NULL otherwise + */ + const Nick* FindNick(const std::string& nick) const; + + /** Returns true if WHOWAS is enabled according to the current configuration + * @return True if WHOWAS is enabled according to the configuration, false if WHOWAS is disabled + */ + bool IsEnabled() const; + + /** Constructor */ + Manager(); + + /** Destructor */ + ~Manager(); + + private: + /** Order in which the users were added into the map, used to remove oldest nick */ + typedef insp::intrusive_list_tail FIFO; + + /** Sets of users in the whowas system */ + typedef TR1NS::unordered_map whowas_users; + + /** Primary container, links nicknames tracked by WHOWAS to a list of records */ + whowas_users whowas; + + /** List of nicknames in the order they were inserted into the map */ + FIFO whowas_fifo; + + /** Max number of WhoWas entries per user. */ + unsigned int GroupSize; + + /** Max number of cumulative user-entries in WhoWas. + * When max reached and added to, push out oldest entry FIFO style. + */ + unsigned int MaxGroups; + + /** Max seconds a user is kept in WhoWas before being pruned. */ + unsigned int MaxKeep; + + /** Shrink all data structures to honor the current settings */ + void Prune(); + + /** Remove a nick (and all entries belonging to it) from the database + * @param it Iterator to the nick to purge + */ + void PurgeNick(whowas_users::iterator it); + + /** Remove a nick (and all entries belonging to it) from the database + * @param nick Nick to purge + */ + void PurgeNick(WhoWas::Nick* nick); + }; +} + +class CommandWhowas : public Command +{ + public: + // Manager handling all whowas database related tasks + WhoWas::Manager manager; + + CommandWhowas(Module* parent); + CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE; +}; CommandWhowas::CommandWhowas( Module* parent) : Command(parent, "WHOWAS", 1) - , GroupSize(0), MaxGroups(0), MaxKeep(0) { - syntax = "{,}"; + syntax = ""; Penalty = 2; } -CmdResult CommandWhowas::Handle (const std::vector& parameters, User* user) +CmdResult CommandWhowas::Handle(User* user, const Params& parameters) { /* if whowas disabled in config */ - if (this->GroupSize == 0 || this->MaxGroups == 0) + if (!manager.IsEnabled()) { - user->WriteNumeric(ERR_UNKNOWNCOMMAND, "%s :This command has been disabled.", name.c_str()); + user->WriteNumeric(ERR_UNKNOWNCOMMAND, name, "This command has been disabled."); return CMD_FAILURE; } - whowas_users::iterator i = whowas.find(assign(parameters[0])); - - if (i == whowas.end()) + const WhoWas::Nick* const nick = manager.FindNick(parameters[0]); + if (!nick) { - user->WriteNumeric(ERR_WASNOSUCHNICK, "%s :There was no such nickname", parameters[0].c_str()); + user->WriteNumeric(ERR_WASNOSUCHNICK, parameters[0], "There was no such nickname"); } else { - WhoWas::Nick* nick = i->second; - whowas_set* grp = &nick->entries; - if (!grp->empty()) + const WhoWas::Nick::List& list = nick->entries; + for (WhoWas::Nick::List::const_iterator i = list.begin(); i != list.end(); ++i) { - for (whowas_set::iterator ux = grp->begin(); ux != grp->end(); ux++) - { - WhoWasGroup* u = *ux; + WhoWas::Entry* u = *i; - user->WriteNumeric(RPL_WHOWASUSER, "%s %s %s * :%s", parameters[0].c_str(), - u->ident.c_str(),u->dhost.c_str(),u->gecos.c_str()); + user->WriteNumeric(RPL_WHOWASUSER, parameters[0], u->ident, u->dhost, '*', u->real); - if (user->HasPrivPermission("users/auspex")) - user->WriteNumeric(RPL_WHOWASIP, "%s :was connecting from *@%s", - parameters[0].c_str(), u->host.c_str()); + if (user->HasPrivPermission("users/auspex")) + user->WriteNumeric(RPL_WHOWASIP, parameters[0], InspIRCd::Format("was connecting from *@%s", u->host.c_str())); - std::string signon = InspIRCd::TimeString(u->signon); - bool hide_server = (!ServerInstance->Config->HideWhoisServer.empty() && !user->HasPrivPermission("servers/auspex")); - user->WriteNumeric(RPL_WHOISSERVER, "%s %s :%s", parameters[0].c_str(), (hide_server ? ServerInstance->Config->HideWhoisServer.c_str() : u->server.c_str()), signon.c_str()); - } - } - else - { - user->WriteNumeric(ERR_WASNOSUCHNICK, "%s :There was no such nickname", parameters[0].c_str()); + std::string signon = InspIRCd::TimeString(u->signon); + bool hide_server = (!ServerInstance->Config->HideServer.empty() && !user->HasPrivPermission("servers/auspex")); + user->WriteNumeric(RPL_WHOISSERVER, parameters[0], (hide_server ? ServerInstance->Config->HideServer : u->server), signon); } } - user->WriteNumeric(RPL_ENDOFWHOWAS, "%s :End of WHOWAS", parameters[0].c_str()); + user->WriteNumeric(RPL_ENDOFWHOWAS, parameters[0], "End of WHOWAS"); return CMD_SUCCESS; } -std::string CommandWhowas::GetStats() +WhoWas::Manager::Manager() + : GroupSize(0), MaxGroups(0), MaxKeep(0) { - int whowas_size = 0; - for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ++i) +} + +const WhoWas::Nick* WhoWas::Manager::FindNick(const std::string& nickname) const +{ + whowas_users::const_iterator it = whowas.find(nickname); + if (it == whowas.end()) + return NULL; + return it->second; +} + +WhoWas::Manager::Stats WhoWas::Manager::GetStats() const +{ + size_t entrycount = 0; + for (whowas_users::const_iterator i = whowas.begin(); i != whowas.end(); ++i) { - whowas_set* n = &i->second->entries; - whowas_size += n->size(); + WhoWas::Nick::List& list = i->second->entries; + entrycount += list.size(); } - return "Whowas entries: " + ConvToStr(whowas_size); + + Stats stats; + stats.entrycount = entrycount; + return stats; } -void CommandWhowas::AddToWhoWas(User* user) +void WhoWas::Manager::Add(User* user) { - /* if whowas disabled */ - if (this->GroupSize == 0 || this->MaxGroups == 0) - { + if (!IsEnabled()) return; - } // Insert nick if it doesn't exist // 'first' will point to the newly inserted element or to the existing element with an equivalent key - std::pair ret = whowas.insert(std::make_pair(irc::string(user->nick.c_str()), static_cast(NULL))); + std::pair ret = whowas.insert(std::make_pair(user->nick, static_cast(NULL))); if (ret.second) // If inserted { // This nick is new, create a list for it and add the first record to it - WhoWas::Nick* nick = new WhoWas::Nick; - nick->entries.push_back(new WhoWasGroup(user)); + WhoWas::Nick* nick = new WhoWas::Nick(ret.first->first); + nick->entries.push_back(new Entry(user)); ret.first->second = nick; // Add this nick to the fifo too - whowas_fifo.push_back(std::make_pair(ServerInstance->Time(), ret.first->first)); + whowas_fifo.push_back(nick); if (whowas.size() > this->MaxGroups) { // Too many nicks, remove the nick which was inserted the longest time ago from both the map and the fifo - whowas_users::iterator it = whowas.find(whowas_fifo.front().second); - if (it != whowas.end()) - { - WhoWas::Nick* set = it->second; - stdalgo::delete_all(set->entries); - - delete set; - whowas.erase(it); - } - whowas_fifo.pop_front(); + PurgeNick(whowas_fifo.front()); } } else { // We've met this nick before, add a new record to the list - whowas_set* set = &ret.first->second->entries; - set->push_back(new WhoWasGroup(user)); + WhoWas::Nick::List& list = ret.first->second->entries; + list.push_back(new Entry(user)); // If there are too many records for this nick, remove the oldest (front) - if (set->size() > this->GroupSize) + if (list.size() > this->GroupSize) { - delete set->front(); - set->pop_front(); + delete list.front(); + list.pop_front(); } } } /* on rehash, refactor maps according to new conf values */ -void CommandWhowas::Prune() +void WhoWas::Manager::Prune() { time_t min = ServerInstance->Time() - this->MaxKeep; /* first cut the list to new size (maxgroups) and also prune entries that are timed out. */ while (!whowas_fifo.empty()) { - if ((whowas_fifo.size() > this->MaxGroups) || (whowas_fifo.front().first < min)) - { - whowas_users::iterator iter = whowas.find(whowas_fifo.front().second); - - /* hopefully redundant integrity check, but added while debugging r6216 */ - if (iter == whowas.end()) - { - /* this should never happen, if it does maps are corrupt */ - ServerInstance->Logs->Log("WHOWAS", LOG_DEFAULT, "BUG: Whowas maps got corrupted! (1)"); - return; - } - - WhoWas::Nick* nick = iter->second; - stdalgo::delete_all(nick->entries); - - delete nick; - whowas.erase(iter); - whowas_fifo.pop_front(); - } + WhoWas::Nick* nick = whowas_fifo.front(); + if ((whowas_fifo.size() > this->MaxGroups) || (nick->addtime < min)) + PurgeNick(nick); else break; } /* Then cut the whowas sets to new size (groupsize) */ - for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ++i) + for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ) { - whowas_set* n = &i->second->entries; - while (n->size() > this->GroupSize) + WhoWas::Nick::List& list = i->second->entries; + while (list.size() > this->GroupSize) { - delete n->front(); - n->pop_front(); + delete list.front(); + list.pop_front(); } + + if (list.empty()) + PurgeNick(i++); + else + ++i; } } /* call maintain once an hour to remove expired nicks */ -void CommandWhowas::Maintain() +void WhoWas::Manager::Maintain() { time_t min = ServerInstance->Time() - this->MaxKeep; - for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ++i) + for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ) { - whowas_set* set = &i->second->entries; - while (!set->empty() && set->front()->signon < min) + WhoWas::Nick::List& list = i->second->entries; + while (!list.empty() && list.front()->signon < min) { - delete set->front(); - set->pop_front(); + delete list.front(); + list.pop_front(); } + + if (list.empty()) + PurgeNick(i++); + else + ++i; } } -CommandWhowas::~CommandWhowas() +WhoWas::Manager::~Manager() { for (whowas_users::iterator i = whowas.begin(); i != whowas.end(); ++i) { WhoWas::Nick* nick = i->second; - whowas_set* set = &nick->entries; - for (whowas_set::iterator j = set->begin(); j != set->end(); ++j) - delete *j; - delete nick; } } -WhoWasGroup::WhoWasGroup(User* user) : host(user->host), dhost(user->dhost), ident(user->ident), - server(user->server->GetName()), gecos(user->fullname), signon(user->signon) +bool WhoWas::Manager::IsEnabled() const +{ + return ((GroupSize != 0) && (MaxGroups != 0)); +} + +void WhoWas::Manager::UpdateConfig(unsigned int NewGroupSize, unsigned int NewMaxGroups, unsigned int NewMaxKeep) +{ + if ((NewGroupSize == GroupSize) && (NewMaxGroups == MaxGroups) && (NewMaxKeep == MaxKeep)) + return; + + GroupSize = NewGroupSize; + MaxGroups = NewMaxGroups; + MaxKeep = NewMaxKeep; + Prune(); +} + +void WhoWas::Manager::PurgeNick(whowas_users::iterator it) +{ + WhoWas::Nick* nick = it->second; + whowas_fifo.erase(nick); + whowas.erase(it); + delete nick; +} + +void WhoWas::Manager::PurgeNick(WhoWas::Nick* nick) +{ + whowas_users::iterator it = whowas.find(nick->nick); + if (it == whowas.end()) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "ERROR: Inconsistency detected in whowas database, please report"); + return; + } + PurgeNick(it); +} + +WhoWas::Entry::Entry(User* user) + : host(user->GetRealHost()) + , dhost(user->GetDisplayedHost()) + , ident(user->ident) + , server(user->server->GetName()) + , real(user->GetRealName()) + , signon(user->signon) +{ +} + +WhoWas::Nick::Nick(const std::string& nickname) + : addtime(ServerInstance->Time()) + , nick(nickname) { } -class ModuleWhoWas : public Module +WhoWas::Nick::~Nick() +{ + stdalgo::delete_all(entries); +} + +class ModuleWhoWas : public Module, public Stats::EventListener { CommandWhowas cmd; public: - ModuleWhoWas() : cmd(this) + ModuleWhoWas() + : Stats::EventListener(this) + , cmd(this) { } - void OnGarbageCollect() + void OnGarbageCollect() CXX11_OVERRIDE { // Remove all entries older than MaxKeep - cmd.Maintain(); + cmd.manager.Maintain(); } - void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) + void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) CXX11_OVERRIDE { - cmd.AddToWhoWas(user); + cmd.manager.Add(user); } - ModResult OnStats(char symbol, User* user, string_list &results) + ModResult OnStats(Stats::Context& stats) CXX11_OVERRIDE { - if (symbol == 'z') - results.push_back("249 "+user->nick+" :"+cmd.GetStats()); + if (stats.GetSymbol() == 'z') + stats.AddRow(249, "Whowas entries: "+ConvToStr(cmd.manager.GetStats().entrycount)); return MOD_RES_PASSTHRU; } @@ -248,22 +443,16 @@ class ModuleWhoWas : public Module void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE { ConfigTag* tag = ServerInstance->Config->ConfValue("whowas"); - unsigned int NewGroupSize = tag->getInt("groupsize", 10, 0, 10000); - unsigned int NewMaxGroups = tag->getInt("maxgroups", 10240, 0, 1000000); + unsigned int NewGroupSize = tag->getUInt("groupsize", 10, 0, 10000); + unsigned int NewMaxGroups = tag->getUInt("maxgroups", 10240, 0, 1000000); unsigned int NewMaxKeep = tag->getDuration("maxkeep", 3600, 3600); - if ((NewGroupSize == cmd.GroupSize) && (NewMaxGroups == cmd.MaxGroups) && (NewMaxKeep == cmd.MaxKeep)) - return; - - cmd.GroupSize = NewGroupSize; - cmd.MaxGroups = NewMaxGroups; - cmd.MaxKeep = NewMaxKeep; - cmd.Prune(); + cmd.manager.UpdateConfig(NewGroupSize, NewMaxGroups, NewMaxKeep); } - Version GetVersion() + Version GetVersion() CXX11_OVERRIDE { - return Version("WHOWAS", VF_VENDOR); + return Version("Provides the WHOWAS command", VF_CORE | VF_VENDOR); } };