]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - include/configreader.h
Add <dns:enabled>; allows disabling DNS lookups entirely.
[user/henk/code/inspircd.git] / include / configreader.h
1 /*
2  * InspIRCd -- Internet Relay Chat Daemon
3  *
4  *   Copyright (C) 2019 Matt Schatz <genius3000@g3k.solutions>
5  *   Copyright (C) 2018 Chris Novakovic <chrisnovakovic@users.noreply.github.com>
6  *   Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com>
7  *   Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org>
8  *   Copyright (C) 2012-2014, 2016-2020 Sadie Powell <sadie@witchery.services>
9  *   Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be>
10  *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
11  *   Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
12  *   Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net>
13  *   Copyright (C) 2007-2008 Craig Edwards <brain@inspircd.org>
14  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
15  *
16  * This file is part of InspIRCd.  InspIRCd is free software: you can
17  * redistribute it and/or modify it under the terms of the GNU General Public
18  * License as published by the Free Software Foundation, version 2.
19  *
20  * This program is distributed in the hope that it will be useful, but WITHOUT
21  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
22  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
23  * details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
27  */
28
29
30 #pragma once
31
32 #include <sstream>
33 #include <string>
34 #include <vector>
35 #include <map>
36 #include "inspircd.h"
37 #include "modules.h"
38 #include "socketengine.h"
39 #include "socket.h"
40 #include "token_list.h"
41
42 /** Structure representing a single \<tag> in config */
43 class CoreExport ConfigTag : public refcountbase
44 {
45         ConfigItems items;
46  public:
47         const std::string tag;
48         const std::string src_name;
49         const int src_line;
50
51         /** Get the value of an option, using def if it does not exist */
52         std::string getString(const std::string& key, const std::string& def, const TR1NS::function<bool(const std::string&)>& validator);
53         /** Get the value of an option, using def if it does not exist */
54         std::string getString(const std::string& key, const std::string& def = "", size_t minlen = 0, size_t maxlen = UINT32_MAX);
55         /** Get the value of an option, using def if it does not exist */
56         long getInt(const std::string& key, long def, long min = LONG_MIN, long max = LONG_MAX);
57         /** Get the value of an option, using def if it does not exist */
58         unsigned long getUInt(const std::string& key, unsigned long def, unsigned long min = 0, unsigned long max = ULONG_MAX);
59         /** Get the value of an option, using def if it does not exist */
60         double getFloat(const std::string& key, double def, double min = DBL_MIN, double max = DBL_MAX);
61         /** Get the value of an option, using def if it does not exist */
62         bool getBool(const std::string& key, bool def = false);
63
64         /** Get the value in seconds of a duration that is in the user-friendly "1h2m3s" format,
65          * using a default value if it does not exist or is out of bounds.
66          * @param key The config key name
67          * @param def Default value (optional)
68          * @param min Minimum acceptable value (optional)
69          * @param max Maximum acceptable value (optional)
70          * @return The duration in seconds
71          */
72         unsigned long getDuration(const std::string& key, unsigned long def, unsigned long min = 0, unsigned long max = ULONG_MAX);
73
74         /** Get the value of an option
75          * @param key The option to get
76          * @param value The location to store the value (unmodified if does not exist)
77          * @param allow_newline Allow newlines in the option (normally replaced with spaces)
78          * @return true if the option exists
79          */
80         bool readString(const std::string& key, std::string& value, bool allow_newline = false);
81
82         std::string getTagLocation();
83
84         inline const ConfigItems& getItems() const { return items; }
85
86         /** Create a new ConfigTag, giving access to the private ConfigItems item list */
87         static ConfigTag* create(const std::string& Tag, const std::string& file, int line, ConfigItems*& Items);
88  private:
89         ConfigTag(const std::string& Tag, const std::string& file, int line);
90 };
91
92 /** Defines the server's length limits on various length-limited
93  * items such as topics, nicknames, channel names etc.
94  */
95 class ServerLimits
96 {
97  public:
98         /** Maximum line length */
99         size_t MaxLine;
100         /** Maximum nickname length */
101         size_t NickMax;
102         /** Maximum channel length */
103         size_t ChanMax;
104         /** Maximum number of modes per line */
105         size_t MaxModes;
106         /** Maximum length of ident, not including ~ etc */
107         size_t IdentMax;
108         /** Maximum length of a quit message */
109         size_t MaxQuit;
110         /** Maximum topic length */
111         size_t MaxTopic;
112         /** Maximum kick message length */
113         size_t MaxKick;
114         /** Maximum real name length */
115         size_t MaxReal;
116         /** Maximum away message length */
117         size_t MaxAway;
118         /** Maximum hostname length */
119         size_t MaxHost;
120
121         /** Read all limits from a config tag. Limits which aren't specified in the tag are set to a default value.
122          * @param tag Configuration tag to read the limits from
123          */
124         ServerLimits(ConfigTag* tag);
125
126         /** Maximum length of a n!u\@h mask */
127         size_t GetMaxMask() const { return NickMax + 1 + IdentMax + 1 + MaxHost; }
128 };
129
130 struct CommandLineConf
131 {
132         /** If this value is true, the owner of the
133          * server specified -nofork on the command
134          * line, causing the daemon to stay in the
135          * foreground.
136          */
137         bool nofork;
138
139         /** If this value if true then all log
140          * messages will be output, regardless of
141          * the level given in the config file.
142          * This is set with the -debug commandline
143          * option.
144          */
145         bool forcedebug;
146
147         /** If this is true then log output will be
148          * written to the logfile. This is the default.
149          * If you put -nolog on the commandline then
150          * the logfile will not be written.
151          * This is meant to be used in conjunction with
152          * -debug for debugging without filling up the
153          * hard disk.
154          */
155         bool writelog;
156
157         /** If this is true, a PID file will be written
158          * to the file given in the "file" variable of
159          * the \<pid> tag in the config file. This is
160          * the default.
161          * Passing --nopid as a command line argument
162          * sets this to false; in this case, a PID file
163          * will not be written, even the default PID
164          * file that is usually written when the \<pid>
165          * tag is not defined in the config file.
166          */
167         bool writepid;
168
169         /* Whether the --runasroot option was specified at boot. */
170         bool runasroot;
171
172         /** Saved argc from startup. */
173         int argc;
174
175         /** Saved argv from startup. */
176         char** argv;
177 };
178
179 class CoreExport OperInfo : public refcountbase
180 {
181  public:
182         TokenList AllowedOperCommands;
183         TokenList AllowedPrivs;
184
185         /** Allowed user modes from oper classes. */
186         std::bitset<64> AllowedUserModes;
187
188         /** Allowed channel modes from oper classes. */
189         std::bitset<64> AllowedChanModes;
190
191         /** Allowed snomasks from oper classes. */
192         std::bitset<64> AllowedSnomasks;
193
194         /** \<oper> block used for this oper-up. May be NULL. */
195         reference<ConfigTag> oper_block;
196         /** \<type> block used for this oper-up. Valid for local users, may be NULL on remote */
197         reference<ConfigTag> type_block;
198         /** \<class> blocks referenced from the \<type> block. These define individual permissions */
199         std::vector<reference<ConfigTag> > class_blocks;
200         /** Name of the oper type; i.e. the one shown in WHOIS */
201         std::string name;
202
203         /** Creates a new OperInfo with the specified oper type name.
204          * @param Name The name of the oper type.
205          */
206         OperInfo(const std::string& Name);
207
208         /** Get a configuration item, searching in the oper, type, and class blocks (in that order) */
209         std::string getConfig(const std::string& key);
210         void init();
211 };
212
213 /** This class holds the bulk of the runtime configuration for the ircd.
214  * It allows for reading new config values, accessing configuration files,
215  * and storage of the configuration data needed to run the ircd, such as
216  * the servername, connect classes, /ADMIN data, MOTDs and filenames etc.
217  */
218 class CoreExport ServerConfig
219 {
220   private:
221         void CrossCheckOperClassType();
222         void CrossCheckConnectBlocks(ServerConfig* current);
223
224  public:
225         /** How to treat a user in a channel who is banned. */
226         enum BannedUserTreatment
227         {
228                 /** Don't treat a banned user any different to normal. */
229                 BUT_NORMAL,
230
231                 /** Restrict the actions of a banned user. */
232                 BUT_RESTRICT_SILENT,
233
234                 /** Restrict the actions of a banned user and notify them of their treatment. */
235                 BUT_RESTRICT_NOTIFY
236         };
237
238         class ServerPaths
239         {
240          public:
241                 /** Config path */
242                 std::string Config;
243
244                 /** Data path */
245                 std::string Data;
246
247                 /** Log path */
248                 std::string Log;
249
250                 /** Module path */
251                 std::string Module;
252
253                 /** Runtime path */
254                 std::string Runtime;
255
256                 ServerPaths(ConfigTag* tag);
257
258                 std::string PrependConfig(const std::string& fn) const { return FileSystem::ExpandPath(Config, fn); }
259                 std::string PrependData(const std::string& fn) const { return FileSystem::ExpandPath(Data, fn); }
260                 std::string PrependLog(const std::string& fn) const { return FileSystem::ExpandPath(Log, fn); }
261                 std::string PrependModule(const std::string& fn) const { return FileSystem::ExpandPath(Module, fn); }
262                 std::string PrependRuntime(const std::string& fn) const { return FileSystem::ExpandPath(Runtime, fn); }
263         };
264
265         /** Holds a complete list of all connect blocks
266          */
267         typedef std::vector<reference<ConnectClass> > ClassVector;
268
269         /** Index of valid oper blocks and types
270          */
271         typedef insp::flat_map<std::string, reference<OperInfo> > OperIndex;
272
273         /** Get a configuration tag by name. If one or more tags are present then the first is returned.
274          * @param tag The name of the tag to get.
275          * @returns Either a tag from the config or EmptyTag.
276          */
277         ConfigTag* ConfValue(const std::string& tag);
278
279         /** Get a list of configuration tags by name.
280          * @param tag The name of the tags to get.
281          * @returns Either a list of tags from the config or an empty ConfigTagList.
282          */
283         ConfigTagList ConfTags(const std::string& tag);
284
285         /** An empty configuration tag. */
286         ConfigTag* EmptyTag;
287
288         /** Error stream, contains error output from any failed configuration parsing.
289          */
290         std::stringstream errstr;
291
292         /** True if this configuration is valid enough to run with */
293         bool valid;
294
295         /** Bind to IPv6 by default */
296         bool WildcardIPv6;
297
298         /** This holds all the information in the config file,
299          * it's indexed by tag name to a vector of key/values.
300          */
301         ConfigDataHash config_data;
302
303         /** This holds all extra files that have been read in the configuration
304          * (for example, MOTD and RULES files are stored here)
305          */
306         ConfigFileCache Files;
307
308         /** Length limits, see definition of ServerLimits class
309          */
310         ServerLimits Limits;
311
312         /** Locations of various types of file (config, module, etc). */
313         ServerPaths Paths;
314
315         /** Configuration parsed from the command line.
316          */
317         CommandLineConf cmdline;
318
319         /** Clones CIDR range for ipv4 (0-32)
320          * Defaults to 32 (checks clones on all IPs separately)
321          */
322         unsigned char c_ipv4_range;
323
324         /** Clones CIDR range for ipv6 (0-128)
325          * Defaults to 128 (checks on all IPs separately)
326          */
327         unsigned char c_ipv6_range;
328
329         /** Holds the server name of the local server
330          * as defined by the administrator.
331          */
332         std::string ServerName;
333
334         /** Notice to give to users when they are banned by an XLine
335          */
336         std::string XLineMessage;
337
338         /* Holds the network name the local server
339          * belongs to. This is an arbitrary field defined
340          * by the administrator.
341          */
342         std::string Network;
343
344         /** Holds the description of the local server
345          * as defined by the administrator.
346          */
347         std::string ServerDesc;
348
349         /** How to treat a user in a channel who is banned. */
350         BannedUserTreatment RestrictBannedUsers;
351
352         /** The size of the read() buffer in the user
353          * handling code, used to read data into a user's
354          * recvQ.
355          */
356         int NetBufferSize;
357
358         /** The value to be used for listen() backlogs
359          * as default.
360          */
361         int MaxConn;
362
363         /** If we should check for clones during CheckClass() in AddUser()
364          * Setting this to false allows to not trigger on maxclones for users
365          * that may belong to another class after DNS-lookup is complete.
366          * It does, however, make the server spend more time on users we may potentially not want.
367          */
368         bool CCOnConnect;
369
370         /** The soft limit value assigned to the irc server.
371          * The IRC server will not allow more than this
372          * number of local users.
373          */
374         unsigned int SoftLimit;
375
376         /** Maximum number of targets for a multi target command
377          * such as PRIVMSG or KICK
378          */
379         unsigned int MaxTargets;
380
381         /** The number of seconds that the server clock can skip by before server operators are warned. */
382         time_t TimeSkipWarn;
383
384         /** True if we're going to hide ban reasons for non-opers (e.g. G-lines,
385          * K-lines, Z-lines)
386          */
387         bool HideBans;
388
389         /** True if raw I/O is being logged */
390         bool RawLog;
391
392         /** Set to a non-empty string to obfuscate server names. */
393         std::string HideServer;
394
395         /** The full pathname and filename of the PID
396          * file as defined in the configuration.
397          */
398         std::string PID;
399
400         /** The connect classes in use by the IRC server.
401          */
402         ClassVector Classes;
403
404         /** Default channel modes
405          */
406         std::string DefaultModes;
407
408         /** Custom version string, which if defined can replace the system info in VERSION.
409          */
410         std::string CustomVersion;
411
412         /** If set to true, provide syntax hints for unknown commands
413          */
414         bool SyntaxHints;
415
416         /** The name of the casemapping method used by this server.
417          */
418         std::string CaseMapping;
419
420         /** If set to true, the full nick!user\@host will be shown in the TOPIC command
421          * for who set the topic last. If false, only the nick is shown.
422          */
423         bool FullHostInTopic;
424
425         /** Oper blocks keyed by their name
426          */
427         OperIndex oper_blocks;
428
429         /** Oper types keyed by their name
430          */
431         OperIndex OperTypes;
432
433         /** Default value for <connect:maxchans>, deprecated in 3.0
434          */
435         unsigned int MaxChans;
436
437         /** Default value for <oper:maxchans>, deprecated in 3.0
438          */
439         unsigned int OperMaxChans;
440
441         /** TS6-like server ID.
442          * NOTE: 000...999 are usable for InspIRCd servers. This
443          * makes code simpler. 0AA, 1BB etc with letters are reserved
444          * for services use.
445          */
446         std::string sid;
447
448         /** Construct a new ServerConfig
449          */
450         ServerConfig();
451
452         ~ServerConfig();
453
454         /** Get server ID as string with required leading zeroes
455          */
456         const std::string& GetSID() const { return sid; }
457
458         /** Retrieves the server name which should be shown to users. */
459         const std::string& GetServerName() const { return HideServer.empty() ? ServerName : HideServer; }
460
461         /** Retrieves the server description which should be shown to users. */
462         const std::string& GetServerDesc() const { return HideServer.empty() ? ServerDesc : HideServer; }
463
464         /** Read the entire configuration into memory
465          * and initialize this class. All other methods
466          * should be used only by the core.
467          */
468         void Read();
469
470         /** Apply configuration changes from the old configuration.
471          */
472         void Apply(ServerConfig* old, const std::string &useruid);
473         void ApplyModules(User* user);
474
475         void Fill();
476
477         /** Escapes a value for storage in a configuration key.
478          * @param str The string to escape.
479          * @param xml Are we using the XML config format?
480          */
481         static std::string Escape(const std::string& str, bool xml = true);
482
483         /** If this value is true, snotices will not stack when repeats are sent
484          */
485         bool NoSnoticeStack;
486 };
487
488 /** The background thread for config reading, so that reading from executable includes
489  * does not block.
490  */
491 class CoreExport ConfigReaderThread : public Thread
492 {
493         ServerConfig* Config;
494         volatile bool done;
495  public:
496         const std::string TheUserUID;
497         ConfigReaderThread(const std::string &useruid)
498                 : Config(new ServerConfig), done(false), TheUserUID(useruid)
499         {
500         }
501
502         virtual ~ConfigReaderThread()
503         {
504                 delete Config;
505         }
506
507         void Run() CXX11_OVERRIDE;
508         /** Run in the main thread to apply the configuration */
509         void Finish();
510         bool IsDone() { return done; }
511 };
512
513 /** Represents the status of a config load. */
514 class CoreExport ConfigStatus
515 {
516  public:
517         /** Whether this is the initial config load. */
518         bool const initial;
519
520         /** The user who initiated the config load or NULL if not initiated by a user. */
521         User* const srcuser;
522
523         /** Initializes a new instance of the ConfigStatus class.
524          * @param user The user who initiated the config load or NULL if not initiated by a user.
525          * @param isinitial Whether this is the initial config load.
526          */
527         ConfigStatus(User* user = NULL, bool isinitial = false)
528                 : initial(isinitial)
529                 , srcuser(user)
530         {
531         }
532 };