X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fcoremods%2Fcore_whowas.cpp;h=02bcdf5d4ccada7362fafb699bdc756472e681a5;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=d73fdf491bae833100a7ab53315a3fffe3cfbcb3;hpb=3a3ff949670c61a4a8856e1391222e156eb1cd17;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/coremods/core_whowas.cpp b/src/coremods/core_whowas.cpp index d73fdf491..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,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) - { - WhoWas::Entry* 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,11 +236,7 @@ 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; } WhoWas::Manager::Stats WhoWas::Manager::GetStats() const @@ -124,10 +275,7 @@ 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 @@ -155,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) @@ -180,6 +317,11 @@ void WhoWas::Manager::Prune() delete list.front(); list.pop_front(); } + + if (list.empty()) + PurgeNick(i++); + else + ++i; } } @@ -187,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) @@ -195,6 +337,11 @@ void WhoWas::Manager::Maintain() delete list.front(); list.pop_front(); } + + if (list.empty()) + PurgeNick(i++); + else + ++i; } } @@ -223,12 +370,31 @@ void WhoWas::Manager::UpdateConfig(unsigned int NewGroupSize, unsigned int NewMa 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->host) - , dhost(user->dhost) + : host(user->GetRealHost()) + , dhost(user->GetDisplayedHost()) , ident(user->ident) , server(user->server->GetName()) - , gecos(user->fullname) + , real(user->GetRealName()) , signon(user->signon) { } @@ -244,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+" :Whowas entries: "+ConvToStr(cmd.manager.GetStats().entrycount)); + if (stats.GetSymbol() == 'z') + stats.AddRow(249, "Whowas entries: "+ConvToStr(cmd.manager.GetStats().entrycount)); return MOD_RES_PASSTHRU; } @@ -275,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); } };