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 "stdinc.h"
#include "list.h"
#include "modules.h"
#include "s_log.h"
#include "ircd.h"
#include "client.h"
#include "send.h"
#include "s_conf.h"
#include "handlers.h"
#include "numeric.h"
#include "parse.h"
#include "ircd_defs.h"
#include "irc_string.h"
#include "memory.h"


dlink_list mod_list = { NULL, NULL, 0 };

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 };

static void mo_modload(struct Client *, struct Client *, int, char *[]);
static void mo_modlist(struct Client *, struct Client *, int, char *[]);
static void mo_modreload(struct Client *, struct Client *, int, char *[]);
static void mo_modunload(struct Client *, struct Client *, int, char *[]);
static void mo_modrestart(struct Client *, struct Client *, int, char *[]);

struct Message modload_msgtab = {
 "MODLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
  {m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modload, m_ignore}
};

struct Message modunload_msgtab = {
 "MODUNLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
  {m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modunload, m_ignore}
};

struct Message modreload_msgtab = {
  "MODRELOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
  {m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modreload, m_ignore}
};

struct Message modlist_msgtab = {
 "MODLIST", 0, 0, 0, 0, MFLG_SLOW, 0,
  {m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modlist, m_ignore}
};

struct Message modrestart_msgtab = {
 "MODRESTART", 0, 0, 0, 0, MFLG_SLOW, 0,
 {m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modrestart, m_ignore}
};


/*
 * modules_init
 *
 * input        - NONE
 * output       - NONE
 * side effects - The basic module manipulation modules are loaded
 */
void
modules_init(void)
{
  dynlink_init();

  mod_add_cmd(&modload_msgtab);
  mod_add_cmd(&modunload_msgtab);
  mod_add_cmd(&modreload_msgtab);
  mod_add_cmd(&modlist_msgtab);
  mod_add_cmd(&modrestart_msgtab);
}

/* 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;
  struct module_path *mpath;

  DLINK_FOREACH(ptr, mod_paths.head)
  {
    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)
{
  struct module_path *pathst;
  dlink_node *ptr;
  dlink_node *next_ptr;

  DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
  {
    pathst = ptr->data;

    dlinkDelete(&pathst->node, &mod_paths);
    MyFree(pathst);
  }

  DLINK_FOREACH_SAFE(ptr, next_ptr, conf_modules.head)
  {
    pathst = ptr->data;

    dlinkDelete(&pathst->node, &conf_modules);
    MyFree(pathst);
  }
}

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

  DLINK_FOREACH(ptr, mod_list.head)
  {
    modp = ptr->data;

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

  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];

  modules_init();

  if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
  {
    ilog(L_WARN, "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, 0);
    }
  }

  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;
  struct module_path *mpath = NULL;

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

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

/* 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) == -1)
    {
      ilog(L_CRIT, "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, int coremodule)
{
  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, coremodule);
        }
      }
    }
  }

  sendto_realops_flags(UMODE_ALL, L_ALL,
                       "Cannot locate module %s", path);
  ilog(L_WARN, "Cannot locate module %s", path);
  return -1;
}

/* load a module .. */
static void
mo_modload(struct Client *client_p, struct Client *source_p,
           int parc, char *parv[])
{
  const char *m_bn = NULL;

  if (!IsAdmin(source_p))
  {
    sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
               me.name, source_p->name);
    return;
  }

  m_bn = libio_basename(parv[1]);

  if (findmodule_byname(m_bn) != NULL)
  {
    sendto_one(source_p, ":%s NOTICE %s :Module %s is already loaded",
               me.name, source_p->name, m_bn);
    return;
  }

  load_one_module(parv[1], 0);
}

/* unload a module .. */
static void
mo_modunload(struct Client *client_p, struct Client *source_p,
             int parc, char *parv[])
{
  const char *m_bn = NULL;
  dlink_node *ptr;
  struct module *modp;

  if (!IsAdmin(source_p))
  {
    sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
               me.name, source_p->name);
    return;
  }

  m_bn = libio_basename(parv[1]);

  if ((ptr = findmodule_byname(m_bn)) == NULL)
  {
    sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
               me.name, source_p->name, m_bn);
    return;
  }

  modp = ptr->data;

  if (modp->core == 1)
  {
    sendto_one(source_p,
               ":%s NOTICE %s :Module %s is a core module and may not be unloaded",
               me.name, source_p->name, m_bn);
    return;
  }

  /* XXX might want to simply un dlink it here */

  if (unload_one_module(m_bn, 1) == -1)
  {
    sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
               me.name, source_p->name, m_bn);
  }
}

