/*
* InspIRCd -- Internet Relay Chat Daemon
*
* Copyright (C) 2018 B00mX0r <b00mx0r@aureus.pw>
* Copyright (C) 2013-2014 Attila Molnar <attilamolnar@hush.com>
* Copyright (C) 2013, 2017-2019 Sadie Powell <sadie@witchery.services>
*
* 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
* License as published by the Free Software Foundation, version 2.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "extension.h"
/** The base class for list modes, should be inherited.
*/
class CoreExport ListModeBase
: public ModeHandler
{
public:
/** An item in a listmode's list
*/
struct ListItem final
{
std::string setter;
std::string mask;
time_t time;
ListItem(const std::string& Mask, const std::string& Setter, time_t Time)
: setter(Setter)
, mask(Mask)
, time(Time)
{
}
};
/** Items stored in the channel's list
*/
typedef std::vector<ListItem> ModeList;
private:
class ChanData final
{
public:
ModeList list;
std::optional<size_t> maxitems;
};
/** The number of items a listmode's list may contain
*/
struct ListLimit final
{
std::string mask;
size_t limit;
ListLimit(const std::string& Mask, size_t 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<ListLimit> limitlist;
/** The default maximum list size. */
static constexpr 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
*/
size_t 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
*/
size_t 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;
/** Limits on a per-channel basis read from the \<listmode>
* config tag.
*/
limitlist chanlimits;
/** Storage key
*/
SimpleExtItem<ChanData> extItem;
public:
/** Constructor.
* @param Creator The creator of this class
* @param Name Mode name
* @param modechar Mode character
* @param lnum List numeric
* @param eolnum End of list numeric
*/
ListModeBase(Module* Creator, const std::string& Name, char modechar, unsigned int lnum, unsigned int eolnum);
/** Determines whether some channels have longer lists than others. */
bool HasVariableLength() const { return chanlimits.size() > 1; }
/** Compares an entry from this list with the specified value.
* @param entry The list entry to compare against.
* @param value The value to compare to.
* @return If the entries are equivalent then true; otherwise, false.
*/
virtual bool CompareEntry(const std::string& entry, const std::string& value) const { return entry == value; }
/** Get limit of this mode on a channel
* @param channel The channel to inspect
* @return Maximum number of modes of this type that can be placed on the given channel
*/
size_t GetLimit(Channel* channel);
/** Gets the lower list limit for this listmode.
*/
size_t 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
*/
ModeList* GetList(Channel* channel);
/** @copydoc ModeHandler::DisplayList */
void DisplayList(User* user, Channel* channel) override;
/** @copydoc ModeHandler::DisplayEmptyList */
void DisplayEmptyList(User* user, Channel* channel) override;
/** @copydoc ModeHandler::RemoveMode(Channel*,Modes::ChangeList&) */
void RemoveMode(Channel* channel, Modes::ChangeList& changelist) override;
/** Perform a rehash of this mode's configuration data
*/
void DoRehash();
/** @copydoc ModeHandler::OnModeChange */
bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override;
/** Validate a potential entry for this list mode. This is only for local validation, you
* should be prepared to handle malformed entries from remote servers as there is no good
* way to prevent them from being set without causing a desync.
* @param user The local user which sent the list mode change.
* @param channel The channel the mode is being changed on.
* @param parameter The parameter that the user specified.
* @return True if the parameter is valid; otherwise, false.
*/
virtual bool ValidateParam(LocalUser* user, Channel* channel, std::string& parameter);
/** @copydoc ModeHandler::OnParameterMissing */
void OnParameterMissing(User* user, User* dest, Channel* channel) override;
/** Tell the user the list is too long.
* Overridden by implementing module.
* @param source Source user adding the parameter
* @param channel Channel the parameter is being added to
* @param parameter The actual parameter being added
* @param limit The list limit for the channel.
*/
virtual void TellListTooLong(LocalUser* source, Channel* channel, const std::string& parameter, size_t limit);
/** Tell the user an item is already on the list.
* Overridden by implementing module.
* @param source Source user adding the parameter
* @param channel Channel the parameter is being added to
* @param parameter The actual parameter being added
*/
virtual void TellAlreadyOnList(LocalUser* source, Channel* channel, const std::string& parameter);
/** Tell the user that the parameter is not in the list.
* Overridden by implementing module.
* @param source Source user removing the parameter
* @param channel Channel the parameter is being removed from
* @param parameter The actual parameter being removed
*/
virtual void TellNotSet(LocalUser* source, Channel* channel, const std::string& parameter);
};
inline ListModeBase::ModeList* ListModeBase::GetList(Channel* channel)
{
ChanData* cd = extItem.Get(channel);
if (!cd)
return nullptr;
return &cd->list;
}
