1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/*
* 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, 2021-2023 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;
}
|
