trunk/src/modules.c

/*
 *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
 *  modules.c: A module loader.
 *
 *  Copyright (C) 2002 by the past and present ircd coders, and others.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 *
 *  $Id$
 */

#include "ltdl.h"

#include "stdinc.h"
#include "list.h"
#include "modules.h"
#include "log.h"
#include "ircd.h"
#include "client.h"
#include "send.h"
#include "conf.h"
#include "numeric.h"
#include "parse.h"
#include "ircd_defs.h"
#include "irc_string.h"
#include "memory.h"


dlink_list modules_list = { NULL, NULL, 0 };

static const char *unknown_ver = "<unknown>";

static const char *core_module_table[] =
{
  "m_die.la",
  "m_error.la",
  "m_join.la",
  "m_kick.la",
  "m_kill.la",
  "m_message.la",
  "m_mode.la",
  "m_nick.la",
  "m_part.la",
  "m_quit.la",
  "m_server.la",
  "m_sjoin.la",
  "m_squit.la",
  NULL
};

static dlink_list mod_paths = { NULL, NULL, 0 };
static dlink_list conf_modules = { NULL, NULL, 0 };

int
modules_valid_suffix(const char *name)
{
  return ((name = strrchr(name, '.'))) && !strcmp(name, ".la");
}

/* unload_one_module()
 *
 * inputs       - name of module to unload
 *              - 1 to say modules unloaded, 0 to not
 * output       - 0 if successful, -1 if error
 * side effects - module is unloaded
 */
int
unload_one_module(const char *name, int warn)
{
  struct module *modp = NULL;

  if ((modp = findmodule_byname(name)) == NULL)
    return -1;

  if (modp->modexit)
   modp->modexit();

  assert(dlink_list_length(&modules_list) > 0);
  dlinkDelete(&modp->node, &modules_list);
  MyFree(modp->name);

  lt_dlclose(modp->handle);

  if (warn == 1)
  {
    ilog(LOG_TYPE_IRCD, "Module %s unloaded", name);
    sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s unloaded", name);
  }

  return 0;
}

/* load_a_module()
 *
 * inputs       - path name of module, int to notice, int of core
 * output       - -1 if error 0 if success
 * side effects - loads a module if successful
 */
int
load_a_module(const char *path, int warn)
{
  lt_dlhandle tmpptr = NULL;
  const char *mod_basename = NULL;
  struct module *modp = NULL;

  if (findmodule_byname((mod_basename = libio_basename(path))))
    return 1;

  if (!(tmpptr = lt_dlopen(path))) {
    const char *err = ((err = lt_dlerror())) ? err : "<unknown>";

    sendto_realops_flags(UMODE_ALL, L_ALL, "Error loading module %s: %s",
                         mod_basename, err);
    ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
    return -1;
  }

  if ((modp = lt_dlsym(tmpptr, "module_entry")) == NULL)
  {
    sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s has no module_entry export",
                         mod_basename);
    ilog(LOG_TYPE_IRCD, "Module %s has no module_entry export", mod_basename);
    lt_dlclose(tmpptr);
    return -1;
  }

  modp->handle = tmpptr;

  if (EmptyString(modp->version))
    modp->version = unknown_ver;

  DupString(modp->name, mod_basename);
  dlinkAdd(modp, &modp->node, &modules_list);

  if (modp->modinit)
    modp->modinit();

  if (warn == 1)
  {
    sendto_realops_flags(UMODE_ALL, L_ALL,
                         "Module %s [version: %s handle: %p] loaded.",
                         modp->name, modp->version, tmpptr);
    ilog(LOG_TYPE_IRCD, "Module %s [version: %s handle: %p] loaded.",
         modp->name, modp->version, tmpptr);
  }

  return 0;
}

/*
 * modules_init
 *
 * input        - NONE
 * output       - NONE
 * side effects - The basic module manipulation modules are loaded
 */
void
modules_init(void)
{
  if (lt_dlinit())
  {
    ilog(LOG_TYPE_IRCD, "Couldn't initialize the libltdl run time dynamic"
         " link library. Exiting.");
    exit(0);
  }
}

