ViewVC Help

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

root/svn/ircd-hybrid/releases/8.1.0beta2/src/modules.c

Comparing:
ircd-hybrid-8/src/modules.c (file contents), Revision 1238 by michael, Thu Sep 29 11:37:31 2011 UTC vs.
ircd-hybrid/trunk/src/modules.c (file contents), Revision 1737 by michael, Mon Jan 14 17:37:55 2013 UTC

#	Line 27 | Line 27
27		#include "stdinc.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"
35	<	#include "handlers.h"
34	>	#include "conf.h"
35		#include "numeric.h"
36		#include "parse.h"
37		#include "ircd_defs.h"
#	Line 40 | Line 39
39		#include "memory.h"
40
41
42	<	static dlink_list modules_list = { NULL, NULL, 0 };
42	>	dlink_list modules_list = { NULL, NULL, 0 };
43
44		static const char *unknown_ver = "<unknown>";
45
#	Line 65 | Line 64 | static const char *core_module_table[] =
64		static dlink_list mod_paths = { NULL, NULL, 0 };
65		static dlink_list conf_modules = { NULL, NULL, 0 };
66
68	–	static void mo_modload(struct Client *, struct Client *, int, char *[]);
69	–	static void mo_modlist(struct Client *, struct Client *, int, char *[]);
70	–	static void mo_modreload(struct Client *, struct Client *, int, char *[]);
71	–	static void mo_modunload(struct Client *, struct Client *, int, char *[]);
72	–	static void mo_modrestart(struct Client *, struct Client *, int, char *[]);
73	–
74	–	struct Message modload_msgtab = {
75	–	"MODLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
76	–	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modload, m_ignore}
77	–	};
78	–
79	–	struct Message modunload_msgtab = {
80	–	"MODUNLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
81	–	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modunload, m_ignore}
82	–	};
83	–
84	–	struct Message modreload_msgtab = {
85	–	"MODRELOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
86	–	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modreload, m_ignore}
87	–	};
88	–
89	–	struct Message modlist_msgtab = {
90	–	"MODLIST", 0, 0, 0, 0, MFLG_SLOW, 0,
91	–	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modlist, m_ignore}
92	–	};
93	–
94	–	struct Message modrestart_msgtab = {
95	–	"MODRESTART", 0, 0, 0, 0, MFLG_SLOW, 0,
96	–	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modrestart, m_ignore}
97	–	};
98	–
99	–
67		int
68		modules_valid_suffix(const char *name)
69		{
#	Line 129 | Line 96 | unload_one_module(const char *name, int
96
97		if (warn == 1)
98		{
99	<	ilog(L_INFO, "Module %s unloaded", name);
100	<	sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s unloaded", name);
99	>	ilog(LOG_TYPE_IRCD, "Module %s unloaded", name);
100	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
101	>	"Module %s unloaded", name);
102		}
103
104		return 0;
#	Line 143 | Line 111 | unload_one_module(const char *name, int
111		* side effects - loads a module if successful
112		*/
113		int
114	<	load_a_module(const char *path, int warn, int core)
114	>	load_a_module(const char *path, int warn)
115		{
116		lt_dlhandle tmpptr = NULL;
117		const char *mod_basename = NULL;
#	Line 155 | Line 123 | load_a_module(const char *path, int warn
123		if (!(tmpptr = lt_dlopen(path))) {
124		const char *err = ((err = lt_dlerror())) ? err : "<unknown>";
125
126	<	sendto_realops_flags(UMODE_ALL, L_ALL, "Error loading module %s: %s",
126	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
127	>	"Error loading module %s: %s",
128		mod_basename, err);
129	<	ilog(L_WARN, "Error loading module %s: %s", mod_basename, err);
129	>	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
130		return -1;
131		}
132
133		if ((modp = lt_dlsym(tmpptr, "module_entry")) == NULL)
134		{
135	<	sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s has no module_entry export",
136	<	mod_basename);
137	<	ilog(L_WARN, "Module %s has no module_entry export", mod_basename);
135	>	const char *err = ((err = lt_dlerror())) ? err : "<unknown>";
136	>
137	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
138	>	"Error loading module %s: %s",
139	>	mod_basename, err);
140	>	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
141		lt_dlclose(tmpptr);
142		return -1;
143		}
#	Line 175 | Line 147 | load_a_module(const char *path, int warn
147		if (EmptyString(modp->version))
148		modp->version = unknown_ver;
149
150	<	if (core)
179	<	modp->flags |= MODULE_FLAG_CORE;
180	<
181	<	DupString(modp->name, mod_basename);
150	>	modp->name = xstrdup(mod_basename);
151		dlinkAdd(modp, &modp->node, &modules_list);
152
153		if (modp->modinit)
#	Line 186 | Line 155 | load_a_module(const char *path, int warn
155
156		if (warn == 1)
157		{
158	<	sendto_realops_flags(UMODE_ALL, L_ALL,
158	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
159		"Module %s [version: %s handle: %p] loaded.",
160		modp->name, modp->version, tmpptr);
161	<	ilog(L_WARN, "Module %s [version: %s handle: %p] loaded.",
161	>	ilog(LOG_TYPE_IRCD, "Module %s [version: %s handle: %p] loaded.",
162		modp->name, modp->version, tmpptr);
163		}
164
#	Line 208 | Line 177 | modules_init(void)
177		{
178		if (lt_dlinit())
179		{
180	<	ilog(L_ERROR, "Couldn't initialize the libltdl run time dynamic"
180	>	ilog(LOG_TYPE_IRCD, "Couldn't initialize the libltdl run time dynamic"
181		" link library. Exiting.");
182		exit(0);
183		}
215	–
216	–	mod_add_cmd(&modload_msgtab);
217	–	mod_add_cmd(&modunload_msgtab);
218	–	mod_add_cmd(&modreload_msgtab);
219	–	mod_add_cmd(&modlist_msgtab);
220	–	mod_add_cmd(&modrestart_msgtab);
184		}
185
186		/* mod_find_path()
#	Line 230 | Line 193 | static struct module_path *
193		mod_find_path(const char *path)
194		{
195		dlink_node *ptr;
233	–	struct module_path *mpath;
196
197		DLINK_FOREACH(ptr, mod_paths.head)
198		{
199	<	mpath = ptr->data;
199	>	struct module_path *mpath = ptr->data;
200
201		if (!strcmp(path, mpath->path))
202		return mpath;
#	Line 289 | Line 251 | add_conf_module(const char *name)
251		void
252		mod_clear_paths(void)
253		{
292	–	struct module_path *pathst = NULL;
254		dlink_node *ptr = NULL, *next_ptr = NULL;
255
256		DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
257		{
258	<	pathst = ptr->data;
259	<
299	<	dlinkDelete(&pathst->node, &mod_paths);
300	<	MyFree(pathst);
258	>	dlinkDelete(ptr, &mod_paths);
259	>	MyFree(ptr->data);
260		}
261
262		DLINK_FOREACH_SAFE(ptr, next_ptr, conf_modules.head)
263		{
264	<	pathst = ptr->data;
265	<
307	<	dlinkDelete(&pathst->node, &conf_modules);
308	<	MyFree(pathst);
264	>	dlinkDelete(ptr, &conf_modules);
265	>	MyFree(ptr->data);
266		}
267		}
268
#	Line 342 | Line 299 | load_all_modules(int warn)
299		{
300		DIR *system_module_dir = NULL;
301		struct dirent *ldirent = NULL;
302	<	char module_fq_name[PATH_MAX + 1];
346	<
347	<	modules_init();
302	>	char module_fq_name[HYB_PATH_MAX + 1];
303
304		if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
305		{
306	<	ilog(L_WARN, "Could not load modules from %s: %s",
306	>	ilog(LOG_TYPE_IRCD, "Could not load modules from %s: %s",
307		AUTOMODPATH, strerror(errno));
308		return;
309		}
#	Line 359 | Line 314 | load_all_modules(int warn)
314		{
315		snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s",
316		AUTOMODPATH, ldirent->d_name);
317	<	load_a_module(module_fq_name, warn, 0);
317	>	load_a_module(module_fq_name, warn);
318		}
319		}
320
#	Line 376 | Line 331 | void
331		load_conf_modules(void)
332		{
333		dlink_node *ptr = NULL;
379	–	struct module_path *mpath = NULL;
334
335		DLINK_FOREACH(ptr, conf_modules.head)
336		{
337	<	mpath = ptr->data;
337	>	struct module_path *mpath = ptr->data;
338
339		if (findmodule_byname(mpath->path) == NULL)
340	<	load_one_module(mpath->path, 0);
340	>	load_one_module(mpath->path);
341		}
342		}
343
#	Line 396 | Line 350 | load_conf_modules(void)
350		void
351		load_core_modules(int warn)
352		{
353	<	char module_name[PATH_MAX + 1];
353	>	char module_name[HYB_PATH_MAX + 1];
354		int i = 0;
355
356		for (; core_module_table[i]; ++i)
#	Line 404 | Line 358 | load_core_modules(int warn)
358		snprintf(module_name, sizeof(module_name), "%s%s",
359		MODPATH, core_module_table[i]);
360
361	<	if (load_a_module(module_name, warn, 1) == -1)
361	>	if (load_a_module(module_name, warn) == -1)
362		{
363	<	ilog(L_CRIT, "Error loading core module %s: terminating ircd",
363	>	ilog(LOG_TYPE_IRCD, "Error loading core module %s: terminating ircd",
364		core_module_table[i]);
365		exit(EXIT_FAILURE);
366		}
#	Line 421 | Line 375 | load_core_modules(int warn)
375		* side effects - module is loaded if found.
376		*/
377		int
378	<	load_one_module(const char *path, int coremodule)
378	>	load_one_module(const char *path)
379		{
380		dlink_node *ptr = NULL;
381	<	char modpath[PATH_MAX + 1];
381	>	char modpath[HYB_PATH_MAX + 1];
382		struct stat statbuf;
383
384		DLINK_FOREACH(ptr, mod_paths.head)
#	Line 438 | Line 392 | load_one_module(const char *path, int co
392
393		if (strstr(modpath, "../") == NULL &&
394		strstr(modpath, "/..") == NULL)
441	–	{
395		if (!stat(modpath, &statbuf))
396	<	{
397	<	if (S_ISREG(statbuf.st_mode))
445	<	{
446	<	/* Regular files only please */
447	<	return load_a_module(modpath, 1, coremodule);
448	<	}
449	<	}
450	<	}
396	>	if (S_ISREG(statbuf.st_mode))  /* Regular files only please */
397	>	return load_a_module(modpath, 1);
398		}
399
400	<	sendto_realops_flags(UMODE_ALL, L_ALL,
400	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
401		"Cannot locate module %s", path);
402	<	ilog(L_WARN, "Cannot locate module %s", path);
402	>	ilog(LOG_TYPE_IRCD, "Cannot locate module %s", path);
403		return -1;
404		}
458	–
459	–	/* load a module .. */
460	–	static void
461	–	mo_modload(struct Client *client_p, struct Client *source_p,
462	–	int parc, char *parv[])
463	–	{
464	–	const char *m_bn = NULL;
465	–
466	–	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
467	–	{
468	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
469	–	me.name, source_p->name);
470	–	return;
471	–	}
472	–
473	–	m_bn = libio_basename(parv[1]);
474	–
475	–	if (findmodule_byname(m_bn) != NULL)
476	–	{
477	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is already loaded",
478	–	me.name, source_p->name, m_bn);
479	–	return;
480	–	}
481	–
482	–	load_one_module(parv[1], 0);
483	–	}
484	–
485	–	/* unload a module .. */
486	–	static void
487	–	mo_modunload(struct Client *client_p, struct Client *source_p,
488	–	int parc, char *parv[])
489	–	{
490	–	const char *m_bn = NULL;
491	–	struct module *modp = NULL;
492	–
493	–	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
494	–	{
495	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
496	–	me.name, source_p->name);
497	–	return;
498	–	}
499	–
500	–	m_bn = libio_basename(parv[1]);
501	–
502	–	if ((modp = findmodule_byname(m_bn)) == NULL)
503	–	{
504	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
505	–	me.name, source_p->name, m_bn);
506	–	return;
507	–	}
508	–
509	–	if (modp->flags & MODULE_FLAG_CORE)
510	–	{
511	–	sendto_one(source_p,
512	–	":%s NOTICE %s :Module %s is a core module and may not be unloaded",
513	–	me.name, source_p->name, m_bn);
514	–	return;
515	–	}
516	–
517	–	if (unload_one_module(m_bn, 1) == -1)
518	–	{
519	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
520	–	me.name, source_p->name, m_bn);
521	–	}
522	–	}
523	–
524	–	/* unload and load in one! */
525	–	static void
526	–	mo_modreload(struct Client *client_p, struct Client *source_p,
527	–	int parc, char *parv[])
528	–	{
529	–	const char *m_bn = NULL;
530	–	struct module *modp = NULL;
531	–	int check_core;
532	–
533	–	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
534	–	{
535	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
536	–	me.name, source_p->name);
537	–	return;
538	–	}
539	–
540	–	m_bn = libio_basename(parv[1]);
541	–
542	–	if ((modp = findmodule_byname(m_bn)) == NULL)
543	–	{
544	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
545	–	me.name, source_p->name, m_bn);
546	–	return;
547	–	}
548	–
549	–	check_core = (modp->flags & MODULE_FLAG_CORE) != 0;
550	–
551	–	if (unload_one_module(m_bn, 1) == -1)
552	–	{
553	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
554	–	me.name, source_p->name, m_bn);
555	–	return;
556	–	}
557	–
558	–	if ((load_one_module(parv[1], check_core) == -1) && check_core)
559	–	{
560	–	sendto_realops_flags(UMODE_ALL, L_ALL, "Error reloading core "
561	–	"module: %s: terminating ircd", parv[1]);
562	–	ilog(L_CRIT, "Error loading core module %s: terminating ircd", parv[1]);
563	–	exit(0);
564	–	}
565	–	}
566	–
567	–	/* list modules .. */
568	–	static void
569	–	mo_modlist(struct Client *client_p, struct Client *source_p,
570	–	int parc, char *parv[])
571	–	{
572	–	const dlink_node *ptr = NULL;
573	–
574	–	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
575	–	{
576	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
577	–	me.name, source_p->name);
578	–	return;
579	–	}
580	–
581	–	DLINK_FOREACH(ptr, modules_list.head)
582	–	{
583	–	const struct module *modp = ptr->data;
584	–
585	–	if (parc > 1 && !match(parv[1], modp->name))
586	–	continue;
587	–
588	–	sendto_one(source_p, form_str(RPL_MODLIST), me.name, source_p->name,
589	–	modp->name, modp->handle,
590	–	modp->version, (modp->flags & MODULE_FLAG_CORE) ?"(core)":"");
591	–	}
592	–
593	–	sendto_one(source_p, form_str(RPL_ENDOFMODLIST),
594	–	me.name, source_p->name);
595	–	}
596	–
597	–	/* unload and reload all modules */
598	–	static void
599	–	mo_modrestart(struct Client *client_p, struct Client *source_p,
600	–	int parc, char *parv[])
601	–	{
602	–	unsigned int modnum = 0;
603	–	dlink_node *ptr = NULL, *ptr_next = NULL;
604	–
605	–	if (!HasOFlag(source_p, OPER_FLAG_MODULE))
606	–	{
607	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
608	–	me.name, source_p->name);
609	–	return;
610	–	}
611	–
612	–	sendto_one(source_p, ":%s NOTICE %s :Reloading all modules",
613	–	me.name, source_p->name);
614	–
615	–	modnum = dlink_list_length(&modules_list);
616	–
617	–	DLINK_FOREACH_SAFE(ptr, ptr_next, modules_list.head)
618	–	{
619	–	struct module *modp = ptr->data;
620	–	unload_one_module(modp->name, 0);
621	–	}
622	–
623	–	load_all_modules(0);
624	–	load_conf_modules();
625	–	load_core_modules(0);
626	–
627	–	sendto_realops_flags(UMODE_ALL, L_ALL,
628	–	"Module Restart: %u modules unloaded, %u modules loaded",
629	–	modnum, dlink_list_length(&modules_list));
630	–	ilog(L_WARN, "Module Restart: %u modules unloaded, %u modules loaded",
631	–	modnum, dlink_list_length(&modules_list));
632	–	}

Diff Legend

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