/* unload and load in one! */
static void
mo_modreload(struct Client *client_p, struct Client *source_p,
             int parc, char *parv[])
{
  const char *m_bn = NULL;
  dlink_node *ptr;
  struct module *modp;
  int check_core;

  if (!IsAdmin(source_p))
  {
    sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
               me.name, source_p->name);
    return;
  }

  m_bn = libio_basename(parv[1]);

  if ((ptr = findmodule_byname(m_bn)) == NULL)
  {
    sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
               me.name, source_p->name, m_bn);
    return;
  }

  modp = ptr->data;
  check_core = modp->core;

  if (unload_one_module(m_bn, 1) == -1)
  {
    sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
               me.name, source_p->name, m_bn);
    return;
  }

  if ((load_one_module(parv[1], check_core) == -1) && check_core)
  {
    sendto_realops_flags(UMODE_ALL, L_ALL, "Error reloading core "
                         "module: %s: terminating ircd", parv[1]);
    ilog(L_CRIT, "Error loading core module %s: terminating ircd", parv[1]);
    exit(0);
  }
}

/* list modules .. */
static void
mo_modlist(struct Client *client_p, struct Client *source_p,
           int parc, char *parv[])
{
  const dlink_node *ptr = NULL;

  if (!IsAdmin(source_p))
  {
    sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
               me.name, source_p->name);
    return;
  }

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

    if (parc > 1 && !match(parv[1], modp->name))
      continue;

    sendto_one(source_p, form_str(RPL_MODLIST), me.name, parv[0],
               modp->name, modp->handle,
               modp->version, modp->core?"(core)":"");
  }

  sendto_one(source_p, form_str(RPL_ENDOFMODLIST),
             me.name, source_p->name);
}