/* mod_find_path()
 *
 * input        - path
 * output       - none
 * side effects - returns a module path from path
 */
static struct module_path *
mod_find_path(const char *path)
{
  dlink_node *ptr;

  DLINK_FOREACH(ptr, mod_paths.head)
  {
    struct module_path *mpath = ptr->data;

    if (!strcmp(path, mpath->path))
      return mpath;
  }

  return NULL;
}

/* mod_add_path()
 *
 * input        - path
 * output       - NONE
 * side effects - adds path to list
 */
void
mod_add_path(const char *path)
{
  struct module_path *pathst;

  if (mod_find_path(path))
    return;

  pathst = MyMalloc(sizeof(struct module_path));

  strlcpy(pathst->path, path, sizeof(pathst->path));
  dlinkAdd(pathst, &pathst->node, &mod_paths);
}

/* add_conf_module
 *
 * input        - module name
 * output       - NONE
 * side effects - adds module to conf_mod
 */
void
add_conf_module(const char *name)
{
  struct module_path *pathst;

  pathst = MyMalloc(sizeof(struct module_path));

  strlcpy(pathst->path, name, sizeof(pathst->path));
  dlinkAdd(pathst, &pathst->node, &conf_modules);
}

/* mod_clear_paths()
 *
 * input        - NONE
 * output       - NONE
 * side effects - clear the lists of paths and conf modules
 */
void
mod_clear_paths(void)
{
  dlink_node *ptr = NULL, *next_ptr = NULL;

  DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
  {
    dlinkDelete(ptr, &mod_paths);
    MyFree(ptr->data);
  }

  DLINK_FOREACH_SAFE(ptr, next_ptr, conf_modules.head)
  {
    dlinkDelete(ptr, &conf_modules);
    MyFree(ptr->data);
  }
}

/* findmodule_byname
 *
 * input        - name of module
 * output       - NULL if not found or pointer to module
 * side effects - NONE
 */
struct module *
findmodule_byname(const char *name)
{
  dlink_node *ptr = NULL;

  DLINK_FOREACH(ptr, modules_list.head)
  {
    struct module *modp = ptr->data;

    if (strcmp(modp->name, name) == 0)
      return modp;
  }

  return NULL;
}

/* load_all_modules()
 *
 * input        - int flag warn
 * output       - NONE
 * side effects - load all modules found in autoload directory
 */
void
load_all_modules(int warn)
{
  DIR *system_module_dir = NULL;
  struct dirent *ldirent = NULL;
  char module_fq_name[PATH_MAX + 1];

  if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
  {
    ilog(LOG_TYPE_IRCD, "Could not load modules from %s: %s",
         AUTOMODPATH, strerror(errno));
    return;
  }

  while ((ldirent = readdir(system_module_dir)) != NULL)
  {
    if (modules_valid_suffix(ldirent->d_name))
    {
       snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s",
                AUTOMODPATH, ldirent->d_name);
       load_a_module(module_fq_name, warn);
    }
  }

  closedir(system_module_dir);
}

/* load_conf_modules()
 *
 * input        - NONE
 * output       - NONE
 * side effects - load modules given in ircd.conf
 */
void
load_conf_modules(void)
{
  dlink_node *ptr = NULL;

  DLINK_FOREACH(ptr, conf_modules.head)
  {
    struct module_path *mpath = ptr->data;

    if (findmodule_byname(mpath->path) == NULL)
      load_one_module(mpath->path);
  }
}

/* load_core_modules()
 *
 * input        - int flag warn
 * output       - NONE
 * side effects - core modules are loaded, if any fail, kill ircd
 */
void
load_core_modules(int warn)
{
  char module_name[PATH_MAX + 1];
  int i = 0;

  for (; core_module_table[i]; ++i)
  {
    snprintf(module_name, sizeof(module_name), "%s%s",
             MODPATH, core_module_table[i]);

    if (load_a_module(module_name, warn) == -1)
    {
      ilog(LOG_TYPE_IRCD, "Error loading core module %s: terminating ircd",
           core_module_table[i]);
      exit(EXIT_FAILURE);
    }
  }
}

