X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fcoremods%2Fcore_whowas.cpp;h=2b1a6ca1d3f1d51c4bfaabd8794435ae6ea427ce;hb=d38595e7e14e7509e744d33df657d50d00cc201f;hp=fee40377a382b7b7231aa96b1e56048155f68c0b;hpb=da877e4750333f02c48a667241a41412c38bfd16;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/coremods/core_whowas.cpp b/src/coremods/core_whowas.cpp index fee40377a..2b1a6ca1d 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) 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,53 +25,204 @@ #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) { - 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 (!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; } 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 { const WhoWas::Nick::List& list = nick->entries; - if (!list.empty()) + for (WhoWas::Nick::List::const_iterator i = list.begin(); i != list.end(); ++i) { - for (WhoWas::Nick::List::const_iterator i = list.begin(); i != list.end(); ++i) - { - WhoWasGroup* u = *i; + 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()); - } + 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; } @@ -81,14 +236,10 @@ 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; - - const Nick* nick = it->second; - if (nick->entries.empty()) - return NULL; - return nick; + return it->second; } -std::string WhoWas::Manager::GetStats() const +WhoWas::Manager::Stats WhoWas::Manager::GetStats() const { size_t entrycount = 0; for (whowas_users::const_iterator i = whowas.begin(); i != whowas.end(); ++i) @@ -96,7 +247,10 @@ std::string WhoWas::Manager::GetStats() const WhoWas::Nick::List& list = i->second->entries; entrycount += list.size(); } - return "Whowas entries: " + ConvToStr(entrycount); + + Stats stats; + stats.entrycount = entrycount; + return stats; } void WhoWas::Manager::Add(User* user) @@ -112,7 +266,7 @@ void WhoWas::Manager::Add(User* user) { // This nick is new, create a list for it and add the first record to it WhoWas::Nick* nick = new WhoWas::Nick(ret.first->first); - nick->entries.push_back(new WhoWasGroup(user)); + nick->entries.push_back(new Entry(user)); ret.first->second = nick; // Add this nick to the fifo too @@ -121,17 +275,14 @@ void WhoWas::Manager::Add(User* user) 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 - nick = whowas_fifo.front(); - whowas_fifo.pop_front(); - whowas.erase(nick->nick); - delete nick; + PurgeNick(whowas_fifo.front()); } } else { // We've met this nick before, add a new record to the list WhoWas::Nick::List& list = ret.first->second->entries; - list.push_back(new WhoWasGroup(user)); + list.push_back(new Entry(user)); // If there are too many records for this nick, remove the oldest (front) if (list.size() > this->GroupSize) @@ -152,24 +303,13 @@ void WhoWas::Manager::Prune() { WhoWas::Nick* nick = whowas_fifo.front(); if ((whowas_fifo.size() > this->MaxGroups) || (nick->addtime < min)) - { - /* hopefully redundant integrity check, but added while debugging r6216 */ - if (!whowas.erase(nick->nick)) - { - /* this should never happen, if it does maps are corrupt */ - ServerInstance->Logs->Log("WHOWAS", LOG_DEFAULT, "BUG: Whowas maps got corrupted! (1)"); - return; - } - - whowas_fifo.pop_front(); - delete nick; - } + 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::Nick::List& list = i->second->entries; while (list.size() > this->GroupSize) @@ -177,6 +317,11 @@ void WhoWas::Manager::Prune() delete list.front(); list.pop_front(); } + + if (list.empty()) + PurgeNick(i++); + else + ++i; } } @@ -184,7 +329,7 @@ void WhoWas::Manager::Prune() 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::Nick::List& list = i->second->entries; while (!list.empty() && list.front()->signon < min) @@ -192,6 +337,11 @@ void WhoWas::Manager::Maintain() delete list.front(); list.pop_front(); } + + if (list.empty()) + PurgeNick(i++); + else + ++i; } } @@ -220,8 +370,32 @@ void WhoWas::Manager::UpdateConfig(unsigned int NewGroupSize, unsigned int NewMa Prune(); } -WhoWasGroup::WhoWasGroup(User* user) : host(user->host), dhost(user->dhost), ident(user->ident), - server(user->server->GetName()), gecos(user->fullname), signon(user->signon) +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) { } @@ -236,30 +410,32 @@ WhoWas::Nick::~Nick() stdalgo::delete_all(entries); } -class ModuleWhoWas : public Module +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.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.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.manager.GetStats()); + if (stats.GetSymbol() == 'z') + stats.AddRow(249, "Whowas entries: "+ConvToStr(cmd.manager.GetStats().entrycount)); return MOD_RES_PASSTHRU; } @@ -267,16 +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); 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); } };