mBOOL MHookList::remove(plid_t plid, int hindex) {
int i=hindex;
if(!hlist[i])
RETURN_ERRNO(mFALSE, ME_NOTFOUND);
if(hlist[i]->plid != plid)
RETURN_ERRNO(mFALSE, ME_BADREQ);
MXlock();
delete(hlist[i]);
hlist[i]=NULL;
MXunlock();
return(mTRUE);
}
mBOOL MHookList::call(event_args_t *evargs, const char *logline)
{
int i;
if(!evargs)
RETURN_ERRNO(mFALSE, ME_ARGUMENT);
if(evargs->evtype==EV_NONE)
RETURN_ERRNO(mFALSE, ME_BADREQ);
MXlock();
for(i=0; i < endlist && hlist[i]; i++) {
if(hlist[i]->event == evargs->evtype)
hlist[i]->call(evargs, logline);
}
MXunlock();
return(mTRUE);
}
mBOOL MHook::enqueue(MFuncQueue *mfq, event_args_t *args, const char *logline) {
func_item_t *fp;
if(!mfq || !args || !logline)
RETURN_ERRNO(mFALSE, ME_ARGUMENT);
fp = (func_item_t *) malloc(sizeof(func_item_t));
if(!fp) {
META_ERROR("malloc failed for func_item_t");
RETURN_ERRNO(mFALSE, ME_NOMEM);
}
fp->hook=this;
fp->evargs=args;
fp->logline=logline;
mfq->push(fp);
return(mTRUE);
}
MPlugin * MPluginList::plugin_addload(plid_t plid, const char *fname, PLUG_LOADTIME now)
{
MPlugin pl_temp;
MPlugin *pl_found, *pl_added, *pl_loader;
if ( !(pl_loader=find(plid)) )
{
META_DEBUG(1, ("Couldn't find plugin that gave this loading request!"));
RETURN_ERRNO(NULL, ME_BADREQ);
}
memset(&pl_temp, 0, sizeof(pl_temp));
if (!pl_temp.plugin_parseline(fname, pl_loader->index))
{
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
if (pl_temp.resolve() != mTRUE)
{
META_DEBUG(1, ("Couldn't resolve given path into a file: %s", pl_temp.file));
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
if ( (pl_found=find(pl_temp.pathname)) )
{
META_DEBUG(1, ("Plugin '%s' already in current list; file=%s desc='%s'",
pl_temp.file, pl_found->file, pl_found->desc));
RETURN_ERRNO(NULL, ME_ALREADY);
}
if (!(pl_added=add(&pl_temp)))
{
META_DEBUG(1, ("Couldn't add plugin '%s' to list; see log", pl_temp.desc));
return NULL;
}
pl_added->action = PA_LOAD;
if (!pl_added->load(now))
{
if (meta_errno==ME_NOTALLOWED || meta_errno==ME_DELAYED)
{
META_DEBUG(1, ("Plugin '%s' couldn't attach; only allowed %s",
pl_added->desc, pl_added->str_loadable(SL_ALLOWED)));
pl_added->clear();
} else if (pl_added->status == PL_OPENED) {
META_DEBUG(1, ("Opened plugin '%s', but failed to attach; see log", pl_added->desc));
} else {
META_DEBUG(1, ("Couldn't load plugin '%s'; see log", pl_added->desc));
}
return NULL;
}
META_DEBUG(1, ("Loaded plugin '%s' successfully", pl_added->desc));
meta_errno = ME_NOERROR;
return pl_added;
}
MPlugin *MPluginList::find(int pindex) {
MPlugin *pfound;
if(pindex <= 0)
RETURN_ERRNO(NULL, ME_ARGUMENT);
pfound=&plist[pindex-1];
if(pfound->status < PL_VALID)
RETURN_ERRNO(NULL, ME_NOTFOUND);
else
return(pfound);
}
MPlugin *MPluginList::find(plid_t id) {
int i;
if(!id)
RETURN_ERRNO(NULL, ME_ARGUMENT);
for(i=0; i < endlist; i++) {
if(plist[i].status < PL_VALID)
continue;
if(plist[i].info == id)
return(&plist[i]);
}
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
MPlugin *MPluginList::find(DLHANDLE handle)
{
int i;
if(!handle)
RETURN_ERRNO(NULL, ME_ARGUMENT);
for(i=0; i < endlist; i++) {
if(plist[i].status < PL_VALID)
continue;
if(plist[i].handle == handle)
return(&plist[i]);
}
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
void filter_init(int fd) {
#if defined(__x86_64__)
#define X32_SYSCALL_BIT 0x40000000
struct sock_filter filter[] = {
VALIDATE_ARCHITECTURE,
EXAMINE_SYSCALL,
// handle X32 ABI
BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, X32_SYSCALL_BIT, 1, 0),
BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 0, 1, 0),
RETURN_ERRNO(EPERM)
};
#else
struct sock_filter filter[] = {
VALIDATE_ARCHITECTURE,
EXAMINE_SYSCALL
};
#endif
#if 0
{
int i;
unsigned char *ptr = (unsigned char *) &filter[0];
for (i = 0; i < sizeof(filter); i++, ptr++)
printf("%x, ", (*ptr) & 0xff);
printf("\n");
}
#endif
write_to_file(fd, filter, sizeof(filter));
}
// Add the given cvar name to the list and return the instance. This only
// writes the "name" to the new cvar; other fields are written with
// cvar::set().
// meta_errno values:
// - ME_NOMEM couldn't alloc or realloc for various parts
MRegCvar * DLLINTERNAL MRegCvarList::add(const char *addname) {
MRegCvar *icvar;
if(endlist==size) {
// grow array
MRegCvar *temp;
int i, newsize;
newsize=size+REG_CVAR_GROWSIZE;
META_DEBUG(6, ("Growing reg cvar list from %d to %d", size, newsize));
temp = (MRegCvar *) realloc(vlist, newsize*sizeof(MRegCvar));
if(!temp) {
META_WARNING("Couldn't grow registered cvar list to %d for '%s'; %s", newsize, addname, strerror(errno));
RETURN_ERRNO(NULL, ME_NOMEM);
}
vlist=temp;
size=newsize;
// initialize new (unused) entries
for(i=endlist; i<size; i++) {
memset(&vlist[i], 0, sizeof(vlist[i]));
vlist[i].init(i+1); // 1-based
}
}
icvar = &vlist[endlist];
// Malloc space for the cvar and cvar name, for two reasons:
// - Can't point to memory loc in plugin (another segv waiting to
// happen).
// - Can't point to memory in vlist which might get moved later by
// realloc (again, segv).
icvar->data = (cvar_t *) calloc(1, sizeof(cvar_t));
if(!icvar->data) {
META_WARNING("Couldn't malloc cvar for adding reg cvar name '%s': %s",
addname, strerror(errno));
RETURN_ERRNO(NULL, ME_NOMEM);
}
icvar->data->name=strdup(addname);
if(!icvar->data->name) {
META_WARNING("Couldn't strdup for adding reg cvar name '%s': %s",
addname, strerror(errno));
RETURN_ERRNO(NULL, ME_NOMEM);
}
endlist++;
return(icvar);
}
// Try to find a registered cvar with the given name.
// meta_errno values:
// - ME_NOTFOUND couldn't find a matching cvar
MRegCvar * DLLINTERNAL MRegCvarList::find(const char *findname) {
int i;
for(i=0; i < endlist; i++) {
if(!strcasecmp(vlist[i].data->name, findname))
return(&vlist[i]);
}
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
// Try to find a registered msg with the given name.
// meta_errno values:
// - ME_NOTFOUND couldn't find a matching cvar
MRegMsg * DLLINTERNAL MRegMsgList::find(const char *findname) {
int i;
for(i=0; i < endlist; i++) {
if(!mm_strcmp(mlist[i].name, findname))
return(&mlist[i]);
}
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
mBOOL DLLINTERNAL MConfig::set(const char *key, const char *value) {
option_t *optp;
optp=find(key);
if(optp)
return(set(optp, value));
else
RETURN_ERRNO(mFALSE, ME_NOTFOUND);
}
// Try to find a registered msg with the given msgid.
// meta_errno values:
// - ME_NOTFOUND couldn't find a matching cvar
MRegMsg * DLLINTERNAL MRegMsgList::find(int findmsgid) {
int i;
for(i=0; i < endlist; i++) {
if(mlist[i].msgid == findmsgid)
return(&mlist[i]);
}
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
MPlugin *MPluginList::find(const char *findpath) {
int i;
if(!findpath)
RETURN_ERRNO(NULL, ME_ARGUMENT);
META_DEBUG(8, ("Looking for loaded plugin with dlfnamepath: %s", findpath));
for(i=0; i < endlist; i++) {
META_DEBUG(9, ("Looking at: plugin %s loadedpath: %s", plist[i].file, plist[i].pathname));
if(plist[i].status < PL_VALID)
continue;
if(strmatch(plist[i].pathname, findpath)) {
META_DEBUG(8, ("Found loaded plugin %s", plist[i].file));
return(&plist[i]);
}
}
META_DEBUG(8, ("No loaded plugin found with path: %s", findpath));
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
option_t * DLLINTERNAL MConfig::find(const char *lookup) {
option_t *optp;
for(optp=list; optp->name && !strmatch(optp->name, lookup); optp++);
if(optp->name)
return(optp);
else
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
// Check if a client cvar is queried for this player
// Returns NULL if not
// or the name of the cvar.
// meta_errno values:
// - ME_NOTFOUND invalid entity
const char* DLLINTERNAL MPlayerList::is_querying_cvar(const edict_t *pEntity)
{
int indx = ENTINDEX(const_cast<edict_t*>(pEntity));
if(indx < 1 || indx > gpGlobals->maxClients) {
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
return(players[indx].is_querying_cvar());
}
MPlugin *MPluginList::find_match(MPlugin *pmatch) {
int i;
MPlugin *iplug, *pfound;
if(!pmatch)
RETURN_ERRNO(NULL, ME_ARGUMENT);
pfound=NULL;
for(i=0; i < endlist; i++) {
iplug=&plist[i];
if(pmatch->platform_match(iplug)) {
pfound=iplug;
break;
}
}
if(pfound)
return(pfound);
else
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
mBOOL DLLINTERNAL MConfig::load(const char *fn) {
FILE *fp;
char loadfile[PATH_MAX];
char line[MAX_CONF_LEN];
char *optname, *optval;
option_t *optp;
int ln;
// Make full pathname (from gamedir if relative, collapse "..",
// backslashes, etc).
full_gamedir_path(fn, loadfile);
fp=fopen(loadfile, "r");
if(!fp) {
META_WARNING("unable to open config file '%s': %s", loadfile,
strerror(errno));
RETURN_ERRNO(mFALSE, ME_NOFILE);
}
META_DEBUG(2, ("Loading from config file: %s", loadfile));
for(ln=1; !feof(fp) && fgets(line, sizeof(line), fp); ln++) {
if(line[0]=='#')
continue;
if(line[0]==';')
continue;
if(strnmatch(line, "//", 2))
continue;
if(!(optname=strtok(line, " \t\r\n"))) {
META_WARNING("'%s' line %d: bad config format: missing option",
loadfile, ln);
continue;
}
if(!(optval=strtok(NULL, "\r\n"))) {
META_WARNING("'%s' line %d: bad config format: missing value",
loadfile, ln);
continue;
}
if(!(optp=find(optname))) {
META_WARNING("'%s' line %d: unknown option name '%s'",
loadfile, ln, optname);
continue;
}
if(!set(optp, optval)) {
META_WARNING("'%s' line %d: unable to set option '%s' value '%s'",
loadfile, ln, optname, optval);
continue;
}
}
filename=strdup(loadfile);
fclose(fp);
return(mTRUE);
}
MPlugin *MPluginList::find_memloc(void *memptr) {
const char *dlfile;
if(!memptr)
RETURN_ERRNO(NULL, ME_ARGUMENT);
if(!(dlfile=DLFNAME(memptr))) {
META_DEBUG(8, ("DLFNAME failed to find memloc %d", memptr));
// meta_errno should be already set in DLFNAME
return(NULL);
}
return(find(dlfile));
}
// Try to call the function. Relies on OS-specific routine to attempt
// calling the function without generating a segfault from an unloaded
// plugin DLL.
// meta_errno values:
// - ME_BADREQ function disabled/invalid
// - ME_ARGUMENT function pointer is null
mBOOL DLLINTERNAL MRegCmd::call(void) {
mBOOL ret;
// can we expect to call this function?
if(status != RG_VALID)
RETURN_ERRNO(mFALSE, ME_BADREQ);
if(!pfnCmd)
RETURN_ERRNO(mFALSE, ME_ARGUMENT);
// try to call this function
ret=os_safe_call(pfnCmd);
if(!ret) {
META_DEBUG(4, ("Plugin reg_cmd '%s' called after unloaded; removed from list", name));
status=RG_INVALID;
pfnCmd=NULL;
// NOTE: we can't free the malloc'd space for the name, as that
// would just re-introduce the segfault problem..
}
// meta_errno (if failed) is set already in os_safe_call()
return(ret);
}
// Add the given name to the list and return the instance. This only
// writes the "name" to the new cmd; other fields are writtin by caller
// (meta_AddServerCommand).
// meta_errno values:
// - ME_NOMEM couldn't realloc or malloc for various parts
MRegCmd * DLLINTERNAL MRegCmdList::add(const char *addname) {
MRegCmd *icmd;
if(endlist==size) {
// grow array
MRegCmd *temp;
int i, newsize;
newsize=size+REG_CMD_GROWSIZE;
META_DEBUG(6, ("Growing reg cmd list from %d to %d", size, newsize));
temp = (MRegCmd *) realloc(mlist, newsize*sizeof(MRegCmd));
if(!temp) {
META_WARNING("Couldn't grow registered command list to %d for '%s': %s", newsize, addname, strerror(errno));
RETURN_ERRNO(NULL, ME_NOMEM);
}
mlist=temp;
size=newsize;
// initialize new (unused) entries
for(i=endlist; i<size; i++) {
memset(&mlist[i], 0, sizeof(mlist[i]));
mlist[i].init(i+1); // 1-based
}
}
icmd = &mlist[endlist];
// Malloc space separately for the command name, because:
// - Can't point to memory loc in plugin (another segv waiting to
// happen).
// - Can't point to memory in mlist which might get moved later by
// realloc (again, segv).
icmd->name=strdup(addname);
if(!icmd->name) {
META_WARNING("Couldn't strdup for adding reg cmd name '%s': %s",
addname, strerror(errno));
RETURN_ERRNO(NULL, ME_NOMEM);
}
endlist++;
return(icmd);
}
// Set the cvar, copying values from given cvar.
// meta_errno values:
// - ME_ARGUMENT given cvar doesn't match this cvar
mBOOL DLLINTERNAL MRegCvar::set(cvar_t *src) {
if(strcasecmp(src->name, data->name)) {
META_WARNING("Tried to set cvar with mismatched name; src=%s dst=%s",
src->name, data->name);
RETURN_ERRNO(mFALSE, ME_ARGUMENT);
}
// Would like to free() existing string, but can't tell where it was
// allocated...
data->string = strdup(src->string);
data->flags = src->flags;
data->value = src->value;
data->next = src->next;
return(mTRUE);
}
MPlugin *MPluginList::find_match(const char *prefix) {
int i, len;
MPlugin *iplug, *pfound;
char buf[NAME_MAX];
if(!prefix)
RETURN_ERRNO(NULL, ME_ARGUMENT);
pfound=NULL;
len=strlen(prefix);
snprintf(buf, sizeof(buf), "mm_%s", prefix);
for(i=0; i < endlist; i++) {
iplug=&plist[i];
if(iplug->status < PL_VALID)
continue;
if(iplug->info && strncasecmp(iplug->info->name, prefix, len) == 0) {
if(pfound)
RETURN_ERRNO(NULL, ME_NOTUNIQ);
pfound=iplug;
continue;
}
else if(strncasecmp(iplug->desc, prefix, len) == 0) {
if(pfound)
RETURN_ERRNO(NULL, ME_NOTUNIQ);
pfound=iplug;
continue;
}
else if(strncasecmp(iplug->file, prefix, len) == 0) {
if(pfound)
RETURN_ERRNO(NULL, ME_NOTUNIQ);
pfound=iplug;
continue;
}
else if(strncasecmp(iplug->file, buf, strlen(buf)) == 0) {
if(pfound)
RETURN_ERRNO(NULL, ME_NOTUNIQ);
pfound=iplug;
continue;
}
else if(iplug->info
&& strncasecmp(iplug->info->logtag, prefix, len) == 0)
{
if(pfound)
RETURN_ERRNO(NULL, ME_NOTUNIQ);
pfound=iplug;
continue;
}
}
if(pfound)
return(pfound);
else
RETURN_ERRNO(NULL, ME_NOTFOUND);
}
MPlugin *MPluginList::add(MPlugin *padd) {
int i;
MPlugin *iplug;
// Find either:
// - a slot in the list that's not being used
// - the end of the list
for(i=0; i < endlist && plist[i].status != PL_EMPTY; i++);
// couldn't find a slot to use
if(i==size) {
META_ERROR("Couldn't add plugin '%s' to list; reached max plugins (%d)",
padd->file, i);
RETURN_ERRNO(NULL, ME_MAXREACHED);
}
// if we found the end of the list, advance end marker
if(i==endlist)
endlist++;
iplug = &plist[i];
// copy filename into this free slot
STRNCPY(iplug->filename, padd->filename, sizeof(iplug->filename));
// Copy file offset ptr.
// Can't just copy ptr, as it points to offset in padd, which will go
// away; need to point to corresponding offset in iplug.
iplug->file = iplug->filename + (padd->file - padd->filename);
// copy description
STRNCPY(iplug->desc, padd->desc, sizeof(iplug->desc));
// copy pathname
STRNCPY(iplug->pathname, padd->pathname, sizeof(iplug->pathname));
// copy source
iplug->source=padd->source;
// copy status
iplug->status=padd->status;
//copy other things
iplug->source_plugin_index = padd->source_plugin_index;
return(iplug);
}
// Add the given user msg the list and return the instance.
// meta_errno values:
// - ME_MAXREACHED reached max number of msgs allowed
MRegMsg * DLLINTERNAL MRegMsgList::add(const char *addname, int addmsgid, int addsize) {
MRegMsg *imsg;
if(endlist==size) {
// all slots used
META_ERROR("Couldn't add registered msg '%s' to list; reached max msgs (%d)",
addname, size);
RETURN_ERRNO(NULL, ME_MAXREACHED);
}
imsg = &mlist[endlist];
endlist++;
// Copy msg data into empty slot.
// Note: 'addname' assumed to be a constant string allocated in the
// gamedll.
imsg->name=addname;
imsg->msgid=addmsgid;
imsg->size=addsize;
return(imsg);
}
mBOOL MPluginList::ini_startup() {
FILE *fp;
char line[MAX_STRBUF_LEN];
int n, ln;
MPlugin *pmatch;
if(!valid_gamedir_file(inifile)) {
META_ERROR("ini: Metamod plugins file empty or missing: %s", inifile);
RETURN_ERRNO(mFALSE, ME_NOFILE);
}
full_gamedir_path(inifile, inifile);
fp=fopen(inifile, "r");
if(!fp) {
META_ERROR("ini: Unable to open plugins file '%s': %s", inifile,
strerror(errno));
RETURN_ERRNO(mFALSE, ME_NOFILE);
}
META_LOG("ini: Begin reading plugins list: %s", inifile);
for(n=0, ln=1;
!feof(fp) && fgets(line, sizeof(line), fp) && n < size;
ln++)
{
// Remove line terminations.
char *cp;
if((cp=strrchr(line, '\r')))
*cp='\0';
if((cp=strrchr(line, '\n')))
*cp='\0';
// Parse directly into next entry in array
if(!plist[n].ini_parseline(line)) {
if(meta_errno==ME_FORMAT)
META_ERROR("ini: Skipping malformed line %d of %s", ln,
inifile);
continue;
}
// Check for a duplicate - an existing entry with this pathname.
if(find(plist[n].pathname)) {
// Should we check platform specific level here?
META_INFO("ini: Skipping duplicate plugin, line %d of %s: %s",
ln, inifile, plist[n].pathname);
continue;
}
// Check for a matching platform with different platform specifics
// level.
if(NULL != (pmatch=find_match(&plist[n]))) {
if(pmatch->pfspecific >= plist[n].pfspecific) {
META_DEBUG(1, ("ini: Skipping plugin, line %d of %s: plugin with higher platform specific level already exists. (%d >= %d)",
ln, inifile, pmatch->pfspecific, plist[n].pfspecific));
continue;
}
META_DEBUG(1, ("ini: Plugin in line %d overrides existing plugin with lower platform specific level %d, ours %d",
ln, pmatch->pfspecific, plist[n].pfspecific));
int _index = pmatch->index;
memset(pmatch, 0, sizeof(MPlugin));
pmatch->index = _index;
}
plist[n].action=PA_LOAD;
META_LOG("ini: Read plugin config for: %s", plist[n].desc);
n++;
endlist=n; // mark end of list
}
META_LOG("ini: Finished reading plugins list: %s; Found %d plugins to load",
inifile, n);
fclose(fp);
if(!n) {
META_ERROR("ini: Warning; no plugins found to load?");
}
return(mTRUE);
}
mBOOL DLLINTERNAL MConfig::set(option_t *setp, const char *setstr) {
char pathbuf[PATH_MAX];
int *optval = (int *) setp->dest;
char **optstr = (char **) setp->dest;
// cvar_t *optcvar = (cvar_t *) setp->dest;
// SETOPT_FN optcmd = (SETOPT_FN) setp->dest;
if(!setstr)
return(mTRUE);
switch(setp->type) {
case CF_INT:
if(!isdigit(setstr[0])) {
META_WARNING("option '%s' invalid format '%s'", setp->name, setstr);
RETURN_ERRNO(mFALSE, ME_FORMAT);
}
*optval=atoi(setstr);
META_DEBUG(3, ("set config int: %s = %d", setp->name, *optval));
break;
case CF_BOOL:
if(strcasematch(setstr, "true")
|| strcasematch(setstr, "yes")
|| strmatch(setstr, "1"))
{
*optval=1;
}
else if(strcasematch(setstr, "false")
|| strcasematch(setstr, "no")
|| strmatch(setstr, "0"))
{
*optval=0;
}
else {
META_WARNING("option '%s' invalid format '%s'", setp->name, setstr);
RETURN_ERRNO(mFALSE, ME_FORMAT);
}
META_DEBUG(3, ("set config bool: %s = %s", setp->name, *optval ? "true" : "false"));
break;
case CF_STR:
if(*optstr)
free(*optstr);
*optstr=strdup(setstr);
META_DEBUG(3, ("set config string: %s = %s", setp->name, *optstr));
break;
case CF_PATH:
if(*optstr)
free(*optstr);
full_gamedir_path(setstr, pathbuf);
*optstr=strdup(pathbuf);
META_DEBUG(3, ("set config path: %s = %s", setp->name, *optstr));
break;
#if 0
case CF_CVAR:
CVAR_SET_STRING(optcvar->name, setstr);
META_DEBUG(3, ("set config cvar: %s = %s", optcvar->name, setstr));
break;
case CF_CMD:
optcmd(setp->name, setstr);
META_DEBUG(3, ("set config command: %s, %s", optcvar->name, setstr));
break;
#endif
default:
META_WARNING("unrecognized config type '%d'", setp->type);
RETURN_ERRNO(mFALSE, ME_ARGUMENT);
}
return(mTRUE);
}
mBOOL MPluginList::ini_refresh() {
FILE *fp;
char line[MAX_STRBUF_LEN];
int n, ln;
MPlugin pl_temp;
MPlugin *pl_found, *pl_added;
fp=fopen(inifile, "r");
if(!fp) {
META_ERROR("ini: Unable to open plugins file '%s': %s", inifile,
strerror(errno));
RETURN_ERRNO(mFALSE, ME_NOFILE);
}
META_LOG("ini: Begin re-reading plugins list: %s", inifile);
for(n=0, ln=1;
!feof(fp) && fgets(line, sizeof(line), fp) && n < size;
ln++)
{
// Remove line terminations.
char *cp;
if((cp=strrchr(line, '\r')))
*cp='\0';
if((cp=strrchr(line, '\n')))
*cp='\0';
// Parse into a temp plugin
memset(&pl_temp, 0, sizeof(pl_temp));
if(!pl_temp.ini_parseline(line)) {
if(meta_errno==ME_FORMAT)
META_ERROR("ini: Skipping malformed line %d of %s",
ln, inifile);
continue;
}
// Try to find plugin with this pathname in the current list of
// plugins.
if(!(pl_found=find(pl_temp.pathname))) {
// Check for a matching platform with higher platform specifics
// level.
if(NULL != (pl_found=find_match(&pl_temp))) {
if(pl_found->pfspecific >= pl_temp.pfspecific) {
META_DEBUG(1, ("ini: Skipping plugin, line %d of %s: plugin with higher platform specific level already exists. (%d >= %d)",
ln, inifile, pl_found->pfspecific, pl_temp.pfspecific));
continue;
}
if(PA_LOAD == pl_found->action) {
META_DEBUG(1, ("ini: Plugin in line %d overrides loading of plugin with lower platform specific level %d, ours %d",
ln, pl_found->pfspecific, pl_temp.pfspecific));
int _index = pl_found->index;
memset(pl_found, 0, sizeof(MPlugin));
pl_found->index = _index;
}
else {
META_DEBUG(1, ("ini: Plugin in line %d should override existing plugin with lower platform specific level %d, ours %d. Unable to comply.",
ln, pl_found->pfspecific, pl_temp.pfspecific));
continue;
}
}
// new plugin; add to list
if((pl_added=add(&pl_temp))) {
// try to load this plugin at the next opportunity
pl_added->action=PA_LOAD;
}
else
// error details logged in add()
continue;
}
else {
// This plugin is already in the current list of plugins.
// Pathname already matches. Recopy desc, if specified in
// plugins.ini.
if(pl_temp.desc[0] != '<')
STRNCPY(pl_found->desc, pl_temp.desc, sizeof(pl_found->desc));
// Check the file to see if it looks like it's been modified
// since we last loaded it.
if(!pl_found->newer_file()) {
if(meta_errno==ME_NOFILE) {
META_ERROR("ini: Skipping plugin, couldn't stat file '%s': %s",
pl_found->pathname, strerror(errno));
continue;
}
else {
// File hasn't been updated.
// Keep plugin (don't let refresh() unload it).
pl_found->action=PA_KEEP;
}
}
// Newer file on disk.
else if(pl_found->status >= PL_OPENED) {
META_DEBUG(2, ("ini: Plugin '%s' has newer file on disk", pl_found->desc));
pl_found->action=PA_RELOAD;
}
else
META_ERROR("ini: Plugin '%s' has newer file, but unexpected status (%s)",
pl_found->desc, pl_found->str_status());
}
if(NULL != pl_found) {
META_LOG("ini: Read plugin config for: %s", pl_found->desc);
}
else {
META_LOG("ini: Read plugin config for: %s", pl_temp.desc);
}
n++;
}
META_LOG("ini: Finished reading plugins list: %s; Found %d plugins", inifile, n);
fclose(fp);
if(!n) {
META_ERROR("ini: Warning; no plugins found to load?");
}
return(mTRUE);
}
#include <unistd.h>
#include <net/if.h>
#include <stdarg.h>
#include <sys/wait.h>
#include "../include/seccomp.h"
static struct sock_filter filter[] = {
VALIDATE_ARCHITECTURE,
EXAMINE_SYSCALL,
#if defined(__x86_64__)
#define X32_SYSCALL_BIT 0x40000000
// handle X32 ABI
BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, X32_SYSCALL_BIT, 1, 0),
BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 0, 1, 0),
RETURN_ERRNO(EPERM),
#endif
// syscall list
#ifdef SYS_mount
BLACKLIST(SYS_mount), // mount/unmount filesystems
#endif
#ifdef SYS_umount2
BLACKLIST(SYS_umount2),
#endif
#ifdef SYS_ptrace
BLACKLIST(SYS_ptrace), // trace processes
#endif
#ifdef SYS_kexec_file_load
BLACKLIST(SYS_kexec_file_load),
#endif
mBOOL MPluginList::cmd_addload(const char *args) {
MPlugin pl_temp;
MPlugin *pl_found, *pl_added;
// XXX move back to comands_meta ?
// parse into a temp plugin
memset(&pl_temp, 0, sizeof(pl_temp));
if(pl_temp.cmd_parseline(args) != mTRUE) {
META_CONS("Couldn't parse 'meta load' arguments: %s", args);
// meta_errno should be already set in cmd_parseline()
return(mFALSE);
}
// resolve given path into a file; accepts various "shortcut"
// pathnames.
if(pl_temp.resolve() != mTRUE) {
// Couldn't find a matching file on disk
META_CONS("Couldn't resolve given path into a file: %s",
pl_temp.file);
// meta_errno should be already set in resolve()
return(mFALSE);
}
// Try to find plugin with this pathname in the current list of
// plugins.
if((pl_found=find(pl_temp.pathname))) {
// Already in list
META_CONS("Plugin '%s' already in current list; file=%s desc='%s'",
pl_temp.file, pl_found->file, pl_found->desc);
RETURN_ERRNO(mFALSE, ME_ALREADY);
}
// new plugin; add to list
if(!(pl_added=add(&pl_temp))) {
META_CONS("Couldn't add plugin '%s' to list; see log", pl_temp.desc);
// meta_errno should be already set in add()
return(mFALSE);
}
// try to load new plugin
pl_added->action=PA_LOAD;
if(!pl_added->load(PT_ANYTIME)) {
// load failed
if(meta_errno==ME_DELAYED)
META_CONS("Loaded plugin '%s', but will wait to become active, %s",
pl_added->desc, pl_added->str_loadable(SL_ALLOWED));
else if(meta_errno==ME_NOTALLOWED) {
META_CONS("Plugin '%s' couldn't attach; only allowed %s",
pl_added->desc, pl_added->str_loadable(SL_ALLOWED));
pl_added->clear();
}
else if(pl_added->status == PL_OPENED)
META_CONS("Opened plugin '%s', but failed to attach; see log", pl_added->desc);
else
META_CONS("Couldn't load plugin '%s'; see log", pl_added->desc);
show(0);
// meta_errno should be already set in load()
return(mFALSE);
}
META_CONS("Loaded plugin '%s' successfully", pl_added->desc);
show(0);
return(mTRUE);
}
