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 912 by michael, Wed Nov 7 22:47:44 2007 UTC vs.
ircd-hybrid/trunk/src/modules.c (file contents), Revision 2959 by michael, Tue Jan 28 17:30:49 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  modules.c: A module loader.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2002 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 2000-2014 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
21	–	*
22	–	*  $Id$
20		*/
21
22	+	/*! \file modules.c
23	+	* \brief A module loader.
24	+	* \version $Id$
25	+	*/
26	+
27	+	#include "ltdl.h"
28	+
29		#include "stdinc.h"
30	<	#include "tools.h"
30	>	#include "list.h"
31		#include "modules.h"
32	<	#include "s_log.h"
32	>	#include "log.h"
33		#include "ircd.h"
34		#include "client.h"
35		#include "send.h"
36	<	#include "s_conf.h"
33	<	#include "handlers.h"
36	>	#include "conf.h"
37		#include "numeric.h"
38		#include "parse.h"
39		#include "ircd_defs.h"
40		#include "irc_string.h"
41		#include "memory.h"
39	–	#include "list.h"
42
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	–	*/
43
44	<	dlink_list mod_list = { NULL, NULL, 0 };
44	>	static dlink_list modules_list;
45	>	static dlink_list modules_path;
46	>	static dlink_list modules_conf;
47
48	+	static const char *unknown_ver = "<unknown>";
49		static const char *core_module_table[] =
50		{
51		"m_die.la",
52	+	"m_error.la",
53		"m_join.la",
54		"m_kick.la",
55		"m_kill.la",
#	Line 68 | Line 64 | static const char *core_module_table[] =
64		NULL
65		};
66
71	–	static dlink_list mod_paths = { NULL, NULL, 0 };
72	–	static dlink_list conf_modules = { NULL, NULL, 0 };
67
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 *[]);
79	<
80	<	struct Message modload_msgtab = {
81	<	"MODLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
82	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modload, m_ignore}
83	<	};
68	>	dlink_list *
69	>	modules_get_list(void)
70	>	{
71	>	return &modules_list;
72	>	}
73
74	<	struct Message modunload_msgtab = {
75	<	"MODUNLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
76	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modunload, m_ignore}
77	<	};
74	>	int
75	>	modules_valid_suffix(const char *name)
76	>	{
77	>	return ((name = strrchr(name, '.'))) && !strcmp(name, ".la");
78	>	}
79
80	<	struct Message modreload_msgtab = {
81	<	"MODRELOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
82	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modreload, m_ignore}
83	<	};
80	>	/* unload_one_module()
81	>	*
82	>	* inputs       - name of module to unload
83	>	*              - 1 to say modules unloaded, 0 to not
84	>	* output       - 0 if successful, -1 if error
85	>	* side effects - module is unloaded
86	>	*/
87	>	int
88	>	unload_one_module(const char *name, int warn)
89	>	{
90	>	struct module *modp = NULL;
91
92	<	struct Message modlist_msgtab = {
93	<	"MODLIST", 0, 0, 0, 0, MFLG_SLOW, 0,
97	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modlist, m_ignore}
98	<	};
92	>	if ((modp = findmodule_byname(name)) == NULL)
93	>	return -1;
94
95	<	struct Message modrestart_msgtab = {
96	<	"MODRESTART", 0, 0, 0, 0, MFLG_SLOW, 0,
97	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modrestart, m_ignore}
98	<	};
95	>	if (modp->modexit)
96	>	modp->modexit();
97	>
98	>	assert(dlink_list_length(&modules_list) > 0);
99	>	dlinkDelete(&modp->node, &modules_list);
100	>	MyFree(modp->name);
101	>
102	>	lt_dlclose(modp->handle);
103	>
104	>	if (warn == 1)
105	>	{
106	>	ilog(LOG_TYPE_IRCD, "Module %s unloaded", name);
107	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
108	>	"Module %s unloaded", name);
109	>	}
110	>
111	>	return 0;
112	>	}
113
114	+	/* load_a_module()
115	+	*
116	+	* inputs       - path name of module, int to notice, int of core
117	+	* output       - -1 if error 0 if success
118	+	* side effects - loads a module if successful
119	+	*/
120	+	int
121	+	load_a_module(const char *path, int warn)
122	+	{
123	+	lt_dlhandle tmpptr = NULL;
124	+	const char *mod_basename = NULL;
125	+	struct module *modp = NULL;
126
127	<	extern struct Message error_msgtab;
127	>	if (findmodule_byname((mod_basename = libio_basename(path))))
128	>	return 1;
129	>
130	>	if (!(tmpptr = lt_dlopen(path)))
131	>	{
132	>	const char *err = ((err = lt_dlerror())) ? err : "<unknown>";
133	>
134	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
135	>	"Error loading module %s: %s",
136	>	mod_basename, err);
137	>	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
138	>	return -1;
139	>	}
140	>
141	>	if ((modp = lt_dlsym(tmpptr, "module_entry")) == NULL)
142	>	{
143	>	const char *err = ((err = lt_dlerror())) ? err : "<unknown>";
144	>
145	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
146	>	"Error loading module %s: %s",
147	>	mod_basename, err);
148	>	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
149	>	lt_dlclose(tmpptr);
150	>	return -1;
151	>	}
152	>
153	>	modp->handle = tmpptr;
154	>
155	>	if (EmptyString(modp->version))
156	>	modp->version = unknown_ver;
157	>
158	>	modp->name = xstrdup(mod_basename);
159	>	dlinkAdd(modp, &modp->node, &modules_list);
160	>
161	>	if (modp->modinit)
162	>	modp->modinit();
163	>
164	>	if (warn == 1)
165	>	{
166	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
167	>	"Module %s [version: %s handle: %p] loaded.",
168	>	modp->name, modp->version, tmpptr);
169	>	ilog(LOG_TYPE_IRCD, "Module %s [version: %s handle: %p] loaded.",
170	>	modp->name, modp->version, tmpptr);
171	>	}
172	>
173	>	return 0;
174	>	}
175
176		/*
177		* modules_init
#	Line 115 | Line 183 | extern struct Message error_msgtab;
183		void
184		modules_init(void)
185		{
186	<	dynlink_init();
187	<
188	<	mod_add_cmd(&modload_msgtab);
189	<	mod_add_cmd(&modunload_msgtab);
190	<	mod_add_cmd(&modreload_msgtab);
191	<	mod_add_cmd(&modlist_msgtab);
124	<	mod_add_cmd(&modrestart_msgtab);
125	<	mod_add_cmd(&error_msgtab);
186	>	if (lt_dlinit())
187	>	{
188	>	ilog(LOG_TYPE_IRCD, "Couldn't initialize the libltdl run time dynamic"
189	>	" link library. Exiting.");
190	>	exit(0);
191	>	}
192		}
193
194		/* mod_find_path()
#	Line 134 | Line 200 | modules_init(void)
200		static struct module_path *
201		mod_find_path(const char *path)
202		{
203	<	dlink_node *ptr;
138	<	struct module_path *mpath;
203	>	dlink_node *ptr = NULL;
204
205	<	DLINK_FOREACH(ptr, mod_paths.head)
205	>	DLINK_FOREACH(ptr, modules_path.head)
206		{
207	<	mpath = ptr->data;
207	>	struct module_path *mpath = ptr->data;
208
209		if (!strcmp(path, mpath->path))
210		return mpath;
#	Line 165 | Line 230 | mod_add_path(const char *path)
230		pathst = MyMalloc(sizeof(struct module_path));
231
232		strlcpy(pathst->path, path, sizeof(pathst->path));
233	<	dlinkAdd(pathst, &pathst->node, &mod_paths);
233	>	dlinkAdd(pathst, &pathst->node, &modules_path);
234		}
235
236		/* add_conf_module
#	Line 182 | Line 247 | add_conf_module(const char *name)
247		pathst = MyMalloc(sizeof(struct module_path));
248
249		strlcpy(pathst->path, name, sizeof(pathst->path));
250	<	dlinkAdd(pathst, &pathst->node, &conf_modules);
250	>	dlinkAdd(pathst, &pathst->node, &modules_conf);
251		}
252
253		/* mod_clear_paths()
#	Line 194 | Line 259 | add_conf_module(const char *name)
259		void
260		mod_clear_paths(void)
261		{
262	<	struct module_path *pathst;
198	<	dlink_node *ptr;
199	<	dlink_node *next_ptr;
262	>	dlink_node *ptr = NULL, *next_ptr = NULL;
263
264	<	DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
264	>	DLINK_FOREACH_SAFE(ptr, next_ptr, modules_path.head)
265		{
266	<	pathst = ptr->data;
267	<
205	<	dlinkDelete(&pathst->node, &mod_paths);
206	<	MyFree(pathst);
266	>	dlinkDelete(ptr, &modules_path);
267	>	MyFree(ptr->data);
268		}
269
270	<	DLINK_FOREACH_SAFE(ptr, next_ptr, conf_modules.head)
270	>	DLINK_FOREACH_SAFE(ptr, next_ptr, modules_conf.head)
271		{
272	<	pathst = ptr->data;
273	<
213	<	dlinkDelete(&pathst->node, &conf_modules);
214	<	MyFree(pathst);
272	>	dlinkDelete(ptr, &modules_conf);
273	>	MyFree(ptr->data);
274		}
275		}
276
#	Line 221 | Line 280 | mod_clear_paths(void)
280		* output       - NULL if not found or pointer to module
281		* side effects - NONE
282		*/
283	<	dlink_node *
283	>	struct module *
284		findmodule_byname(const char *name)
285		{
286	<	dlink_node *ptr;
228	<	struct module *modp;
286	>	dlink_node *ptr = NULL;
287
288	<	DLINK_FOREACH(ptr, mod_list.head)
288	>	DLINK_FOREACH(ptr, modules_list.head)
289		{
290	<	modp = ptr->data;
290	>	struct module *modp = ptr->data;
291
292		if (strcmp(modp->name, name) == 0)
293	<	return ptr;
293	>	return modp;
294		}
295
296		return NULL;
#	Line 249 | Line 307 | load_all_modules(int warn)
307		{
308		DIR *system_module_dir = NULL;
309		struct dirent *ldirent = NULL;
310	<	char module_fq_name[PATH_MAX + 1];
253	<
254	<	modules_init();
310	>	char module_fq_name[HYB_PATH_MAX + 1];
311
312		if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
313		{
314	<	ilog(L_WARN, "Could not load modules from %s: %s",
314	>	ilog(LOG_TYPE_IRCD, "Could not load modules from %s: %s",
315		AUTOMODPATH, strerror(errno));
316		return;
317		}
#	Line 266 | Line 322 | load_all_modules(int warn)
322		{
323		snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s",
324		AUTOMODPATH, ldirent->d_name);
325	<	load_a_module(module_fq_name, warn, 0);
325	>	load_a_module(module_fq_name, warn);
326		}
327		}
328
#	Line 283 | Line 339 | void
339		load_conf_modules(void)
340		{
341		dlink_node *ptr = NULL;
286	–	struct module_path *mpath = NULL;
342
343	<	DLINK_FOREACH(ptr, conf_modules.head)
343	>	DLINK_FOREACH(ptr, modules_conf.head)
344		{
345	<	mpath = ptr->data;
345	>	struct module_path *mpath = ptr->data;
346
347		if (findmodule_byname(mpath->path) == NULL)
348	<	load_one_module(mpath->path, 0);
348	>	load_one_module(mpath->path);
349		}
350		}
351
#	Line 303 | Line 358 | load_conf_modules(void)
358		void
359		load_core_modules(int warn)
360		{
361	<	char module_name[PATH_MAX + 1];
361	>	char module_name[HYB_PATH_MAX + 1];
362		int i = 0;
363
364		for (; core_module_table[i]; ++i)
#	Line 311 | Line 366 | load_core_modules(int warn)
366		snprintf(module_name, sizeof(module_name), "%s%s",
367		MODPATH, core_module_table[i]);
368
369	<	if (load_a_module(module_name, warn, 1) == -1)
369	>	if (load_a_module(module_name, warn) == -1)
370		{
371	<	ilog(L_CRIT, "Error loading core module %s: terminating ircd",
371	>	ilog(LOG_TYPE_IRCD, "Error loading core module %s: terminating ircd",
372		core_module_table[i]);
373		exit(EXIT_FAILURE);
374		}
#	Line 324 | Line 379 | load_core_modules(int warn)
379		*
380		* input        - pointer to path
381		*              - flagged as core module or not
382	<	* output       - -1 if error
382	>	* output       - -1 if error
383		* side effects - module is loaded if found.
384		*/
385		int
386	<	load_one_module(char *path, int coremodule)
386	>	load_one_module(const char *path)
387		{
388		dlink_node *ptr = NULL;
389	<	char modpath[PATH_MAX + 1];
389	>	char modpath[HYB_PATH_MAX + 1];
390		struct stat statbuf;
391
392	<	DLINK_FOREACH(ptr, mod_paths.head)
392	>	DLINK_FOREACH(ptr, modules_path.head)
393		{
394		const struct module_path *mpath = ptr->data;
395
#	Line 344 | Line 399 | load_one_module(char *path, int coremodu
399		continue;
400
401		if (strstr(modpath, "../") == NULL &&
402	<	strstr(modpath, "/..") == NULL)
348	<	{
402	>	strstr(modpath, "/..") == NULL)
403		if (!stat(modpath, &statbuf))
404	<	{
405	<	if (S_ISREG(statbuf.st_mode))
352	<	{
353	<	/* Regular files only please */
354	<	return load_a_module(modpath, 1, coremodule);
355	<	}
356	<	}
357	<	}
404	>	if (S_ISREG(statbuf.st_mode))  /* Regular files only please */
405	>	return load_a_module(modpath, 1);
406		}
407
408	<	sendto_realops_flags(UMODE_ALL, L_ALL,
408	>	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
409		"Cannot locate module %s", path);
410	<	ilog(L_WARN, "Cannot locate module %s", path);
410	>	ilog(LOG_TYPE_IRCD, "Cannot locate module %s", path);
411		return -1;
412		}
365	–
366	–	/* load a module .. */
367	–	static void
368	–	mo_modload(struct Client *client_p, struct Client *source_p,
369	–	int parc, char *parv[])
370	–	{
371	–	char *m_bn;
372	–
373	–	if (!IsAdmin(source_p))
374	–	{
375	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
376	–	me.name, source_p->name);
377	–	return;
378	–	}
379	–
380	–	m_bn = basename(parv[1]);
381	–
382	–	if (findmodule_byname(m_bn) != NULL)
383	–	{
384	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is already loaded",
385	–	me.name, source_p->name, m_bn);
386	–	return;
387	–	}
388	–
389	–	load_one_module(parv[1], 0);
390	–	}
391	–
392	–	/* unload a module .. */
393	–	static void
394	–	mo_modunload(struct Client *client_p, struct Client *source_p,
395	–	int parc, char *parv[])
396	–	{
397	–	char *m_bn;
398	–	dlink_node *ptr;
399	–	struct module *modp;
400	–
401	–	if (!IsAdmin(source_p))
402	–	{
403	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
404	–	me.name, source_p->name);
405	–	return;
406	–	}
407	–
408	–	m_bn = basename(parv[1]);
409	–
410	–	if ((ptr = findmodule_byname(m_bn)) == NULL)
411	–	{
412	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
413	–	me.name, source_p->name, m_bn);
414	–	return;
415	–	}
416	–
417	–	modp = ptr->data;
418	–
419	–	if (modp->core == 1)
420	–	{
421	–	sendto_one(source_p,
422	–	":%s NOTICE %s :Module %s is a core module and may not be unloaded",
423	–	me.name, source_p->name, m_bn);
424	–	return;
425	–	}
426	–
427	–	/* XXX might want to simply un dlink it here */
428	–
429	–	if (unload_one_module(m_bn, 1) == -1)
430	–	{
431	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
432	–	me.name, source_p->name, m_bn);
433	–	}
434	–	}
435	–
436	–	/* unload and load in one! */
437	–	static void
438	–	mo_modreload(struct Client *client_p, struct Client *source_p,
439	–	int parc, char *parv[])
440	–	{
441	–	char *m_bn;
442	–	dlink_node *ptr;
443	–	struct module *modp;
444	–	int check_core;
445	–
446	–	if (!IsAdmin(source_p))
447	–	{
448	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
449	–	me.name, source_p->name);
450	–	return;
451	–	}
452	–
453	–	m_bn = basename(parv[1]);
454	–
455	–	if ((ptr = findmodule_byname(m_bn)) == NULL)
456	–	{
457	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
458	–	me.name, source_p->name, m_bn);
459	–	return;
460	–	}
461	–
462	–	modp = ptr->data;
463	–	check_core = modp->core;
464	–
465	–	if (unload_one_module(m_bn, 1) == -1)
466	–	{
467	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
468	–	me.name, source_p->name, m_bn);
469	–	return;
470	–	}
471	–
472	–	if ((load_one_module(parv[1], check_core) == -1) && check_core)
473	–	{
474	–	sendto_realops_flags(UMODE_ALL, L_ALL, "Error reloading core "
475	–	"module: %s: terminating ircd", parv[1]);
476	–	ilog(L_CRIT, "Error loading core module %s: terminating ircd", parv[1]);
477	–	exit(0);
478	–	}
479	–	}
480	–
481	–	/* list modules .. */
482	–	static void
483	–	mo_modlist(struct Client *client_p, struct Client *source_p,
484	–	int parc, char *parv[])
485	–	{
486	–	const dlink_node *ptr = NULL;
487	–
488	–	if (!IsAdmin(source_p))
489	–	{
490	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
491	–	me.name, source_p->name);
492	–	return;
493	–	}
494	–
495	–	DLINK_FOREACH(ptr, mod_list.head)
496	–	{
497	–	const struct module *modp = ptr->data;
498	–
499	–	if (parc > 1 && !match(parv[1], modp->name))
500	–	continue;
501	–
502	–	sendto_one(source_p, form_str(RPL_MODLIST), me.name, parv[0],
503	–	modp->name, modp->handle,
504	–	modp->version, modp->core?"(core)":"");
505	–	}
506	–
507	–	sendto_one(source_p, form_str(RPL_ENDOFMODLIST),
508	–	me.name, source_p->name);
509	–	}
510	–
511	–	/* unload and reload all modules */
512	–	static void
513	–	mo_modrestart(struct Client *client_p, struct Client *source_p,
514	–	int parc, char *parv[])
515	–	{
516	–	unsigned int modnum = 0;
517	–	dlink_node *ptr = NULL, *ptr_next = NULL;
518	–
519	–	if (!IsAdmin(source_p))
520	–	{
521	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
522	–	me.name, source_p->name);
523	–	return;
524	–	}
525	–
526	–	sendto_one(source_p, ":%s NOTICE %s :Reloading all modules",
527	–	me.name, source_p->name);
528	–
529	–	modnum = dlink_list_length(&mod_list);
530	–
531	–	DLINK_FOREACH_SAFE(ptr, ptr_next, mod_list.head)
532	–	{
533	–	struct module *modp = ptr->data;
534	–	unload_one_module(modp->name, 0);
535	–	}
536	–
537	–	load_all_modules(0);
538	–	load_conf_modules();
539	–	load_core_modules(0);
540	–
541	–	sendto_realops_flags(UMODE_ALL, L_ALL,
542	–	"Module Restart: %u modules unloaded, %lu modules loaded",
543	–	modnum, dlink_list_length(&mod_list));
544	–	ilog(L_WARN, "Module Restart: %u modules unloaded, %lu modules loaded",
545	–	modnum, dlink_list_length(&mod_list));
546	–	}

Diff Legend

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