void
mowgli_eventloop_destroy(mowgli_eventloop_t *eventloop)
{
eventloop->eventloop_ops->pollshutdown(eventloop);
mowgli_mutex_uninit(&eventloop->mutex);
mowgli_heap_free(eventloop_heap, eventloop);
}
static void chanacs_ext_delete(chanacs_exttarget_t *e)
{
return_if_fail(e != NULL);
mowgli_patricia_delete(chanacs_exttarget_tree, e->channel);
strshare_unref(e->channel);
strshare_unref(entity(e)->name);
mowgli_heap_free(chanacs_ext_heap, e);
}
static void
server_ext_delete(struct this_exttarget *e)
{
return_if_fail(e != NULL);
mowgli_patricia_delete(server_exttarget_tree, e->server);
strshare_unref(e->server);
strshare_unref(entity(e)->name);
mowgli_heap_free(server_ext_heap, e);
}
void
mowgli_linebuf_destroy(mowgli_linebuf_t *linebuf)
{
if (linebuf->eventloop != NULL)
mowgli_linebuf_detach_from_eventloop(linebuf);
mowgli_vio_destroy(linebuf->vio);
mowgli_free(linebuf->readbuf.buffer);
mowgli_free(linebuf->writebuf.buffer);
mowgli_heap_free(linebuf_heap, linebuf);
}
void pcommand_delete(const char *token)
{
pcommand_t *pcmd;
if (!(pcmd = pcommand_find(token)))
{
slog(LG_INFO, "pcommand_delete(): token %s is not registered", token);
return;
}
mowgli_patricia_delete(pcommands, pcmd->token);
free(pcmd->token);
pcmd->handler = NULL;
mowgli_heap_free(pcommand_heap, pcmd);
}
static void resolve_cb(void *vptr, dns_reply_t *reply)
{
resolve_req_t *req = vptr;
char buf[BUFSIZE];
return_if_fail(vptr != NULL);
return_if_fail(reply != NULL);
if (reply->addr.saddr.sa.sa_family != AF_INET)
return;
inet_ntop(reply->addr.saddr.sa.sa_family, &reply->addr.saddr.sin.sin_addr, buf, reply->addr.saddr_len);
command_success_nodata(req->si, "Result is %s", buf);
mowgli_heap_free(request_heap, req);
object_unref(req->si);
}
mowgli_queue_t *
mowgli_queue_remove(mowgli_queue_t *head)
{
mowgli_queue_t *out;
return_val_if_fail(head != NULL, NULL);
if (head->prev != NULL)
head->prev->next = head->next;
if (head->next != NULL)
head->next->prev = head->prev;
out = head->prev != NULL ? head->prev : head->next;
mowgli_heap_free(mowgli_queue_heap, head);
return out;
}
void perl_script_module_unload_handler(module_t *m, module_unload_intent_t intent)
{
perl_script_module_t *pm = (perl_script_module_t *)m;
do_script_unload(pm->filename);
mowgli_heap_free(perl_script_module_heap, pm);
}
/*
* Implementation functions: load or unload a perl script.
*/
static module_t *do_script_load(const char *filename)
{
/* Remember, this must now be re-entrant. The use of the static
* perl_error buffer is still OK, as it's only used immediately after
* setting, without control passing from this function.
*/
perl_script_module_t *m = mowgli_heap_alloc(perl_script_module_heap);
mowgli_strlcpy(m->filename, filename, sizeof(m->filename));
snprintf(perl_error, sizeof(perl_error), "Unknown error attempting to load perl script %s",
filename);
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(newRV_noinc((SV*)get_cv("Atheme::Init::load_script", 0)));
XPUSHs(sv_2mortal(newSVpv(filename, 0)));
PUTBACK;
int perl_return_count = call_pv("Atheme::Init::call_wrapper", G_EVAL | G_SCALAR);
SPAGAIN;
if (SvTRUE(ERRSV))
{
mowgli_strlcpy(perl_error, SvPV_nolen(ERRSV), sizeof(perl_error));
goto fail;
}
if (1 != perl_return_count)
{
snprintf(perl_error, sizeof(perl_error), "Script load didn't return a package name");
goto fail;
}
/* load_script should have returned the package name that was just
* loaded...
*/
const char *packagename = POPp;
char info_varname[BUFSIZE];
snprintf(info_varname, BUFSIZE, "%s::Info", packagename);
/* ... so use that name to grab the script information hash...
*/
HV *info_hash = get_hv(info_varname, 0);
if (!info_hash)
{
snprintf(perl_error, sizeof(perl_error), "Couldn't get package info hash %s", info_varname);
goto fail;
}
/* ..., extract the canonical name...
*/
SV **name_var = hv_fetch(info_hash, "name", 4, 0);
if (!name_var)
{
snprintf(perl_error, sizeof(perl_error), "Couldn't find canonical name in package info hash");
goto fail;
}
mowgli_strlcpy(m->mod.name, SvPV_nolen(*name_var), sizeof(m->mod.name));
/* ... and dependency list.
*/
SV **deplist_var = hv_fetch(info_hash, "depends", 7, 0);
/* Not declaring this is legal... */
if (deplist_var)
{
/* ... but having it as anything but an arrayref isn't. */
if (!SvROK(*deplist_var) || SvTYPE(SvRV(*deplist_var)) != SVt_PVAV)
{
snprintf(perl_error, sizeof(perl_error), "$Info::depends must be an array reference");
goto fail;
}
AV *deplist = (AV*)SvRV(*deplist_var);
I32 len = av_len(deplist);
/* av_len returns max index, not number of items */
for (I32 i = 0; i <= len; ++i)
{
SV **item = av_fetch(deplist, i, 0);
if (!item)
continue;
const char *dep_name = SvPV_nolen(*item);
if (!module_request(dep_name))
{
snprintf(perl_error, sizeof(perl_error), "Dependent module %s failed to load",
dep_name);
goto fail;
}
module_t *dep_mod = module_find_published(dep_name);
mowgli_node_add(dep_mod, mowgli_node_create(), &m->mod.deplist);
mowgli_node_add(m, mowgli_node_create(), &dep_mod->dephost);
}
}
FREETMPS;
LEAVE;
invalidate_object_references();
/* Now that everything's loaded, do the module housekeeping stuff. */
m->mod.unload_handler = perl_script_module_unload_handler;
/* Can't do much better than the address of the module_t here */
m->mod.address = m;
m->mod.can_unload = MODULE_UNLOAD_CAPABILITY_OK;
return (module_t*)m;
fail:
slog(LG_ERROR, "Failed to load Perl script %s: %s", filename, perl_error);
if (info_hash)
SvREFCNT_dec((SV*)info_hash);
do_script_unload(filename);
mowgli_heap_free(perl_script_module_heap, m);
POPs;
FREETMPS;
LEAVE;
invalidate_object_references();
return NULL;
}
