]> jfr.im git - solanum.git/blob - ircd/modules.c
projects / solanum.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
librb: remove socklen parameter from rb_connect_tcp
[solanum.git] / ircd / modules.c
1 /*
2 * ircd-ratbox: A slightly useful ircd.
3 * modules.c: A module loader.
4 *
5 * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
6 * Copyright (C) 1996-2002 Hybrid Development Team
7 * Copyright (C) 2002-2005 ircd-ratbox development team
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
22 * USA
23 */
24
25 #include "stdinc.h"
26 #include "modules.h"
27 #include "logger.h"
28 #include "ircd.h"
29 #include "client.h"
30 #include "send.h"
31 #include "s_conf.h"
32 #include "s_newconf.h"
33 #include "numeric.h"
34 #include "parse.h"
35 #include "ircd_defs.h"
36 #include "match.h"
37 #include "s_serv.h"
38 #include "capability.h"
39
40 #include <ltdl.h>
41
42 #ifndef LT_MODULE_EXT
43 # error "Charybdis requires loadable module support."
44 #endif
45
46 struct module **modlist = NULL;
47
48 static const char *core_module_table[] = {
49 "m_ban",
50 "m_die",
51 "m_error",
52 "m_join",
53 "m_kick",
54 "m_kill",
55 "m_message",
56 "m_mode",
57 "m_modules",
58 "m_nick",
59 "m_part",
60 "m_quit",
61 "m_server",
62 "m_squit",
63 NULL
64 };
65
66 #define MOD_WARN_DELTA (90 * 86400) /* time in seconds, 86400 seconds in a day */
67
68 #define MODS_INCREMENT 10
69 int num_mods = 0;
70 int max_mods = MODS_INCREMENT;
71
72 static rb_dlink_list mod_paths;
73
74 void
75 modules_init(void)
76 {
77 if(lt_dlinit())
78 {
79 ilog(L_MAIN, "lt_dlinit failed");
80 exit(0);
81 }
82
83 /* Add the default paths we look in to the module system --nenolod */
84 mod_add_path(ircd_paths[IRCD_PATH_MODULES]);
85 mod_add_path(ircd_paths[IRCD_PATH_AUTOLOAD_MODULES]);
86 }
87
88 /* mod_find_path()
89 *
90 * input - path
91 * output - none
92 * side effects - returns a module path from path
93 */
94 static char *
95 mod_find_path(const char *path)
96 {
97 rb_dlink_node *ptr;
98 char *mpath;
99
100 RB_DLINK_FOREACH(ptr, mod_paths.head)
101 {
102 mpath = ptr->data;
103
104 if(!strcmp(path, mpath))
105 return mpath;
106 }
107
108 return NULL;
109 }
110
111 /* mod_add_path
112 *
113 * input - path
114 * ouput -
115 * side effects - adds path to list
116 */
117 void
118 mod_add_path(const char *path)
119 {
120 char *pathst;
121
122 if(mod_find_path(path))
123 return;
124
125 pathst = rb_strdup(path);
126 rb_dlinkAddAlloc(pathst, &mod_paths);
127 }
128
129 /* mod_clear_paths()
130 *
131 * input -
132 * output -
133 * side effects - clear the lists of paths
134 */
135 void
136 mod_clear_paths(void)
137 {
138 rb_dlink_node *ptr, *next_ptr;
139
140 RB_DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
141 {
142 rb_free(ptr->data);
143 rb_free_rb_dlink_node(ptr);
144 }
145
146 mod_paths.head = mod_paths.tail = NULL;
147 mod_paths.length = 0;
148 }
149
150 /* findmodule_byname
151 *
152 * input - module to load
153 * output - index of module on success, -1 on failure
154 * side effects - none
155 */
156 int
157 findmodule_byname(const char *name)
158 {
159 int i;
160 char name_ext[PATH_MAX + 1];
161
162 rb_strlcpy(name_ext, name, sizeof name_ext);
163 rb_strlcat(name_ext, LT_MODULE_EXT, sizeof name_ext);
164
165 for (i = 0; i < num_mods; i++)
166 {
167 if(!irccmp(modlist[i]->name, name))
168 return i;
169
170 if(!irccmp(modlist[i]->name, name_ext))
171 return i;
172 }
173
174 return -1;
175 }
176
177 /* load_all_modules()
178 *
179 * input -
180 * output -
181 * side effects -
182 */
183 void
184 load_all_modules(bool warn)
185 {
186 DIR *system_module_dir = NULL;
187 struct dirent *ldirent = NULL;
188 char module_fq_name[PATH_MAX + 1];
189 size_t module_ext_len = strlen(LT_MODULE_EXT);
190
191 modules_init();
192
193 modlist = (struct module **) rb_malloc(sizeof(struct module *) * (MODS_INCREMENT));
194
195 max_mods = MODS_INCREMENT;
196
197 system_module_dir = opendir(ircd_paths[IRCD_PATH_AUTOLOAD_MODULES]);
198
199 if(system_module_dir == NULL)
200 {
201 ilog(L_MAIN, "Could not load modules from %s: %s", ircd_paths[IRCD_PATH_AUTOLOAD_MODULES], strerror(errno));
202 return;
203 }
204
205 while ((ldirent = readdir(system_module_dir)) != NULL)
206 {
207 size_t len = strlen(ldirent->d_name);
208
209 if(len > module_ext_len &&
210 rb_strncasecmp(ldirent->d_name + (len - module_ext_len), LT_MODULE_EXT, module_ext_len) == 0)
211 {
212 (void) snprintf(module_fq_name, sizeof(module_fq_name), "%s%c%s",
213 ircd_paths[IRCD_PATH_AUTOLOAD_MODULES], RB_PATH_SEPARATOR, ldirent->d_name);
214 (void) load_a_module(module_fq_name, warn, MAPI_ORIGIN_CORE, false);
215 }
216
217 }
218 (void) closedir(system_module_dir);
219 }
220
221 /* load_core_modules()
222 *
223 * input -
224 * output -
225 * side effects - core modules are loaded, if any fail, kill ircd
226 */
227 void
228 load_core_modules(bool warn)
229 {
230 char module_name[PATH_MAX];
231 int i;
232
233
234 for (i = 0; core_module_table[i]; i++)
235 {
236 snprintf(module_name, sizeof(module_name), "%s%c%s", ircd_paths[IRCD_PATH_MODULES], RB_PATH_SEPARATOR,
237 core_module_table[i]);
238
239 if(load_a_module(module_name, warn, MAPI_ORIGIN_CORE, true) == false)
240 {
241 ilog(L_MAIN,
242 "Error loading core module %s: terminating ircd",
243 core_module_table[i]);
244 exit(0);
245 }
246 }
247 }
248
249 /* load_one_module()
250 *
251 * input -
252 * output -
253 * side effects -
254 */
255 bool
256 load_one_module(const char *path, int origin, bool coremodule)
257 {
258 char modpath[PATH_MAX];
259 rb_dlink_node *pathst;
260
261 if (server_state_foreground)
262 inotice("loading module %s ...", path);
263
264 if(coremodule)
265 origin = MAPI_ORIGIN_CORE;
266
267 RB_DLINK_FOREACH(pathst, mod_paths.head)
268 {
269 struct stat statbuf;
270 const char *mpath = pathst->data;
271
272 snprintf(modpath, sizeof(modpath), "%s%c%s%s", mpath, RB_PATH_SEPARATOR, path, LT_MODULE_EXT);
273 if((strstr(modpath, "../") == NULL) && (strstr(modpath, "/..") == NULL))
274 {
275 if(stat(modpath, &statbuf) == 0 && S_ISREG(statbuf.st_mode))
276 {
277 /* Regular files only please */
278 return load_a_module(modpath, true, origin, coremodule);
279 }
280
281 }
282 }
283
284 sendto_realops_snomask(SNO_GENERAL, L_ALL, "Cannot locate module %s", path);
285 return false;
286 }
287
288 static void increase_modlist(void);
289
290 #define MODS_INCREMENT 10
291
292 static char unknown_ver[] = "<unknown>";
293 static char unknown_description[] = "<none>";
294
295 /* unload_one_module()
296 *
297 * inputs - name of module to unload
298 * - true to say modules unloaded, false to not
299 * output - true if successful, false if error
300 * side effects - module is unloaded
301 */
302 bool
303 unload_one_module(const char *name, bool warn)
304 {
305 int modindex;
306
307 if((modindex = findmodule_byname(name)) == -1)
308 return false;
309
310 /*
311 ** XXX - The type system in C does not allow direct conversion between
312 ** data and function pointers, but as it happens, most C compilers will
313 ** safely do this, however it is a theoretical overlow to cast as we
314 ** must do here. I have library functions to take care of this, but
315 ** despite being more "correct" for the C language, this is more
316 ** practical. Removing the abuse of the ability to cast ANY pointer
317 ** to and from an integer value here will break some compilers.
318 ** -jmallett
319 */
320 /* Left the comment in but the code isn't here any more -larne */
321 switch (modlist[modindex]->mapi_version)
322 {
323 case 1:
324 {
325 struct mapi_mheader_av1 *mheader = modlist[modindex]->mapi_header;
326 if(mheader->mapi_command_list)
327 {
328 struct Message **m;
329 for (m = mheader->mapi_command_list; *m; ++m)
330 mod_del_cmd(*m);
331 }
332
333 /* hook events are never removed, we simply lose the
334 * ability to call them --fl
335 */
336 if(mheader->mapi_hfn_list)
337 {
338 mapi_hfn_list_av1 *m;
339 for (m = mheader->mapi_hfn_list; m->hapi_name; ++m)
340 remove_hook(m->hapi_name, m->fn);
341 }
342
343 if(mheader->mapi_unregister)
344 mheader->mapi_unregister();
345 break;
346 }
347 case 2:
348 {
349 struct mapi_mheader_av2 *mheader = modlist[modindex]->mapi_header;
350
351 /* XXX duplicate code :( */
352 if(mheader->mapi_command_list)
353 {
354 struct Message **m;
355 for (m = mheader->mapi_command_list; *m; ++m)
356 mod_del_cmd(*m);
357 }
358
359 /* hook events are never removed, we simply lose the
360 * ability to call them --fl
361 */
362 if(mheader->mapi_hfn_list)
363 {
364 mapi_hfn_list_av1 *m;
365 for (m = mheader->mapi_hfn_list; m->hapi_name; ++m)
366 remove_hook(m->hapi_name, m->fn);
367 }
368
369 if(mheader->mapi_unregister)
370 mheader->mapi_unregister();
371
372 if(mheader->mapi_cap_list)
373 {
374 mapi_cap_list_av2 *m;
375 for (m = mheader->mapi_cap_list; m->cap_name; ++m)
376 {
377 struct CapabilityIndex *idx;
378
379 switch (m->cap_index)
380 {
381 case MAPI_CAP_CLIENT:
382 idx = cli_capindex;
383 break;
384 case MAPI_CAP_SERVER:
385 idx = serv_capindex;
386 break;
387 default:
388 sendto_realops_snomask(SNO_GENERAL, L_ALL,
389 "Unknown/unsupported CAP index found of type %d on capability %s when unloading %s",
390 m->cap_index, m->cap_name, modlist[modindex]->name);
391 ilog(L_MAIN,
392 "Unknown/unsupported CAP index found of type %d on capability %s when unloading %s",
393 m->cap_index, m->cap_name, modlist[modindex]->name);
394 continue;
395 }
396
397 if (m->cap_id != NULL)
398 {
399 capability_orphan(idx, m->cap_name);
400 sendto_local_clients_with_capability(CLICAP_CAP_NOTIFY, ":%s CAP * DEL :%s", me.name, m->cap_name);
401 }
402 }
403 }
404 break;
405 }
406 default:
407 sendto_realops_snomask(SNO_GENERAL, L_ALL,
408 "Unknown/unsupported MAPI version %d when unloading %s!",
409 modlist[modindex]->mapi_version, modlist[modindex]->name);
410 ilog(L_MAIN, "Unknown/unsupported MAPI version %d when unloading %s!",
411 modlist[modindex]->mapi_version, modlist[modindex]->name);
412 break;
413 }
414
415 lt_dlclose(modlist[modindex]->address);
416
417 rb_free(modlist[modindex]->name);
418 rb_free(modlist[modindex]);
419 memmove(&modlist[modindex], &modlist[modindex + 1],
420 sizeof(struct module *) * ((num_mods - 1) - modindex));
421
422 if(num_mods != 0)
423 num_mods--;
424
425 if(warn)
426 {
427 ilog(L_MAIN, "Module %s unloaded", name);
428 sendto_realops_snomask(SNO_GENERAL, L_ALL, "Module %s unloaded", name);
429 }
430
431 return true;
432 }
433
434 /*
435 * load_a_module()
436 *
437 * inputs - path name of module, bool to notice, int of origin, bool if core
438 * output - false if error true if success
439 * side effects - loads a module if successful
440 */
441 bool
442 load_a_module(const char *path, bool warn, int origin, bool core)
443 {
444 lt_dlhandle tmpptr;
445 char *mod_displayname, *c;
446 const char *ver, *description = NULL;
447 size_t module_ext_len = strlen(LT_MODULE_EXT);
448
449 int *mapi_version;
450
451 mod_displayname = rb_basename(path);
452
453 /* Trim off the ending for the display name if we have to */
454 if((c = rb_strcasestr(mod_displayname, LT_MODULE_EXT)) != NULL)
455 *c = '\0';
456
457 tmpptr = lt_dlopenext(path);
458
459 if(tmpptr == NULL)
460 {
461 const char *err = lt_dlerror();
462
463 sendto_realops_snomask(SNO_GENERAL, L_ALL,
464 "Error loading module %s: %s", mod_displayname, err);
465 ilog(L_MAIN, "Error loading module %s: %s", mod_displayname, err);
466 rb_free(mod_displayname);
467 return false;
468 }
469
470 /*
471 * _mheader is actually a struct mapi_mheader_*, but mapi_version
472 * is always the first member of this structure, so we treate it
473 * as a single int in order to determine the API version.
474 * -larne.
475 */
476 mapi_version = (int *) (uintptr_t) lt_dlsym(tmpptr, "_mheader");
477 if((mapi_version == NULL
478 && (mapi_version = (int *) (uintptr_t) lt_dlsym(tmpptr, "__mheader")) == NULL)
479 || MAPI_MAGIC(*mapi_version) != MAPI_MAGIC_HDR)
480 {
481 sendto_realops_snomask(SNO_GENERAL, L_ALL,
482 "Data format error: module %s has no MAPI header.",
483 mod_displayname);
484 ilog(L_MAIN, "Data format error: module %s has no MAPI header.", mod_displayname);
485 (void) lt_dlclose(tmpptr);
486 rb_free(mod_displayname);
487 return false;
488 }
489
490 switch (MAPI_VERSION(*mapi_version))
491 {
492 case 1:
493 {
494 struct mapi_mheader_av1 *mheader = (struct mapi_mheader_av1 *)(void *)mapi_version; /* see above */
495 if(mheader->mapi_register && (mheader->mapi_register() == -1))
496 {
497 ilog(L_MAIN, "Module %s indicated failure during load.",
498 mod_displayname);
499 sendto_realops_snomask(SNO_GENERAL, L_ALL,
500 "Module %s indicated failure during load.",
501 mod_displayname);
502 lt_dlclose(tmpptr);
503 rb_free(mod_displayname);
504 return false;
505 }
506 if(mheader->mapi_command_list)
507 {
508 struct Message **m;
509 for (m = mheader->mapi_command_list; *m; ++m)
510 mod_add_cmd(*m);
511 }
512
513 if(mheader->mapi_hook_list)
514 {
515 mapi_hlist_av1 *m;
516 for (m = mheader->mapi_hook_list; m->hapi_name; ++m)
517 *m->hapi_id = register_hook(m->hapi_name);
518 }
519
520 if(mheader->mapi_hfn_list)
521 {
522 mapi_hfn_list_av1 *m;
523 for (m = mheader->mapi_hfn_list; m->hapi_name; ++m)
524 add_hook(m->hapi_name, m->fn);
525 }
526
527 ver = mheader->mapi_module_version;
528 break;
529 }
530 case 2:
531 {
532 struct mapi_mheader_av2 *mheader = (struct mapi_mheader_av2 *)(void *)mapi_version; /* see above */
533
534 /* XXX duplicated code :( */
535 if(mheader->mapi_register && (mheader->mapi_register() == -1))
536 {
537 ilog(L_MAIN, "Module %s indicated failure during load.",
538 mod_displayname);
539 sendto_realops_snomask(SNO_GENERAL, L_ALL,
540 "Module %s indicated failure during load.",
541 mod_displayname);
542 lt_dlclose(tmpptr);
543 rb_free(mod_displayname);
544 return false;
545 }
546
547 /* Basic date code checks
548 *
549 * Don't make them fatal, but do complain about differences within a certain time frame.
550 * Later on if there are major API changes we can add fatal checks.
551 * -- Elizafox
552 */
553 if(mheader->mapi_datecode != datecode && mheader->mapi_datecode > 0)
554 {
555 long int delta = datecode - mheader->mapi_datecode;
556 if (delta > MOD_WARN_DELTA)
557 {
558 delta /= 86400;
559 iwarn("Module %s build date is out of sync with ircd build date by %ld days, expect problems",
560 mod_displayname, delta);
561 sendto_realops_snomask(SNO_GENERAL, L_ALL,
562 "Module %s build date is out of sync with ircd build date by %ld days, expect problems",
563 mod_displayname, delta);
564 }
565 }
566
567 if(mheader->mapi_command_list)
568 {
569 struct Message **m;
570 for (m = mheader->mapi_command_list; *m; ++m)
571 mod_add_cmd(*m);
572 }
573
574 if(mheader->mapi_hook_list)
575 {
576 mapi_hlist_av1 *m;
577 for (m = mheader->mapi_hook_list; m->hapi_name; ++m)
578 *m->hapi_id = register_hook(m->hapi_name);
579 }
580
581 if(mheader->mapi_hfn_list)
582 {
583 mapi_hfn_list_av1 *m;
584 for (m = mheader->mapi_hfn_list; m->hapi_name; ++m)
585 add_hook(m->hapi_name, m->fn);
586 }
587
588 /* New in MAPI v2 - version replacement */
589 ver = mheader->mapi_module_version ? mheader->mapi_module_version : ircd_version;
590 description = mheader->mapi_module_description;
591
592 if(mheader->mapi_cap_list)
593 {
594 mapi_cap_list_av2 *m;
595 for (m = mheader->mapi_cap_list; m->cap_name; ++m)
596 {
597 struct CapabilityIndex *idx;
598 int result;
599
600 switch (m->cap_index)
601 {
602 case MAPI_CAP_CLIENT:
603 idx = cli_capindex;
604 break;
605 case MAPI_CAP_SERVER:
606 idx = serv_capindex;
607 break;
608 default:
609 sendto_realops_snomask(SNO_GENERAL, L_ALL,
610 "Unknown/unsupported CAP index found of type %d on capability %s when loading %s",
611 m->cap_index, m->cap_name, mod_displayname);
612 ilog(L_MAIN,
613 "Unknown/unsupported CAP index found of type %d on capability %s when loading %s",
614 m->cap_index, m->cap_name, mod_displayname);
615 continue;
616 }
617
618 result = capability_put(idx, m->cap_name, m->cap_ownerdata);
619 if (m->cap_id != NULL)
620 {
621 *(m->cap_id) = result;
622 sendto_local_clients_with_capability(CLICAP_CAP_NOTIFY, ":%s CAP * ADD :%s", me.name, m->cap_name);
623 }
624 }
625 }
626 }
627
628 break;
629 default:
630 ilog(L_MAIN, "Module %s has unknown/unsupported MAPI version %d.",
631 mod_displayname, MAPI_VERSION(*mapi_version));
632 sendto_realops_snomask(SNO_GENERAL, L_ALL,
633 "Module %s has unknown/unsupported MAPI version %d.",
634 mod_displayname, *mapi_version);
635 lt_dlclose(tmpptr);
636 rb_free(mod_displayname);
637 return false;
638 }
639
640 if(ver == NULL)
641 ver = unknown_ver;
642
643 if(description == NULL)
644 description = unknown_description;
645
646 increase_modlist();
647
648 modlist[num_mods] = rb_malloc(sizeof(struct module));
649 modlist[num_mods]->address = tmpptr;
650 modlist[num_mods]->version = ver;
651 modlist[num_mods]->description = description;
652 modlist[num_mods]->core = core;
653 modlist[num_mods]->name = rb_strdup(mod_displayname);
654 modlist[num_mods]->mapi_header = mapi_version;
655 modlist[num_mods]->mapi_version = MAPI_VERSION(*mapi_version);
656 modlist[num_mods]->origin = origin;
657 num_mods++;
658
659 if(warn)
660 {
661 const char *o;
662
663 switch (origin)
664 {
665 case MAPI_ORIGIN_EXTENSION:
666 o = "extension";
667 break;
668 case MAPI_ORIGIN_CORE:
669 o = "core";
670 break;
671 default:
672 o = "unknown";
673 break;
674 }
675
676 sendto_realops_snomask(SNO_GENERAL, L_ALL,
677 "Module %s [version: %s; MAPI version: %d; origin: %s; description: \"%s\"] loaded at %p",
678 mod_displayname, ver, MAPI_VERSION(*mapi_version), o, description,
679 (void *) tmpptr);
680 ilog(L_MAIN, "Module %s [version: %s; MAPI version: %d; origin: %s; description: \"%s\"] loaded at %p",
681 mod_displayname, ver, MAPI_VERSION(*mapi_version), o, description, (void *) tmpptr);
682 }
683 rb_free(mod_displayname);
684 return true;
685 }
686
687 /*
688 * increase_modlist
689 *
690 * inputs - NONE
691 * output - NONE
692 * side effects - expand the size of modlist if necessary
693 */
694 static void
695 increase_modlist(void)
696 {
697 struct module **new_modlist = NULL;
698
699 if((num_mods + 1) < max_mods)
700 return;
701
702 new_modlist = (struct module **) rb_malloc(sizeof(struct module *) *
703 (max_mods + MODS_INCREMENT));
704 memcpy((void *) new_modlist, (void *) modlist, sizeof(struct module *) * num_mods);
705
706 rb_free(modlist);
707 modlist = new_modlist;
708 max_mods += MODS_INCREMENT;
709 }
Fork of solanum ircd, history is rebased regularly