ViewVC Help

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

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

Comparing:
ircd-hybrid/src/modules.c (file contents), Revision 30 by adx, Sun Oct 2 20:03:27 2005 UTC vs.
ircd-hybrid/trunk/src/modules.c (file contents), Revision 1592 by michael, Sat Oct 27 21:02:32 2012 UTC

#	Line 19 | Line 19
19		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
20		*  USA
21		*
22	<	*  $Id: modules.c,v 7.178 2005/09/18 23:07:29 adx Exp $
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	>	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
64		static dlink_list mod_paths = { NULL, NULL, 0 };
65		static dlink_list conf_modules = { NULL, NULL, 0 };
66
67	<	static void mo_modload(struct Client *, struct Client *, int, char *[]);
68	<	static void mo_modlist(struct Client *, struct Client *, int, char *[]);
69	<	static void mo_modreload(struct Client *, struct Client *, int, char *[]);
70	<	static void mo_modunload(struct Client *, struct Client *, int, char *[]);
71	<	static void mo_modrestart(struct Client *, struct Client *, int, char *[]);
81	<
82	<	struct Message modload_msgtab = {
83	<	"MODLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
84	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modload, m_ignore}
85	<	};
67	>	int
68	>	modules_valid_suffix(const char *name)
69	>	{
70	>	return ((name = strrchr(name, '.'))) && !strcmp(name, ".la");
71	>	}
72
73	<	struct Message modunload_msgtab = {
74	<	"MODUNLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
75	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modunload, m_ignore}
76	<	};
73	>	/* unload_one_module()
74	>	*
75	>	* inputs       - name of module to unload
76	>	*              - 1 to say modules unloaded, 0 to not
77	>	* output       - 0 if successful, -1 if error
78	>	* side effects - module is unloaded
79	>	*/
80	>	int
81	>	unload_one_module(const char *name, int warn)
82	>	{
83	>	struct module *modp = NULL;
84
85	<	struct Message modreload_msgtab = {
86	<	"MODRELOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
94	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modreload, m_ignore}
95	<	};
85	>	if ((modp = findmodule_byname(name)) == NULL)
86	>	return -1;
87
88	<	struct Message modlist_msgtab = {
89	<	"MODLIST", 0, 0, 0, 0, MFLG_SLOW, 0,
99	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modlist, m_ignore}
100	<	};
88	>	if (modp->modexit)
89	>	modp->modexit();
90
91	<	struct Message modrestart_msgtab = {
92	<	"MODRESTART", 0, 0, 0, 0, MFLG_SLOW, 0,
93	<	{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modrestart, m_ignore}
94	<	};
91	>	assert(dlink_list_length(&modules_list) > 0);
92	>	dlinkDelete(&modp->node, &modules_list);
93	>	MyFree(modp->name);
94	>
95	>	lt_dlclose(modp->handle);
96	>
97	>	if (warn == 1)
98	>	{
99	>	ilog(LOG_TYPE_IRCD, "Module %s unloaded", name);
100	>	sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s unloaded", name);
101	>	}
102	>
103	>	return 0;
104	>	}
105	>
106	>	/* load_a_module()
107	>	*
108	>	* inputs       - path name of module, int to notice, int of core
109	>	* output       - -1 if error 0 if success
110	>	* side effects - loads a module if successful
111	>	*/
112	>	int
113	>	load_a_module(const char *path, int warn)
114	>	{
115	>	lt_dlhandle tmpptr = NULL;
116	>	const char *mod_basename = NULL;
117	>	struct module *modp = NULL;
118	>
119	>	if (findmodule_byname((mod_basename = libio_basename(path))))
120	>	return 1;
121	>
122	>	if (!(tmpptr = lt_dlopen(path))) {
123	>	const char *err = ((err = lt_dlerror())) ? err : "<unknown>";
124	>
125	>	sendto_realops_flags(UMODE_ALL, L_ALL, "Error loading module %s: %s",
126	>	mod_basename, err);
127	>	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
128	>	return -1;
129	>	}
130	>
131	>	if ((modp = lt_dlsym(tmpptr, "module_entry")) == NULL)
132	>	{
133	>	const char *err = ((err = lt_dlerror())) ? err : "<unknown>";
134	>
135	>	sendto_realops_flags(UMODE_ALL, L_ALL, "Error loading module %s: %s",
136	>	mod_basename, err);
137	>	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
138	>	lt_dlclose(tmpptr);
139	>	return -1;
140	>	}
141	>
142	>	modp->handle = tmpptr;
143	>
144	>	if (EmptyString(modp->version))
145	>	modp->version = unknown_ver;
146	>
147	>	DupString(modp->name, mod_basename);
148	>	dlinkAdd(modp, &modp->node, &modules_list);
149	>
150	>	if (modp->modinit)
151	>	modp->modinit();
152
153	+	if (warn == 1)
154	+	{
155	+	sendto_realops_flags(UMODE_ALL, L_ALL,
156	+	"Module %s [version: %s handle: %p] loaded.",
157	+	modp->name, modp->version, tmpptr);
158	+	ilog(LOG_TYPE_IRCD, "Module %s [version: %s handle: %p] loaded.",
159	+	modp->name, modp->version, tmpptr);
160	+	}
161
162	<	extern struct Message error_msgtab;
162	>	return 0;
163	>	}
164
165		/*
166		* modules_init
#	Line 117 | Line 172 | extern struct Message error_msgtab;
172		void
173		modules_init(void)
174		{
175	<	mod_add_cmd(&modload_msgtab);
176	<	mod_add_cmd(&modunload_msgtab);
177	<	mod_add_cmd(&modreload_msgtab);
178	<	mod_add_cmd(&modlist_msgtab);
179	<	mod_add_cmd(&modrestart_msgtab);
180	<	mod_add_cmd(&error_msgtab);
175	>	if (lt_dlinit())
176	>	{
177	>	ilog(LOG_TYPE_IRCD, "Couldn't initialize the libltdl run time dynamic"
178	>	" link library. Exiting.");
179	>	exit(0);
180	>	}
181		}
182
183		/* mod_find_path()
#	Line 135 | Line 190 | static struct module_path *
190		mod_find_path(const char *path)
191		{
192		dlink_node *ptr;
138	–	struct module_path *mpath;
193
194		DLINK_FOREACH(ptr, mod_paths.head)
195		{
196	<	mpath = ptr->data;
196	>	struct module_path *mpath = ptr->data;
197
198		if (!strcmp(path, mpath->path))
199		return mpath;
#	Line 194 | Line 248 | add_conf_module(const char *name)
248		void
249		mod_clear_paths(void)
250		{
251	<	struct module_path *pathst;
198	<	dlink_node *ptr;
199	<	dlink_node *next_ptr;
251	>	dlink_node *ptr = NULL, *next_ptr = NULL;
252
253		DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
254		{
255	<	pathst = ptr->data;
256	<
205	<	dlinkDelete(&pathst->node, &mod_paths);
206	<	MyFree(pathst);
255	>	dlinkDelete(ptr, &mod_paths);
256	>	MyFree(ptr->data);
257		}
258
259		DLINK_FOREACH_SAFE(ptr, next_ptr, conf_modules.head)
260		{
261	<	pathst = ptr->data;
262	<
213	<	dlinkDelete(&pathst->node, &conf_modules);
214	<	MyFree(pathst);
261	>	dlinkDelete(ptr, &conf_modules);
262	>	MyFree(ptr->data);
263		}
264		}
265
#	Line 221 | Line 269 | mod_clear_paths(void)
269		* output       - NULL if not found or pointer to module
270		* side effects - NONE
271		*/
272	<	dlink_node *
272	>	struct module *
273		findmodule_byname(const char *name)
274		{
275	<	dlink_node *ptr;
228	<	struct module *modp;
275	>	dlink_node *ptr = NULL;
276
277	<	DLINK_FOREACH(ptr, mod_list.head)
277	>	DLINK_FOREACH(ptr, modules_list.head)
278		{
279	<	modp = ptr->data;
279	>	struct module *modp = ptr->data;
280
281	<	if (!irccmp(modp->name, name))
282	<	return ptr;
281	>	if (strcmp(modp->name, name) == 0)
282	>	return modp;
283		}
284
285		return NULL;
#	Line 251 | Line 298 | load_all_modules(int warn)
298		struct dirent *ldirent = NULL;
299		char module_fq_name[PATH_MAX + 1];
300
254	–	modules_init();
255	–
301		if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
302		{
303	<	ilog(L_WARN, "Could not load modules from %s: %s",
303	>	ilog(LOG_TYPE_IRCD, "Could not load modules from %s: %s",
304		AUTOMODPATH, strerror(errno));
305		return;
306		}
307
308		while ((ldirent = readdir(system_module_dir)) != NULL)
309		{
310	<	const char *offset = strrchr(ldirent->d_name, '.');
266	<
267	<	if (offset && !strcmp(offset, SHARED_SUFFIX))
310	>	if (modules_valid_suffix(ldirent->d_name))
311		{
312		snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s",
313		AUTOMODPATH, ldirent->d_name);
314	<	load_a_module(module_fq_name, warn, 0);
314	>	load_a_module(module_fq_name, warn);
315		}
316		}
317
#	Line 285 | Line 328 | void
328		load_conf_modules(void)
329		{
330		dlink_node *ptr = NULL;
288	–	struct module_path *mpath = NULL;
331
332		DLINK_FOREACH(ptr, conf_modules.head)
333		{
334	<	mpath = ptr->data;
334	>	struct module_path *mpath = ptr->data;
335
336		if (findmodule_byname(mpath->path) == NULL)
337	<	load_one_module(mpath->path, 0);
337	>	load_one_module(mpath->path);
338		}
339		}
340
#	Line 310 | Line 352 | load_core_modules(int warn)
352
353		for (; core_module_table[i]; ++i)
354		{
355	<	snprintf(module_name, sizeof(module_name), "%s%s%s", MODPATH,
356	<	core_module_table[i], SHARED_SUFFIX);
355	>	snprintf(module_name, sizeof(module_name), "%s%s",
356	>	MODPATH, core_module_table[i]);
357
358	<	if (load_a_module(module_name, warn, 1) == -1)
358	>	if (load_a_module(module_name, warn) == -1)
359		{
360	<	ilog(L_CRIT, "Error loading core module %s%s: terminating ircd",
361	<	core_module_table[i], SHARED_SUFFIX);
360	>	ilog(LOG_TYPE_IRCD, "Error loading core module %s: terminating ircd",
361	>	core_module_table[i]);
362		exit(EXIT_FAILURE);
363		}
364		}
#	Line 330 | Line 372 | load_core_modules(int warn)
372		* side effects - module is loaded if found.
373		*/
374		int
375	<	load_one_module(char *path, int coremodule)
375	>	load_one_module(const char *path)
376		{
377		dlink_node *ptr = NULL;
378		char modpath[PATH_MAX + 1];
#	Line 342 | Line 384 | load_one_module(char *path, int coremodu
384
385		snprintf(modpath, sizeof(modpath), "%s/%s", mpath->path, path);
386
387	+	if (!modules_valid_suffix(path))
388	+	continue;
389	+
390		if (strstr(modpath, "../") == NULL &&
391		strstr(modpath, "/..") == NULL)
347	–	{
392		if (!stat(modpath, &statbuf))
393	<	{
394	<	if (S_ISREG(statbuf.st_mode))
351	<	{
352	<	/* Regular files only please */
353	<	return load_a_module(modpath, 1, coremodule);
354	<	}
355	<	}
356	<	}
393	>	if (S_ISREG(statbuf.st_mode))  /* Regular files only please */
394	>	return load_a_module(modpath, 1);
395		}
396
397		sendto_realops_flags(UMODE_ALL, L_ALL,
398		"Cannot locate module %s", path);
399	<	ilog(L_WARN, "Cannot locate module %s", path);
399	>	ilog(LOG_TYPE_IRCD, "Cannot locate module %s", path);
400		return -1;
401		}
364	–
365	–	/* load a module .. */
366	–	static void
367	–	mo_modload(struct Client *client_p, struct Client *source_p,
368	–	int parc, char *parv[])
369	–	{
370	–	char *m_bn;
371	–
372	–	if (!IsAdmin(source_p))
373	–	{
374	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
375	–	me.name, source_p->name);
376	–	return;
377	–	}
378	–
379	–	m_bn = basename(parv[1]);
380	–
381	–	if (findmodule_byname(m_bn) != NULL)
382	–	{
383	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is already loaded",
384	–	me.name, source_p->name, m_bn);
385	–	return;
386	–	}
387	–
388	–	load_one_module(parv[1], 0);
389	–	}
390	–
391	–	/* unload a module .. */
392	–	static void
393	–	mo_modunload(struct Client *client_p, struct Client *source_p,
394	–	int parc, char *parv[])
395	–	{
396	–	char *m_bn;
397	–	dlink_node *ptr;
398	–	struct module *modp;
399	–
400	–	if (!IsAdmin(source_p))
401	–	{
402	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
403	–	me.name, source_p->name);
404	–	return;
405	–	}
406	–
407	–	m_bn = basename(parv[1]);
408	–
409	–	if ((ptr = findmodule_byname(m_bn)) == NULL)
410	–	{
411	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
412	–	me.name, source_p->name, m_bn);
413	–	return;
414	–	}
415	–
416	–	modp = ptr->data;
417	–
418	–	if (modp->core == 1)
419	–	{
420	–	sendto_one(source_p,
421	–	":%s NOTICE %s :Module %s is a core module and may not be unloaded",
422	–	me.name, source_p->name, m_bn);
423	–	return;
424	–	}
425	–
426	–	/* XXX might want to simply un dlink it here */
427	–
428	–	if (unload_one_module(m_bn, 1) == -1)
429	–	{
430	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
431	–	me.name, source_p->name, m_bn);
432	–	}
433	–	}
434	–
435	–	/* unload and load in one! */
436	–	static void
437	–	mo_modreload(struct Client *client_p, struct Client *source_p,
438	–	int parc, char *parv[])
439	–	{
440	–	char *m_bn;
441	–	dlink_node *ptr;
442	–	struct module *modp;
443	–	int check_core;
444	–
445	–	if (!IsAdmin(source_p))
446	–	{
447	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
448	–	me.name, source_p->name);
449	–	return;
450	–	}
451	–
452	–	m_bn = basename(parv[1]);
453	–
454	–	if ((ptr = findmodule_byname(m_bn)) == NULL)
455	–	{
456	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
457	–	me.name, source_p->name, m_bn);
458	–	return;
459	–	}
460	–
461	–	modp = ptr->data;
462	–	check_core = modp->core;
463	–
464	–	if (unload_one_module(m_bn, 1) == -1)
465	–	{
466	–	sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
467	–	me.name, source_p->name, m_bn);
468	–	return;
469	–	}
470	–
471	–	if ((load_one_module(parv[1], check_core) == -1) && check_core)
472	–	{
473	–	sendto_realops_flags(UMODE_ALL, L_ALL, "Error reloading core "
474	–	"module: %s: terminating ircd", parv[1]);
475	–	ilog(L_CRIT, "Error loading core module %s: terminating ircd", parv[1]);
476	–	exit(0);
477	–	}
478	–	}
479	–
480	–	/* list modules .. */
481	–	static void
482	–	mo_modlist(struct Client *client_p, struct Client *source_p,
483	–	int parc, char *parv[])
484	–	{
485	–	dlink_node *ptr;
486	–	struct module *modp;
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	–	modp = ptr->data;
498	–
499	–	if (parc > 1)
500	–	{
501	–	if (match(parv[1], modp->name))
502	–	{
503	–	sendto_one(source_p, form_str(RPL_MODLIST), me.name, parv[0],
504	–	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	–	}
514	–	}
515	–
516	–	sendto_one(source_p, form_str(RPL_ENDOFMODLIST),
517	–	me.name, source_p->name);
518	–	}
519	–
520	–	/* unload and reload all modules */
521	–	static void
522	–	mo_modrestart(struct Client *client_p, struct Client *source_p,
523	–	int parc, char *parv[])
524	–	{
525	–	unsigned int modnum = 0;
526	–	dlink_node *ptr;
527	–	dlink_node *tptr;
528	–	struct module *modp;
529	–
530	–	if (!IsAdmin(source_p))
531	–	{
532	–	sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
533	–	me.name, source_p->name);
534	–	return;
535	–	}
536	–
537	–	sendto_one(source_p, ":%s NOTICE %s :Reloading all modules",
538	–	me.name, source_p->name);
539	–
540	–	modnum = dlink_list_length(&mod_list);
541	–
542	–	DLINK_FOREACH_SAFE(ptr, tptr, mod_list.head)
543	–	{
544	–	modp = ptr->data;
545	–	unload_one_module(modp->name, 0);
546	–	}
547	–
548	–	load_all_modules(0);
549	–	load_conf_modules();
550	–	load_core_modules(0);
551	–
552	–	sendto_realops_flags(UMODE_ALL, L_ALL,
553	–	"Module Restart: %u modules unloaded, %lu modules loaded",
554	–	modnum, dlink_list_length(&mod_list));
555	–	ilog(L_WARN, "Module Restart: %u modules unloaded, %lu modules loaded",
556	–	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(&capab_msgtab);
576	–	mod_add_cmd(&cburst_msgtab);
577	–	mod_add_cmd(&close_msgtab);
578	–	mod_add_cmd(&connect_msgtab);
579	–	#ifdef HAVE_LIBCRYPTO
580	–	mod_add_cmd(&challenge_msgtab);
581	–	mod_add_cmd(&cryptlink_msgtab);
582	–	#endif
583	–	mod_add_cmd(&die_msgtab);
584	–	mod_add_cmd(&drop_msgtab);
585	–	mod_add_cmd(&eob_msgtab);
586	–	mod_add_cmd(&etrace_msgtab);
587	–	mod_add_cmd(&gline_msgtab);
588	–	add_capability("GLN", CAP_GLN, 1);
589	–	mod_add_cmd(&hash_msgtab);
590	–	mod_add_cmd(&ungline_msgtab);
591	–	mod_add_cmd(&info_msgtab);
592	–	mod_add_cmd(&invite_msgtab);
593	–	mod_add_cmd(&ison_msgtab);
594	–	mod_add_cmd(&join_msgtab);
595	–	mod_add_cmd(&kick_msgtab);
596	–	mod_add_cmd(&kill_msgtab);
597	–	mod_add_cmd(&kline_msgtab);
598	–	add_capability("KLN", CAP_KLN, 1);
599	–	mod_add_cmd(&dline_msgtab);
600	–	mod_add_cmd(&unkline_msgtab);
601	–	mod_add_cmd(&undline_msgtab);
602	–	mod_add_cmd(&knock_msgtab);
603	–	add_capability("KNOCK", CAP_KNOCK, 1);
604	–	mod_add_cmd(&knockll_msgtab);
605	–	mod_add_cmd(&links_msgtab);
606	–	mod_add_cmd(&list_msgtab);
607	–	mod_add_cmd(&lljoin_msgtab);
608	–	mod_add_cmd(&llnick_msgtab);
609	–	mod_add_cmd(&locops_msgtab);
610	–	mod_add_cmd(&lusers_msgtab);
611	–	mod_add_cmd(&privmsg_msgtab);
612	–	mod_add_cmd(&notice_msgtab);
613	–	mod_add_cmd(&map_msgtab);
614	–	mod_add_cmd(&mode_msgtab);
615	–	mod_add_cmd(&motd_msgtab);
616	–	mod_add_cmd(&names_msgtab);
617	–	mod_add_cmd(&nburst_msgtab);
618	–	mod_add_cmd(&nick_msgtab);
619	–	mod_add_cmd(&omotd_msgtab);
620	–	mod_add_cmd(&oper_msgtab);
621	–	mod_add_cmd(&operwall_msgtab);
622	–	mod_add_cmd(&part_msgtab);
623	–	mod_add_cmd(&pass_msgtab);
624	–	mod_add_cmd(&ping_msgtab);
625	–	mod_add_cmd(&pong_msgtab);
626	–	mod_add_cmd(&post_msgtab);
627	–	mod_add_cmd(&get_msgtab);
628	–	mod_add_cmd(&put_msgtab);
629	–	mod_add_cmd(&quit_msgtab);
630	–	mod_add_cmd(&rehash_msgtab);
631	–	mod_add_cmd(&restart_msgtab);
632	–	mod_add_cmd(&resv_msgtab);
633	–	mod_add_cmd(&rkline_msgtab);
634	–	mod_add_cmd(&rxline_msgtab);
635	–	mod_add_cmd(&server_msgtab);
636	–	mod_add_cmd(&set_msgtab);
637	–	mod_add_cmd(&sid_msgtab);
638	–	mod_add_cmd(&sjoin_msgtab);
639	–	mod_add_cmd(&squit_msgtab);
640	–	mod_add_cmd(&stats_msgtab);
641	–	mod_add_cmd(&svinfo_msgtab);
642	–	mod_add_cmd(&tb_msgtab);
643	–	add_capability("TB", CAP_TB, 1);
644	–	mod_add_cmd(&testline_msgtab);
645	–	mod_add_cmd(&testgecos_msgtab);
646	–	mod_add_cmd(&testmask_msgtab);
647	–	mod_add_cmd(&time_msgtab);
648	–	mod_add_cmd(&topic_msgtab);
649	–	mod_add_cmd(&trace_msgtab);
650	–	add_capability("UNKLN", CAP_UNKLN, 1);
651	–	mod_add_cmd(&uid_msgtab);
652	–	mod_add_cmd(&unresv_msgtab);
653	–	mod_add_cmd(&unxline_msgtab);
654	–	mod_add_cmd(&user_msgtab);
655	–	mod_add_cmd(&userhost_msgtab);
656	–	mod_add_cmd(&users_msgtab);
657	–	mod_add_cmd(&version_msgtab);
658	–	mod_add_cmd(&wallops_msgtab);
659	–	mod_add_cmd(&who_msgtab);
660	–	mod_add_cmd(&whois_msgtab);
661	–	mod_add_cmd(&whowas_msgtab);
662	–	mod_add_cmd(&xline_msgtab);
663	–	mod_add_cmd(&help_msgtab);
664	–	mod_add_cmd(&uhelp_msgtab);
665	–	#ifdef BUILD_CONTRIB
666	–	mod_add_cmd(&botserv_msgtab);
667	–	mod_add_cmd(&capture_msgtab);
668	–	mod_add_cmd(&chanserv_msgtab);
669	–	mod_add_cmd(&chghost_msgtab);
670	–	mod_add_cmd(&chgident_msgtab);
671	–	mod_add_cmd(&chgname_msgtab);
672	–	mod_add_cmd(&classlist_msgtab);
673	–	mod_add_cmd(&clearchan_msgtab);
674	–	mod_add_cmd(&cs_msgtab);
675	–	mod_add_cmd(&ctrace_msgtab);
676	–	mod_add_cmd(&delspoof_msgtab);
677	–	mod_add_cmd(&flags_msgtab);
678	–	mod_add_cmd(&forcejoin_msgtab);
679	–	mod_add_cmd(&forcepart_msgtab);
680	–	mod_add_cmd(&global_msgtab);
681	–	mod_add_cmd(&help_msgtab);
682	–	mod_add_cmd(&uhelp_msgtab);
683	–	mod_add_cmd(&helpserv_msgtab);
684	–	mod_add_cmd(&hostserv_msgtab);
685	–	mod_add_cmd(&identify_msgtab);
686	–	mod_add_cmd(&jupe_msgtab);
687	–	mod_add_cmd(&killhost_msgtab);
688	–	mod_add_cmd(&ltrace_msgtab);
689	–	mod_add_cmd(&memoserv_msgtab);
690	–	mod_add_cmd(&mkpasswd_msgtab);
691	–	mod_add_cmd(&ms_msgtab);
692	–	mod_add_cmd(&nickserv_msgtab);
693	–	mod_add_cmd(&ns_msgtab);
694	–	mod_add_cmd(&ojoin_msgtab);
695	–	mod_add_cmd(&operserv_msgtab);
696	–	mod_add_cmd(&operspy_msgtab);
697	–	mod_add_cmd(&opme_msgtab);
698	–	mod_add_cmd(&os_msgtab);
699	–	mod_add_cmd(&seenserv_msgtab);
700	–	mod_add_cmd(&spoof_msgtab);
701	–	mod_add_cmd(&statserv_msgtab);
702	–	mod_add_cmd(&svsnick_msgtab);
703	–	mod_add_cmd(&uncapture_msgtab);
704	–	/* FIXME: what about spy*? */
705	–	#endif
706	–	}
707	–	#endif /* STATIC_MODULES */

Comparing:
ircd-hybrid/src/modules.c (property svn:keywords), Revision 30 by adx, Sun Oct 2 20:03:27 2005 UTC vs.
ircd-hybrid/trunk/src/modules.c (property svn:keywords), Revision 1592 by michael, Sat Oct 27 21:02:32 2012 UTC

#	Line 1 | Line 1
1	<	"Id Revision"
1	>	Id Revision

Diff Legend

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