X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fcoremods%2Fcore_whowas.cpp;h=02bcdf5d4ccada7362fafb699bdc756472e681a5;hb=b4a174ee9c32d62ea6bf010e837e8c5b1c3d36a3;hp=0bb47b2731546bade973a8191af552d96256ffad;hpb=ff3b706b2506d7614bce5e54bc88657bd62ebd4d;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/coremods/core_whowas.cpp b/src/coremods/core_whowas.cpp index 0bb47b273..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,16 +25,172 @@ #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()) @@ -51,14 +211,14 @@ CmdResult CommandWhowas::Handle (const std::vector& parameters, Use { WhoWas::Entry* u = *i; - user->WriteNumeric(RPL_WHOWASUSER, parameters[0], u->ident, u->dhost, '*', u->gecos); + user->WriteNumeric(RPL_WHOWASUSER, parameters[0], u->ident, u->dhost, '*', u->real); 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, parameters[0], (hide_server ? ServerInstance->Config->HideWhoisServer : u->server), 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); } } @@ -230,11 +390,11 @@ void WhoWas::Manager::PurgeNick(WhoWas::Nick* nick) } 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) { } @@ -250,12 +410,14 @@ 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) { } @@ -281,8 +443,8 @@ 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); @@ -290,7 +452,7 @@ class ModuleWhoWas : public Module Version GetVersion() CXX11_OVERRIDE { - return Version("WHOWAS", VF_VENDOR); + return Version("Provides the WHOWAS command", VF_CORE | VF_VENDOR); } };