void
mowgli_queue_bootstrap(void)
{
mowgli_queue_heap = mowgli_heap_create(sizeof(mowgli_queue_t), 256, BH_NOW);
if (mowgli_queue_heap == NULL)
mowgli_log("mowgli_queue_heap was not created, expect problems.");
}
void _modinit(module_t *m)
{
MODULE_TRY_REQUEST_SYMBOL(m, exttarget_tree, "exttarget/main", "exttarget_tree");
mowgli_patricia_add(*exttarget_tree, "chanacs", chanacs_validate_f);
/* since we are dealing with channel names, we use irccasecanon. */
chanacs_exttarget_tree = mowgli_patricia_create(irccasecanon);
chanacs_ext_heap = mowgli_heap_create(sizeof(chanacs_exttarget_t), 32, BH_LAZY);
}
int
mowgli_vio_openssl_setssl(mowgli_vio_t *vio, mowgli_vio_ssl_settings_t *settings, mowgli_vio_ops_t *ops)
{
mowgli_ssl_connection_t *connection;
return_val_if_fail(vio, -255);
if (!ssl_heap)
ssl_heap = mowgli_heap_create(sizeof(mowgli_ssl_connection_t), 64, BH_NOW);
connection = mowgli_heap_alloc(ssl_heap);
vio->privdata = connection;
if (settings)
memcpy(&connection->settings, settings, sizeof(mowgli_vio_ssl_settings_t));
else
/* Greatest compat without being terribly insecure */
connection->settings.ssl_version = MOWGLI_VIO_SSLFLAGS_SSLV3;
if (ops == NULL)
{
if (!openssl_ops)
{
openssl_ops = mowgli_alloc(sizeof(mowgli_vio_ops_t));
memcpy(openssl_ops, &mowgli_vio_default_ops, sizeof(mowgli_vio_ops_t));
}
vio->ops = openssl_ops;
}
else
{
vio->ops = ops;
}
/* Change ops */
mowgli_vio_ops_set_op(vio->ops, connect, mowgli_vio_openssl_default_connect);
mowgli_vio_ops_set_op(vio->ops, read, mowgli_vio_openssl_default_read);
mowgli_vio_ops_set_op(vio->ops, write, mowgli_vio_openssl_default_write);
mowgli_vio_ops_set_op(vio->ops, close, mowgli_vio_openssl_default_close);
mowgli_vio_ops_set_op(vio->ops, accept, mowgli_vio_openssl_default_accept);
mowgli_vio_ops_set_op(vio->ops, listen, mowgli_vio_openssl_default_listen);
/* SSL setup */
if (!openssl_init)
{
openssl_init = true;
SSL_library_init();
SSL_load_error_strings();
ERR_load_BIO_strings();
OpenSSL_add_all_algorithms();
}
return 0;
}
mowgli_eventloop_t *
mowgli_eventloop_create(void)
{
mowgli_eventloop_t *eventloop;
if (eventloop_heap == NULL)
eventloop_heap = mowgli_heap_create(sizeof(mowgli_eventloop_t), 16, BH_NOW);
eventloop = mowgli_heap_alloc(eventloop_heap);
eventloop->eventloop_ops = &_mowgli_null_pollops;
#ifdef HAVE_SELECT
eventloop->eventloop_ops = &_mowgli_select_pollops;
#endif
#ifdef HAVE_POLL_H
eventloop->eventloop_ops = &_mowgli_poll_pollops;
#endif
#ifdef HAVE_SYS_EPOLL_H
eventloop->eventloop_ops = &_mowgli_epoll_pollops;
#endif
#ifdef HAVE_KQUEUE
eventloop->eventloop_ops = &_mowgli_kqueue_pollops;
#endif
#ifdef HAVE_DISPATCH_BLOCK
eventloop->eventloop_ops = &_mowgli_qnx_pollops;
#endif
#ifdef HAVE_PORT_CREATE
eventloop->eventloop_ops = &_mowgli_ports_pollops;
#endif
#if 0
eventloop->eventloop_ops = &_mowgli_winsock_pollops;
#endif
if (mowgli_mutex_init(&eventloop->mutex) != 0)
{
mowgli_log("couldn't create mutex for eventloop %p, aborting...", (void *) eventloop);
abort();
}
eventloop->eventloop_ops->pollsetup(eventloop);
eventloop->deadline = -1;
mowgli_eventloop_calibrate(eventloop);
return eventloop;
}
/*
* Module startup/shutdown
*/
void _modinit(module_t *m)
{
perl_script_module_heap = mowgli_heap_create(sizeof(perl_script_module_t), 256, BH_NOW);
if (!perl_script_module_heap)
{
m->mflags |= MODTYPE_FAIL;
return;
}
if (! startup_perl())
{
m->mflags |= MODTYPE_FAIL;
return;
}
service_named_bind_command("operserv", &os_perl);
hook_add_event("module_load");
hook_add_module_load(hook_module_load);
add_top_conf("LOADSCRIPT", conf_loadscript);
}
static void os_cmd_resolve(sourceinfo_t *si, int parc, char *parv[])
{
resolve_req_t *req;
if (request_heap == NULL)
request_heap = mowgli_heap_create(sizeof(resolve_req_t), 32, BH_LAZY);
if (!parv[0])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "RESOLVE");
return;
}
req = mowgli_heap_alloc(request_heap);
req->si = si;
req->dns_query.ptr = req;
req->dns_query.callback = resolve_cb;
gethost_byname_type(parv[0], &req->dns_query, T_A);
object_ref(req->si);
}
// initialize the object.
atheme_object_init(atheme_object(ext), entity(ext)->name, (atheme_object_destructor_fn) server_ext_delete);
// add the object to the exttarget tree.
mowgli_patricia_add(server_exttarget_tree, ext->server, ext);
// return the object as initially unowned by sinking the reference count
return atheme_object_sink_ref(ext);
}
static void
mod_init(struct module *const restrict m)
{
MODULE_TRY_REQUEST_SYMBOL(m, exttarget_tree, "exttarget/main", "exttarget_tree");
mowgli_patricia_add(*exttarget_tree, "server", server_validate_f);
server_exttarget_tree = mowgli_patricia_create(irccasecanon);
server_ext_heap = mowgli_heap_create(sizeof(struct this_exttarget), 32, BH_LAZY);
}
static void
mod_deinit(const enum module_unload_intent ATHEME_VATTR_UNUSED intent)
{
mowgli_heap_destroy(server_ext_heap);
mowgli_patricia_delete(*exttarget_tree, "server");
mowgli_patricia_destroy(server_exttarget_tree, NULL, NULL);
}
SIMPLE_DECLARE_MODULE_V1("exttarget/server", MODULE_UNLOAD_CAPABILITY_OK)