ponymap/plugins/lua-loader.c

462 lines
11 KiB
C

/*
* lua-loader.c: Lua plugin loader plugin
*
* Copyright (c) 2015, Přemysl Janouch <p.janouch@gmail.com>
* All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
// I can't really recommend using this interface as it adds a lot of overhead
#include "config.h"
#include "../liberty/liberty.c"
#include "../plugin-api.h"
#include <dirent.h>
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
#define XLUA_API_VERSION 1 ///< Version of the Lua API
// --- Utilities ---------------------------------------------------------------
static struct plugin_data
{
void *ctx; ///< Application context
struct plugin_api *api; ///< Plugin API vtable
}
g_data;
static void *
xlua_alloc (void *ud, void *ptr, size_t o_size, size_t n_size)
{
(void) ud;
(void) o_size;
if (n_size)
return realloc (ptr, n_size);
free (ptr);
return NULL;
}
static int
xlua_panic (lua_State *L)
{
// XXX: we might be able to do something better
print_fatal ("Lua panicked: %s", lua_tostring (L, -1));
lua_close (L);
exit (EXIT_FAILURE);
return 0;
}
// --- Unit wrapper ------------------------------------------------------------
#define UNIT_METATABLE "unit" ///< Identifier for the Lua metatable
struct unit_wrapper
{
struct unit *unit; ///< The underlying unit
};
static int
xlua_unit_get_address (lua_State *L)
{
struct unit_wrapper *data = luaL_checkudata (L, 1, UNIT_METATABLE);
lua_pushstring (L, g_data.api->unit_get_address (data->unit));
return 1;
}
static int
xlua_unit_write (lua_State *L)
{
struct unit_wrapper *data = luaL_checkudata (L, 1, UNIT_METATABLE);
size_t buffer_len;
const char *buffer = luaL_checklstring (L, 2, &buffer_len);
lua_pushinteger (L, g_data.api->unit_write
(data->unit, buffer, buffer_len));
return 1;
}
static int
xlua_unit_set_success (lua_State *L)
{
struct unit_wrapper *data = luaL_checkudata (L, 1, UNIT_METATABLE);
bool success = lua_toboolean (L, 2);
g_data.api->unit_set_success (data->unit, success);
return 0;
}
static int
xlua_unit_add_info (lua_State *L)
{
struct unit_wrapper *data = luaL_checkudata (L, 1, UNIT_METATABLE);
const char *info = luaL_checkstring (L, 2);
g_data.api->unit_add_info (data->unit, info);
return 0;
}
static int
xlua_unit_abort (lua_State *L)
{
struct unit_wrapper *data = luaL_checkudata (L, 1, UNIT_METATABLE);
g_data.api->unit_abort (data->unit);
return 0;
}
static int
xlua_unit_destroy (lua_State *L)
{
// TODO: when creating the wrapper object, increase the reference
// count for the unit and decrease it in here again. If we don't do
// this, the Lua plugin may cause a use-after-free error.
(void) L;
return 0;
}
static luaL_Reg xlua_unit_table[] =
{
{ "get_address", xlua_unit_get_address },
{ "write", xlua_unit_write },
{ "set_success", xlua_unit_set_success },
{ "add_info", xlua_unit_add_info },
{ "abort", xlua_unit_abort },
{ "__gc", xlua_unit_destroy },
{ NULL, NULL }
};
// --- Scan wrapper ------------------------------------------------------------
struct service_data
{
struct service *service; ///< The corresponding service
lua_State *L; ///< Lua state
int new_scan_cb_ref; ///< Reference to "new_scan" callback
};
struct scan_data
{
struct service *service; ///< The corresponding service
struct unit *unit; ///< The corresponding unit
lua_State *L; ///< Lua state
int scan_ref; ///< Reference to scan data in Lua
};
static void *
scan_init (struct service *self, struct unit *unit)
{
struct service_data *service = self->user_data;
lua_geti (service->L, LUA_REGISTRYINDEX, service->new_scan_cb_ref);
// Wrap the unit in Lua userdata so that Lua code can use it
struct unit_wrapper *wrapper =
lua_newuserdata (service->L, sizeof *wrapper);
wrapper->unit = unit;
luaL_setmetatable (service->L, UNIT_METATABLE);
// Ask for a Lua object (table) to use for protocol detection
if (lua_pcall (service->L, 1, 1, 0))
{
print_error ("Lua: service `%s': new_scan: %s",
service->service->name, lua_tostring (service->L, -1));
lua_pop (service->L, 1);
return NULL;
}
if (!lua_istable (service->L, -1))
{
print_error ("Lua: service `%s': new_scan must return a table",
service->service->name);
return NULL;
}
// Return a scan handle
struct scan_data *data = xmalloc (sizeof *data);
data->service = self;
data->L = service->L;
data->scan_ref = luaL_ref (service->L, LUA_REGISTRYINDEX);
data->unit = unit;
return data;
}
static void
scan_free (void *handle)
{
if (!handle)
return;
struct scan_data *data = handle;
luaL_unref (data->L, LUA_REGISTRYINDEX, data->scan_ref);
free (handle);
}
static void
handle_scan_method_failure (struct scan_data *data)
{
print_error ("Lua: service `%s': %s", data->service->name,
lua_tostring (data->L, -1));
g_data.api->unit_abort (data->unit);
lua_pop (data->L, 1);
}
static bool
prepare_scan_method (struct scan_data *data, const char *method_name)
{
if (!data)
return false;
lua_geti (data->L, LUA_REGISTRYINDEX, data->scan_ref);
lua_getfield (data->L, -1, method_name);
if (lua_isnil (data->L, -1))
{
lua_pop (data->L, 2);
return false;
}
if (!lua_isfunction (data->L, -1))
{
lua_pop (data->L, 2);
lua_pushfstring (data->L, "`%s' must be a function", method_name);
handle_scan_method_failure (data);
return false;
}
// Swap the first two values on the stack, so that the function
// is first and the object we're calling it on is second
lua_insert (data->L, -2);
return true;
}
static void
on_data (void *handle, const void *network_data, size_t len)
{
struct scan_data *data = handle;
if (!prepare_scan_method (data, "on_data"))
return;
lua_pushlstring (data->L, network_data, len);
if (lua_pcall (data->L, 2, 0, 0))
handle_scan_method_failure (data);
}
static void
on_eof (void *handle)
{
struct scan_data *data = handle;
if (!prepare_scan_method (data, "on_eof"))
return;
if (lua_pcall (data->L, 1, 0, 0))
handle_scan_method_failure (data);
}
static void
on_error (void *handle)
{
struct scan_data *data = handle;
if (!prepare_scan_method (data, "on_error"))
return;
if (lua_pcall (data->L, 1, 0, 0))
handle_scan_method_failure (data);
}
static void
on_aborted (void *handle)
{
struct scan_data *data = handle;
if (!prepare_scan_method (data, "on_aborted"))
return;
if (lua_pcall (data->L, 1, 0, 0))
handle_scan_method_failure (data);
}
// --- Top-level interface -----------------------------------------------------
static int
xlua_register_service (lua_State *L)
{
// Validate and decode the arguments
luaL_checktype (L, 1, LUA_TTABLE);
lua_getfield (L, 1, "name");
if (!lua_isstring (L, -1))
return luaL_error (L, "service registration failed: "
"invalid or missing `%s'", "name");
const char *name = lua_tostring (L, -1);
lua_pop (L, 1);
lua_getfield (L, 1, "flags");
lua_Unsigned flags;
if (lua_isnil (L, -1))
flags = 0;
else if (lua_isinteger (L, -1))
flags = lua_tointeger (L, -1);
else
return luaL_error (L, "service registration failed: "
"invalid or missing `%s'", "flags");
lua_pop (L, 1);
lua_getfield (L, 1, "new_scan");
if (!lua_isfunction (L, -1))
return luaL_error (L, "service registration failed: "
"invalid or missing `%s'", "new_scan");
// Reference the "new_scan" function for later use
struct service_data *data = xcalloc (1, sizeof *data);
data->L = L;
data->new_scan_cb_ref = luaL_ref (L, LUA_REGISTRYINDEX);
// Register a new service that proxies calls to Lua code
struct service *s = data->service = xcalloc (1, sizeof *s);
s->name = xstrdup (name);
s->flags = flags;
s->user_data = data;
s->scan_init = scan_init;
s->scan_free = scan_free;
s->on_data = on_data;
s->on_eof = on_eof;
s->on_error = on_error;
s->on_aborted = on_aborted;
g_data.api->register_service (g_data.ctx, s);
return 0;
}
static int
xlua_get_config (lua_State *L)
{
const char *key = luaL_checkstring (L, 1);
lua_pushstring (L, g_data.api->get_config (g_data.ctx, key));
return 0;
}
static int
xlua_check_api_version (lua_State *L)
{
lua_Integer requested = luaL_checkinteger (L, 1);
if (requested != XLUA_API_VERSION)
return luaL_error (L, "incompatible API version");
return 0;
}
static luaL_Reg xlua_library[] =
{
{ "register_service", xlua_register_service },
{ "get_config", xlua_get_config },
{ "check_api_version", xlua_check_api_version },
{ NULL, NULL }
};
static bool
load_one_plugin (lua_State *L, const char *name, const char *path)
{
int ret;
if (!(ret = luaL_loadfile (L, path))
&& !(ret = lua_pcall (L, 0, 0, 0)))
return true;
print_error ("Lua: could not load `%s': %s", name, lua_tostring (L, -1));
lua_pop (L, 1);
return false;
}
static bool
initialize (void *ctx, struct plugin_api *api)
{
g_data = (struct plugin_data) { .ctx = ctx, .api = api };
if (sizeof (lua_Integer) < 8)
{
print_error ("%s: %s", "Lua",
"at least 64-bit Lua integers are required");
return false;
}
const char *plugin_dir = api->get_config (ctx, "plugin_dir");
if (!plugin_dir)
{
print_fatal ("%s: %s", "Lua", "no plugin directory defined");
return false;
}
DIR *dir = opendir (plugin_dir);
if (!dir)
{
print_fatal ("%s: %s: %s", "Lua",
"cannot open plugin directory", strerror (errno));
return false;
}
bool success = false;
lua_State *L;
if (!(L = lua_newstate (xlua_alloc, NULL)))
{
print_fatal ("%s: %s", "Lua", "initialization failed");
goto end;
}
lua_atpanic (L, xlua_panic);
luaL_openlibs (L);
// Register the ponymap library
luaL_newlib (L, xlua_library);
lua_pushinteger (L, SERVICE_SUPPORTS_TLS);
lua_setfield (L, -2, "SERVICE_SUPPORTS_TLS");
lua_pushinteger (L, XLUA_API_VERSION);
lua_setfield (L, -2, "api_version");
lua_setglobal (L, PROGRAM_NAME);
// Create a metatable for the units
luaL_newmetatable (L, UNIT_METATABLE);
lua_pushvalue (L, -1);
lua_setfield (L, -2, "__index");
luaL_setfuncs (L, xlua_unit_table, 0);
struct dirent buf, *iter;
while (true)
{
if (readdir_r (dir, &buf, &iter))
{
print_fatal ("%s: %s: %s", "Lua", "readdir_r", strerror (errno));
break;
}
if (!iter)
{
success = true;
break;
}
char *dot = strrchr (iter->d_name, '.');
if (!dot || strcmp (dot, ".lua"))
continue;
char *path = xstrdup_printf ("%s/%s", plugin_dir, iter->d_name);
(void) load_one_plugin (L, iter->d_name, path);
free (path);
}
end:
closedir (dir);
return success;
}
struct plugin_info ponymap_plugin_info =
{
.api_version = API_VERSION,
.initialize = initialize
};