ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/modules.c

Comparing:
ircd-hybrid-7.2/src/modules.c (file contents), Revision 425 by michael, Sat Feb 11 00:27:28 2006 UTC vs.
ircd-hybrid-8/src/modules.c (file contents), Revision 1309 by michael, Sun Mar 25 11:24:18 2012 UTC

#	Line 22 | Line 22
22		*  $Id$
23		*/
24
25	+	#include "ltdl.h"
26	+
27		#include "stdinc.h"
28	<	#include "tools.h"
28	>	#include "list.h"
29		#include "modules.h"
30	<	#include "s_log.h"
30	>	#include "log.h"
31		#include "ircd.h"
32		#include "client.h"
33		#include "send.h"
34	<	#include "s_conf.h"
33	<	#include "handlers.h"
34	>	#include "conf.h"
35		#include "numeric.h"
36		#include "parse.h"
37		#include "ircd_defs.h"
38		#include "irc_string.h"
39		#include "memory.h"
39	–	#include "list.h"
40
41	–	/* -TimeMr14C:
42	–	* I have moved the dl* function definitions and
43	–	* the two functions (load_a_module / unload_a_module) to the
44	–	* file dynlink.c
45	–	* And also made the necessary changes to those functions
46	–	* to comply with shl_load and friends.
47	–	* In this file, to keep consistency with the makefile,
48	–	* I added the ability to load *.sl files, too.
49	–	* 27/02/2002
50	–	*/
41
42	<	#ifndef STATIC_MODULES
42	>	static dlink_list modules_list = { NULL, NULL, 0 };
43
44	<	dlink_list mod_list = { NULL, NULL, 0 };
44	>	static const char *unknown_ver = "<unknown>";
45
46		static const char *core_module_table[] =
47		{
48	<	"m_die",
49	<	"m_join",
50	<	"m_kick",
51	<	"m_kill",
52	<	"m_message",
53	<	"m_mode",
54	<	"m_nick",
55	<	"m_part",
56	<	"m_quit",
57	<	"m_server",
58	<	"m_sjoin",
59	<	"m_squit",
48	>	"m_die.la",
49	>	"m_error.la",
50	>	"m_join.la",
51	>	"m_kick.la",
52	>	"m_kill.la",
53	>	"m_message.la",
54	>	"m_mode.la",
55	>	"m_nick.la",
56	>	"m_part.la",
57	>	"m_quit.la",
58	>	"m_server.la",
59	>	"m_sjoin.la",
60	>	"m_squit.la",
61		NULL
62		};
63
#	Line 105 | Line 96 | struct Message modrestart_msgtab = {
96		};
97
98
99	<	extern struct Message error_msgtab;
99	>	int
100	>	modules_valid_suffix(const char *name)
101	>	{
102	>	return ((name = strrchr(name, '.'))) && !strcmp(name, ".la");
103	>	}
104	>
105	>	/* unload_one_module()
106	>	*
107	>	* inputs       - name of module to unload
108	>	*              - 1 to say modules unloaded, 0 to not
109	>	* output       - 0 if successful, -1 if error
110	>	* side effects - module is unloaded
111	>	*/
112	>	int
113	>	unload_one_module(const char *name, int warn)
114	>	{
115	>	struct module *modp = NULL;
116	>
117	>	if ((modp = findmodule_byname(name)) == NULL)
118	>	return -1;
119	>
120	>	if (modp->modexit)
121	>	modp->modexit();
122	>
123	>	assert(dlink_list_length(&modules_list) > 0);
124	>	dlinkDelete(&modp->node, &modules_list);
125	>	MyFree(modp->name);
126	>
127	>	lt_dlclose(modp->handle);
128	>
129	>	if (warn == 1)
130	>	{
131	>	ilog(LOG_TYPE_IRCD, "Module %s unloaded", name);
132	>	sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s unloaded", name);
133	>	}
134	>
135	>	return 0;
136	>	}
137	>
138	>	/* load_a_module()
139	>	*
140	>	* inputs       - path name of module, int to notice, int of core
141	>	* output       - -1 if error 0 if success
142	>	* side effects - loads a module if successful
143	>	*/
144	>	int
145	>	load_a_module(const char *path, int warn, int core)
146	>	{
147	>	lt_dlhandle tmpptr = NULL;
148	>	const char *mod_basename = NULL;
149	>	struct module *modp = NULL;
150	>
151	>	if (findmodule_byname((mod_basename = libio_basename(path))))
152	>	return 1;
153	>
154	>	if (!(tmpptr = lt_dlopen(path))) {
155	>	const char *err = ((err = lt_dlerror())) ? err : "<unknown>";
156	>
157	>	sendto_realops_flags(UMODE_ALL, L_ALL, "Error loading module %s: %s",
158	>	mod_basename, err);
159	>	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
160	>	return -1;
161	>	}
162	>
163	>	if ((modp = lt_dlsym(tmpptr, "module_entry")) == NULL)
164	>	{
165	>	sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s has no module_entry export",
166	>	mod_basename);
167	>	ilog(LOG_TYPE_IRCD, "Module %s has no module_entry export", mod_basename);
168	>	lt_dlclose(tmpptr);
169	>	return -1;
170	>	}
171	>
172	>	modp->handle = tmpptr;
173	>
174	>	if (EmptyString(modp->version))
175	>	modp->version = unknown_ver;
176	>
177	>	if (core)
178	>	modp->flags |= MODULE_FLAG_CORE;
179	>
180	>	DupString(modp->name, mod_basename);
181	>	dlinkAdd(modp, &modp->node, &modules_list);
182	>
183	>	if (modp->modinit)
184	>	modp->modinit();
185	>
186	>	if (warn == 1)
187	>	{
188	>	sendto_realops_flags(UMODE_ALL, L_ALL,
189	>	"Module %s [version: %s handle: %p] loaded.",
190	>	modp->name, modp->version, tmpptr);
191	>	ilog(LOG_TYPE_IRCD, "Module %s [version: %s handle: %p] loaded.",
192	>	modp->name, modp->version, tmpptr);
193	>	}
194	>
195	>	return 0;
196	>	}
197
198		/*
199		* modules_init
#	Line 117 | Line 205 | extern struct Message error_msgtab;
205		void
206		modules_init(void)
207		{
208	+	if (lt_dlinit())
209	+	{
210	+	ilog(LOG_TYPE_IRCD, "Couldn't initialize the libltdl run time dynamic"
211	+	" link library. Exiting.");
212	+	exit(0);
213	+	}
214	+
215		mod_add_cmd(&modload_msgtab);
216		mod_add_cmd(&modunload_msgtab);
217		mod_add_cmd(&modreload_msgtab);
218		mod_add_cmd(&modlist_msgtab);
219		mod_add_cmd(&modrestart_msgtab);
125	–	mod_add_cmd(&error_msgtab);
220		}
221
222		/* mod_find_path()
#	Line 194 | Line 288 | add_conf_module(const char *name)
288		void
289		mod_clear_paths(void)
290		{
291	<	struct module_path *pathst;
292	<	dlink_node *ptr;
199	<	dlink_node *next_ptr;
291	>	struct module_path *pathst = NULL;
292	>	dlink_node *ptr = NULL, *next_ptr = NULL;
293
294		DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
295		{
#	Line 221 | Line 314 | mod_clear_paths(void)
314		* output       - NULL if not found or pointer to module
315		* side effects - NONE
316		*/
317	<	dlink_node *
317	>	struct module *
318		findmodule_byname(const char *name)
319		{
320	<	dlink_node *ptr;
228	<	struct module *modp;
320	>	dlink_node *ptr = NULL;
321
322	<	DLINK_FOREACH(ptr, mod_list.head)
322	>	DLINK_FOREACH(ptr, modules_list.head)
323		{
324	<	modp = ptr->data;
324	>	struct module *modp = ptr->data;
325
326		if (strcmp(modp->name, name) == 0)
327	<	return ptr;
327	>	return modp;
328		}
329
330		return NULL;
#	Line 255 | Line 347 | load_all_modules(int warn)
347
348		if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
349		{
350	<	ilog(L_WARN, "Could not load modules from %s: %s",
350	>	ilog(LOG_TYPE_IRCD, "Could not load modules from %s: %s",
351		AUTOMODPATH, strerror(errno));
352		return;
353		}
354
355		while ((ldirent = readdir(system_module_dir)) != NULL)
356		{
357	<	const char *offset = strrchr(ldirent->d_name, '.');
266	<
267	<	if (offset && !strcmp(offset, SHARED_SUFFIX))
357	>	if (modules_valid_suffix(ldirent->d_name))
358		{
359		snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s",
360		AUTOMODPATH, ldirent->d_name);
#	Line 310 | Line 400 | load_core_modules(int warn)
400
401		for (; core_module_table[i]; ++i)
402		{
403	<	snprintf(module_name, sizeof(module_name), "%s%s%s", MODPATH,
404	<	core_module_table[i], SHARED_SUFFIX);
403	>	snprintf(module_name, sizeof(module_name), "%s%s",
404	>	MODPATH, core_module_table[i]);
405
406		if (load_a_module(module_name, warn, 1) == -1)
407		{
408	<	ilog(L_CRIT, "Error loading core module %s%s: terminating ircd",
409	<	core_module_table[i], SHARED_SUFFIX);
408	>	ilog(LOG_TYPE_IRCD, "Error loading core module %s: terminating ircd",
409	>	core_module_table[i]);
410		exit(EXIT_FAILURE);
411		}
412		}
#	Line 330 | Line 420 | load_core_modules(int warn)
420		* side effects - module is loaded if found.
421		*/
422		int
423	<	load_one_module(char *path, int coremodule)
423	>	load_one_module(const char *path, int coremodule)
424		{
425		dlink_node *ptr = NULL;
426		char modpath[PATH_MAX + 1];
#	Line 342 | Line 432 | load_one_module(char *path, int coremodu
432
433		snprintf(modpath, sizeof(modpath), "%s/%s", mpath->path, path);
434
435	+	if (!modules_valid_suffix(path))
436	+	continue;
437	+
438		if (strstr(modpath, "../") == NULL &&
439		strstr(modpath, "/..") == NULL)
440		{
#	Line 358 | Line 451 | load_one_module(char *path, int coremodu
451
452		sendto_realops_flags(UMODE_ALL, L_ALL,
453		"Cannot locate module %s", path);
454	<	ilog(L_WARN, "Cannot locate module %s", path);
454	>	ilog(LOG_TYPE_IRCD, "Cannot locate module %s", path);
455		return -1;
456		}
457
#	Line 367 | Line 460 | static void
460		mo_modload(struct Client *client_p, struct Client *source_p,
461		int parc, char *parv[])
462		{
463	<	char *m_bn;
463	>	const char *m_bn = NULL;
464
465	<	if (!IsAdmin(source_p))
465	>	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
466		{
467		sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
468		me.name, source_p->name);
469		return;
470		}
471
472	<	m_bn = basename(parv[1]);
472	>	m_bn = libio_basename(parv[1]);
473
474		if (findmodule_byname(m_bn) != NULL)
475		{
#	Line 393 | Line 486 | static void
486		mo_modunload(struct Client *client_p, struct Client *source_p,
487		int parc, char *parv[])
488		{
489	<	char *m_bn;
490	<	dlink_node *ptr;
398	<	struct module *modp;
489	>	const char *m_bn = NULL;
490	>	struct module *modp = NULL;
491
492	<	if (!IsAdmin(source_p))
492	>	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
493		{
494		sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
495		me.name, source_p->name);
496		return;
497		}
498
499	<	m_bn = basename(parv[1]);
499	>	m_bn = libio_basename(parv[1]);
500
501	<	if ((ptr = findmodule_byname(m_bn)) == NULL)
501	>	if ((modp = findmodule_byname(m_bn)) == NULL)
502		{
503		sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
504		me.name, source_p->name, m_bn);
505		return;
506		}
507
508	<	modp = ptr->data;
417	<
418	<	if (modp->core == 1)
508	>	if (modp->flags & MODULE_FLAG_CORE)
509		{
510		sendto_one(source_p,
511		":%s NOTICE %s :Module %s is a core module and may not be unloaded",
#	Line 423 | Line 513 | mo_modunload(struct Client *client_p, st
513		return;
514		}
515
426	–	/* XXX might want to simply un dlink it here */
427	–
516		if (unload_one_module(m_bn, 1) == -1)
517		{
518		sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
#	Line 437 | Line 525 | static void
525		mo_modreload(struct Client *client_p, struct Client *source_p,
526		int parc, char *parv[])
527		{
528	<	char *m_bn;
529	<	dlink_node *ptr;
442	<	struct module *modp;
528	>	const char *m_bn = NULL;
529	>	struct module *modp = NULL;
530		int check_core;
531
532	<	if (!IsAdmin(source_p))
532	>	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
533		{
534		sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
535		me.name, source_p->name);
536		return;
537		}
538
539	<	m_bn = basename(parv[1]);
539	>	m_bn = libio_basename(parv[1]);
540
541	<	if ((ptr = findmodule_byname(m_bn)) == NULL)
541	>	if ((modp = findmodule_byname(m_bn)) == NULL)
542		{
543		sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
544		me.name, source_p->name, m_bn);
545		return;
546		}
547
548	<	modp = ptr->data;
462	<	check_core = modp->core;
548	>	check_core = (modp->flags & MODULE_FLAG_CORE) != 0;
549
550		if (unload_one_module(m_bn, 1) == -1)
551		{
#	Line 472 | Line 558 | mo_modreload(struct Client *client_p, st
558		{
559		sendto_realops_flags(UMODE_ALL, L_ALL, "Error reloading core "
560		"module: %s: terminating ircd", parv[1]);
561	<	ilog(L_CRIT, "Error loading core module %s: terminating ircd", parv[1]);
561	>	ilog(LOG_TYPE_IRCD, "Error loading core module %s: terminating ircd", parv[1]);
562		exit(0);
563		}
564		}
#	Line 482 | Line 568 | static void
568		mo_modlist(struct Client *client_p, struct Client *source_p,
569		int parc, char *parv[])
570		{
571	<	dlink_node *ptr;
486	<	struct module *modp;
571	>	const dlink_node *ptr = NULL;
572
573	<	if (!IsAdmin(source_p))
573	>	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
574		{
575		sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
576		me.name, source_p->name);
577		return;
578		}
579
580	<	DLINK_FOREACH(ptr, mod_list.head)
580	>	DLINK_FOREACH(ptr, modules_list.head)
581		{
582	<	modp = ptr->data;
582	>	const struct module *modp = ptr->data;
583
584	<	if (parc > 1)
585	<	{
586	<	if (match(parv[1], modp->name))
587	<	{
588	<	sendto_one(source_p, form_str(RPL_MODLIST), me.name, parv[0],
589	<	modp->name, modp->address,
505	<	modp->version, modp->core?"(core)":"");
506	<	}
507	<	}
508	<	else
509	<	{
510	<	sendto_one(source_p, form_str(RPL_MODLIST), me.name, parv[0],
511	<	modp->name, modp->address,
512	<	modp->version, modp->core?"(core)":"");
513	<	}
584	>	if (parc > 1 && !match(parv[1], modp->name))
585	>	continue;
586	>
587	>	sendto_one(source_p, form_str(RPL_MODLIST), me.name, source_p->name,
588	>	modp->name, modp->handle,
589	>	modp->version, (modp->flags & MODULE_FLAG_CORE) ?"(core)":"");
590		}
591
592		sendto_one(source_p, form_str(RPL_ENDOFMODLIST),
#	Line 523 | Line 599 | mo_modrestart(struct Client *client_p, s
599		int parc, char *parv[])
600		{
601		unsigned int modnum = 0;
602	<	dlink_node *ptr;
603	<	dlink_node *tptr;
604	<	struct module *modp;
529	<
530	<	if (!IsAdmin(source_p))
602	>	dlink_node *ptr = NULL, *ptr_next = NULL;
603	>
604	>	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
605		{
606		sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
607		me.name, source_p->name);
#	Line 537 | Line 611 | mo_modrestart(struct Client *client_p, s
611		sendto_one(source_p, ":%s NOTICE %s :Reloading all modules",
612		me.name, source_p->name);
613
614	<	modnum = dlink_list_length(&mod_list);
614	>	modnum = dlink_list_length(&modules_list);
615
616	<	DLINK_FOREACH_SAFE(ptr, tptr, mod_list.head)
616	>	DLINK_FOREACH_SAFE(ptr, ptr_next, modules_list.head)
617		{
618	<	modp = ptr->data;
618	>	struct module *modp = ptr->data;
619		unload_one_module(modp->name, 0);
620		}
621
#	Line 550 | Line 624 | mo_modrestart(struct Client *client_p, s
624		load_core_modules(0);
625
626		sendto_realops_flags(UMODE_ALL, L_ALL,
627	<	"Module Restart: %u modules unloaded, %lu modules loaded",
628	<	modnum, dlink_list_length(&mod_list));
629	<	ilog(L_WARN, "Module Restart: %u modules unloaded, %lu modules loaded",
630	<	modnum, dlink_list_length(&mod_list));
557	<	}
558	<
559	<	#else /* STATIC_MODULES */
560	<	#include "s_serv.h"
561	<
562	<	/* load_all_modules()
563	<	*
564	<	* input        - warn flag
565	<	* output       - NONE
566	<	* side effects - all the msgtabs are added for static modules
567	<	*/
568	<	void
569	<	load_all_modules(int warn)
570	<	{
571	<	mod_add_cmd(&error_msgtab);
572	<	mod_add_cmd(&accept_msgtab);
573	<	mod_add_cmd(&admin_msgtab);
574	<	mod_add_cmd(&away_msgtab);
575	<	mod_add_cmd(&bmask_msgtab);
576	<	mod_add_cmd(&capab_msgtab);
577	<	mod_add_cmd(&cburst_msgtab);
578	<	mod_add_cmd(&close_msgtab);
579	<	mod_add_cmd(&connect_msgtab);
580	<	#ifdef HAVE_LIBCRYPTO
581	<	mod_add_cmd(&challenge_msgtab);
582	<	mod_add_cmd(&cryptlink_msgtab);
583	<	#endif
584	<	mod_add_cmd(&die_msgtab);
585	<	mod_add_cmd(&drop_msgtab);
586	<	mod_add_cmd(&eob_msgtab);
587	<	mod_add_cmd(&etrace_msgtab);
588	<	mod_add_cmd(&gline_msgtab);
589	<	add_capability("GLN", CAP_GLN, 1);
590	<	mod_add_cmd(&hash_msgtab);
591	<	mod_add_cmd(&ungline_msgtab);
592	<	mod_add_cmd(&info_msgtab);
593	<	mod_add_cmd(&invite_msgtab);
594	<	mod_add_cmd(&ison_msgtab);
595	<	mod_add_cmd(&join_msgtab);
596	<	mod_add_cmd(&kick_msgtab);
597	<	mod_add_cmd(&kill_msgtab);
598	<	mod_add_cmd(&kline_msgtab);
599	<	add_capability("KLN", CAP_KLN, 1);
600	<	mod_add_cmd(&dline_msgtab);
601	<	mod_add_cmd(&unkline_msgtab);
602	<	mod_add_cmd(&undline_msgtab);
603	<	mod_add_cmd(&knock_msgtab);
604	<	add_capability("KNOCK", CAP_KNOCK, 1);
605	<	mod_add_cmd(&knockll_msgtab);
606	<	mod_add_cmd(&links_msgtab);
607	<	mod_add_cmd(&list_msgtab);
608	<	mod_add_cmd(&lljoin_msgtab);
609	<	mod_add_cmd(&llnick_msgtab);
610	<	mod_add_cmd(&locops_msgtab);
611	<	mod_add_cmd(&lusers_msgtab);
612	<	mod_add_cmd(&privmsg_msgtab);
613	<	mod_add_cmd(&notice_msgtab);
614	<	mod_add_cmd(&map_msgtab);
615	<	mod_add_cmd(&mode_msgtab);
616	<	mod_add_cmd(&motd_msgtab);
617	<	mod_add_cmd(&names_msgtab);
618	<	mod_add_cmd(&nburst_msgtab);
619	<	mod_add_cmd(&nick_msgtab);
620	<	mod_add_cmd(&omotd_msgtab);
621	<	mod_add_cmd(&oper_msgtab);
622	<	mod_add_cmd(&operwall_msgtab);
623	<	mod_add_cmd(&part_msgtab);
624	<	mod_add_cmd(&pass_msgtab);
625	<	mod_add_cmd(&ping_msgtab);
626	<	mod_add_cmd(&pong_msgtab);
627	<	mod_add_cmd(&post_msgtab);
628	<	mod_add_cmd(&get_msgtab);
629	<	mod_add_cmd(&put_msgtab);
630	<	mod_add_cmd(&quit_msgtab);
631	<	mod_add_cmd(&rehash_msgtab);
632	<	mod_add_cmd(&restart_msgtab);
633	<	mod_add_cmd(&resv_msgtab);
634	<	mod_add_cmd(&rkline_msgtab);
635	<	mod_add_cmd(&rxline_msgtab);
636	<	mod_add_cmd(&server_msgtab);
637	<	mod_add_cmd(&set_msgtab);
638	<	mod_add_cmd(&sid_msgtab);
639	<	mod_add_cmd(&sjoin_msgtab);
640	<	mod_add_cmd(&squit_msgtab);
641	<	mod_add_cmd(&stats_msgtab);
642	<	mod_add_cmd(&svinfo_msgtab);
643	<	mod_add_cmd(&tb_msgtab);
644	<	add_capability("TB", CAP_TB, 1);
645	<	mod_add_cmd(&tburst_msgtab);
646	<	add_capability("TBURST", CAP_TBURST, 1);
647	<	mod_add_cmd(&testline_msgtab);
648	<	mod_add_cmd(&testgecos_msgtab);
649	<	mod_add_cmd(&testmask_msgtab);
650	<	mod_add_cmd(&time_msgtab);
651	<	mod_add_cmd(&tmode_msgtab);
652	<	mod_add_cmd(&topic_msgtab);
653	<	mod_add_cmd(&trace_msgtab);
654	<	add_capability("UNKLN", CAP_UNKLN, 1);
655	<	mod_add_cmd(&uid_msgtab);
656	<	mod_add_cmd(&unresv_msgtab);
657	<	mod_add_cmd(&unxline_msgtab);
658	<	mod_add_cmd(&user_msgtab);
659	<	mod_add_cmd(&userhost_msgtab);
660	<	mod_add_cmd(&users_msgtab);
661	<	mod_add_cmd(&version_msgtab);
662	<	mod_add_cmd(&wallops_msgtab);
663	<	mod_add_cmd(&who_msgtab);
664	<	mod_add_cmd(&whois_msgtab);
665	<	mod_add_cmd(&whowas_msgtab);
666	<	mod_add_cmd(&xline_msgtab);
667	<	mod_add_cmd(&help_msgtab);
668	<	mod_add_cmd(&uhelp_msgtab);
669	<	#ifdef BUILD_CONTRIB
670	<	mod_add_cmd(&botserv_msgtab);
671	<	mod_add_cmd(&capture_msgtab);
672	<	mod_add_cmd(&chanserv_msgtab);
673	<	mod_add_cmd(&chghost_msgtab);
674	<	mod_add_cmd(&chgident_msgtab);
675	<	mod_add_cmd(&chgname_msgtab);
676	<	mod_add_cmd(&classlist_msgtab);
677	<	mod_add_cmd(&clearchan_msgtab);
678	<	mod_add_cmd(&cs_msgtab);
679	<	mod_add_cmd(&ctrace_msgtab);
680	<	mod_add_cmd(&delspoof_msgtab);
681	<	mod_add_cmd(&flags_msgtab);
682	<	mod_add_cmd(&forcejoin_msgtab);
683	<	mod_add_cmd(&forcepart_msgtab);
684	<	mod_add_cmd(&global_msgtab);
685	<	mod_add_cmd(&help_msgtab);
686	<	mod_add_cmd(&uhelp_msgtab);
687	<	mod_add_cmd(&helpserv_msgtab);
688	<	mod_add_cmd(&hostserv_msgtab);
689	<	mod_add_cmd(&identify_msgtab);
690	<	mod_add_cmd(&jupe_msgtab);
691	<	mod_add_cmd(&killhost_msgtab);
692	<	mod_add_cmd(&ltrace_msgtab);
693	<	mod_add_cmd(&memoserv_msgtab);
694	<	mod_add_cmd(&mkpasswd_msgtab);
695	<	mod_add_cmd(&ms_msgtab);
696	<	mod_add_cmd(&nickserv_msgtab);
697	<	mod_add_cmd(&ns_msgtab);
698	<	mod_add_cmd(&ojoin_msgtab);
699	<	mod_add_cmd(&operserv_msgtab);
700	<	mod_add_cmd(&operspy_msgtab);
701	<	mod_add_cmd(&opme_msgtab);
702	<	mod_add_cmd(&os_msgtab);
703	<	mod_add_cmd(&seenserv_msgtab);
704	<	mod_add_cmd(&spoof_msgtab);
705	<	mod_add_cmd(&statserv_msgtab);
706	<	mod_add_cmd(&svsnick_msgtab);
707	<	mod_add_cmd(&uncapture_msgtab);
708	<	/* FIXME: what about spy*? */
709	<	#endif
627	>	"Module Restart: %u modules unloaded, %u modules loaded",
628	>	modnum, dlink_list_length(&modules_list));
629	>	ilog(LOG_TYPE_IRCD, "Module Restart: %u modules unloaded, %u modules loaded",
630	>	modnum, dlink_list_length(&modules_list));
631		}
711	–	#endif /* STATIC_MODULES */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)