805 lines
20 KiB
C
805 lines
20 KiB
C
/* NeoStats - IRC Statistical Services
|
|
** Copyright (c) 1999-2003 Adam Rutter, Justin Hammond
|
|
** http://www.neostats.net/
|
|
**
|
|
** Portions Copyright (c) 2000 - 2001 ^Enigma^
|
|
**
|
|
** 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
|
|
**
|
|
** NeoStats CVS Identification
|
|
** $Id: dl.c,v 1.62 2003/07/30 13:58:22 fishwaldo Exp $
|
|
*/
|
|
|
|
#include <dlfcn.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "dl.h"
|
|
#include "hash.h"
|
|
#include "stats.h"
|
|
#include "config.h"
|
|
#include "log.h"
|
|
|
|
|
|
|
|
|
|
void
|
|
__init_mod_list ()
|
|
{
|
|
|
|
strcpy (segv_location, "__init_mod_list");
|
|
|
|
mh = hash_create (NUM_MODULES, 0, 0);
|
|
bh = hash_create (B_TABLE_SIZE, 0, 0);
|
|
th = hash_create (T_TABLE_SIZE, 0, 0);
|
|
bch = hash_create (C_TABLE_SIZE, 0, 0);
|
|
sockh = hash_create (me.maxsocks, 0, 0);
|
|
}
|
|
|
|
static Mod_Timer *
|
|
new_timer (char *timer_name)
|
|
{
|
|
Mod_Timer *t;
|
|
hnode_t *tn;
|
|
strcpy (segv_location, "Mod_Timer");
|
|
nlog (LOG_DEBUG2, LOG_CORE, "New Timer: %s", timer_name);
|
|
t = smalloc (sizeof (Mod_Timer));
|
|
if (!timer_name)
|
|
timer_name = "";
|
|
strncpy (t->timername, timer_name, MAXHOST);
|
|
tn = hnode_create (t);
|
|
if (hash_isfull (th)) {
|
|
nlog (LOG_WARNING, LOG_CORE, "new_timer(): Couldn't add new Timer, Hash is Full!");
|
|
return NULL;
|
|
} else {
|
|
hash_insert (th, tn, timer_name);
|
|
}
|
|
return t;
|
|
}
|
|
|
|
Mod_Timer *
|
|
findtimer (char *timer_name)
|
|
{
|
|
hnode_t *tn;
|
|
|
|
strcpy (segv_location, "findtimer");
|
|
tn = hash_lookup (th, timer_name);
|
|
if (tn)
|
|
return (Mod_Timer *) hnode_get (tn);
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
add_mod_timer (char *func_name, char *timer_name, char *mod_name, int interval)
|
|
{
|
|
Mod_Timer *Mod_timer_list;
|
|
|
|
strcpy (segv_location, "add_mod_timer");
|
|
|
|
|
|
if (dlsym ((int *) get_dl_handle (mod_name), func_name) == NULL) {
|
|
nlog (LOG_WARNING, LOG_CORE, "Oh Oh, The Timer Function doesn't exist");
|
|
return -1;
|
|
}
|
|
Mod_timer_list = new_timer (timer_name);
|
|
if (Mod_timer_list) {
|
|
Mod_timer_list->interval = interval;
|
|
Mod_timer_list->lastrun = time (NULL);
|
|
strncpy (Mod_timer_list->modname, mod_name, MAXHOST);
|
|
Mod_timer_list->function = dlsym ((int *) get_dl_handle (mod_name), func_name);
|
|
nlog (LOG_DEBUG2, LOG_CORE, "Registered Module %s with timer for Function %s", mod_name, func_name);
|
|
return 1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int
|
|
del_mod_timer (char *timer_name)
|
|
{
|
|
Mod_Timer *list;
|
|
hnode_t *tn;
|
|
strcpy (segv_location, "del_mod_timer");
|
|
|
|
tn = hash_lookup (th, timer_name);
|
|
if (tn) {
|
|
list = hnode_get (tn);
|
|
nlog (LOG_DEBUG2, LOG_CORE, "Unregistered Timer function %s from Module %s", timer_name, list->modname);
|
|
hash_delete (th, tn);
|
|
hnode_destroy (tn);
|
|
free (list);
|
|
return 1;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
list_module_timer (User * u)
|
|
{
|
|
Mod_Timer *mod_ptr = NULL;
|
|
hscan_t ts;
|
|
hnode_t *tn;
|
|
|
|
strcpy (segv_location, "list_module_timer");
|
|
prefmsg (u->nick, s_Services, "Module timer List:");
|
|
hash_scan_begin (&ts, th);
|
|
while ((tn = hash_scan_next (&ts)) != NULL) {
|
|
mod_ptr = hnode_get (tn);
|
|
prefmsg (u->nick, s_Services, "%s:--------------------------------", mod_ptr->modname);
|
|
prefmsg (u->nick, s_Services, "Module Timer Name: %s", mod_ptr->timername);
|
|
prefmsg (u->nick, s_Services, "Module Interval: %d", mod_ptr->interval);
|
|
prefmsg (u->nick, s_Services, "Time till next Run: %d", mod_ptr->interval - (time (NULL) - mod_ptr->lastrun));
|
|
}
|
|
prefmsg (u->nick, s_Services, "End of Module timer List");
|
|
}
|
|
|
|
static Sock_List *
|
|
new_sock (char *sock_name)
|
|
{
|
|
Sock_List *s;
|
|
hnode_t *sn;
|
|
|
|
strcpy (segv_location, "Sock_List");
|
|
nlog (LOG_DEBUG2, LOG_CORE, "New Socket: %s", sock_name);
|
|
s = smalloc (sizeof (Sock_List));
|
|
if (!sock_name)
|
|
sock_name = "";
|
|
strncpy (s->sockname, sock_name, MAXHOST);
|
|
sn = hnode_create (s);
|
|
if (hash_isfull (sockh)) {
|
|
nlog (LOG_CRITICAL, LOG_CORE, "Eeek, SocketHash is full, can not add a new socket");
|
|
return NULL;
|
|
} else {
|
|
hash_insert (sockh, sn, s->sockname);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
Sock_List *
|
|
findsock (char *sock_name)
|
|
{
|
|
hnode_t *sn;
|
|
strcpy (segv_location, "findsock");
|
|
sn = hash_lookup (sockh, sock_name);
|
|
if (sn)
|
|
return hnode_get (sn);
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
add_socket (char *readfunc, char *writefunc, char *errfunc, char *sock_name, int socknum, char *mod_name)
|
|
{
|
|
Sock_List *Sockets_mod_list;
|
|
|
|
strcpy (segv_location, "add_Socket");
|
|
if (readfunc) {
|
|
if (dlsym ((int *) get_dl_handle (mod_name), readfunc) == NULL) {
|
|
nlog (LOG_WARNING, LOG_CORE, "oh oh, the Read socket function doesn't exist = %s (%s)", readfunc, mod_name);
|
|
return -1;
|
|
}
|
|
}
|
|
if (writefunc) {
|
|
if (dlsym ((int *) get_dl_handle (mod_name), writefunc) == NULL) {
|
|
nlog (LOG_WARNING, LOG_CORE, "oh oh, the Write socket function doesn't exist = %s (%s)", writefunc, mod_name);
|
|
return -1;
|
|
}
|
|
}
|
|
if (errfunc) {
|
|
if (dlsym ((int *) get_dl_handle (mod_name), errfunc) == NULL) {
|
|
nlog (LOG_WARNING, LOG_CORE, "oh oh, the Error socket function doesn't exist = %s (%s)", errfunc, mod_name);
|
|
return -1;
|
|
}
|
|
}
|
|
Sockets_mod_list = new_sock (sock_name);
|
|
Sockets_mod_list->sock_no = socknum;
|
|
strncpy (Sockets_mod_list->modname, mod_name, MAXHOST);
|
|
Sockets_mod_list->readfnc = dlsym ((int *) get_dl_handle (mod_name), readfunc);
|
|
Sockets_mod_list->writefnc = dlsym ((int *) get_dl_handle (mod_name), writefunc);
|
|
Sockets_mod_list->errfnc = dlsym ((int *) get_dl_handle (mod_name), errfunc);
|
|
nlog (LOG_DEBUG2, LOG_CORE, "Registered Module %s with Socket functions %s", mod_name, Sockets_mod_list->sockname);
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
del_socket (char *sock_name)
|
|
{
|
|
Sock_List *list;
|
|
hnode_t *sn;
|
|
strcpy (segv_location, "del_mod_timer");
|
|
|
|
sn = hash_lookup (sockh, sock_name);
|
|
if (sn) {
|
|
list = hnode_get (sn);
|
|
nlog (LOG_DEBUG2, LOG_CORE, "Unregistered Socket function %s from Module %s", sock_name, list->modname);
|
|
hash_scan_delete (sockh, sn);
|
|
hnode_destroy (sn);
|
|
// free(list->sockname);
|
|
free (list);
|
|
return 1;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
list_sockets (User * u)
|
|
{
|
|
Sock_List *mod_ptr = NULL;
|
|
hscan_t ss;
|
|
hnode_t *sn;
|
|
|
|
strcpy (segv_location, "list_sockets");
|
|
prefmsg (u->nick, s_Services, "Sockets List: (%d)", hash_count (sockh));
|
|
hash_scan_begin (&ss, sockh);
|
|
while ((sn = hash_scan_next (&ss)) != NULL) {
|
|
mod_ptr = hnode_get (sn);
|
|
prefmsg (u->nick, s_Services, "%s:--------------------------------", mod_ptr->modname);
|
|
prefmsg (u->nick, s_Services, "Socket Name: %s", mod_ptr->sockname);
|
|
prefmsg (u->nick, s_Services, "Socket Number: %d", mod_ptr->sock_no);
|
|
}
|
|
prefmsg (u->nick, s_Services, "End of Socket List");
|
|
}
|
|
|
|
extern void
|
|
add_bot_to_chan (char *bot, char *chan)
|
|
{
|
|
hnode_t *cbn;
|
|
Chan_Bot *bc;
|
|
lnode_t *bmn;
|
|
char *botname;
|
|
cbn = hash_lookup (bch, chan);
|
|
if (!cbn) {
|
|
bc = malloc (sizeof (Chan_Bot));
|
|
strncpy (bc->chan, chan, CHANLEN);
|
|
bc->bots = list_create (B_TABLE_SIZE);
|
|
cbn = hnode_create (bc);
|
|
if (hash_isfull (bch)) {
|
|
nlog (LOG_CRITICAL, LOG_CORE, "eek, bot channel hash is full");
|
|
return;
|
|
}
|
|
hash_insert (bch, cbn, bc->chan);
|
|
} else {
|
|
bc = hnode_get (cbn);
|
|
}
|
|
if (list_isfull (bc->bots)) {
|
|
nlog (LOG_CRITICAL, LOG_CORE, "Eeek, Bot Channel List is full for Chan %s", chan);
|
|
return;
|
|
}
|
|
botname = sstrdup (bot);
|
|
bmn = lnode_create (botname);
|
|
list_append (bc->bots, bmn);
|
|
return;
|
|
}
|
|
|
|
extern void
|
|
del_bot_from_chan (char *bot, char *chan)
|
|
{
|
|
hnode_t *cbn;
|
|
Chan_Bot *bc;
|
|
lnode_t *bmn;
|
|
cbn = hash_lookup (bch, chan);
|
|
if (!cbn) {
|
|
nlog (LOG_WARNING, LOG_CORE, "Hu? Can't Find Channel %s for botchanhash", chan);
|
|
return;
|
|
}
|
|
bc = hnode_get (cbn);
|
|
bmn = list_find (bc->bots, bot, comparef);
|
|
if (!bmn) {
|
|
nlog (LOG_WARNING, LOG_CORE, "Hu? Can't find bot %s in %s in botchanhash", bot, chan);
|
|
return;
|
|
}
|
|
list_delete (bc->bots, bmn);
|
|
free (lnode_get (bmn));
|
|
if (list_isempty (bc->bots)) {
|
|
/* delete the hash and list because its all over */
|
|
hash_delete (bch, cbn);
|
|
list_destroy (bc->bots);
|
|
lnode_destroy (bmn);
|
|
free (bc->chan);
|
|
hnode_destroy (cbn);
|
|
}
|
|
}
|
|
|
|
extern void
|
|
bot_chan_message (char *origin, char *chan, char **av, int ac)
|
|
{
|
|
hnode_t *cbn;
|
|
Chan_Bot *bc;
|
|
lnode_t *bmn;
|
|
Mod_User *u;
|
|
cbn = hash_lookup (bch, chan);
|
|
if (!cbn) {
|
|
nlog (LOG_WARNING, LOG_CORE, "eeeh, Can't find channel %s for BotChanMessage", chan);
|
|
return;
|
|
}
|
|
bc = hnode_get (cbn);
|
|
bmn = list_first (bc->bots);
|
|
while (bmn) {
|
|
u = findbot (lnode_get (bmn));
|
|
if (u->chanfunc) {
|
|
nlog (LOG_DEBUG2, LOG_CORE, "Running Module for Chanmessage %s", chan);
|
|
u->chanfunc (origin, chan, av, ac);
|
|
}
|
|
bmn = list_next (bc->bots, bmn);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
extern void
|
|
botchandump (User * u)
|
|
{
|
|
hscan_t hs;
|
|
hnode_t *hn;
|
|
lnode_t *ln;
|
|
Chan_Bot *bc;
|
|
prefmsg (u->nick, s_Services, "BotChanDump:");
|
|
hash_scan_begin (&hs, bch);
|
|
while ((hn = hash_scan_next (&hs)) != NULL) {
|
|
bc = hnode_get (hn);
|
|
prefmsg (u->nick, s_Services, "%s:--------------------------------", bc->chan);
|
|
ln = list_first (bc->bots);
|
|
while (ln) {
|
|
prefmsg (u->nick, s_Services, "Bot Name: %s", lnode_get (ln));
|
|
ln = list_next (bc->bots, ln);
|
|
}
|
|
}
|
|
}
|
|
|
|
static Mod_User *
|
|
new_bot (char *bot_name)
|
|
{
|
|
Mod_User *u;
|
|
hnode_t *bn;
|
|
strcpy (segv_location, "Mod_User");
|
|
nlog (LOG_DEBUG2, LOG_CORE, "New Bot: %s", bot_name);
|
|
u = malloc (sizeof (Mod_User));
|
|
if (!bot_name)
|
|
bot_name = "";
|
|
strncpy (u->nick, bot_name, MAXNICK);
|
|
u->chanlist = hash_create (C_TABLE_SIZE, 0, 0);
|
|
bn = hnode_create (u);
|
|
if (hash_isfull (bh)) {
|
|
chanalert (s_Services, "Warning ModuleBotlist is full");
|
|
return NULL;
|
|
} else {
|
|
hash_insert (bh, bn, bot_name);
|
|
}
|
|
return u;
|
|
}
|
|
|
|
int
|
|
add_mod_user (char *nick, char *mod_name)
|
|
{
|
|
Mod_User *Mod_Usr_list;
|
|
Module *list_ptr;
|
|
hnode_t *mn;
|
|
|
|
strcpy (segv_location, "add_mod_user");
|
|
|
|
|
|
Mod_Usr_list = new_bot (nick);
|
|
/* add a brand new user */
|
|
strncpy (Mod_Usr_list->nick, nick, MAXNICK);
|
|
strncpy (Mod_Usr_list->modname, mod_name, MAXHOST);
|
|
|
|
mn = hash_lookup (mh, mod_name);
|
|
if (mn) {
|
|
list_ptr = hnode_get (mn);
|
|
Mod_Usr_list->function = dlsym (list_ptr->dl_handle, "__Bot_Message");
|
|
Mod_Usr_list->chanfunc = dlsym (list_ptr->dl_handle, "__Chan_Message");
|
|
return 1;
|
|
}
|
|
nlog (LOG_WARNING, LOG_CORE, "add_mod_user(): Couldn't Add ModuleBot to List");
|
|
return 0;
|
|
}
|
|
|
|
|
|
Mod_User *
|
|
findbot (char *bot_name)
|
|
{
|
|
hnode_t *bn;
|
|
|
|
strcpy (segv_location, "findbot");
|
|
bn = hash_lookup (bh, bot_name);
|
|
if (bn) {
|
|
return (Mod_User *) hnode_get (bn);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
del_mod_user (char *bot_name)
|
|
{
|
|
Mod_User *list;
|
|
hnode_t *bn;
|
|
|
|
strcpy (segv_location, "del_mod_user");
|
|
|
|
bn = hash_lookup (bh, bot_name);
|
|
if (bn) {
|
|
hash_delete (bh, bn);
|
|
list = hnode_get (bn);
|
|
hnode_destroy (bn);
|
|
free (list);
|
|
return 1;
|
|
}
|
|
return -1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
int
|
|
bot_nick_change (char *oldnick, char *newnick)
|
|
{
|
|
User *u;
|
|
Mod_User *mod_tmp, *mod_ptr;
|
|
|
|
strcpy (segv_location, "bot_nick_change");
|
|
|
|
/* First, try to find out if the newnick is unique! */
|
|
u = finduser (oldnick);
|
|
if (!u) {
|
|
nlog (LOG_WARNING, LOG_CORE, "A non-registered bot(%s) attempted to change its nick to %s", oldnick, newnick);
|
|
return -1;
|
|
}
|
|
u = finduser (newnick);
|
|
if (!u) {
|
|
if ((mod_ptr = findbot (oldnick)) != NULL) {
|
|
nlog (LOG_DEBUG3, LOG_CORE, "Bot %s Changed its nick to %s", oldnick, newnick);
|
|
mod_tmp = new_bot (newnick);
|
|
|
|
/* add a brand new user */
|
|
|
|
strncpy (mod_tmp->nick, newnick, MAXNICK);
|
|
strncpy (mod_tmp->modname, mod_ptr->modname, MAXHOST);
|
|
mod_tmp->function = mod_ptr->function;
|
|
|
|
/* Now Delete the Old bot nick */
|
|
|
|
del_mod_user (oldnick);
|
|
snick_cmd (oldnick, newnick);
|
|
return 1;
|
|
}
|
|
}
|
|
nlog (LOG_NOTICE, LOG_CORE, "Couldn't find Bot Nick %s in Bot list", oldnick);
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
list_module_bots (User * u)
|
|
{
|
|
Mod_User *mod_ptr;
|
|
hnode_t *bn;
|
|
hscan_t bs;
|
|
strcpy (segv_location, "list_module_bots");
|
|
|
|
prefmsg (u->nick, s_Services, "Module Bot List:");
|
|
hash_scan_begin (&bs, bh);
|
|
while ((bn = hash_scan_next (&bs)) != NULL) {
|
|
mod_ptr = hnode_get (bn);
|
|
prefmsg (u->nick, s_Services, "Module: %s", mod_ptr->modname);
|
|
prefmsg (u->nick, s_Services, "Module Bots: %s", mod_ptr->nick);
|
|
}
|
|
prefmsg (u->nick, s_Services, "End of Module Bot List");
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
load_module (char *path1, User * u)
|
|
{
|
|
|
|
|
|
#ifndef HAVE_LIBDL
|
|
const char *dl_error;
|
|
#else
|
|
char *dl_error;
|
|
#endif
|
|
void *dl_handle;
|
|
int do_msg;
|
|
char path[255];
|
|
char p[255];
|
|
char **av;
|
|
int ac = 0;
|
|
int i = 0;
|
|
Module_Info *(*mod_get_info) () = NULL;
|
|
Functions *(*mod_get_funcs) () = NULL;
|
|
EventFnList *(*mod_get_events) () = NULL;
|
|
Module_Info *mod_info_ptr = NULL;
|
|
Functions *mod_funcs_ptr = NULL;
|
|
EventFnList *event_fn_ptr = NULL;
|
|
Module *mod_ptr = NULL;
|
|
hnode_t *mn;
|
|
|
|
strcpy (segv_location, "load_module");
|
|
|
|
if (u == NULL) {
|
|
do_msg = 0;
|
|
} else {
|
|
do_msg = 1;
|
|
}
|
|
#if 0
|
|
snprintf (path, 255, "%s.so", path1);
|
|
dl_handle = dlopen (path, RTLD_NOW || RTLD_GLOBAL);
|
|
if (!dl_handle) {
|
|
#endif
|
|
snprintf (p, 255, "dl/%s.so", path1);
|
|
dl_handle = dlopen (p, RTLD_NOW || RTLD_GLOBAL);
|
|
#if 0
|
|
}
|
|
#endif
|
|
strcpy (segvinmodule, "");
|
|
if (!dl_handle) {
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "Error, Couldn't Load Module");
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "%s", dlerror ());
|
|
nlog (LOG_WARNING, LOG_CORE, "Couldn't Load Module: %s", dlerror ());
|
|
nlog (LOG_WARNING, LOG_CORE, "Module was %s", p);
|
|
return -1;
|
|
}
|
|
|
|
mod_get_info = dlsym (dl_handle, "__module_get_info");
|
|
#ifndef HAVE_LIBDL
|
|
if (mod_get_info == NULL) {
|
|
dl_error = dlerror ();
|
|
#else
|
|
if ((dl_error = dlerror ()) != NULL) {
|
|
#endif
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "Error, Couldn't Load Module");
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "%s", dl_error);
|
|
nlog (LOG_WARNING, LOG_CORE, "Couldn't Load Module: %s", dl_error);
|
|
dlclose (dl_handle);
|
|
return -1;
|
|
}
|
|
|
|
mod_get_funcs = dlsym (dl_handle, "__module_get_functions");
|
|
#ifndef HAVE_LIBDL
|
|
if (mod_get_info == NULL) {
|
|
dl_error = dlerror ();
|
|
#else
|
|
if ((dl_error = dlerror ()) != NULL) {
|
|
#endif
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "Error, Couldn't Load Module");
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "%s", dl_error);
|
|
nlog (LOG_WARNING, LOG_CORE, "Couldn't Load Module: %s", dl_error);
|
|
dlclose (dl_handle);
|
|
return -1;
|
|
}
|
|
|
|
mod_get_events = dlsym (dl_handle, "__module_get_events");
|
|
/* no error check here - this one isn't essential to the functioning of the module */
|
|
|
|
mod_info_ptr = (*mod_get_info) ();
|
|
mod_funcs_ptr = (*mod_get_funcs) ();
|
|
if (mod_get_events)
|
|
event_fn_ptr = (*mod_get_events) ();
|
|
|
|
if (mod_info_ptr == NULL || mod_funcs_ptr == NULL) {
|
|
dlclose (dl_handle);
|
|
nlog (LOG_WARNING, LOG_CORE, "%s: Could not load dynamic library %s!\n", __PRETTY_FUNCTION__, path);
|
|
nlog (LOG_WARNING, LOG_CORE, "Couldn't Load Module: %s", dlerror ());
|
|
return -1;
|
|
}
|
|
|
|
/* Check that the Module hasn't already been loaded */
|
|
|
|
if (hash_lookup (mh, mod_info_ptr->module_name)) {
|
|
dlclose (dl_handle);
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "Module %s already Loaded, Can't Load 2 Copies", mod_info_ptr->module_name);
|
|
free (mod_ptr);
|
|
return -1;
|
|
}
|
|
|
|
mod_ptr = (Module *) smalloc (sizeof (Module));
|
|
|
|
mn = hnode_create (mod_ptr);
|
|
if (hash_isfull (mh)) {
|
|
if (do_msg)
|
|
chanalert (s_Services, "Module List is Full. Can't Load any more modules");
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "Module List is Full, Can't Load any more Modules");
|
|
dlclose (dl_handle);
|
|
free (mod_ptr);
|
|
return -1;
|
|
} else {
|
|
hash_insert (mh, mn, mod_info_ptr->module_name);
|
|
}
|
|
nlog (LOG_NORMAL, LOG_CORE, "Module Internal name: %s", mod_info_ptr->module_name);
|
|
nlog (LOG_NORMAL, LOG_CORE, "Module description: %s", mod_info_ptr->module_description);
|
|
|
|
mod_ptr->info = mod_info_ptr;
|
|
mod_ptr->function_list = mod_funcs_ptr;
|
|
mod_ptr->dl_handle = dl_handle;
|
|
mod_ptr->other_funcs = event_fn_ptr;
|
|
|
|
/* assign a module number to this module */
|
|
i = 0;
|
|
while (ModNum[i].used != 0)
|
|
i++;
|
|
/* no need to check for overflow of NUM_MODULES, as its done above */
|
|
ModNum[i].used = 1;
|
|
ModNum[i].mod = mod_ptr;
|
|
nlog (LOG_DEBUG1, LOG_CORE, "Assigned %d to Module %s for ModuleNum", i, ModNum[i].mod->info->module_name);
|
|
|
|
|
|
|
|
|
|
/* Let this module know we are online if we are! */
|
|
if (me.onchan == 1) {
|
|
while (event_fn_ptr->cmd_name != NULL) {
|
|
if (!strcasecmp (event_fn_ptr->cmd_name, "ONLINE")) {
|
|
AddStringToList (&av, me.s->name, &ac);
|
|
strcpy (segv_location, mod_ptr->info->module_name);
|
|
strcpy (segvinmodule, mod_ptr->info->module_name);
|
|
event_fn_ptr->function (av, ac);
|
|
strcpy (segv_location, "AfterDLLoadOnline");
|
|
strcpy (segvinmodule, "");
|
|
free (av);
|
|
break;
|
|
}
|
|
event_fn_ptr++;
|
|
}
|
|
}
|
|
if (do_msg)
|
|
prefmsg (u->nick, s_Services, "Module %s Loaded, Description: %s", mod_info_ptr->module_name, mod_info_ptr->module_description);
|
|
if (do_msg)
|
|
globops (me.name, "%s Module Loaded", mod_info_ptr->module_name);
|
|
return 0;
|
|
|
|
|
|
}
|
|
extern int
|
|
get_dl_handle (char *mod_name)
|
|
{
|
|
Module *list_ptr;
|
|
hnode_t *mn;
|
|
strcpy (segv_location, "get_dl_handle");
|
|
|
|
|
|
mn = hash_lookup (mh, mod_name);
|
|
if (mn) {
|
|
list_ptr = hnode_get (mn);
|
|
return (int) list_ptr->dl_handle;
|
|
}
|
|
return 0;
|
|
}
|
|
extern int
|
|
get_mod_num (char *mod_name)
|
|
{
|
|
int i;
|
|
for (i = 0; i <= NUM_MODULES; i++) {
|
|
if (ModNum[i].used > 0) {
|
|
if (!strcasecmp (ModNum[i].mod->info->module_name, mod_name)) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
/* if we get here, it wasn't found */
|
|
nlog (LOG_DEBUG1, LOG_CORE, "Can't find %s in module number list", mod_name);
|
|
return -1;
|
|
};
|
|
|
|
|
|
void
|
|
list_module (User * u)
|
|
{
|
|
Module *mod_ptr = NULL;
|
|
hnode_t *mn;
|
|
hscan_t hs;
|
|
|
|
strcpy (segv_location, "list_module");
|
|
hash_scan_begin (&hs, mh);
|
|
while ((mn = hash_scan_next (&hs)) != NULL) {
|
|
mod_ptr = hnode_get (mn);
|
|
prefmsg (u->nick, s_Services, "Module: %s (%s)", mod_ptr->info->module_name, mod_ptr->info->module_version);
|
|
prefmsg (u->nick, s_Services, "Module Description: %s", mod_ptr->info->module_description);
|
|
prefmsg (u->nick, s_Services, "Module Number: %d", get_mod_num (mod_ptr->info->module_name));
|
|
}
|
|
prefmsg (u->nick, s_Services, "End of Module List");
|
|
}
|
|
|
|
int
|
|
unload_module (char *module_name, User * u)
|
|
{
|
|
Module *list;
|
|
Mod_User *mod_ptr = NULL;
|
|
Mod_Timer *mod_tmr = NULL;
|
|
Sock_List *mod_sock = NULL;
|
|
hnode_t *modnode;
|
|
hscan_t hscan;
|
|
int i;
|
|
|
|
strcpy (segv_location, "unload_module");
|
|
/* Check to see if this Module has any timers registered.... */
|
|
|
|
modnode = hash_lookup (mh, module_name);
|
|
if (modnode) {
|
|
chanalert (s_Services, "Unloading Module %s", module_name);
|
|
} else {
|
|
if (u) {
|
|
prefmsg (u->nick, s_Services, "Couldn't Find Module %s Loaded, Try /msg %s modlist", module_name, s_Services);
|
|
chanalert (s_Services, "%s tried to Unload %s but its not loaded", u->nick, module_name);
|
|
return -1;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
hash_scan_begin (&hscan, th);
|
|
while ((modnode = hash_scan_next (&hscan)) != NULL) {
|
|
mod_tmr = hnode_get (modnode);
|
|
if (!strcasecmp (mod_tmr->modname, module_name)) {
|
|
nlog (LOG_DEBUG1, LOG_CORE, "Module %s has timer %s Registered. Deleting..", module_name, mod_tmr->timername);
|
|
del_mod_timer (mod_tmr->timername);
|
|
}
|
|
}
|
|
/* check if the module had a socket registered... */
|
|
hash_scan_begin (&hscan, sockh);
|
|
while ((modnode = hash_scan_next (&hscan)) != NULL) {
|
|
mod_sock = hnode_get (modnode);
|
|
if (!strcasecmp (mod_sock->modname, module_name)) {
|
|
nlog (LOG_DEBUG1, LOG_CORE, "Module %s had Socket %s Registered. Deleting..", module_name, mod_sock->sockname);
|
|
del_socket (mod_sock->sockname);
|
|
}
|
|
}
|
|
|
|
/* now, see if this Module has any bots with it */
|
|
hash_scan_begin (&hscan, bh);
|
|
while ((modnode = hash_scan_next (&hscan)) != NULL) {
|
|
mod_ptr = hnode_get (modnode);
|
|
if (!strcasecmp (mod_ptr->modname, module_name)) {
|
|
nlog (LOG_DEBUG1, LOG_CORE, "Module %s had bot %s Registered. Deleting..", module_name, mod_ptr->nick);
|
|
del_bot (mod_ptr->nick, "Module Unloaded");
|
|
}
|
|
}
|
|
modnode = hash_lookup (mh, module_name);
|
|
if (modnode) {
|
|
nlog (LOG_DEBUG1, LOG_CORE, "Deleting Module %s from ModHash", module_name);
|
|
globops (me.name, "%s Module Unloaded", module_name);
|
|
|
|
i = get_mod_num (module_name);
|
|
|
|
list = hnode_get (modnode);
|
|
hash_delete (mh, modnode);
|
|
hnode_destroy (modnode);
|
|
/* set segv in module */
|
|
strcpy (segvinmodule, module_name);
|
|
dlclose (list->dl_handle);
|
|
strcpy (segvinmodule, "");
|
|
|
|
if (i >= 0) {
|
|
nlog (LOG_DEBUG1, LOG_CORE, "Freeing %d from Module Numbers", i);
|
|
/* free the module number */
|
|
ModNum[i].mod = NULL;
|
|
ModNum[i].used = 0;
|
|
}
|
|
free (list);
|
|
return 1;
|
|
}
|
|
return -1;
|
|
}
|