X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Flistmode.h;h=510604e6e84e411bf1c579d1beade30815024013;hb=b0f16081ccaef527ed4b5434a7264508cf455f39;hp=c21f9b93fc81507ac4a563962c4e1d7fa4f4a3a9;hpb=9de86c34d41fcbcedf7b332746b7f0e8c37c7c45;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/listmode.h b/include/listmode.h index c21f9b93f..510604e6e 100644 --- a/include/listmode.h +++ b/include/listmode.h @@ -1,7 +1,9 @@ /* * InspIRCd -- Internet Relay Chat Daemon * - * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2018 B00mX0r + * Copyright (C) 2013-2014 Attila Molnar + * Copyright (C) 2013, 2017-2019 Sadie Powell * * 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 @@ -16,11 +18,12 @@ * along with this program. If not, see . */ + #pragma once /** The base class for list modes, should be inherited. */ -class ListModeBase : public ModeHandler +class CoreExport ListModeBase : public ModeHandler { public: /** An item in a listmode's list @@ -36,9 +39,18 @@ class ListModeBase : public ModeHandler /** Items stored in the channel's list */ - typedef std::list ModeList; + typedef std::vector ModeList; private: + class ChanData + { + public: + ModeList list; + int maxitems; + + ChanData() : maxitems(-1) { } + }; + /** The number of items a listmode's list may contain */ struct ListLimit @@ -46,48 +58,72 @@ class ListModeBase : public ModeHandler std::string mask; unsigned int limit; ListLimit(const std::string& Mask, unsigned int Limit) : mask(Mask), limit(Limit) { } + bool operator==(const ListLimit& other) const { return (this->mask == other.mask && this->limit == other.limit); } }; /** Max items per channel by name */ typedef std::vector limitlist; + /** The default maximum list size. */ + static const unsigned int DEFAULT_LIST_SIZE = 100; + + /** Finds the limit of modes that can be placed on the given channel name according to the config + * @param channame The channel name to find the limit for + * @return The maximum number of modes of this type that we allow to be set on the given channel name + */ + unsigned int FindLimit(const std::string& channame); + + /** Returns the limit on the given channel for this mode. + * If the limit is cached then the cached value is returned, + * otherwise the limit is determined using FindLimit() and cached + * for later queries before it is returned + * @param channame The channel name to find the limit for + * @param cd The ChanData associated with channel channame + * @return The maximum number of modes of this type that we allow to be set on the given channel + */ + unsigned int GetLimitInternal(const std::string& channame, ChanData* cd); + protected: /** Numeric to use when outputting the list */ unsigned int listnumeric; + /** Numeric to indicate end of list */ unsigned int endoflistnumeric; + /** String to send for end of list */ std::string endofliststring; + /** Automatically tidy up entries */ bool tidy; - /** Config tag to check for max items per channel - */ - std::string configtag; - /** Limits on a per-channel basis read from the tag - * specified in ListModeBase::configtag + + /** Limits on a per-channel basis read from the \ + * config tag. */ limitlist chanlimits; /** Storage key */ - SimpleExtItem extItem; + SimpleExtItem extItem; public: /** Constructor. - * @param Instance The creator of this class + * @param Creator The creator of this class + * @param Name Mode name * @param modechar Mode character * @param eolstr End of list string * @param lnum List numeric * @param eolnum End of list numeric * @param autotidy Automatically tidy list entries on add - * @param ctag Configuration tag to get limits from */ - ListModeBase(Module* Creator, const std::string& Name, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist"); + ListModeBase(Module* Creator, const std::string& Name, char modechar, const std::string& eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy); + + /** Determines whether some channels have longer lists than others. */ + bool HasVariableLength() const { return chanlimits.size() > 1; } /** Get limit of this mode on a channel * @param channel The channel to inspect @@ -95,6 +131,10 @@ class ListModeBase : public ModeHandler */ unsigned int GetLimit(Channel* channel); + /** Gets the lower list limit for this listmode. + */ + unsigned int GetLowerLimit(); + /** Retrieves the list of all modes set on the given channel * @param channel Channel to get the list from * @return A list with all modes of this type set on the given channel, can be NULL @@ -106,7 +146,7 @@ class ListModeBase : public ModeHandler * @param user The user to send the list to * @param channel The channel the user is requesting the list for */ - virtual void DisplayList(User* user, Channel* channel); + void DisplayList(User* user, Channel* channel) CXX11_OVERRIDE; /** Tell a user that a list contains no elements. * Sends 'eolnum' numeric with text 'eolstr', unless overridden (see constructor) @@ -114,48 +154,44 @@ class ListModeBase : public ModeHandler * @param channel The channel that has the empty list * See mode.h */ - virtual void DisplayEmptyList(User* user, Channel* channel); + void DisplayEmptyList(User* user, Channel* channel) CXX11_OVERRIDE; /** Remove all instances of the mode from a channel. - * See mode.h + * Populates the given modestack with modes that remove every instance of + * this mode from the channel. + * See mode.h for more details. * @param channel The channel to remove all instances of the mode from + * @param changelist Mode change list to populate with the removal of this mode */ - virtual void RemoveMode(Channel* channel, irc::modestacker* stack); - - /** Listmodes don't get set on users, no-op - */ - virtual void RemoveMode(User*, irc::modestacker* stack); + void RemoveMode(Channel* channel, Modes::ChangeList& changelist) CXX11_OVERRIDE; /** Perform a rehash of this mode's configuration data */ - virtual void DoRehash(); - - /** Populate the Implements list with the correct events for a List Mode - */ - virtual void DoImplements(Module* m); + void DoRehash(); /** Handle the list mode. * See mode.h */ - virtual ModeAction OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding); - - /** Syncronize channel item list with another server. - * See modules.h - * @param chan Channel to syncronize - * @param proto Protocol module pointer - * @param opaque Opaque connection handle - */ - virtual void DoSyncChannel(Channel* chan, Module* proto, void* opaque); + ModeAction OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE; /** Validate parameters. * Overridden by implementing module. - * @param source Source user adding the parameter + * @param user Source user adding the parameter * @param channel Channel the parameter is being added to * @param parameter The actual parameter being added * @return true if the parameter is valid */ virtual bool ValidateParam(User* user, Channel* channel, std::string& parameter); + /** In the event that the mode should be given a parameter, and no parameter was provided, this method is called. + * This allows you to give special information to the user, or handle this any way you like. + * @param user The user issuing the mode change + * @param dest For user mode changes, the target of the mode. For channel mode changes, NULL. + * @param channel For channel mode changes, the target of the mode. For user mode changes, NULL. + * See mode.h + */ + virtual void OnParameterMissing(User* user, User* dest, Channel* channel) CXX11_OVERRIDE; + /** Tell the user the list is too long. * Overridden by implementing module. * @param source Source user adding the parameter @@ -183,5 +219,9 @@ class ListModeBase : public ModeHandler inline ListModeBase::ModeList* ListModeBase::GetList(Channel* channel) { - return extItem.get(channel); + ChanData* cd = extItem.get(channel); + if (!cd) + return NULL; + + return &cd->list; }