/* unload and reload all modules */
static void
mo_modrestart(struct Client *client_p, struct Client *source_p,
              int parc, char *parv[])
{
  unsigned int modnum = 0;
  dlink_node *ptr = NULL, *ptr_next = NULL;

  if (!IsAdmin(source_p))
  {
    sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
               me.name, source_p->name);
    return;
  }

  sendto_one(source_p, ":%s NOTICE %s :Reloading all modules",
             me.name, source_p->name);

  modnum = dlink_list_length(&mod_list);

  DLINK_FOREACH_SAFE(ptr, ptr_next, mod_list.head)
  {
    struct module *modp = ptr->data;
    unload_one_module(modp->name, 0);
  }

  load_all_modules(0);
  load_conf_modules();
  load_core_modules(0);

  sendto_realops_flags(UMODE_ALL, L_ALL,
              "Module Restart: %u modules unloaded, %u modules loaded",
                        modnum, dlink_list_length(&mod_list));
  ilog(L_WARN, "Module Restart: %u modules unloaded, %u modules loaded",
       modnum, dlink_list_length(&mod_list));
}
Revision:	1028
Committed:	Sun Nov 8 13:03:38 2009 UTC (16 years, 8 months ago) by michael
Content type:	text/x-csrc
Original Path:	*ircd-hybrid/src/modules.c*
File size:	12160 byte(s)
Log Message:	- move ircd-hybrid-7.2 to trunk
#	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			#include "stdinc.h"
26	michael	1011	#include "list.h"
27	adx	30	#include "modules.h"
28			#include "s_log.h"
29			#include "ircd.h"
30			#include "client.h"
31			#include "send.h"
32			#include "s_conf.h"
33			#include "handlers.h"
34			#include "numeric.h"
35			#include "parse.h"
36			#include "ircd_defs.h"
37			#include "irc_string.h"
38			#include "memory.h"
39
40
41			dlink_list mod_list = { NULL, NULL, 0 };
42
43			static const char *core_module_table[] =
44			{
45	michael	912	"m_die.la",
46	michael	946	"m_error.la",
47	michael	912	"m_join.la",
48			"m_kick.la",
49			"m_kill.la",
50			"m_message.la",
51			"m_mode.la",
52			"m_nick.la",
53			"m_part.la",
54			"m_quit.la",
55			"m_server.la",
56			"m_sjoin.la",
57			"m_squit.la",
58	adx	30	NULL
59			};
60
61			static dlink_list mod_paths = { NULL, NULL, 0 };
62			static dlink_list conf_modules = { NULL, NULL, 0 };
63
64			static void mo_modload(struct Client , struct Client , int, char *[]);
65			static void mo_modlist(struct Client , struct Client , int, char *[]);
66			static void mo_modreload(struct Client , struct Client , int, char *[]);
67			static void mo_modunload(struct Client , struct Client , int, char *[]);
68			static void mo_modrestart(struct Client , struct Client , int, char *[]);
69
70			struct Message modload_msgtab = {
71			"MODLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
72			{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modload, m_ignore}
73			};
74
75			struct Message modunload_msgtab = {
76			"MODUNLOAD", 0, 0, 2, 0, MFLG_SLOW, 0,
77			{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modunload, m_ignore}
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			};
84
85			struct Message modlist_msgtab = {
86			"MODLIST", 0, 0, 0, 0, MFLG_SLOW, 0,
87			{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modlist, m_ignore}
88			};
89
90			struct Message modrestart_msgtab = {
91			"MODRESTART", 0, 0, 0, 0, MFLG_SLOW, 0,
92			{m_unregistered, m_not_oper, m_ignore, m_ignore, mo_modrestart, m_ignore}
93			};
94
95
96			/*
97			* modules_init
98			*
99			* input - NONE
100			* output - NONE
101			* side effects - The basic module manipulation modules are loaded
102			*/
103			void
104			modules_init(void)
105			{
106	michael	912	dynlink_init();
107
108	adx	30	mod_add_cmd(&modload_msgtab);
109			mod_add_cmd(&modunload_msgtab);
110			mod_add_cmd(&modreload_msgtab);
111			mod_add_cmd(&modlist_msgtab);
112			mod_add_cmd(&modrestart_msgtab);
113			}
114
115			/* mod_find_path()
116			*
117			* input - path
118			* output - none
119			* side effects - returns a module path from path
120			*/
121			static struct module_path *
122			mod_find_path(const char *path)
123			{
124			dlink_node *ptr;
125			struct module_path *mpath;
126
127			DLINK_FOREACH(ptr, mod_paths.head)
128			{
129			mpath = ptr->data;
130
131			if (!strcmp(path, mpath->path))
132			return mpath;
133			}
134
135			return NULL;
136			}
137
138			/* mod_add_path()
139			*
140			* input - path
141			* output - NONE
142			* side effects - adds path to list
143			*/
144			void
145			mod_add_path(const char *path)
146			{
147			struct module_path *pathst;
148
149			if (mod_find_path(path))
150			return;
151
152			pathst = MyMalloc(sizeof(struct module_path));
153
154			strlcpy(pathst->path, path, sizeof(pathst->path));
155			dlinkAdd(pathst, &pathst->node, &mod_paths);
156			}
157
158			/* add_conf_module
159			*
160			* input - module name
161			* output - NONE
162			* side effects - adds module to conf_mod
163			*/
164			void
165			add_conf_module(const char *name)
166			{
167			struct module_path *pathst;
168
169			pathst = MyMalloc(sizeof(struct module_path));
170
171			strlcpy(pathst->path, name, sizeof(pathst->path));
172			dlinkAdd(pathst, &pathst->node, &conf_modules);
173			}
174
175			/* mod_clear_paths()
176			*
177			* input - NONE
178			* output - NONE
179			* side effects - clear the lists of paths and conf modules
180			*/
181			void
182			mod_clear_paths(void)
183			{
184			struct module_path *pathst;
185			dlink_node *ptr;
186			dlink_node *next_ptr;
187
188			DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
189			{
190			pathst = ptr->data;
191
192			dlinkDelete(&pathst->node, &mod_paths);
193			MyFree(pathst);
194			}
195
196			DLINK_FOREACH_SAFE(ptr, next_ptr, conf_modules.head)
197			{
198			pathst = ptr->data;
199
200			dlinkDelete(&pathst->node, &conf_modules);
201			MyFree(pathst);
202			}
203			}
204
205			/* findmodule_byname
206			*
207			* input - name of module
208			* output - NULL if not found or pointer to module
209			* side effects - NONE
210			*/
211			dlink_node *
212			findmodule_byname(const char *name)
213			{
214			dlink_node *ptr;
215			struct module *modp;
216
217			DLINK_FOREACH(ptr, mod_list.head)
218			{
219			modp = ptr->data;
220
221	db	218	if (strcmp(modp->name, name) == 0)
222	adx	30	return ptr;
223			}
224
225			return NULL;
226			}
227
228			/* load_all_modules()
229			*
230			* input - int flag warn
231			* output - NONE
232			* side effects - load all modules found in autoload directory
233			*/
234			void
235			load_all_modules(int warn)
236			{
237			DIR *system_module_dir = NULL;
238			struct dirent *ldirent = NULL;
239			char module_fq_name[PATH_MAX + 1];
240
241			modules_init();
242
243			if ((system_module_dir = opendir(AUTOMODPATH)) == NULL)
244			{
245			ilog(L_WARN, "Could not load modules from %s: %s",
246			AUTOMODPATH, strerror(errno));
247			return;
248			}
249
250			while ((ldirent = readdir(system_module_dir)) != NULL)
251			{
252	michael	912	if (modules_valid_suffix(ldirent->d_name))
253	adx	30	{
254			snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s",
255			AUTOMODPATH, ldirent->d_name);
256			load_a_module(module_fq_name, warn, 0);
257			}
258			}
259
260			closedir(system_module_dir);
261			}
262
263			/* load_conf_modules()
264			*
265			* input - NONE
266			* output - NONE
267			* side effects - load modules given in ircd.conf
268			*/
269			void
270			load_conf_modules(void)
271			{
272			dlink_node *ptr = NULL;
273			struct module_path *mpath = NULL;
274
275			DLINK_FOREACH(ptr, conf_modules.head)
276			{
277			mpath = ptr->data;
278
279			if (findmodule_byname(mpath->path) == NULL)
280			load_one_module(mpath->path, 0);
281			}
282			}
283
284			/* load_core_modules()
285			*
286			* input - int flag warn
287			* output - NONE
288			* side effects - core modules are loaded, if any fail, kill ircd
289			*/
290			void
291			load_core_modules(int warn)
292			{
293			char module_name[PATH_MAX + 1];
294			int i = 0;
295
296			for (; core_module_table[i]; ++i)
297			{
298	michael	912	snprintf(module_name, sizeof(module_name), "%s%s",
299			MODPATH, core_module_table[i]);
300	adx	30
301			if (load_a_module(module_name, warn, 1) == -1)
302			{
303	michael	912	ilog(L_CRIT, "Error loading core module %s: terminating ircd",
304			core_module_table[i]);
305	adx	30	exit(EXIT_FAILURE);
306			}
307			}
308			}
309
310			/* load_one_module()
311			*
312			* input - pointer to path
313			* - flagged as core module or not
314			* output - -1 if error
315			* side effects - module is loaded if found.
316			*/
317			int
318	michael	978	load_one_module(const char *path, int coremodule)
319	adx	30	{
320			dlink_node *ptr = NULL;
321			char modpath[PATH_MAX + 1];
322			struct stat statbuf;
323
324			DLINK_FOREACH(ptr, mod_paths.head)
325			{
326			const struct module_path *mpath = ptr->data;
327
328			snprintf(modpath, sizeof(modpath), "%s/%s", mpath->path, path);
329
330	michael	912	if (!modules_valid_suffix(path))
331			continue;
332
333	adx	30	if (strstr(modpath, "../") == NULL &&
334			strstr(modpath, "/..") == NULL)
335			{
336			if (!stat(modpath, &statbuf))
337			{
338			if (S_ISREG(statbuf.st_mode))
339			{
340			/* Regular files only please */
341			return load_a_module(modpath, 1, coremodule);
342			}
343			}
344			}
345			}
346
347			sendto_realops_flags(UMODE_ALL, L_ALL,
348			"Cannot locate module %s", path);
349			ilog(L_WARN, "Cannot locate module %s", path);
350			return -1;
351			}
352
353			/* load a module .. */
354			static void
355			mo_modload(struct Client client_p, struct Client source_p,
356			int parc, char *parv[])
357			{
358	michael	978	const char *m_bn = NULL;
359	adx	30
360			if (!IsAdmin(source_p))
361			{
362			sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
363			me.name, source_p->name);
364			return;
365			}
366
367	michael	978	m_bn = libio_basename(parv[1]);
368	adx	30
369			if (findmodule_byname(m_bn) != NULL)
370			{
371			sendto_one(source_p, ":%s NOTICE %s :Module %s is already loaded",
372			me.name, source_p->name, m_bn);
373			return;
374			}
375
376			load_one_module(parv[1], 0);
377			}
378
379			/* unload a module .. */
380			static void
381			mo_modunload(struct Client client_p, struct Client source_p,
382			int parc, char *parv[])
383			{
384	michael	978	const char *m_bn = NULL;
385	adx	30	dlink_node *ptr;
386			struct module *modp;
387
388			if (!IsAdmin(source_p))
389			{
390			sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
391			me.name, source_p->name);
392			return;
393			}
394
395	michael	978	m_bn = libio_basename(parv[1]);
396	adx	30
397			if ((ptr = findmodule_byname(m_bn)) == NULL)
398			{
399			sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
400			me.name, source_p->name, m_bn);
401			return;
402			}
403
404			modp = ptr->data;
405
406			if (modp->core == 1)
407			{
408			sendto_one(source_p,
409			":%s NOTICE %s :Module %s is a core module and may not be unloaded",
410			me.name, source_p->name, m_bn);
411			return;
412			}
413
414			/* XXX might want to simply un dlink it here */
415
416			if (unload_one_module(m_bn, 1) == -1)
417			{
418			sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
419			me.name, source_p->name, m_bn);
420			}
421			}
422
423			/* unload and load in one! */
424			static void
425			mo_modreload(struct Client client_p, struct Client source_p,
426			int parc, char *parv[])
427			{
428	michael	978	const char *m_bn = NULL;
429	adx	30	dlink_node *ptr;
430			struct module *modp;
431			int check_core;
432
433			if (!IsAdmin(source_p))
434			{
435			sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
436			me.name, source_p->name);
437			return;
438			}
439
440	michael	978	m_bn = libio_basename(parv[1]);
441	adx	30
442			if ((ptr = findmodule_byname(m_bn)) == NULL)
443			{
444			sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
445			me.name, source_p->name, m_bn);
446			return;
447			}
448
449			modp = ptr->data;
450			check_core = modp->core;
451
452			if (unload_one_module(m_bn, 1) == -1)
453			{
454			sendto_one(source_p, ":%s NOTICE %s :Module %s is not loaded",
455			me.name, source_p->name, m_bn);
456			return;
457			}
458
459			if ((load_one_module(parv[1], check_core) == -1) && check_core)
460			{
461			sendto_realops_flags(UMODE_ALL, L_ALL, "Error reloading core "
462			"module: %s: terminating ircd", parv[1]);
463			ilog(L_CRIT, "Error loading core module %s: terminating ircd", parv[1]);
464			exit(0);
465			}
466			}
467
468			/* list modules .. */
469			static void
470			mo_modlist(struct Client client_p, struct Client source_p,
471			int parc, char *parv[])
472			{
473	michael	912	const dlink_node *ptr = NULL;
474	adx	30
475			if (!IsAdmin(source_p))
476			{
477			sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
478			me.name, source_p->name);
479			return;
480			}
481
482			DLINK_FOREACH(ptr, mod_list.head)
483			{
484	michael	912	const struct module *modp = ptr->data;
485	adx	30
486	michael	912	if (parc > 1 && !match(parv[1], modp->name))
487			continue;
488
489			sendto_one(source_p, form_str(RPL_MODLIST), me.name, parv[0],
490			modp->name, modp->handle,
491			modp->version, modp->core?"(core)":"");
492	adx	30	}
493
494			sendto_one(source_p, form_str(RPL_ENDOFMODLIST),
495			me.name, source_p->name);
496			}
497
498			/* unload and reload all modules */
499			static void
500			mo_modrestart(struct Client client_p, struct Client source_p,
501			int parc, char *parv[])
502			{
503			unsigned int modnum = 0;
504	michael	912	dlink_node ptr = NULL, ptr_next = NULL;
505
506	adx	30	if (!IsAdmin(source_p))
507			{
508			sendto_one(source_p, form_str(ERR_NOPRIVILEGES),
509			me.name, source_p->name);
510			return;
511			}
512
513			sendto_one(source_p, ":%s NOTICE %s :Reloading all modules",
514			me.name, source_p->name);
515
516			modnum = dlink_list_length(&mod_list);
517
518	michael	912	DLINK_FOREACH_SAFE(ptr, ptr_next, mod_list.head)
519	adx	30	{
520	michael	912	struct module *modp = ptr->data;
521	adx	30	unload_one_module(modp->name, 0);
522			}
523
524			load_all_modules(0);
525			load_conf_modules();
526			load_core_modules(0);
527
528			sendto_realops_flags(UMODE_ALL, L_ALL,
529	michael	1013	"Module Restart: %u modules unloaded, %u modules loaded",
530	adx	30	modnum, dlink_list_length(&mod_list));
531	michael	1013	ilog(L_WARN, "Module Restart: %u modules unloaded, %u modules loaded",
532	adx	30	modnum, dlink_list_length(&mod_list));
533			}