/* load_one_module()
 *
 * input        - pointer to path
 *              - flagged as core module or not
 * output       - -1 if error 
 * side effects - module is loaded if found.
 */
int
load_one_module(const char *path)
{
  dlink_node *ptr = NULL;
  char modpath[PATH_MAX + 1];
  struct stat statbuf;

  DLINK_FOREACH(ptr, mod_paths.head)
  {
    const struct module_path *mpath = ptr->data;

    snprintf(modpath, sizeof(modpath), "%s/%s", mpath->path, path);

    if (!modules_valid_suffix(path))
      continue;

    if (strstr(modpath, "../") == NULL &&
        strstr(modpath, "/..") == NULL) 
      if (!stat(modpath, &statbuf))
        if (S_ISREG(statbuf.st_mode))  /* Regular files only please */
          return load_a_module(modpath, 1);
  }

  sendto_realops_flags(UMODE_ALL, L_ALL,
                       "Cannot locate module %s", path);
  ilog(LOG_TYPE_IRCD, "Cannot locate module %s", path);
  return -1;
}
Revision:	1447
Committed:	Mon Jun 25 20:22:29 2012 UTC (13 years, 2 months ago) by michael
Content type:	text/x-csrc
Original Path:	*ircd-hybrid-8/src/modules.c*
File size:	8869 byte(s)
Log Message:	- Added m_module.c and moved mo_module() into it
#	User	Rev	Content
1	adx	30	/*
2			* ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3			* modules.c: A module loader.
4			*
5			* Copyright (C) 2002 by the past and present ircd coders, and others.
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20			* USA
21			*
22	knight	31	* $Id$
23	adx	30	*/
24
25	michael	1237	#include "ltdl.h"
26
27	adx	30	#include "stdinc.h"
28	michael	1011	#include "list.h"
29	adx	30	#include "modules.h"
30	michael	1309	#include "log.h"
31	adx	30	#include "ircd.h"
32			#include "client.h"
33			#include "send.h"
34	michael	1309	#include "conf.h"
35	adx	30	#include "numeric.h"
36			#include "parse.h"
37			#include "ircd_defs.h"
38			#include "irc_string.h"
39			#include "memory.h"
40
41
42	michael	1447	dlink_list modules_list = { NULL, NULL, 0 };
43	adx	30
44	michael	1237	static const char *unknown_ver = "<unknown>";
45
46	adx	30	static const char *core_module_table[] =
47			{
48	michael	912	"m_die.la",
49	michael	946	"m_error.la",
50	michael	912	"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	adx	30	NULL
62			};
63
64			static dlink_list mod_paths = { NULL, NULL, 0 };
65			static dlink_list conf_modules = { NULL, NULL, 0 };
66
67	michael	1237	int
68			modules_valid_suffix(const char *name)
69			{
70			return ((name = strrchr(name, '.'))) && !strcmp(name, ".la");
71			}
72
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			if ((modp = findmodule_byname(name)) == NULL)
86			return -1;
87
88			if (modp->modexit)
89			modp->modexit();
90
91	michael	1238	assert(dlink_list_length(&modules_list) > 0);
92			dlinkDelete(&modp->node, &modules_list);
93	michael	1237	MyFree(modp->name);
94
95			lt_dlclose(modp->handle);
96
97			if (warn == 1)
98			{
99	michael	1247	ilog(LOG_TYPE_IRCD, "Module %s unloaded", name);
100	michael	1237	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	michael	1404	load_a_module(const char *path, int warn)
114	michael	1237	{
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	michael	1247	ilog(LOG_TYPE_IRCD, "Error loading module %s: %s", mod_basename, err);
128	michael	1237	return -1;
129			}
130
131			if ((modp = lt_dlsym(tmpptr, "module_entry")) == NULL)
132			{
133			sendto_realops_flags(UMODE_ALL, L_ALL, "Module %s has no module_entry export",
134			mod_basename);
135	michael	1247	ilog(LOG_TYPE_IRCD, "Module %s has no module_entry export", mod_basename);
136	michael	1237	lt_dlclose(tmpptr);
137			return -1;
138			}
139
140			modp->handle = tmpptr;
141
142			if (EmptyString(modp->version))
143			modp->version = unknown_ver;
144
145			DupString(modp->name, mod_basename);
146	michael	1238	dlinkAdd(modp, &modp->node, &modules_list);
147	michael	1237
148			if (modp->modinit)
149			modp->modinit();
150
151			if (warn == 1)
152			{
153			sendto_realops_flags(UMODE_ALL, L_ALL,
154			"Module %s [version: %s handle: %p] loaded.",
155			modp->name, modp->version, tmpptr);
156	michael	1247	ilog(LOG_TYPE_IRCD, "Module %s [version: %s handle: %p] loaded.",
157	michael	1237	modp->name, modp->version, tmpptr);
158			}
159
160			return 0;
161			}
162
163	adx	30	/*
164			* modules_init
165			*
166			* input - NONE
167			* output - NONE
168			* side effects - The basic module manipulation modules are loaded
169			*/
170			void
171			modules_init(void)
172			{
173	michael	1237	if (lt_dlinit())
174			{
175	michael	1247	ilog(LOG_TYPE_IRCD, "Couldn't initialize the libltdl run time dynamic"
176	michael	1237	" link library. Exiting.");
177			exit(0);
178			}
179	adx	30	}
180
181			/* mod_find_path()
182			*
183			* input - path
184			* output - none
185			* side effects - returns a module path from path
186			*/
187			static struct module_path *
188			mod_find_path(const char *path)
189			{
190			dlink_node *ptr;
191
192			DLINK_FOREACH(ptr, mod_paths.head)
193			{
194	michael	1404	struct module_path *mpath = ptr->data;
195	adx	30
196			if (!strcmp(path, mpath->path))
197			return mpath;
198			}
199
200			return NULL;
201			}
202
203			/* mod_add_path()
204			*
205			* input - path
206			* output - NONE
207			* side effects - adds path to list
208			*/
209			void
210			mod_add_path(const char *path)
211			{
212			struct module_path *pathst;
213
214			if (mod_find_path(path))
215			return;
216
217			pathst = MyMalloc(sizeof(struct module_path));
218
219			strlcpy(pathst->path, path, sizeof(pathst->path));
220			dlinkAdd(pathst, &pathst->node, &mod_paths);
221			}
222
223			/* add_conf_module
224			*
225			* input - module name
226			* output - NONE
227			* side effects - adds module to conf_mod
228			*/
229			void
230			add_conf_module(const char *name)
231			{
232			struct module_path *pathst;
233
234			pathst = MyMalloc(sizeof(struct module_path));
235
236			strlcpy(pathst->path, name, sizeof(pathst->path));
237			dlinkAdd(pathst, &pathst->node, &conf_modules);
238			}
239
240			/* mod_clear_paths()
241			*
242			* input - NONE
243			* output - NONE
244			* side effects - clear the lists of paths and conf modules
245			*/
246			void
247			mod_clear_paths(void)
248			{
249	michael	1237	dlink_node ptr = NULL, next_ptr = NULL;
250	adx	30
251			DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
252			{
253	michael	1404	dlinkDelete(ptr, &mod_paths);
254			MyFree(ptr->data);
255	adx	30	}
256
257			DLINK_FOREACH_SAFE(ptr, next_ptr, conf_modules.head)
258			{
259	michael	1404	dlinkDelete(ptr, &conf_modules);
260			MyFree(ptr->data);
261	adx	30	}
262			}
263
264			/* findmodule_byname
265			*
266			* input - name of module
267			* output - NULL if not found or pointer to module
268			* side effects - NONE
269			*/
270	michael	1230	struct module *
271	adx	30	findmodule_byname(const char *name)
272			{
273	michael	1230	dlink_node *ptr = NULL;
274	adx	30
275	michael	1238	DLINK_FOREACH(ptr, modules_list.head)
276	adx	30	{
277	michael	1230	struct module *modp = ptr->data;
278	adx	30
279	db	218	if (strcmp(modp->name, name) == 0)
280	michael	1230	return modp;
281	adx	30	}
282
283			return NULL;
284			}
285
286			/* load_all_modules()
287			*
288			* input - int flag warn
289			* output - NONE
290			* side effects - load all modules found in autoload directory
291			*/
292			void
293			load_all_modules(int warn)
294			{
295			DIR *system_module_dir = NULL;
296			struct dirent *ldirent = NULL;
297			char module_fq_name[PATH_MAX + 1];
298
299			if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
300			{
301	michael	1247	ilog(LOG_TYPE_IRCD, "Could not load modules from %s: %s",
302	adx	30	AUTOMODPATH, strerror(errno));
303			return;
304			}
305
306			while ((ldirent = readdir(system_module_dir)) != NULL)
307			{
308	michael	912	if (modules_valid_suffix(ldirent->d_name))
309	adx	30	{
310			snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s",
311			AUTOMODPATH, ldirent->d_name);
312	michael	1404	load_a_module(module_fq_name, warn);
313	adx	30	}
314			}
315
316			closedir(system_module_dir);
317			}
318
319			/* load_conf_modules()
320			*
321			* input - NONE
322			* output - NONE
323			* side effects - load modules given in ircd.conf
324			*/
325			void
326			load_conf_modules(void)
327			{
328			dlink_node *ptr = NULL;
329
330			DLINK_FOREACH(ptr, conf_modules.head)
331			{
332	michael	1404	struct module_path *mpath = ptr->data;
333	adx	30
334			if (findmodule_byname(mpath->path) == NULL)
335	michael	1404	load_one_module(mpath->path);
336	adx	30	}
337			}
338
339			/* load_core_modules()
340			*
341			* input - int flag warn
342			* output - NONE
343			* side effects - core modules are loaded, if any fail, kill ircd
344			*/
345			void
346			load_core_modules(int warn)
347			{
348			char module_name[PATH_MAX + 1];
349			int i = 0;
350
351			for (; core_module_table[i]; ++i)
352			{
353	michael	912	snprintf(module_name, sizeof(module_name), "%s%s",
354			MODPATH, core_module_table[i]);
355	adx	30
356	michael	1404	if (load_a_module(module_name, warn) == -1)
357	adx	30	{
358	michael	1247	ilog(LOG_TYPE_IRCD, "Error loading core module %s: terminating ircd",
359	michael	912	core_module_table[i]);
360	adx	30	exit(EXIT_FAILURE);
361			}
362			}
363			}
364
365			/* load_one_module()
366			*
367			* input - pointer to path
368			* - flagged as core module or not
369			* output - -1 if error
370			* side effects - module is loaded if found.
371			*/
372			int
373	michael	1404	load_one_module(const char *path)
374	adx	30	{
375			dlink_node *ptr = NULL;
376			char modpath[PATH_MAX + 1];
377			struct stat statbuf;
378
379			DLINK_FOREACH(ptr, mod_paths.head)
380			{
381			const struct module_path *mpath = ptr->data;
382
383			snprintf(modpath, sizeof(modpath), "%s/%s", mpath->path, path);
384
385	michael	912	if (!modules_valid_suffix(path))
386			continue;
387
388	adx	30	if (strstr(modpath, "../") == NULL &&
389			strstr(modpath, "/..") == NULL)
390			if (!stat(modpath, &statbuf))
391	michael	1404	if (S_ISREG(statbuf.st_mode)) /* Regular files only please */
392			return load_a_module(modpath, 1);
393	adx	30	}
394
395			sendto_realops_flags(UMODE_ALL, L_ALL,
396			"Cannot locate module %s", path);
397	michael	1247	ilog(LOG_TYPE_IRCD, "Cannot locate module %s", path);
398	adx	30	return -1;
399			}