supernets/unrealircd
supernets/unrealircd
4
Fork 0
mirror of git://git.acid.vegas/unrealircd.git synced 2024-12-26 16:26:38 +00:00
Code Issues Activity
ba6084af1c
unrealircd/src/modules.c
acidvegas d53bf1d1c0
Updated to 6.1.0
2023-05-05 18:12:01 -04:00

1528 lines
37 KiB
C
Raw Blame History

/************************************************************************
* UnrealIRCd - Unreal Internet Relay Chat Daemon - src/modules.c
* (C) 2001 Carsten Munk (Techie/Stskeeps) <stskeeps@tspre.org>
*
* See file AUTHORS in IRC package for additional names of
* the programmers.
*
* 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 1, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define UNREALCORE
#include "unrealircd.h"
#ifdef _WIN32
#define RTLD_NOW 0
#elif defined(HPUX)
#include <dl.h>
#define RTLD_NOW BIND_IMMEDIATE
#else
#include <dlfcn.h>
#endif
#ifndef RTLD_NOW
#define RTLD_NOW RTLD_LAZY
#endif
#include "modversion.h"
Hook *Hooks[MAXHOOKTYPES];
Hooktype Hooktypes[MAXCUSTOMHOOKS];
Callback *Callbacks[MAXCALLBACKS]; /* Callback objects for modules, used for rehashing etc (can be multiple) */
Callback *RCallbacks[MAXCALLBACKS]; /* 'Real' callback function, used for callback function calls */
MODVAR Module *Modules = NULL;
MODVAR Versionflag *Versionflags = NULL;
Module *Module_make(ModuleHeader *header,
#ifdef _WIN32
HMODULE mod
#else
void *mod
#endif
);
#ifdef UNDERSCORE
/* dlsym for OpenBSD */
void *obsd_dlsym(void *handle, const char *symbol)
{
size_t buflen = strlen(symbol) + 2;
char *obsdsymbol = safe_alloc(buflen);
void *symaddr = NULL;
if (obsdsymbol)
{
ircsnprintf(obsdsymbol, buflen, "_%s", symbol);
symaddr = dlsym(handle, obsdsymbol);
safe_free(obsdsymbol);
}
return symaddr;
}
#endif
void deletetmp(const char *path)
{
#ifndef NOREMOVETMP
if (!loop.config_test)
remove(path);
#endif
}
void DeleteTempModules(void)
{
char tempbuf[PATH_MAX+1];
#ifndef _WIN32
DIR *fd = opendir(TMPDIR);
struct dirent *dir;
if (!fd) /* Ouch.. this is NOT good!! */
{
config_error("Unable to open temp directory %s: %s, please create one with the appropriate permissions",
TMPDIR, strerror(errno));
if (!loop.booted)
exit(7);
return;
}
while ((dir = readdir(fd)))
{
char *fname = dir->d_name;
if (!strcmp(fname, ".") || !strcmp(fname, ".."))
continue;
if (!strstr(fname, ".so") && !strstr(fname, ".conf") &&
(strstr(fname, "core") || strstr(fname, "unrealircd_asan.")))
continue; /* core dump or ASan log */
ircsnprintf(tempbuf, sizeof(tempbuf), "%s/%s", TMPDIR, fname);
deletetmp(tempbuf);
}
closedir(fd);
#else
WIN32_FIND_DATA hData;
HANDLE hFile;
snprintf(tempbuf, sizeof(tempbuf), "%s/*", TMPDIR);
hFile = FindFirstFile(tempbuf, &hData);
if (hFile != INVALID_HANDLE_VALUE)
{
if (strcmp(hData.cFileName, ".") || strcmp(hData.cFileName, ".."))
{
ircsnprintf(tempbuf, sizeof(tempbuf), "%s/%s", TMPDIR, hData.cFileName);
deletetmp(tempbuf);
}
}
while (FindNextFile(hFile, &hData))
{
if (!strcmp(hData.cFileName, ".") || !strcmp(hData.cFileName, ".."))
continue;
ircsnprintf(tempbuf, sizeof(tempbuf), "%s/%s", TMPDIR, hData.cFileName);
deletetmp(tempbuf);
}
FindClose(hFile);
#endif
}
Module *Module_Find(const char *name)
{
Module *p;
for (p = Modules; p; p = p->next)
{
if (!(p->options & MOD_OPT_PERM) &&
(!(p->flags & MODFLAG_TESTING) || (p->flags & MODFLAG_DELAYED)))
continue;
if (!strcmp(p->header->name, name))
{
return (p);
}
}
return NULL;
}
int parse_modsys_version(const char *version)
{
if (!strcmp(version, "unrealircd-6"))
return 0x600000;
return 0;
}
void make_compiler_string(char *buf, size_t buflen, unsigned int ver)
{
unsigned int maj, min, plevel;
if (ver == 0)
{
strlcpy(buf, "0", buflen);
return;
}
maj = ver >> 16;
min = (ver >> 8) & 0xff;
plevel = ver & 0xff;
if (plevel == 0)
snprintf(buf, buflen, "%d.%d", maj, min);
else
snprintf(buf, buflen, "%d.%d.%d", maj, min, plevel);
}
/** Transform a loadmodule path like "third/la" to
* something like "/home/xyz/unrealircd/modules/third/la.so
* (and other tricks)
*/
const char *Module_TransformPath(const char *path_)
{
static char path[1024];
/* Prefix the module path with MODULESDIR, unless it's an absolute path
* (we check for "/", "\" and things like "C:" to detect absolute paths).
*/
if ((*path_ != '/') && (*path_ != '\\') && !(*path_ && (path_[1] == ':')))
{
snprintf(path, sizeof(path), "%s/%s", MODULESDIR, path_);
} else {
strlcpy(path, path_, sizeof(path));
}
/* Auto-suffix .dll / .so */
if (!strstr(path, MODULE_SUFFIX))
strlcat(path, MODULE_SUFFIX, sizeof(path));
return path;
}
/** This function is the inverse of Module_TransformPath() */
const char *Module_GetRelPath(const char *fullpath)
{
static char buf[512];
char prefix[512];
const char *without_prefix = fullpath;
char *s;
/* Strip the prefix */
snprintf(prefix, sizeof(prefix), "%s/", MODULESDIR);
if (!strncasecmp(fullpath, prefix, strlen(prefix)))
without_prefix += strlen(prefix);
strlcpy(buf, without_prefix, sizeof(buf));
/* Strip the suffix */
s = strstr(buf, MODULE_SUFFIX);
if (s)
*s = '\0';
return buf;
}
/** Validate a modules' ModuleHeader.
* @returns Error message is returned, or NULL if everything is OK.
*/
static const char *validate_mod_header(const char *relpath, ModuleHeader *mod_header)
{
char *p;
static char buf[256];
if (!mod_header->name || !mod_header->version || !mod_header->author || !mod_header->description)
return "NULL values encountered in Mod_Header struct members";
/* Validate module name */
if (strcmp(mod_header->name, relpath))
{
snprintf(buf, sizeof(buf), "Module has path '%s' but uses name '%s' in MOD_HEADER. These should be the same!",
relpath, mod_header->name);
return buf;
}
/* This too, just to be sure.. we never ever want other characters
* than these, since it may break the S2S SMOD command or /MODULE
* output etc.
*/
for (p = mod_header->name; *p; p++)
if (!isalnum(*p) && !strchr("._-/", *p))
return "ModuleHeader.name contains illegal characters (must be: a-zA-Z0-9._-/)";
/* Validate version, even more strict */
if (!isdigit(mod_header->version[0]))
return "ModuleHeader.version must start with a digit";
for (p = mod_header->version; *p; p++)
if (!isalnum(*p) && !strchr("._-", *p))
return "ModuleHeader.version contains illegal characters (must be: a-zA-Z0-9._-)";
/* Author and description are not checked, has no constraints */
return NULL; /* SUCCESS */
}
int module_already_in_testing(const char *relpath)
{
Module *m;
for (m = Modules; m; m = m->next)
{
if (!(m->options & MOD_OPT_PERM) &&
(!(m->flags & MODFLAG_TESTING) || (m->flags & MODFLAG_DELAYED)))
continue;
if (!strcmp(m->relpath, relpath))
return 1;
}
return 0;
}
/*
* Returns an error if insucessful .. yes NULL is OK!
*/
const char *Module_Create(const char *path_)
{
#ifdef _WIN32
HMODULE Mod;
#else /* _WIN32 */
void *Mod;
#endif /* _WIN32 */
int (*Mod_Test)();
int (*Mod_Init)();
int (*Mod_Load)();
int (*Mod_Unload)();
char *Mod_Version;
unsigned int *compiler_version;
static char errorbuf[1024];
const char *path, *relpath, *tmppath;
ModuleHeader *mod_header = NULL;
int ret = 0;
const char *reterr;
Module *mod = NULL, **Mod_Handle = NULL;
char *expectedmodversion = our_mod_version;
unsigned int expectedcompilerversion = our_compiler_version;
long modsys_ver = 0;
path = Module_TransformPath(path_);
relpath = Module_GetRelPath(path);
if (module_already_in_testing(relpath))
return 0;
if (!file_exists(path))
{
snprintf(errorbuf, sizeof(errorbuf), "Cannot open module file: %s", strerror(errno));
return errorbuf;
}
if (loop.config_test)
{
/* For './unrealircd configtest' we don't have to do any copying and shit */
tmppath = path;
} else {
tmppath = unreal_mktemp(TMPDIR, unreal_getmodfilename(path));
if (!tmppath)
return "Unable to create temporary file!";
/* We have to copy the module, because otherwise the dynamic loader
* will not load the new .so if we rehash while holding the original .so
* We used to hardlink here instead of copy, but then OpenBSD and Linux
* got smart and detected that, so now we always copy.
*/
ret = unreal_copyfileex(path, tmppath, 0);
if (!ret)
{
snprintf(errorbuf, sizeof(errorbuf), "Failed to copy module file.");
return errorbuf;
}
}
if ((Mod = irc_dlopen(tmppath, RTLD_NOW)))
{
/* We have engaged the borg cube. Scan for lifesigns. */
irc_dlsym(Mod, "Mod_Version", Mod_Version);
if (Mod_Version && strcmp(Mod_Version, expectedmodversion))
{
snprintf(errorbuf, sizeof(errorbuf),
"Module was compiled for '%s', we were configured for '%s'. SOLUTION: Recompile the module(s).",
Mod_Version, expectedmodversion);
irc_dlclose(Mod);
deletetmp(tmppath);
return errorbuf;
}
if (!Mod_Version)
{
snprintf(errorbuf, sizeof(errorbuf),
"Module is lacking Mod_Version. Perhaps a very old one you forgot to recompile?");
irc_dlclose(Mod);
deletetmp(tmppath);
return errorbuf;
}
irc_dlsym(Mod, "compiler_version", compiler_version);
if (compiler_version && ( ((*compiler_version) & 0xffff00) != (expectedcompilerversion & 0xffff00) ) )
{
char theyhad[64], wehave[64];
make_compiler_string(theyhad, sizeof(theyhad), *compiler_version);
make_compiler_string(wehave, sizeof(wehave), expectedcompilerversion);
snprintf(errorbuf, sizeof(errorbuf),
"Module was compiled with GCC %s, core was compiled with GCC %s. SOLUTION: Recompile your UnrealIRCd and all its modules by doing a 'make clean; ./Config -quick && make'.",
theyhad, wehave);
irc_dlclose(Mod);
deletetmp(tmppath);
return errorbuf;
}
irc_dlsym(Mod, "Mod_Header", mod_header);
if (!mod_header)
{
irc_dlclose(Mod);
deletetmp(tmppath);
return ("Unable to locate Mod_Header");
}
if (!mod_header->modversion)
{
irc_dlclose(Mod);
deletetmp(tmppath);
return ("Lacking mod_header->modversion");
}
if (!(modsys_ver = parse_modsys_version(mod_header->modversion)))
{
snprintf(errorbuf, 1023, "Unsupported module system version '%s'",
mod_header->modversion);
irc_dlclose(Mod);
deletetmp(tmppath);
return(errorbuf);
}
if ((reterr = validate_mod_header(relpath, mod_header)))
{
irc_dlclose(Mod);
deletetmp(tmppath);
return(reterr);
}
if (Module_Find(mod_header->name))
{
irc_dlclose(Mod);
deletetmp(tmppath);
return (NULL);
}
mod = (Module *)Module_make(mod_header, Mod);
safe_strdup(mod->tmp_file, tmppath);
mod->mod_sys_version = modsys_ver;
mod->compiler_version = compiler_version ? *compiler_version : 0;
safe_strdup(mod->relpath, relpath);
irc_dlsym(Mod, "Mod_Init", Mod_Init);
if (!Mod_Init)
{
Module_free(mod);
return ("Unable to locate Mod_Init");
}
irc_dlsym(Mod, "Mod_Unload", Mod_Unload);
if (!Mod_Unload)
{
Module_free(mod);
return ("Unable to locate Mod_Unload");
}
irc_dlsym(Mod, "Mod_Load", Mod_Load);
if (!Mod_Load)
{
Module_free(mod);
return ("Unable to locate Mod_Load");
}
irc_dlsym(Mod, "Mod_Handle", Mod_Handle);
if (Mod_Handle)
*Mod_Handle = mod;
irc_dlsym(Mod, "Mod_Test", Mod_Test);
/* add module here, so ModuleSetOptions() w/MOD_OPT_PRIORITY is available in Mod_Test() */
AddListItemPrio(mod, Modules, 0);
if (Mod_Test)
{
if ((ret = (*Mod_Test)(&mod->modinfo)) < MOD_SUCCESS)
{
ircsnprintf(errorbuf, sizeof(errorbuf), "Mod_Test returned %i", ret);
/* We EXPECT the module to have cleaned up its mess */
Module_free(mod);
return (errorbuf);
}
}
mod->flags = MODFLAG_TESTING;
return NULL;
}
else
{
/* Return the error .. */
return irc_dlerror();
}
}
void Module_DelayChildren(Module *m)
{
ModuleChild *c;
for (c = m->children; c; c = c->next)
{
c->child->flags |= MODFLAG_DELAYED;
Module_DelayChildren(c->child);
}
}
Module *Module_make(ModuleHeader *header,
#ifdef _WIN32
HMODULE mod
#else
void *mod
#endif
)
{
Module *modp = NULL;
modp = safe_alloc(sizeof(Module));
modp->header = header;
modp->dll = mod;
modp->flags = MODFLAG_NONE;
modp->options = 0;
modp->errorcode = MODERR_NOERROR;
modp->children = NULL;
modp->modinfo.size = sizeof(ModuleInfo);
modp->modinfo.module_load = 0;
modp->modinfo.handle = modp;
return (modp);
}
void Init_all_testing_modules(void)
{
Module *mi, *next;
int ret;
iFP Mod_Init;
for (mi = Modules; mi; mi = next)
{
next = mi->next;
if (!(mi->flags & MODFLAG_TESTING))
continue;
irc_dlsym(mi->dll, "Mod_Init", Mod_Init);
if ((ret = (*Mod_Init)(&mi->modinfo)) < MOD_SUCCESS) {
config_error("Error loading %s: Mod_Init returned %i",
mi->header->name, ret);
Module_free(mi);
continue;
}
mi->flags = MODFLAG_INIT;
}
}
void FreeModObj(ModuleObject *obj, Module *m)
{
if (obj->type == MOBJ_EVENT) {
EventDel(obj->object.event);
}
else if (obj->type == MOBJ_HOOK) {
HookDel(obj->object.hook);
}
else if (obj->type == MOBJ_COMMAND) {
CommandDel(obj->object.command);
}
else if (obj->type == MOBJ_HOOKTYPE) {
//HooktypeDel(obj->object.hooktype, m); -- reinstate if we audited this code
}
else if (obj->type == MOBJ_VERSIONFLAG) {
VersionflagDel(obj->object.versionflag, m);
}
else if (obj->type == MOBJ_UMODE) {
UmodeDel(obj->object.umode);
}
else if (obj->type == MOBJ_CMODE) {
CmodeDel(obj->object.cmode);
}
else if (obj->type == MOBJ_COMMANDOVERRIDE) {
CommandOverrideDel(obj->object.cmdoverride);
}
else if (obj->type == MOBJ_EXTBAN) {
ExtbanDel(obj->object.extban);
}
else if (obj->type == MOBJ_CALLBACK) {
CallbackDel(obj->object.callback);
}
else if (obj->type == MOBJ_EFUNCTION) {
EfunctionDel(obj->object.efunction);
}
else if (obj->type == MOBJ_ISUPPORT) {
ISupportDel(obj->object.isupport);
}
else if (obj->type == MOBJ_MODDATA) {
ModDataDel(obj->object.moddata);
}
else if (obj->type == MOBJ_VALIDATOR) {
OperClassValidatorDel(obj->object.validator);
}
else if (obj->type == MOBJ_CLICAP) {
ClientCapabilityDel(obj->object.clicap);
}
else if (obj->type == MOBJ_MTAG) {
MessageTagHandlerDel(obj->object.mtag);
}
else if (obj->type == MOBJ_HISTORY_BACKEND) {
HistoryBackendDel(obj->object.history_backend);
}
else if (obj->type == MOBJ_RPC) {
RPCHandlerDel(obj->object.rpc);
}
else
{
unreal_log(ULOG_FATAL, "module", "FREEMODOBJ_UNKNOWN_TYPE", NULL,
"[BUG] FreeModObj() called for unknown object (type $type)",
log_data_integer("type", obj->type));
abort();
}
}
void Unload_all_loaded_modules(void)
{
Module *mi, *next;
ModuleChild *child, *childnext;
ModuleObject *objs, *objnext;
iFP Mod_Unload;
int ret;
for (mi = Modules; mi; mi = next)
{
next = mi->next;
if (!(mi->flags & MODFLAG_LOADED) || (mi->flags & MODFLAG_DELAYED) || (mi->options & MOD_OPT_PERM))
continue;
irc_dlsym(mi->dll, "Mod_Unload", Mod_Unload);
if (Mod_Unload)
{
ret = (*Mod_Unload)(&mi->modinfo);
if (ret == MOD_DELAY)
{
mi->flags |= MODFLAG_DELAYED;
Module_DelayChildren(mi);
}
}
for (objs = mi->objects; objs; objs = objnext) {
objnext = objs->next;
FreeModObj(objs, mi);
}
for (child = mi->children; child; child = childnext)
{
childnext = child->next;
DelListItem(child,mi->children);
safe_free(child);
}
DelListItem(mi,Modules);
irc_dlclose(mi->dll);
deletetmp(mi->tmp_file);
safe_free(mi->tmp_file);
safe_free(mi->relpath);
safe_free(mi);
}
}
void Unload_all_testing_modules(void)
{
Module *mi, *next;
ModuleChild *child, *childnext;
ModuleObject *objs, *objnext;
for (mi = Modules; mi; mi = next)
{
next = mi->next;
if (!(mi->flags & MODFLAG_TESTING))
continue;
for (objs = mi->objects; objs; objs = objnext) {
objnext = objs->next;
FreeModObj(objs, mi);
}
for (child = mi->children; child; child = childnext)
{
childnext = child->next;
DelListItem(child,mi->children);
safe_free(child);
}
DelListItem(mi,Modules);
irc_dlclose(mi->dll);
deletetmp(mi->tmp_file);
safe_free(mi->tmp_file);
safe_free(mi->relpath);
safe_free(mi);
}
}
/*
* Returns -1 if you cannot unload due to children still alive
* Returns 1 if successful
*/
int Module_free(Module *mod)
{
Module *p;
ModuleChild *cp, *cpnext;
ModuleObject *objs, *next;
/* Do not kill parent if children still alive */
for (cp = mod->children; cp; cp = cp->next)
{
Module_Unload(cp->child->header->name);
}
for (objs = mod->objects; objs; objs = next) {
next = objs->next;
FreeModObj(objs, mod);
}
for (p = Modules; p; p = p->next)
{
for (cp = p->children; cp; cp = cpnext)
{
cpnext = cp->next;
if (cp->child == mod)
{
DelListItem(mod, p->children);
safe_free(cp);
/* We can assume there can be only one. */
break;
}
}
}
DelListItem(mod, Modules);
irc_dlclose(mod->dll);
safe_free(mod->tmp_file);
safe_free(mod->relpath);
safe_free(mod);
return 1;
}
/*
* Module_Unload ()
* char *name Internal module name
* Returns:
* -1 Not able to locate module, severe failure, anything
* 1 Module unloaded
* 2 Module wishes delayed unloading, has placed event
*/
int Module_Unload(const char *name)
{
Module *m;
int (*Mod_Unload)();
int ret;
for (m = Modules; m; m = m->next)
{
if (!strcmp(m->header->name, name))
{
break;
}
}
if (!m)
return -1;
irc_dlsym(m->dll, "Mod_Unload", Mod_Unload);
if (!Mod_Unload)
{
return -1;
}
ret = (*Mod_Unload)(&m->modinfo);
if (ret == MOD_DELAY)
{
m->flags |= MODFLAG_DELAYED;
Module_DelayChildren(m);
return 2;
}
if (ret == MOD_FAILED)
{
return -1;
}
/* No more pain detected, let's unload */
DelListItem(m, Modules);
Module_free(m);
return 1;
}
void module_loadall(void)
{
iFP fp;
Module *mi, *next;
loop.config_status = CONFIG_STATUS_LOAD;
/* Run through all modules and check for module load */
for (mi = Modules; mi; mi = next)
{
next = mi->next;
if (mi->flags & MODFLAG_LOADED)
continue;
irc_dlsym(mi->dll, "Mod_Load", fp);
/* Call the module_load */
if ((*fp)(&mi->modinfo) != MOD_SUCCESS)
{
config_status("cannot load module %s", mi->header->name);
Module_free(mi);
}
else
mi->flags = MODFLAG_LOADED;
}
}
int Module_IsAlreadyChild(Module *parent, Module *child)
{
ModuleChild *mcp;
for (mcp = parent->children; mcp; mcp = mcp->next)
{
if (mcp->child == child)
return 1;
}
return 0;
}
void Module_AddAsChild(Module *parent, Module *child)
{
ModuleChild *childp = NULL;
childp = safe_alloc(sizeof(ModuleChild));
childp->child = child;
AddListItem(childp, parent->children);
}
/* cmd_module.
* by Stskeeps, codemastr, Syzop.
* Changed it so it's now public for users too, as quite some people
* (and users) requested they should have the right to see what kind
* of weird modules are loaded on the server, especially since people
* like to load spy modules these days.
* I do not consider this sensitive information, but just in case
* I stripped the version string for non-admins (eg: normal users). -- Syzop
*/
CMD_FUNC(cmd_module)
{
Module *mi;
int i;
char tmp[1024], *p;
RealCommand *mptr;
int all = 0;
if ((parc > 1) && !strcmp(parv[1], "-all"))
all = 1;
if (MyUser(client) && !IsOper(client) && all)
add_fake_lag(client, 7000); /* Lag them up. Big list. */
if ((parc > 2) && (hunt_server(client, recv_mtags, "MODULE", 2, parc, parv) != HUNTED_ISME))
return;
if ((parc == 2) && (parv[1][0] != '-') && (hunt_server(client, recv_mtags, "MODULE", 1, parc, parv) != HUNTED_ISME))
return;
if (all)
sendtxtnumeric(client, "Showing ALL loaded modules:");
else
sendtxtnumeric(client, "Showing loaded 3rd party modules (use \"MODULE -all\" to show all modules):");
for (mi = Modules; mi; mi = mi->next)
{
/* Skip official modules unless "MODULE -all" */
if (!all && (mi->options & MOD_OPT_OFFICIAL))
continue;
tmp[0] = '\0';
if (mi->flags & MODFLAG_DELAYED)
strlcat(tmp, "[Unloading] ", sizeof(tmp));
if (mi->options & MOD_OPT_PERM_RELOADABLE)
strlcat(tmp, "[PERM-BUT-RELOADABLE] ", sizeof(tmp));
if (mi->options & MOD_OPT_PERM)
strlcat(tmp, "[PERM] ", sizeof(tmp));
if (!(mi->options & MOD_OPT_OFFICIAL))
strlcat(tmp, "[3RD] ", sizeof(tmp));
if (!ValidatePermissionsForPath("server:module",client,NULL,NULL,NULL))
sendtxtnumeric(client, "*** %s - %s - by %s %s",
mi->header->name,
mi->header->description,
mi->header->author,
mi->options & MOD_OPT_OFFICIAL ? "" : "[3RD]");
else
sendtxtnumeric(client, "*** %s %s - %s - by %s %s",
mi->header->name,
mi->header->version,
mi->header->description,
mi->header->author,
tmp);
}
sendtxtnumeric(client, "End of module list");
if (!ValidatePermissionsForPath("server:module",client,NULL,NULL,NULL))
return;
tmp[0] = '\0';
p = tmp;
for (i=0; i < MAXHOOKTYPES; i++)
{
if (!Hooks[i])
continue;
ircsnprintf(p, sizeof(tmp) - strlen(tmp), "%d ", i);
p += strlen(p);
if (p > tmp + 380)
{
sendtxtnumeric(client, "Hooks: %s", tmp);
tmp[0] = '\0';
p = tmp;
}
}
sendtxtnumeric(client, "Hooks: %s ", tmp);
tmp[0] = '\0';
p = tmp;
for (i=0; i < 256; i++)
{
for (mptr = CommandHash[i]; mptr; mptr = mptr->next)
if (mptr->overriders)
{
ircsnprintf(p, sizeof(tmp)-strlen(tmp), "%s ", mptr->cmd);
p += strlen(p);
if (p > tmp+380)
{
sendtxtnumeric(client, "Override: %s", tmp);
tmp[0] = '\0';
p = tmp;
}
}
}
sendtxtnumeric(client, "Override: %s", tmp);
}
Hooktype *HooktypeFind(const char *string) {
Hooktype *hooktype;
for (hooktype = Hooktypes; hooktype->string ;hooktype++) {
if (!strcasecmp(hooktype->string, string))
return hooktype;
}
return NULL;
}
Versionflag *VersionflagFind(char flag)
{
Versionflag *vflag;
for (vflag = Versionflags; vflag; vflag = vflag->next)
{
if (vflag->flag == flag)
return vflag;
}
return NULL;
}
Versionflag *VersionflagAdd(Module *module, char flag)
{
Versionflag *vflag;
ModuleChild *parent;
if ((vflag = VersionflagFind(flag)))
{
ModuleChild *child;
for (child = vflag->parents; child; child = child->next) {
if (child->child == module)
break;
}
if (!child)
{
parent = safe_alloc(sizeof(ModuleChild));
parent->child = module;
if (module) {
ModuleObject *vflagobj;
vflagobj = safe_alloc(sizeof(ModuleObject));
vflagobj->type = MOBJ_VERSIONFLAG;
vflagobj->object.versionflag = vflag;
AddListItem(vflagobj, module->objects);
module->errorcode = MODERR_NOERROR;
}
AddListItem(parent,vflag->parents);
}
return vflag;
}
vflag = safe_alloc(sizeof(Versionflag));
vflag->flag = flag;
parent = safe_alloc(sizeof(ModuleChild));
parent->child = module;
if (module)
{
ModuleObject *vflagobj;
vflagobj = safe_alloc(sizeof(ModuleObject));
vflagobj->type = MOBJ_VERSIONFLAG;
vflagobj->object.versionflag = vflag;
AddListItem(vflagobj, module->objects);
module->errorcode = MODERR_NOERROR;
}
flag_add(flag);
AddListItem(parent,vflag->parents);
AddListItem(vflag, Versionflags);
return vflag;
}
void VersionflagDel(Versionflag *vflag, Module *module)
{
ModuleChild *owner;
if (!vflag)
return;
for (owner = vflag->parents; owner; owner = owner->next)
{
if (owner->child == module)
{
DelListItem(owner,vflag->parents);
safe_free(owner);
break;
}
}
if (module)
{
ModuleObject *objs;
for (objs = module->objects; objs; objs = objs->next) {
if (objs->type == MOBJ_VERSIONFLAG && objs->object.versionflag == vflag) {
DelListItem(objs,module->objects);
safe_free(objs);
break;
}
}
}
if (!vflag->parents)
{
flag_del(vflag->flag);
DelListItem(vflag, Versionflags);
safe_free(vflag);
}
}
Hook *HookAddMain(Module *module, int hooktype, int priority, int (*func)(), void (*vfunc)(), char *(*stringfunc)(), const char *(*conststringfunc)())
{
Hook *p;
p = (Hook *) safe_alloc(sizeof(Hook));
if (func)
p->func.intfunc = func;
if (vfunc)
p->func.voidfunc = vfunc;
if (stringfunc)
p->func.stringfunc = stringfunc;
if (conststringfunc)
p->func.conststringfunc = conststringfunc;
p->type = hooktype;
p->owner = module;
p->priority = priority;
if (module) {
ModuleObject *hookobj = (ModuleObject *)safe_alloc(sizeof(ModuleObject));
hookobj->object.hook = p;
hookobj->type = MOBJ_HOOK;
AddListItem(hookobj, module->objects);
module->errorcode = MODERR_NOERROR;
}
AddListItemPrio(p, Hooks[hooktype], p->priority);
return p;
}
Hook *HookDel(Hook *hook)
{
Hook *p, *q;
for (p = Hooks[hook->type]; p; p = p->next) {
if (p == hook) {
q = p->next;
DelListItem(p, Hooks[hook->type]);
if (p->owner) {
ModuleObject *hookobj;
for (hookobj = p->owner->objects; hookobj; hookobj = hookobj->next) {
if (hookobj->type == MOBJ_HOOK && hookobj->object.hook == p) {
DelListItem(hookobj, hook->owner->objects);
safe_free(hookobj);
break;
}
}
}
safe_free(p);
return q;
}
}
return NULL;
}
static int num_callbacks(int cbtype)
{
Callback *e;
int cnt = 0;
for (e = Callbacks[cbtype]; e; e = e->next)
if (!e->willberemoved)
cnt++;
return cnt;
}
Callback *CallbackAddMain(Module *module, int cbtype, int (*func)(), void (*vfunc)(), void *(*pvfunc)(), char *(*stringfunc)(), const char *(*conststringfunc)())
{
Callback *p;
if (num_callbacks(cbtype) > 0)
{
if (module)
module->errorcode = MODERR_EXISTS;
return NULL;
}
p = safe_alloc(sizeof(Callback));
if (func)
p->func.intfunc = func;
if (vfunc)
p->func.voidfunc = vfunc;
if (pvfunc)
p->func.pvoidfunc = pvfunc;
if (stringfunc)
p->func.stringfunc = stringfunc;
if (conststringfunc)
p->func.conststringfunc = conststringfunc;
p->type = cbtype;
p->owner = module;
AddListItem(p, Callbacks[cbtype]);
if (module) {
ModuleObject *cbobj = safe_alloc(sizeof(ModuleObject));
cbobj->object.callback = p;
cbobj->type = MOBJ_CALLBACK;
AddListItem(cbobj, module->objects);
module->errorcode = MODERR_NOERROR;
}
return p;
}
Callback *CallbackDel(Callback *cb)
{
Callback *p, *q;
for (p = Callbacks[cb->type]; p; p = p->next) {
if (p == cb) {
q = p->next;
DelListItem(p, Callbacks[cb->type]);
if (RCallbacks[cb->type] == p)
RCallbacks[cb->type] = NULL;
if (p->owner) {
ModuleObject *cbobj;
for (cbobj = p->owner->objects; cbobj; cbobj = cbobj->next) {
if ((cbobj->type == MOBJ_CALLBACK) && (cbobj->object.callback == p)) {
DelListItem(cbobj, cb->owner->objects);
safe_free(cbobj);
break;
}
}
}
safe_free(p);
return q;
}
}
return NULL;
}
CommandOverride *CommandOverrideAdd(Module *module, const char *name, int priority, OverrideCmdFunc function)
{
RealCommand *p;
CommandOverride *ovr;
if (!(p = find_command_simple(name)))
{
if (module)
module->errorcode = MODERR_NOTFOUND;
return NULL;
}
for (ovr=p->overriders; ovr; ovr=ovr->next)
{
if ((ovr->owner == module) && (ovr->func == function))
{
if (module)
module->errorcode = MODERR_EXISTS;
return NULL;
}
}
ovr = safe_alloc(sizeof(CommandOverride));
ovr->func = function;
ovr->owner = module;
ovr->priority = priority;
if (module)
{
ModuleObject *cmdoverobj = safe_alloc(sizeof(ModuleObject));
cmdoverobj->type = MOBJ_COMMANDOVERRIDE;
cmdoverobj->object.cmdoverride = ovr;
AddListItem(cmdoverobj, module->objects);
module->errorcode = MODERR_NOERROR;
}
ovr->command = p;
AddListItemPrio(ovr, p->overriders, ovr->priority);
if (p->friend)
{
AddListItem(ovr, p->friend->overriders);
}
return ovr;
}
void CommandOverrideDel(CommandOverride *cmd)
{
DelListItem(cmd, cmd->command->overriders);
if (cmd->command->friend)
{
DelListItem(cmd, cmd->command->friend->overriders);
}
if (cmd->owner)
{
ModuleObject *obj;
for (obj = cmd->owner->objects; obj; obj = obj->next)
{
if (obj->type != MOBJ_COMMANDOVERRIDE)
continue;
if (obj->object.cmdoverride == cmd)
{
DelListItem(obj, cmd->owner->objects);
safe_free(obj);
break;
}
}
}
safe_free(cmd);
}
void CallCommandOverride(CommandOverride *ovr, Client *client, MessageTag *mtags, int parc, const char *parv[])
{
if (ovr->next)
ovr->next->func(ovr->next, client, mtags, parc, parv);
else
ovr->command->func(client, mtags, parc, parv);
}
EVENT(e_unload_module_delayed)
{
char *name = (char *)data;
int i;
i = Module_Unload(name);
if (i == 1)
{
unreal_log(ULOG_INFO, "module", "MODULE_UNLOADING_DELAYED", NULL,
"Unloading module $module_name (was delayed earlier)",
log_data_string("module_name", name));
}
safe_free(name);
extcmodes_check_for_changes();
umodes_check_for_changes();
return;
}
void unload_all_modules(void)
{
Module *m;
int (*Mod_Unload)();
for (m = Modules; m; m = m->next)
{
#ifdef DEBUGMODE
unreal_log(ULOG_DEBUG, "module", "MODULE_UNLOADING", NULL,
"Unloading module $module_name",
log_data_string("module_name", m->header->name));
#endif
irc_dlsym(m->dll, "Mod_Unload", Mod_Unload);
if (Mod_Unload)
(*Mod_Unload)(&m->modinfo);
deletetmp(m->tmp_file);
}
}
void ModuleSetOptions(Module *module, unsigned int options, int action)
{
unsigned int oldopts = module->options;
if (options == MOD_OPT_PRIORITY)
{
DelListItem(module, Modules);
AddListItemPrio(module, Modules, action);
} else {
/* Simple bit flag(s) */
if (action)
module->options |= options;
else
module->options &= ~options;
}
}
unsigned int ModuleGetOptions(Module *module)
{
return module->options;
}
unsigned int ModuleGetError(Module *module)
{
return module->errorcode;
}
static const char *module_error_str[] = {
"No error",
"Object already exists",
"No space available",
"Invalid parameter(s)",
"Object was not found"
};
const char *ModuleGetErrorStr(Module *module)
{
if (module->errorcode >= sizeof(module_error_str)/sizeof(module_error_str[0]))
return NULL;
return module_error_str[module->errorcode];
}
/** Ensure that all required callbacks are in place and meet
* all specified requirements
*/
int callbacks_check(void)
{
int i;
for (i=0; i < MAXCALLBACKS; i++)
{
if (num_callbacks(i) > 1)
{
config_error("ERROR: Multiple callbacks loaded for type %d. "
"Make sure you only load 1 module of 1 type (eg: only 1 cloaking module)",
i);
return -1;
}
}
if (!Callbacks[CALLBACKTYPE_CLOAK_KEY_CHECKSUM])
{
unreal_log(ULOG_ERROR, "config", "NO_CLOAKING_MODULE", NULL,
"No cloaking module loaded, you must load 1 of these modulese:\n"
"1) cloak_sha256 - if you are a new network starting with UnrealIRCd 6\n"
"2) cloak_md5 - the old one if migrating an existing network from UnrealIRCd 3.2/4/5\n"
"3) cloak_none - if you don't want to use cloaking at all\n"
"See also https://www.unrealircd.org/docs/FAQ#choose-a-cloaking-module");
return -1;
}
return 0;
}
void callbacks_switchover(void)
{
Callback *e;
int i;
/* Now set the real callback, and tag the new one
* as 'willberemoved' if needed.
*/
for (i=0; i < MAXCALLBACKS; i++)
for (e = Callbacks[i]; e; e = e->next)
if (!e->willberemoved)
{
RCallbacks[i] = e; /* This is the new one. */
if (!(e->owner->options & MOD_OPT_PERM))
e->willberemoved = 1;
break;
}
}
#ifdef _WIN32
const char *our_dlerror(void)
{
static char errbuf[513];
DWORD err = GetLastError();
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err,
0, errbuf, 512, NULL);
if (err == ERROR_MOD_NOT_FOUND)
strlcat(errbuf, " This could be because the DLL depends on another DLL, for example if you "
"are trying to load a 3rd party module which was compiled with a different compiler version.",
sizeof(errbuf));
return errbuf;
}
#endif
/** Check if a module is loaded.
* @param name Name of the module by relative path (eg: 'extbans/timedban')
* @returns 1 if module is loaded, 0 if not.
* @note The name is checked against the module name,
* this can be a problem if two modules have the same name.
*/
int is_module_loaded(const char *name)
{
Module *mi;
for (mi = Modules; mi; mi = mi->next)
{
if (mi->flags & MODFLAG_DELAYED)
continue; /* unloading (delayed) */
/* During config_posttest ignore modules that are loaded,
* since we only care about the 'future' state.
*/
if ((loop.config_status < CONFIG_STATUS_LOAD) &&
(loop.config_status >= CONFIG_STATUS_POSTTEST) &&
(mi->flags == MODFLAG_LOADED))
{
continue;
}
if (!strcasecmp(mi->relpath, name))
return 1;
}
return 0;
}
static const char *mod_var_name(ModuleInfo *modinfo, const char *varshortname)
{
static char fullname[512];
snprintf(fullname, sizeof(fullname), "%s:%s", modinfo->handle->header->name, varshortname);
return fullname;
}
int LoadPersistentPointerX(ModuleInfo *modinfo, const char *varshortname, void **var, void (*free_variable)(ModData *m))
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
if (m)
{
*var = moddata_local_variable(m).ptr;
return 1;
} else {
ModDataInfo mreq;
memset(&mreq, 0, sizeof(mreq));
mreq.type = MODDATATYPE_LOCAL_VARIABLE;
mreq.name = strdup(fullname);
mreq.free = free_variable;
m = ModDataAdd(modinfo->handle, mreq);
moddata_local_variable(m).ptr = NULL;
safe_free(mreq.name);
return 0;
}
}
void SavePersistentPointerX(ModuleInfo *modinfo, const char *varshortname, void *var)
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
moddata_local_variable(m).ptr = var;
}
int LoadPersistentIntX(ModuleInfo *modinfo, const char *varshortname, int *var)
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
if (m)
{
*var = moddata_local_variable(m).i;
return 1;
} else {
ModDataInfo mreq;
memset(&mreq, 0, sizeof(mreq));
mreq.type = MODDATATYPE_LOCAL_VARIABLE;
mreq.name = strdup(fullname);
mreq.free = NULL;
m = ModDataAdd(modinfo->handle, mreq);
moddata_local_variable(m).i = 0;
safe_free(mreq.name);
return 0;
}
}
void SavePersistentIntX(ModuleInfo *modinfo, const char *varshortname, int var)
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
moddata_local_variable(m).i = var;
}
int LoadPersistentLongX(ModuleInfo *modinfo, const char *varshortname, long *var)
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
if (m)
{
*var = moddata_local_variable(m).l;
return 1;
} else {
ModDataInfo mreq;
memset(&mreq, 0, sizeof(mreq));
mreq.type = MODDATATYPE_LOCAL_VARIABLE;
mreq.name = strdup(fullname);
mreq.free = NULL;
m = ModDataAdd(modinfo->handle, mreq);
moddata_local_variable(m).l = 0;
safe_free(mreq.name);
return 0;
}
}
void SavePersistentLongX(ModuleInfo *modinfo, const char *varshortname, long var)
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
moddata_local_variable(m).l = var;
}
int LoadPersistentLongLongX(ModuleInfo *modinfo, const char *varshortname, long long *var)
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
if (m)
{
*var = moddata_local_variable(m).ll;
return 1;
} else {
ModDataInfo mreq;
memset(&mreq, 0, sizeof(mreq));
mreq.type = MODDATATYPE_LOCAL_VARIABLE;
mreq.name = strdup(fullname);
mreq.free = NULL;
m = ModDataAdd(modinfo->handle, mreq);
moddata_local_variable(m).ll = 0;
safe_free(mreq.name);
return 0;
}
}
void SavePersistentLongLongX(ModuleInfo *modinfo, const char *varshortname, long long var)
{
ModDataInfo *m;
const char *fullname = mod_var_name(modinfo, varshortname);
m = findmoddata_byname(fullname, MODDATATYPE_LOCAL_VARIABLE);
moddata_local_variable(m).ll = var;
}
extern int module_has_moddata(Module *mod);
extern int module_has_extcmode_param_mode(Module *mod);
/** Special hack for unloading modules with moddata and parameter extcmodes */
void special_delayed_unloading(void)
{
Module *m, *m2;
extern Module *Modules;
for (m = Modules; m; m = m->next)
{
if (!(m->flags & MODFLAG_LOADED))
continue;
if ((m->options & MOD_OPT_PERM) || (m->options & MOD_OPT_PERM_RELOADABLE))
continue;
if (module_has_moddata(m) || module_has_extcmode_param_mode(m))
{
int found = 0;
for (m2 = Modules; m2; m2 = m2->next)
{
if ((m != m2) && !strcmp(m->header->name, m2->header->name))
found = 1;
}
if (!found)
{
char *name = strdup(m->header->name);
config_warn("Delaying module unloading of '%s' for a millisecond...", name);
m->flags |= MODFLAG_DELAYED;
EventAdd(NULL, "e_unload_module_delayed", e_unload_module_delayed, name, 0, 1);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink