]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - include/modules.h
Move OnSync{Channel,Network,User} to ServerEventListener.
[user/henk/code/inspircd.git] / include / modules.h
1 /*
2  * InspIRCd -- Internet Relay Chat Daemon
3  *
4  *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
5  *   Copyright (C) 2006-2007, 2009 Dennis Friis <peavey@inspircd.org>
6  *   Copyright (C) 2003-2008 Craig Edwards <craigedwards@brainbox.cc>
7  *   Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
8  *   Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net>
9  *   Copyright (C) 2006-2007 Oliver Lupton <oliverlupton@gmail.com>
10  *   Copyright (C) 2003 randomdan <???@???>
11  *
12  * This file is part of InspIRCd.  InspIRCd is free software: you can
13  * redistribute it and/or modify it under the terms of the GNU General Public
14  * License as published by the Free Software Foundation, version 2.
15  *
16  * This program is distributed in the hope that it will be useful, but WITHOUT
17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
19  * details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
23  */
24
25
26 #pragma once
27
28 #include "dynamic.h"
29 #include "base.h"
30 #include "ctables.h"
31 #include "inspsocket.h"
32 #include <string>
33 #include <deque>
34 #include <sstream>
35 #include "timer.h"
36 #include "mode.h"
37
38 /** Used to specify the behaviour of a module. */
39 enum ModuleFlags
40 {
41         /** The module has no special attributes. */
42         VF_NONE = 0,
43
44         /** The module is a coremod and can be assumed to be loaded on all servers. */
45         VF_CORE = 1,
46
47         /* The module is included with InspIRCd. */
48         VF_VENDOR = 2,
49
50         /** The module MUST be loaded on all servers on a network to link. */
51         VF_COMMON = 4,
52
53         /** The module SHOULD be loaded on all servers on a network for consistency. */
54         VF_OPTCOMMON = 8
55 };
56
57 /** Used to represent an event type, for user, channel or server
58  */
59 enum TargetTypeFlags {
60         TYPE_USER = 1,
61         TYPE_CHANNEL,
62         TYPE_SERVER,
63         TYPE_OTHER
64 };
65
66 /** Used to represent wether a message was PRIVMSG or NOTICE
67  */
68 enum MessageType {
69         MSG_PRIVMSG = 0,
70         MSG_NOTICE = 1
71 };
72
73 #define MOD_RES_ALLOW (ModResult(1))
74 #define MOD_RES_PASSTHRU (ModResult(0))
75 #define MOD_RES_DENY (ModResult(-1))
76
77 /** Used to represent an allow/deny module result.
78  * Not constructed as an enum because it reverses the value logic of some functions;
79  * the compiler will inline accesses to have the same efficiency as integer operations.
80  */
81 struct ModResult {
82         int res;
83         ModResult() : res(0) {}
84         explicit ModResult(int r) : res(r) {}
85         inline bool operator==(const ModResult& r) const
86         {
87                 return res == r.res;
88         }
89         inline bool operator!=(const ModResult& r) const
90         {
91                 return res != r.res;
92         }
93         inline bool operator!() const
94         {
95                 return !res;
96         }
97         inline bool check(bool def) const
98         {
99                 return (res == 1 || (res == 0 && def));
100         }
101         /**
102          * Merges two results, preferring ALLOW to DENY
103          */
104         inline ModResult operator+(const ModResult& r) const
105         {
106                 if (res == r.res || r.res == 0)
107                         return *this;
108                 if (res == 0)
109                         return r;
110                 // they are different, and neither is passthru
111                 return MOD_RES_ALLOW;
112         }
113 };
114
115 /** InspIRCd major version.
116  * 1.2 -> 102; 2.1 -> 201; 2.12 -> 212
117  */
118 #define INSPIRCD_VERSION_MAJ 202
119 /** InspIRCd API version.
120  * If you change any API elements, increment this value. This counter should be
121  * reset whenever the major version is changed. Modules can use these two values
122  * and numerical comparisons in preprocessor macros if they wish to support
123  * multiple versions of InspIRCd in one file.
124  */
125 #define INSPIRCD_VERSION_API 1
126
127 /**
128  * This #define allows us to call a method in all
129  * loaded modules in a readable simple way, e.g.:
130  * 'FOREACH_MOD(OnConnect,(user));'
131  */
132 #define FOREACH_MOD(y,x) do { \
133         const IntModuleList& _handlers = ServerInstance->Modules->EventHandlers[I_ ## y]; \
134         for (IntModuleList::const_reverse_iterator _i = _handlers.rbegin(), _next; _i != _handlers.rend(); _i = _next) \
135         { \
136                 _next = _i+1; \
137                 try \
138                 { \
139                         (*_i)->y x ; \
140                 } \
141                 catch (CoreException& modexcept) \
142                 { \
143                         ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: " + modexcept.GetReason()); \
144                 } \
145         } \
146 } while (0);
147
148 /**
149  * Custom module result handling loop. This is a paired macro, and should only
150  * be used with while_each_hook.
151  *
152  * See src/channels.cpp for an example of use.
153  */
154 #define DO_EACH_HOOK(n,v,args) \
155 do { \
156         const IntModuleList& _handlers = ServerInstance->Modules->EventHandlers[I_ ## n]; \
157         for (IntModuleList::const_reverse_iterator _i = _handlers.rbegin(), _next; _i != _handlers.rend(); _i = _next) \
158         { \
159                 _next = _i+1; \
160                 try \
161                 { \
162                         v = (*_i)->n args;
163
164 #define WHILE_EACH_HOOK(n) \
165                 } \
166                 catch (CoreException& except_ ## n) \
167                 { \
168                         ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: " + (except_ ## n).GetReason()); \
169                 } \
170         } \
171 } while(0)
172
173 /**
174  * Module result iterator
175  * Runs the given hook until some module returns a useful result.
176  *
177  * Example: ModResult result;
178  * FIRST_MOD_RESULT(OnUserPreNick, result, (user, newnick))
179  */
180 #define FIRST_MOD_RESULT(n,v,args) do { \
181         v = MOD_RES_PASSTHRU; \
182         DO_EACH_HOOK(n,v,args) \
183         { \
184                 if (v != MOD_RES_PASSTHRU) \
185                         break; \
186         } \
187         WHILE_EACH_HOOK(n); \
188 } while (0)
189
190 /** Holds a module's Version information.
191  * The members (set by the constructor only) indicate details as to the version number
192  * of a module. A class of type Version is returned by the GetVersion method of the Module class.
193  */
194 class CoreExport Version
195 {
196  public:
197         /** Module description
198          */
199         const std::string description;
200
201         /** Flags
202          */
203         const int Flags;
204
205         /** Server linking description string */
206         const std::string link_data;
207
208         /** Simple module version */
209         Version(const std::string &desc, int flags = VF_NONE);
210
211         /** Complex version information, including linking compatability data */
212         Version(const std::string &desc, int flags, const std::string& linkdata);
213 };
214
215 class CoreExport DataProvider : public ServiceProvider
216 {
217  public:
218         DataProvider(Module* Creator, const std::string& Name)
219                 : ServiceProvider(Creator, Name, SERVICE_DATA) {}
220 };
221
222 /** Priority types which can be used by Module::Prioritize()
223  */
224 enum Priority { PRIORITY_FIRST, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };
225
226 /** Implementation-specific flags which may be set in Module::Implements()
227  */
228 enum Implementation
229 {
230         I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart,
231         I_OnSendSnotice, I_OnUserPreJoin, I_OnUserPreKick, I_OnUserKick, I_OnOper, I_OnInfo,
232         I_OnUserPreInvite, I_OnUserInvite, I_OnUserPreMessage, I_OnUserPreNick,
233         I_OnUserMessage, I_OnMode,
234         I_OnDecodeMetaData, I_OnAcceptConnection, I_OnUserInit,
235         I_OnChangeHost, I_OnChangeName, I_OnAddLine, I_OnDelLine, I_OnExpireLine,
236         I_OnUserPostNick, I_OnPreMode, I_On005Numeric, I_OnKill, I_OnLoadModule,
237         I_OnUnloadModule, I_OnBackgroundTimer, I_OnPreCommand, I_OnCheckReady, I_OnCheckInvite,
238         I_OnRawMode, I_OnCheckKey, I_OnCheckLimit, I_OnCheckBan, I_OnCheckChannelBan, I_OnExtBanCheck,
239         I_OnStats, I_OnChangeLocalUserHost, I_OnPreTopicChange,
240         I_OnPostTopicChange, I_OnPostConnect,
241         I_OnChangeLocalUserGECOS, I_OnUserRegister, I_OnChannelPreDelete, I_OnChannelDelete,
242         I_OnPostOper, I_OnSetAway, I_OnPostCommand, I_OnPostJoin,
243         I_OnBuildNeighborList, I_OnGarbageCollect, I_OnSetConnectClass,
244         I_OnText, I_OnPassCompare, I_OnNamesListItem, I_OnNumeric,
245         I_OnPreRehash, I_OnModuleRehash, I_OnSendWhoLine, I_OnChangeIdent, I_OnSetUserIP,
246         I_OnServiceAdd, I_OnServiceDel,
247         I_END
248 };
249
250 /** Base class for all InspIRCd modules
251  *  This class is the base class for InspIRCd modules. All modules must inherit from this class,
252  *  its methods will be called when irc server events occur. class inherited from module must be
253  *  instantiated by the ModuleFactory class (see relevent section) for the module to be initialised.
254  */
255 class CoreExport Module : public classbase, public usecountbase
256 {
257         /** Detach an event from this module
258          * @param i Event type to detach
259          */
260         void DetachEvent(Implementation i);
261
262  public:
263         /** File that this module was loaded from
264          */
265         std::string ModuleSourceFile;
266         /** Reference to the dlopen() value
267          */
268         DLLManager* ModuleDLLManager;
269
270         /** If true, this module will be unloaded soon, further unload attempts will fail
271          * Value is used by the ModuleManager internally, you should not modify it
272          */
273         bool dying;
274
275         /** Default constructor.
276          * Creates a module class. Don't do any type of hook registration or checks
277          * for other modules here; do that in init().
278          */
279         Module();
280
281         /** Module setup
282          * \exception ModuleException Throwing this class, or any class derived from ModuleException, causes loading of the module to abort.
283          */
284         virtual void init() {}
285
286         /** Clean up prior to destruction
287          * If you override, you must call this AFTER your module's cleanup
288          */
289         CullResult cull() CXX11_OVERRIDE;
290
291         /** Default destructor.
292          * destroys a module class
293          */
294         virtual ~Module();
295
296         virtual void Prioritize()
297         {
298         }
299
300         /** This method is called when you should reload module specific configuration:
301          * on boot, on a /REHASH and on module load.
302          * @param status The current status, can be inspected for more information;
303          * also used for reporting configuration errors and warnings.
304          */
305         virtual void ReadConfig(ConfigStatus& status);
306
307         /** Returns the version number of a Module.
308          * The method should return a Version object with its version information assigned via
309          * Version::Version
310          */
311         virtual Version GetVersion() = 0;
312
313         /** Called when a user connects.
314          * The details of the connecting user are available to you in the parameter User *user
315          * @param user The user who is connecting
316          */
317         virtual void OnUserConnect(LocalUser* user);
318
319         /** Called when a user quits.
320          * The details of the exiting user are available to you in the parameter User *user
321          * This event is only called when the user is fully registered when they quit. To catch
322          * raw disconnections, use the OnUserDisconnect method.
323          * @param user The user who is quitting
324          * @param message The user's quit message (as seen by non-opers)
325          * @param oper_message The user's quit message (as seen by opers)
326          */
327         virtual void OnUserQuit(User* user, const std::string &message, const std::string &oper_message);
328
329         /** Called whenever a user's socket is closed.
330          * The details of the exiting user are available to you in the parameter User *user
331          * This event is called for all users, registered or not, as a cleanup method for modules
332          * which might assign resources to user, such as dns lookups, objects and sockets.
333          * @param user The user who is disconnecting
334          */
335         virtual void OnUserDisconnect(LocalUser* user);
336
337         /** Called whenever a channel is about to be deleted
338          * @param chan The channel being deleted
339          * @return An integer specifying whether or not the channel may be deleted. 0 for yes, 1 for no.
340          */
341         virtual ModResult OnChannelPreDelete(Channel *chan);
342
343         /** Called whenever a channel is deleted, either by QUIT, KICK or PART.
344          * @param chan The channel being deleted
345          */
346         virtual void OnChannelDelete(Channel* chan);
347
348         /** Called when a user joins a channel.
349          * The details of the joining user are available to you in the parameter User *user,
350          * and the details of the channel they have joined is available in the variable Channel *channel
351          * @param memb The channel membership being created
352          * @param sync This is set to true if the JOIN is the result of a network sync and the remote user is being introduced
353          * to a channel due to the network sync.
354          * @param created This is true if the join created the channel
355          * @param except_list A list of users not to send to.
356          */
357         virtual void OnUserJoin(Membership* memb, bool sync, bool created, CUList& except_list);
358
359         /** Called after a user joins a channel
360          * Identical to OnUserJoin, but called immediately afterwards, when any linking module has
361          * seen the join.
362          * @param memb The channel membership created
363          */
364         virtual void OnPostJoin(Membership* memb);
365
366         /** Called when a user parts a channel.
367          * The details of the leaving user are available to you in the parameter User *user,
368          * and the details of the channel they have left is available in the variable Channel *channel
369          * @param memb The channel membership being destroyed
370          * @param partmessage The part message, or an empty string (may be modified)
371          * @param except_list A list of users to not send to.
372          */
373         virtual void OnUserPart(Membership* memb, std::string &partmessage, CUList& except_list);
374
375         /** Called on rehash.
376          * This method is called prior to a /REHASH or when a SIGHUP is received from the operating
377          * system. This is called in all cases -- including when this server will not execute the
378          * rehash because it is directed at a remote server.
379          *
380          * @param user The user performing the rehash, if any. If this is server initiated, the value of
381          * this variable will be NULL.
382          * @param parameter The (optional) parameter given to REHASH from the user. Empty when server
383          * initiated.
384          */
385         virtual void OnPreRehash(User* user, const std::string &parameter);
386
387         /** Called on rehash.
388          * This method is called when a user initiates a module-specific rehash. This can be used to do
389          * expensive operations (such as reloading SSL certificates) that are not executed on a normal
390          * rehash for efficiency. A rehash of this type does not reload the core configuration.
391          *
392          * @param user The user performing the rehash.
393          * @param parameter The parameter given to REHASH
394          */
395         virtual void OnModuleRehash(User* user, const std::string &parameter);
396
397         /** Called whenever a snotice is about to be sent to a snomask.
398          * snomask and type may both be modified; the message may not.
399          * @param snomask The snomask the message is going to (e.g. 'A')
400          * @param type The textual description the snomask will go to (e.g. 'OPER')
401          * @param message The text message to be sent via snotice
402          * @return 1 to block the snotice from being sent entirely, 0 else.
403          */
404         virtual ModResult OnSendSnotice(char &snomask, std::string &type, const std::string &message);
405
406         /** Called whenever a user is about to join a channel, before any processing is done.
407          * Returning a value of 1 from this function stops the process immediately, causing no
408          * output to be sent to the user by the core. If you do this you must produce your own numerics,
409          * notices etc. This is useful for modules which may want to mimic +b, +k, +l etc. Returning -1 from
410          * this function forces the join to be allowed, bypassing restrictions such as banlists, invite, keys etc.
411          *
412          * IMPORTANT NOTE!
413          *
414          * If the user joins a NEW channel which does not exist yet, OnUserPreJoin will be called BEFORE the channel
415          * record is created. This will cause Channel* chan to be NULL. There is very little you can do in form of
416          * processing on the actual channel record at this point, however the channel NAME will still be passed in
417          * char* cname, so that you could for example implement a channel blacklist or whitelist, etc.
418          * @param user The user joining the channel
419          * @param chan If the  channel is a new channel, this will be NULL, otherwise it will be a pointer to the channel being joined
420          * @param cname The channel name being joined. For new channels this is valid where chan is not.
421          * @param privs A string containing the users privilages when joining the channel. For new channels this will contain "o".
422          * You may alter this string to alter the user's modes on the channel.
423          * @param keygiven The key given to join the channel, or an empty string if none was provided
424          * @return 1 To prevent the join, 0 to allow it.
425          */
426         virtual ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven);
427
428         /** Called whenever a user is about to be kicked.
429          * Returning a value of 1 from this function stops the process immediately, causing no
430          * output to be sent to the user by the core. If you do this you must produce your own numerics,
431          * notices etc.
432          * @param source The user issuing the kick
433          * @param memb The channel membership of the user who is being kicked.
434          * @param reason The kick reason
435          * @return 1 to prevent the kick, 0 to continue normally, -1 to explicitly allow the kick regardless of normal operation
436          */
437         virtual ModResult OnUserPreKick(User* source, Membership* memb, const std::string &reason);
438
439         /** Called whenever a user is kicked.
440          * If this method is called, the kick is already underway and cannot be prevented, so
441          * to prevent a kick, please use Module::OnUserPreKick instead of this method.
442          * @param source The user issuing the kick
443          * @param memb The channel membership of the user who was kicked.
444          * @param reason The kick reason
445          * @param except_list A list of users to not send to.
446          */
447         virtual void OnUserKick(User* source, Membership* memb, const std::string &reason, CUList& except_list);
448
449         /** Called whenever a user opers locally.
450          * The User will contain the oper mode 'o' as this function is called after any modifications
451          * are made to the user's structure by the core.
452          * @param user The user who is opering up
453          * @param opertype The opers type name
454          */
455         virtual void OnOper(User* user, const std::string &opertype);
456
457         /** Called after a user opers locally.
458          * This is identical to Module::OnOper(), except it is called after OnOper so that other modules
459          * can be gauranteed to already have processed the oper-up, for example m_spanningtree has sent
460          * out the OPERTYPE, etc.
461          * @param user The user who is opering up
462          * @param opername The name of the oper that the user is opering up to. Only valid locally. Empty string otherwise.
463          * @param opertype The opers type name
464          */
465         virtual void OnPostOper(User* user, const std::string &opername, const std::string &opertype);
466
467         /** Called whenever a user types /INFO.
468          * The User will contain the information of the user who typed the command. Modules may use this
469          * method to output their own credits in /INFO (which is the ircd's version of an about box).
470          * It is purposefully not possible to modify any info that has already been output, or halt the list.
471          * You must write a 371 numeric to the user, containing your info in the following format:
472          *
473          * &lt;nick&gt; :information here
474          *
475          * @param user The user issuing /INFO
476          */
477         virtual void OnInfo(User* user);
478
479         /** Called whenever a user is about to invite another user into a channel, before any processing is done.
480          * Returning 1 from this function stops the process immediately, causing no
481          * output to be sent to the user by the core. If you do this you must produce your own numerics,
482          * notices etc. This is useful for modules which may want to filter invites to channels.
483          * @param source The user who is issuing the INVITE
484          * @param dest The user being invited
485          * @param channel The channel the user is being invited to
486          * @param timeout The time the invite will expire (0 == never)
487          * @return 1 to deny the invite, 0 to check whether or not the user has permission to invite, -1 to explicitly allow the invite
488          */
489         virtual ModResult OnUserPreInvite(User* source,User* dest,Channel* channel, time_t timeout);
490
491         /** Called after a user has been successfully invited to a channel.
492          * You cannot prevent the invite from occuring using this function, to do that,
493          * use OnUserPreInvite instead.
494          * @param source The user who is issuing the INVITE
495          * @param dest The user being invited
496          * @param channel The channel the user is being invited to
497          * @param timeout The time the invite will expire (0 == never)
498          * @param notifyrank Rank required to get an invite announcement (if enabled)
499          * @param notifyexcepts List of users to not send the default NOTICE invite announcement to
500          */
501         virtual void OnUserInvite(User* source, User* dest, Channel* channel, time_t timeout, unsigned int notifyrank, CUList& notifyexcepts);
502
503         /** Called whenever a user is about to PRIVMSG A user or a channel, before any processing is done.
504          * Returning any nonzero value from this function stops the process immediately, causing no
505          * output to be sent to the user by the core. If you do this you must produce your own numerics,
506          * notices etc. This is useful for modules which may want to filter or redirect messages.
507          * target_type can be one of TYPE_USER or TYPE_CHANNEL. If the target_type value is a user,
508          * you must cast dest to a User* otherwise you must cast it to a Channel*, this is the details
509          * of where the message is destined to be sent.
510          * @param user The user sending the message
511          * @param dest The target of the message (Channel* or User*)
512          * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
513          * @param text Changeable text being sent by the user
514          * @param status The status being used, e.g. PRIVMSG @#chan has status== '@', 0 to send to everyone.
515          * @param exempt_list A list of users not to send to. For channel messages, this will usually contain just the sender.
516          * It will be ignored for private messages.
517          * @param msgtype The message type, MSG_PRIVMSG for PRIVMSGs, MSG_NOTICE for NOTICEs
518          * @return 1 to deny the message, 0 to allow it
519          */
520         virtual ModResult OnUserPreMessage(User* user,void* dest,int target_type, std::string &text,char status, CUList &exempt_list, MessageType msgtype);
521
522         /** Called when sending a message to all "neighbors" of a given user -
523          * that is, all users that share a common channel. This is used in
524          * commands such as NICK, QUIT, etc.
525          * @param source The source of the message
526          * @param include_c Channels to scan for users to include
527          * @param exceptions Map of user->bool that overrides the inclusion decision
528          *
529          * Set exceptions[user] = true to include, exceptions[user] = false to exclude
530          */
531         virtual void OnBuildNeighborList(User* source, IncludeChanList& include_c, std::map<User*, bool>& exceptions);
532
533         /** Called before local nickname changes. This can be used to implement Q-lines etc.
534          * If your method returns nonzero, the nickchange is silently forbidden, and it is down to your
535          * module to generate some meaninful output.
536          * @param user The username changing their nick
537          * @param newnick Their new nickname
538          * @return 1 to deny the change, 0 to allow
539          */
540         virtual ModResult OnUserPreNick(LocalUser* user, const std::string& newnick);
541
542         /** Called after any PRIVMSG sent from a user.
543          * The dest variable contains a User* if target_type is TYPE_USER and a Channel*
544          * if target_type is TYPE_CHANNEL.
545          * @param user The user sending the message
546          * @param dest The target of the message
547          * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
548          * @param text the text being sent by the user
549          * @param status The status being used, e.g. PRIVMSG @#chan has status== '@', 0 to send to everyone.
550          * @param exempt_list A list of users to not send to.
551          * @param msgtype The message type, MSG_PRIVMSG for PRIVMSGs, MSG_NOTICE for NOTICEs
552          */
553         virtual void OnUserMessage(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list, MessageType msgtype);
554
555         /** Called immediately before any NOTICE or PRIVMSG sent from a user, local or remote.
556          * The dest variable contains a User* if target_type is TYPE_USER and a Channel*
557          * if target_type is TYPE_CHANNEL.
558          * The difference between this event and OnUserPreMessage is that delivery is gauranteed,
559          * the message has already been vetted. In the case of the other two methods, a later module may stop your
560          * message. This also differs from OnUserMessage which occurs AFTER the message has been sent.
561          * @param user The user sending the message
562          * @param dest The target of the message
563          * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
564          * @param text the text being sent by the user
565          * @param status The status being used, e.g. NOTICE @#chan has status== '@', 0 to send to everyone.
566          * @param exempt_list A list of users not to send to. For channel messages, this will usually contain just the sender.
567          */
568         virtual void OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list);
569
570         /** Called after every MODE command sent from a user
571          * Either the usertarget or the chantarget variable contains the target of the modes,
572          * the actual target will have a non-NULL pointer.
573          * All changed modes are available in the changelist object.
574          * @param user The user sending the MODEs
575          * @param usertarget The target user of the modes, NULL if the target is a channel
576          * @param chantarget The target channel of the modes, NULL if the target is a user
577          * @param changelist The changed modes.
578          * @param processflags Flags passed to ModeParser::Process(), see ModeParser::ModeProcessFlags
579          * for the possible flags.
580          * @param output_mode Changed modes, including '+' and '-' characters, not including any parameters
581          */
582         virtual void OnMode(User* user, User* usertarget, Channel* chantarget, const Modes::ChangeList& changelist, ModeParser::ModeProcessFlag processflags, const std::string& output_mode);
583
584         /** Allows module data, sent via ProtoSendMetaData, to be decoded again by a receiving module.
585          * Please see src/modules/m_swhois.cpp for a working example of how to use this method call.
586          * @param target The Channel* or User* that data should be added to
587          * @param extname The extension name which is being sent
588          * @param extdata The extension data, encoded at the other end by an identical module
589          */
590         virtual void OnDecodeMetaData(Extensible* target, const std::string &extname, const std::string &extdata);
591
592         /** Called whenever a user's hostname is changed.
593          * This event triggers after the host has been set.
594          * @param user The user whos host is being changed
595          * @param newhost The new hostname being set
596          */
597         virtual void OnChangeHost(User* user, const std::string &newhost);
598
599         /** Called whenever a user's GECOS (realname) is changed.
600          * This event triggers after the name has been set.
601          * @param user The user who's GECOS is being changed
602          * @param gecos The new GECOS being set on the user
603          */
604         virtual void OnChangeName(User* user, const std::string &gecos);
605
606         /** Called whenever a user's IDENT is changed.
607          * This event triggers after the name has been set.
608          * @param user The user who's IDENT is being changed
609          * @param ident The new IDENT being set on the user
610          */
611         virtual void OnChangeIdent(User* user, const std::string &ident);
612
613         /** Called whenever an xline is added by a local user.
614          * This method is triggered after the line is added.
615          * @param source The sender of the line or NULL for local server
616          * @param line The xline being added
617          */
618         virtual void OnAddLine(User* source, XLine* line);
619
620         /** Called whenever an xline is deleted MANUALLY. See OnExpireLine for expiry.
621          * This method is triggered after the line is deleted.
622          * @param source The user removing the line or NULL for local server
623          * @param line the line being deleted
624          */
625         virtual void OnDelLine(User* source, XLine* line);
626
627         /** Called whenever an xline expires.
628          * This method is triggered after the line is deleted.
629          * @param line The line being deleted.
630          */
631         virtual void OnExpireLine(XLine *line);
632
633         /** Called before the module is unloaded to clean up extensibles.
634          * This method is called once for every channel, membership, and user.
635          * so that you can clear up any data relating to the specified extensible.
636          * @param type The type of extensible being cleaned up. If this is EXT_CHANNEL
637          *             then item is a Channel*, EXT_MEMBERSHIP then item is a Membership*,
638          *             and EXT_USER then item is a User*.
639          * @param item A pointer to the extensible which is being cleaned up.
640          */
641         virtual void OnCleanup(ExtensionItem::ExtensibleType type, Extensible* item);
642
643         /** Called after any nickchange, local or remote. This can be used to track users after nickchanges
644          * have been applied. Please note that although you can see remote nickchanges through this function, you should
645          * NOT make any changes to the User if the user is a remote user as this may cause a desnyc.
646          * check user->server before taking any action (including returning nonzero from the method).
647          * Because this method is called after the nickchange is taken place, no return values are possible
648          * to indicate forbidding of the nick change. Use OnUserPreNick for this.
649          * @param user The user changing their nick
650          * @param oldnick The old nickname of the user before the nickchange
651          */
652         virtual void OnUserPostNick(User* user, const std::string &oldnick);
653
654         /** Called before a mode change via the MODE command, to allow a single access check for
655          * a full mode change (use OnRawMode to check individual modes)
656          *
657          * Returning MOD_RES_ALLOW will skip prefix level checks, but can be overridden by
658          * OnRawMode for each individual mode
659          *
660          * @param source the user making the mode change
661          * @param dest the user destination of the umode change (NULL if a channel mode)
662          * @param channel the channel destination of the mode change
663          * @param modes Modes being changed, can be edited
664          */
665         virtual ModResult OnPreMode(User* source, User* dest, Channel* channel, Modes::ChangeList& modes);
666
667         /** Called when a 005 numeric is about to be output.
668          * The module should modify the 005 numeric if needed to indicate its features.
669         * @param tokens The 005 map to be modified if neccessary.
670         */
671         virtual void On005Numeric(std::map<std::string, std::string>& tokens);
672
673         /** Called when a client is disconnected by KILL.
674          * If a client is killed by a server, e.g. a nickname collision or protocol error,
675          * source is NULL.
676          * Return 1 from this function to prevent the kill, and 0 from this function to allow
677          * it as normal. If you prevent the kill no output will be sent to the client, it is
678          * down to your module to generate this information.
679          * NOTE: It is NOT advisable to stop kills which originate from servers or remote users.
680          * If you do so youre risking race conditions, desyncs and worse!
681          * @param source The user sending the KILL
682          * @param dest The user being killed
683          * @param reason The kill reason
684          * @return 1 to prevent the kill, 0 to allow
685          */
686         virtual ModResult OnKill(User* source, User* dest, const std::string &reason);
687
688         /** Called whenever a module is loaded.
689          * mod will contain a pointer to the module, and string will contain its name,
690          * for example m_widgets.so. This function is primary for dependency checking,
691          * your module may decide to enable some extra features if it sees that you have
692          * for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly
693          * recommended that modules do *NOT* bail if they cannot satisfy dependencies,
694          * but instead operate under reduced functionality, unless the dependency is
695          * absolutely neccessary (e.g. a module that extends the features of another
696          * module).
697          * @param mod A pointer to the new module
698          */
699         virtual void OnLoadModule(Module* mod);
700
701         /** Called whenever a module is unloaded.
702          * mod will contain a pointer to the module, and string will contain its name,
703          * for example m_widgets.so. This function is primary for dependency checking,
704          * your module may decide to enable some extra features if it sees that you have
705          * for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly
706          * recommended that modules do *NOT* bail if they cannot satisfy dependencies,
707          * but instead operate under reduced functionality, unless the dependency is
708          * absolutely neccessary (e.g. a module that extends the features of another
709          * module).
710          * @param mod Pointer to the module being unloaded (still valid)
711          */
712         virtual void OnUnloadModule(Module* mod);
713
714         /** Called once every five seconds for background processing.
715          * This timer can be used to control timed features. Its period is not accurate
716          * enough to be used as a clock, but it is gauranteed to be called at least once in
717          * any five second period, directly from the main loop of the server.
718          * @param curtime The current timer derived from time(2)
719          */
720         virtual void OnBackgroundTimer(time_t curtime);
721
722         /** Called whenever any command is about to be executed.
723          * This event occurs for all registered commands, wether they are registered in the core,
724          * or another module, and for invalid commands. Invalid commands may only be sent to this
725          * function when the value of validated is false. By returning 1 from this method you may prevent the
726          * command being executed. If you do this, no output is created by the core, and it is
727          * down to your module to produce any output neccessary.
728          * Note that unless you return 1, you should not destroy any structures (e.g. by using
729          * InspIRCd::QuitUser) otherwise when the command's handler function executes after your
730          * method returns, it will be passed an invalid pointer to the user object and crash!)
731          * @param command The command being executed
732          * @param parameters An array of array of characters containing the parameters for the command
733          * @param user the user issuing the command
734          * @param validated True if the command has passed all checks, e.g. it is recognised, has enough parameters, the user has permission to execute it, etc.
735          * You should only change the parameter list and command string if validated == false (e.g. before the command lookup occurs).
736          * @param original_line The entire original line as passed to the parser from the user
737          * @return 1 to block the command, 0 to allow
738          */
739         virtual ModResult OnPreCommand(std::string &command, std::vector<std::string>& parameters, LocalUser *user, bool validated, const std::string &original_line);
740
741         /** Called after any command has been executed.
742          * This event occurs for all registered commands, wether they are registered in the core,
743          * or another module, but it will not occur for invalid commands (e.g. ones which do not
744          * exist within the command table). The result code returned by the command handler is
745          * provided.
746          * @param command The command being executed
747          * @param parameters An array of array of characters containing the parameters for the command
748          * @param user the user issuing the command
749          * @param result The return code given by the command handler, one of CMD_SUCCESS or CMD_FAILURE
750          * @param original_line The entire original line as passed to the parser from the user
751          */
752         virtual void OnPostCommand(Command* command, const std::vector<std::string>& parameters, LocalUser* user, CmdResult result, const std::string& original_line);
753
754         /** Called when a user is first connecting, prior to starting DNS lookups, checking initial
755          * connect class, or accepting any commands.
756          */
757         virtual void OnUserInit(LocalUser* user);
758
759         /** Called to check if a user who is connecting can now be allowed to register
760          * If any modules return false for this function, the user is held in the waiting
761          * state until all modules return true. For example a module which implements ident
762          * lookups will continue to return false for a user until their ident lookup is completed.
763          * Note that the registration timeout for a user overrides these checks, if the registration
764          * timeout is reached, the user is disconnected even if modules report that the user is
765          * not ready to connect.
766          * @param user The user to check
767          * @return true to indicate readiness, false if otherwise
768          */
769         virtual ModResult OnCheckReady(LocalUser* user);
770
771         /** Called whenever a user is about to register their connection (e.g. before the user
772          * is sent the MOTD etc). Modules can use this method if they are performing a function
773          * which must be done before the actual connection is completed (e.g. ident lookups,
774          * dnsbl lookups, etc).
775          * Note that you should NOT delete the user record here by causing a disconnection!
776          * Use OnUserConnect for that instead.
777          * @param user The user registering
778          * @return 1 to indicate user quit, 0 to continue
779          */
780         virtual ModResult OnUserRegister(LocalUser* user);
781
782         /** Called whenever a user joins a channel, to determine if invite checks should go ahead or not.
783          * This method will always be called for each join, wether or not the channel is actually +i, and
784          * determines the outcome of an if statement around the whole section of invite checking code.
785          * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
786          * @param user The user joining the channel
787          * @param chan The channel being joined
788          * @return 1 to explicitly allow the join, 0 to proceed as normal
789          */
790         virtual ModResult OnCheckInvite(User* user, Channel* chan);
791
792         /** Called whenever a mode character is processed.
793          * Return 1 from this function to block the mode character from being processed entirely.
794          * @param user The user who is sending the mode
795          * @param chan The channel the mode is being sent to (or NULL if a usermode)
796          * @param mh The mode handler for the mode being changed
797          * @param param The parameter for the mode or an empty string
798          * @param adding true of the mode is being added, false if it is being removed
799          * @return ACR_DENY to deny the mode, ACR_DEFAULT to do standard mode checking, and ACR_ALLOW
800          * to skip all permission checking. Please note that for remote mode changes, your return value
801          * will be ignored!
802          */
803         virtual ModResult OnRawMode(User* user, Channel* chan, ModeHandler* mh, const std::string& param, bool adding);
804
805         /** Called whenever a user joins a channel, to determine if key checks should go ahead or not.
806          * This method will always be called for each join, wether or not the channel is actually +k, and
807          * determines the outcome of an if statement around the whole section of key checking code.
808          * if the user specified no key, the keygiven string will be a valid but empty value.
809          * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
810          * @param user The user joining the channel
811          * @param chan The channel being joined
812          * @param keygiven The key given on joining the channel.
813          * @return 1 to explicitly allow the join, 0 to proceed as normal
814          */
815         virtual ModResult OnCheckKey(User* user, Channel* chan, const std::string &keygiven);
816
817         /** Called whenever a user joins a channel, to determine if channel limit checks should go ahead or not.
818          * This method will always be called for each join, wether or not the channel is actually +l, and
819          * determines the outcome of an if statement around the whole section of channel limit checking code.
820          * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
821          * @param user The user joining the channel
822          * @param chan The channel being joined
823          * @return 1 to explicitly allow the join, 0 to proceed as normal
824          */
825         virtual ModResult OnCheckLimit(User* user, Channel* chan);
826
827         /**
828          * Checks for a user's ban from the channel
829          * @param user The user to check
830          * @param chan The channel to check in
831          * @return MOD_RES_DENY to mark as banned, MOD_RES_ALLOW to skip the
832          * ban check, or MOD_RES_PASSTHRU to check bans normally
833          */
834         virtual ModResult OnCheckChannelBan(User* user, Channel* chan);
835
836         /**
837          * Checks for a user's match of a single ban
838          * @param user The user to check for match
839          * @param chan The channel on which the match is being checked
840          * @param mask The mask being checked
841          * @return MOD_RES_DENY to mark as banned, MOD_RES_ALLOW to skip the
842          * ban check, or MOD_RES_PASSTHRU to check bans normally
843          */
844         virtual ModResult OnCheckBan(User* user, Channel* chan, const std::string& mask);
845
846         /** Checks for a match on a given extban type
847          * @return MOD_RES_DENY to mark as banned, MOD_RES_ALLOW to skip the
848          * ban check, or MOD_RES_PASSTHRU to check bans normally
849          */
850         virtual ModResult OnExtBanCheck(User* user, Channel* chan, char type);
851
852         /** Called on all /STATS commands
853          * This method is triggered for all /STATS use, including stats symbols handled by the core.
854          * @param stats Context of the /STATS request, contains requesting user, list of answer rows etc.
855          * @return 1 to block the /STATS from being processed by the core, 0 to allow it
856          */
857         virtual ModResult OnStats(Stats::Context& stats);
858
859         /** Called whenever a change of a local users displayed host is attempted.
860          * Return 1 to deny the host change, or 0 to allow it.
861          * @param user The user whos host will be changed
862          * @param newhost The new hostname
863          * @return 1 to deny the host change, 0 to allow
864          */
865         virtual ModResult OnChangeLocalUserHost(LocalUser* user, const std::string &newhost);
866
867         /** Called whenever a change of a local users GECOS (fullname field) is attempted.
868          * return 1 to deny the name change, or 0 to allow it.
869          * @param user The user whos GECOS will be changed
870          * @param newhost The new GECOS
871          * @return 1 to deny the GECOS change, 0 to allow
872          */
873         virtual ModResult OnChangeLocalUserGECOS(LocalUser* user, const std::string &newhost);
874
875         /** Called before a topic is changed.
876          * Return 1 to deny the topic change, 0 to check details on the change, -1 to let it through with no checks
877          * As with other 'pre' events, you should only ever block a local event.
878          * @param user The user changing the topic
879          * @param chan The channels who's topic is being changed
880          * @param topic The actual topic text
881          * @return 1 to block the topic change, 0 to allow
882          */
883         virtual ModResult OnPreTopicChange(User* user, Channel* chan, const std::string &topic);
884
885         /** Called whenever a topic has been changed.
886          * To block topic changes you must use OnPreTopicChange instead.
887          * @param user The user changing the topic
888          * @param chan The channels who's topic is being changed
889          * @param topic The actual topic text
890          */
891         virtual void OnPostTopicChange(User* user, Channel* chan, const std::string &topic);
892
893         /** Called whenever a password check is to be made. Replaces the old OldOperCompare API.
894          * The password field (from the config file) is in 'password' and is to be compared against
895          * 'input'. This method allows for encryption of passwords (oper, connect:allow, die/restart, etc).
896          * You should return a nonzero value to override the normal comparison, or zero to pass it on.
897          * @param ex The object that's causing the authentication (User* for \<oper> \<connect:allow> etc, Server* for \<link>).
898          * @param password The password from the configuration file (the password="" value).
899          * @param input The password entered by the user or whoever.
900          * @param hashtype The hash value from the config
901          * @return 0 to do nothing (pass on to next module/default), 1 == password is OK, -1 == password is not OK
902          */
903         virtual ModResult OnPassCompare(Extensible* ex, const std::string &password, const std::string &input, const std::string& hashtype);
904
905         /** Called after a user has fully connected and all modules have executed OnUserConnect
906          * This event is informational only. You should not change any user information in this
907          * event. To do so, use the OnUserConnect method to change the state of local users.
908          * This is called for both local and remote users.
909          * @param user The user who is connecting
910          */
911         virtual void OnPostConnect(User* user);
912
913         /** Called when a port accepts a connection
914          * Return MOD_RES_ACCEPT if you have used the file descriptor.
915          * @param fd The file descriptor returned from accept()
916          * @param sock The socket connection for the new user
917          * @param client The client IP address and port
918          * @param server The server IP address and port
919          */
920         virtual ModResult OnAcceptConnection(int fd, ListenSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
921
922         /** Called whenever a user sets away or returns from being away.
923          * The away message is available as a parameter, but should not be modified.
924          * At this stage, it has already been copied into the user record.
925          * If awaymsg is empty, the user is returning from away.
926          * @param user The user setting away
927          * @param awaymsg The away message of the user, or empty if returning from away
928          * @return nonzero if the away message should be blocked - should ONLY be nonzero for LOCAL users (IS_LOCAL) (no output is returned by core)
929          */
930         virtual ModResult OnSetAway(User* user, const std::string &awaymsg);
931
932         /** Called at intervals for modules to garbage-collect any hashes etc.
933          * Certain data types such as hash_map 'leak' buckets, which must be
934          * tidied up and freed by copying into a new item every so often. This
935          * method is called when it is time to do that.
936          */
937         virtual void OnGarbageCollect();
938
939         /** Called when a user's connect class is being matched
940          * @return MOD_RES_ALLOW to force the class to match, MOD_RES_DENY to forbid it, or
941          * MOD_RES_PASSTHRU to allow normal matching (by host/port).
942          */
943         virtual ModResult OnSetConnectClass(LocalUser* user, ConnectClass* myclass);
944
945 #ifdef INSPIRCD_ENABLE_TESTSUITE
946         /** Add test suite hooks here. These are used for testing functionality of a module
947          * via the --testsuite debugging parameter.
948          */
949         virtual void OnRunTestSuite();
950 #endif
951
952         /** Called for every item in a NAMES list, so that modules may reformat portions of it as they see fit.
953          * For example NAMESX, channel mode +u and +I, and UHNAMES.
954          * @param issuer The user who is going to receive the NAMES list being built
955          * @param item The channel member being considered for inclusion
956          * @param prefixes The prefix character(s) to display, initially set to the prefix char of the most powerful
957          * prefix mode the member has, can be changed
958          * @param nick The nick to display, initially set to the member's nick, can be changed
959          * @return Return MOD_RES_PASSTHRU to allow the member to be displayed, MOD_RES_DENY to cause them to be
960          * excluded from this NAMES list
961          */
962         virtual ModResult OnNamesListItem(User* issuer, Membership* item, std::string& prefixes, std::string& nick);
963
964         virtual ModResult OnNumeric(User* user, const Numeric::Numeric& numeric);
965
966         /** Called whenever a result from /WHO is about to be returned
967          * @param source The user running the /WHO query
968          * @param params The parameters to the /WHO query
969          * @param user The user that this line of the query is about
970          * @param memb The member shown in this line, NULL if no channel is in this line
971          * @param numeric Numeric to send; modifiable.
972          * @return MOD_RES_PASSTHRU to allow the line to be displayed, MOD_RES_DENY to hide it
973          */
974         virtual ModResult OnSendWhoLine(User* source, const std::vector<std::string>& params, User* user, Membership* memb, Numeric::Numeric& numeric);
975
976         /** Called whenever a local user's IP is set for the first time, or when a local user's IP changes due to
977          * a module like m_cgiirc changing it.
978          * @param user The user whose IP is being set
979          */
980         virtual void OnSetUserIP(LocalUser* user);
981
982         /** Called whenever a ServiceProvider is registered.
983          * @param service ServiceProvider being registered.
984          */
985         virtual void OnServiceAdd(ServiceProvider& service);
986
987         /** Called whenever a ServiceProvider is unregistered.
988          * @param service ServiceProvider being unregistered.
989          */
990         virtual void OnServiceDel(ServiceProvider& service);
991 };
992
993 /** A list of modules
994  */
995 typedef std::vector<Module*> IntModuleList;
996
997 /** ModuleManager takes care of all things module-related
998  * in the core.
999  */
1000 class CoreExport ModuleManager : public fakederef<ModuleManager>
1001 {
1002  public:
1003         typedef std::vector<ServiceProvider*> ServiceList;
1004
1005  private:
1006         /** Holds a string describing the last module error to occur
1007          */
1008         std::string LastModuleError;
1009
1010         /** List of loaded modules and shared object/dll handles
1011          * keyed by module name
1012          */
1013         std::map<std::string, Module*> Modules;
1014
1015         enum {
1016                 PRIO_STATE_FIRST,
1017                 PRIO_STATE_AGAIN,
1018                 PRIO_STATE_LAST
1019         } prioritizationState;
1020
1021         /** Loads all core modules (core_*)
1022          */
1023         void LoadCoreModules(std::map<std::string, ServiceList>& servicemap);
1024
1025         /** Calls the Prioritize() method in all loaded modules
1026          * @return True if all went well, false if a dependency loop was detected
1027          */
1028         bool PrioritizeHooks();
1029
1030         /** Unregister all user modes or all channel modes owned by a module
1031          * @param mod Module whose modes to unregister
1032          * @param modetype MODETYPE_USER to unregister user modes, MODETYPE_CHANNEL to unregister channel modes
1033          */
1034         void UnregisterModes(Module* mod, ModeType modetype);
1035
1036  public:
1037         typedef std::map<std::string, Module*> ModuleMap;
1038
1039         /** Event handler hooks.
1040          * This needs to be public to be used by FOREACH_MOD and friends.
1041          */
1042         IntModuleList EventHandlers[I_END];
1043
1044         /** List of data services keyed by name */
1045         std::multimap<std::string, ServiceProvider*> DataProviders;
1046
1047         /** A list of ServiceProviders waiting to be registered.
1048          * Non-NULL when constructing a Module, NULL otherwise.
1049          * When non-NULL ServiceProviders add themselves to this list on creation and the core
1050          * automatically registers them (that is, call AddService()) after the Module is constructed,
1051          * and before Module::init() is called.
1052          * If a service is created after the construction of the Module (for example in init()) it
1053          * has to be registered manually.
1054          */
1055         ServiceList* NewServices;
1056
1057         /** Expands the name of a module by prepending "m_" and appending ".so".
1058          * No-op if the name already has the ".so" extension.
1059          * @param modname Module name to expand
1060          * @return Module name starting with "m_" and ending with ".so"
1061          */
1062         static std::string ExpandModName(const std::string& modname);
1063
1064         /** Simple, bog-standard, boring constructor.
1065          */
1066         ModuleManager();
1067
1068         /** Destructor
1069          */
1070         ~ModuleManager();
1071
1072         /** Change the priority of one event in a module.
1073          * Each module event has a list of modules which are attached to that event type.
1074          * If you wish to be called before or after other specific modules, you may use this
1075          * method (usually within void Module::Prioritize()) to set your events priority.
1076          * You may use this call in other methods too, however, this is not supported behaviour
1077          * for a module.
1078          * @param mod The module to change the priority of
1079          * @param i The event to change the priority of
1080          * @param s The state you wish to use for this event. Use one of
1081          * PRIO_FIRST to set the event to be first called, PRIO_LAST to
1082          * set it to be the last called, or PRIO_BEFORE and PRIORITY_AFTER
1083          * to set it to be before or after one or more other modules.
1084          * @param which If PRIO_BEFORE or PRIORITY_AFTER is set in parameter 's',
1085          * then this contains a the module that your module must be placed before
1086          * or after.
1087          */
1088         bool SetPriority(Module* mod, Implementation i, Priority s, Module* which = NULL);
1089
1090         /** Change the priority of all events in a module.
1091          * @param mod The module to set the priority of
1092          * @param s The priority of all events in the module.
1093          * Note that with this method, it is not possible to effectively use
1094          * PRIO_BEFORE or PRIORITY_AFTER, you should use the more fine tuned
1095          * SetPriority method for this, where you may specify other modules to
1096          * be prioritized against.
1097          */
1098         void SetPriority(Module* mod, Priority s);
1099
1100         /** Attach an event to a module.
1101          * You may later detatch the event with ModuleManager::Detach().
1102          * If your module is unloaded, all events are automatically detatched.
1103          * @param i Event type to attach
1104          * @param mod Module to attach event to
1105          * @return True if the event was attached
1106          */
1107         bool Attach(Implementation i, Module* mod);
1108
1109         /** Detatch an event from a module.
1110          * This is not required when your module unloads, as the core will
1111          * automatically detatch your module from all events it is attached to.
1112          * @param i Event type to detach
1113          * @param mod Module to detach event from
1114          * @return True if the event was detached
1115          */
1116         bool Detach(Implementation i, Module* mod);
1117
1118         /** Attach an array of events to a module
1119          * @param i Event types (array) to attach
1120          * @param mod Module to attach events to
1121          * @param sz The size of the implementation array
1122          */
1123         void Attach(Implementation* i, Module* mod, size_t sz);
1124
1125         /** Detach all events from a module (used on unload)
1126          * @param mod Module to detach from
1127          */
1128         void DetachAll(Module* mod);
1129
1130         /** Attach all events to a module (used on module load)
1131          * @param mod Module to attach to all events
1132          */
1133         void AttachAll(Module* mod);
1134
1135         /** Returns text describing the last module error
1136          * @return The last error message to occur
1137          */
1138         std::string& LastError();
1139
1140         /** Load a given module file
1141          * @param filename The file to load
1142          * @param defer Defer module init (loading many modules)
1143          * @return True if the module was found and loaded
1144          */
1145         bool Load(const std::string& filename, bool defer = false);
1146
1147         /** Unload a given module file. Note that the module will not be
1148          * completely gone until the cull list has finished processing.
1149          *
1150          * @return true on success; if false, LastError will give a reason
1151          */
1152         bool Unload(Module* module);
1153
1154         /** Called by the InspIRCd constructor to load all modules from the config file.
1155          */
1156         void LoadAll();
1157         void UnloadAll();
1158         void DoSafeUnload(Module*);
1159
1160         /** Check if a module can be unloaded and if yes, prepare it for unload
1161          * @param mod Module to be unloaded
1162          * @return True if the module is unloadable, false otherwise.
1163          * If true the module must be unloaded in the current main loop iteration.
1164          */
1165         bool CanUnload(Module* mod);
1166
1167         /** Find a module by name, and return a Module* to it.
1168          * This is preferred over iterating the module lists yourself.
1169          * @param name The module name to look up
1170          * @return A pointer to the module, or NULL if the module cannot be found
1171          */
1172         Module* Find(const std::string &name);
1173
1174         /** Register a service provided by a module */
1175         void AddService(ServiceProvider&);
1176
1177         /** Unregister a service provided by a module */
1178         void DelService(ServiceProvider&);
1179
1180         /** Register all services in a given ServiceList
1181          * @param list The list containing the services to register
1182          */
1183         void AddServices(const ServiceList& list);
1184
1185         inline void AddServices(ServiceProvider** list, int count)
1186         {
1187                 for(int i=0; i < count; i++)
1188                         AddService(*list[i]);
1189         }
1190
1191         /** Find a service by name.
1192          * If multiple modules provide a given service, the first one loaded will be chosen.
1193          */
1194         ServiceProvider* FindService(ServiceType Type, const std::string& name);
1195
1196         template<typename T> inline T* FindDataService(const std::string& name)
1197         {
1198                 return static_cast<T*>(FindService(SERVICE_DATA, name));
1199         }
1200
1201         /** Get a map of all loaded modules keyed by their name
1202          * @return A ModuleMap containing all loaded modules
1203          */
1204         const ModuleMap& GetModules() const { return Modules; }
1205
1206         /** Make a service referenceable by dynamic_references
1207          * @param name Name that will be used by dynamic_references to find the object
1208          * @param service Service to make referenceable by dynamic_references
1209          */
1210         void AddReferent(const std::string& name, ServiceProvider* service);
1211
1212         /** Make a service no longer referenceable by dynamic_references
1213          * @param service Service to make no longer referenceable by dynamic_references
1214          */
1215         void DelReferent(ServiceProvider* service);
1216 };
1217
1218 /** Do not mess with these functions unless you know the C preprocessor
1219  * well enough to explain why they are needed. The order is important.
1220  */
1221 #define MODULE_INIT_STR MODULE_INIT_STR_FN_2(MODULE_INIT_SYM)
1222 #define MODULE_INIT_STR_FN_2(x) MODULE_INIT_STR_FN_1(x)
1223 #define MODULE_INIT_STR_FN_1(x) #x
1224 #define MODULE_INIT_SYM MODULE_INIT_SYM_FN_2(INSPIRCD_VERSION_MAJ, INSPIRCD_VERSION_API)
1225 #define MODULE_INIT_SYM_FN_2(x,y) MODULE_INIT_SYM_FN_1(x,y)
1226 #define MODULE_INIT_SYM_FN_1(x,y) inspircd_module_ ## x ## _ ## y
1227
1228 #ifdef INSPIRCD_STATIC
1229
1230 struct AllCommandList {
1231         typedef Command* (*fn)(Module*);
1232         AllCommandList(fn cmd);
1233 };
1234 #define COMMAND_INIT(x) static Command* MK_ ## x(Module* m) { return new x(m); } \
1235         static const AllCommandList PREP_ ## x(&MK_ ## x);
1236
1237 struct AllModuleList {
1238         typedef Module* (*fn)();
1239         fn init;
1240         std::string name;
1241         AllModuleList(fn mod, const std::string& Name);
1242 };
1243
1244 #define MODULE_INIT(x) static Module* MK_ ## x() { return new x; } \
1245         static const AllModuleList PREP_ ## x(&MK_ ## x, MODNAME ".so");
1246
1247 #else
1248
1249 /** This definition is used as shorthand for the various classes
1250  * and functions needed to make a module loadable by the OS.
1251  * It defines the class factory and external init_module function.
1252  */
1253 #ifdef _WIN32
1254
1255 #define MODULE_INIT(y) \
1256         extern "C" DllExport Module * MODULE_INIT_SYM() \
1257         { \
1258                 return new y; \
1259         } \
1260         BOOLEAN WINAPI DllMain(HINSTANCE hDllHandle, DWORD nReason, LPVOID Reserved) \
1261         { \
1262                 switch ( nReason ) \
1263                 { \
1264                         case DLL_PROCESS_ATTACH: \
1265                         case DLL_PROCESS_DETACH: \
1266                                 break; \
1267                 } \
1268                 return TRUE; \
1269         } \
1270         extern "C" DllExport const char inspircd_src_version[] = INSPIRCD_VERSION;
1271
1272 #else
1273
1274 #define MODULE_INIT(y) \
1275         extern "C" DllExport Module * MODULE_INIT_SYM() \
1276         { \
1277                 return new y; \
1278         } \
1279         extern "C" DllExport const char inspircd_src_version[] = INSPIRCD_VERSION;
1280 #endif
1281
1282 #define COMMAND_INIT(c) MODULE_INIT(CommandModule<c>)
1283
1284 #endif