diff options
| -rw-r--r-- | hex.c | 547 |
1 files changed, 547 insertions, 0 deletions
@@ -68,6 +68,14 @@ enum #include "tui.c" #include "termo.h" +#ifdef HAVE_LUA +#include <lua.h> +#include <lualib.h> +#include <lauxlib.h> + +#include <dirent.h> +#endif // HAVE_LUA + #define APP_TITLE PROGRAM_NAME ///< Left top corner // --- Utilities --------------------------------------------------------------- @@ -157,6 +165,12 @@ static struct app_context struct poller_fd tty_event; ///< Terminal input event struct poller_fd signal_event; ///< Signal FD event +#ifdef HAVE_LUA + lua_State *L; ///< Lua state + int ref_format; ///< Reference to "string.format" + struct str_map coders; ///< Map of coders by name +#endif // HAVE_LUA + // Data: char *message; ///< Last logged message @@ -777,6 +791,492 @@ app_on_refresh (void *user_data) refresh (); } +// --- Lua --------------------------------------------------------------------- + +#ifdef HAVE_LUA + +static void * +app_lua_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 +app_lua_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; +} + +static bool +app_lua_getfield (lua_State *L, int idx, const char *name, + int expected, bool optional) +{ + int found = lua_getfield (L, idx, name); + if (found == expected) + return true; + if (optional && found == LUA_TNIL) + return false; + + const char *message = optional + ? "invalid field \"%s\" (found: %s, expected: %s or nil)" + : "invalid or missing field \"%s\" (found: %s, expected: %s)"; + return luaL_error (L, message, name, + lua_typename (L, found), lua_typename (L, expected)); +} + +static int +app_lua_error_handler (lua_State *L) +{ + luaL_traceback (L, L, luaL_checkstring (L, 1), 1); + return 1; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +struct app_lua_coder +{ + int ref_detect; ///< Reference to the "detect" method + int ref_decode; ///< Reference to the "decode" method +}; + +static void +app_lua_coder_free (void *coder) +{ + struct app_lua_coder *self = coder; + luaL_unref (g_ctx.L, LUA_REGISTRYINDEX, self->ref_decode); + luaL_unref (g_ctx.L, LUA_REGISTRYINDEX, self->ref_detect); +} + +static int +app_lua_register (lua_State *L) +{ + luaL_checktype (L, 1, LUA_TTABLE); + + (void) app_lua_getfield (L, 1, "type", LUA_TSTRING, false); + const char *type = lua_tostring (L, -1); + if (str_map_find (&g_ctx.coders, type)) + luaL_error (L, "a coder has already been registered for `%s'", type); + + (void) app_lua_getfield (L, 1, "detect", LUA_TFUNCTION, true); + (void) app_lua_getfield (L, 1, "decode", LUA_TFUNCTION, false); + + struct app_lua_coder *coder = xcalloc (1, sizeof *coder); + coder->ref_decode = luaL_ref (L, LUA_REGISTRYINDEX); + coder->ref_detect = luaL_ref (L, LUA_REGISTRYINDEX); + str_map_set (&g_ctx.coders, type, coder); + return 0; +} + +static luaL_Reg app_lua_library[] = +{ + { "register", app_lua_register }, + { NULL, NULL } +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +#define XLUA_CHUNK_METATABLE "chunk" + +struct app_lua_chunk +{ + int64_t offset; ///< Offset from start of file + int64_t len; ///< Length of the sequence + + int64_t position; ///< Read position in the sequence + enum endianity endianity; ///< Read endianity +}; + +static struct app_lua_chunk * +app_lua_chunk_new (lua_State *L) +{ + struct app_lua_chunk *chunk = lua_newuserdata (L, sizeof *chunk); + luaL_setmetatable (L, XLUA_CHUNK_METATABLE); + memset (chunk, 0, sizeof *chunk); + return chunk; +} + +static int +app_lua_chunk_len (lua_State *L) +{ + struct app_lua_chunk *self = luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + lua_pushinteger (L, self->len); + return 0; +} + +/// Create a new subchunk following Lua's string.sub() semantics. +/// An implication is that it is not possible to go extend a chunk's bounds. +static int +app_lua_chunk_call (lua_State *L) +{ + struct app_lua_chunk *self = luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + lua_Integer start = luaL_optinteger (L, 2, 1); + lua_Integer end = luaL_optinteger (L, 3, -1); + + if (start < 0) start += self->len + 1; + if (end < 0) end += self->len + 1; + + start = MAX (start, 1); + end = MIN (end, self->len); + + struct app_lua_chunk *clone = app_lua_chunk_new (L); + clone->position = 0; + clone->endianity = self->endianity; + if (start > end) + { + // "start" can be too high and "end" can be too low; + // the length is zero, so the offset doesn't matter much anyway + clone->offset = self->offset; + clone->len = 0; + } + else + { + clone->offset = self->offset + start - 1; + clone->len = end - start + 1; + } + return 1; +} + +static int +app_lua_chunk_index (lua_State *L) +{ + struct app_lua_chunk *self = luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + const char *key = luaL_checkstring (L, 2); + if (luaL_getmetafield (L, 1, key)) + return 1; + + if (!strcmp (key, "offset")) + lua_pushinteger (L, self->offset); + else if (!strcmp (key, "endianity")) + lua_pushstring (L, self->endianity == ENDIANITY_LE ? "le" : "be"); + else if (!strcmp (key, "position")) + lua_pushinteger (L, self->position + 1); + else if (!strcmp (key, "eof")) + lua_pushboolean (L, self->position >= self->len); + else + return luaL_argerror (L, 2, "not a readable property"); + return 1; +} + +static int +app_lua_chunk_newindex (lua_State *L) +{ + struct app_lua_chunk *self = luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + const char *key = luaL_checkstring (L, 2); + if (!strcmp (key, "endianity")) + { + // Needs to be in the enum order + const char *options[] = { "le", "be" }; + self->endianity = luaL_checkoption (L, 3, options[0], options); + } + else if (!strcmp (key, "position")) + { + lua_Integer position = luaL_checkinteger (L, 3) - 1; + if (position < 1 || position > self->len + 1) + return luaL_error (L, "position out of range: %" PRId64, position); + self->position = position - 1; + } + else + return luaL_argerror (L, 2, "not a writable property"); + return 0; +} + +static void +app_lua_mark (int64_t offset, int64_t len, const char *desc) +{ + ARRAY_RESERVE (g_ctx.marks, 1); + g_ctx.marks[g_ctx.marks_len++] = + (struct mark) { offset, len, g_ctx.mark_strings.len }; + + str_append (&g_ctx.mark_strings, desc); + str_append_c (&g_ctx.mark_strings, 0); +} + +static int +app_lua_chunk_mark (lua_State *L) +{ + struct app_lua_chunk *self = luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + app_lua_mark (self->offset, self->len, luaL_checkstring (L, 2)); + return 0; +} + +/// Try to detect any registered type in the data and return its name +static int +app_lua_chunk_identify (lua_State *L) +{ + (void) luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + + struct str_map_iter iter; + str_map_iter_init (&iter, &g_ctx.coders); + struct app_lua_coder *coder; + while ((coder = str_map_iter_next (&iter))) + { + lua_rawgeti (L, LUA_REGISTRYINDEX, coder->ref_detect); + + // Clone the chunk first to reset its read position + lua_pushcfunction (L, app_lua_chunk_call); + lua_pushvalue (L, 1); + lua_call (L, 1, 1); + + lua_call (L, 1, 1); + if (lua_toboolean (L, -1)) + { + lua_pushstring (L, iter.link->key); + return 1; + } + lua_pop (L, 1); + } + return 0; +} + +static int +app_lua_chunk_decode (lua_State *L) +{ + (void) luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + const char *type = luaL_optstring (L, 2, NULL); + // TODO: further arguments should be passed to the decoding function + + if (!type) + { + lua_pushcfunction (L, app_lua_chunk_identify); + lua_pushvalue (L, 1); + lua_call (L, 1, 1); + type = lua_tostring (L, -1); + } + // Can't identify -> can't decode, nothing to do here + if (!type) + return 0; + + // While we could call "detect" here, just to be sure, some kinds may not + // even be detectable and it's better to leave it up to the plugin + + struct app_lua_coder *coder = str_map_find (&g_ctx.coders, type); + if (!coder) + return luaL_error (L, "unknown type: %s", type); + + lua_rawgeti (L, LUA_REGISTRYINDEX, coder->ref_decode); + lua_pushvalue (L, 1); + // TODO: the chunk could remember the name of the coder and prepend it + // to all marks set from the callback; then reset it back to NULL + lua_call (L, 1, 0); + return 0; +} + +static int +app_lua_chunk_read (lua_State *L) +{ + struct app_lua_chunk *self = luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + lua_Integer len = luaL_checkinteger (L, 2); + if (len < 0) + return luaL_argerror (L, 2, "invalid read length"); + + int64_t start = self->offset + self->position; + // XXX: or just return a shorter string in this case? + if (start + len > g_ctx.data_offset + g_ctx.data_len) + return luaL_argerror (L, 2, "chunk is too short"); + + lua_pushlstring (L, (char *) g_ctx.data + (start - g_ctx.data_offset), len); + self->position += len; + return 1; +} + +/// Mark a field that has just been read from the chunk and advance position: +/// - the second argument, if present, is a simple format string for marking; +/// - the third argument, if present, is a filtering function. +/// +/// I am aware of how ugly the implicit "string.format" is. Convenience wins. +static void +app_lua_chunk_finish_read + (lua_State *L, struct app_lua_chunk *self, int64_t len) +{ + int n_args = lua_gettop (L) - 1; + if (n_args < 2) + return; + + // Prepare <string.format>, <format>, <value> + lua_rawgeti (L, LUA_REGISTRYINDEX, g_ctx.ref_format); + lua_pushvalue (L, 2); + + int pre_filter_top = lua_gettop (L); + lua_pushvalue (L, -3); + + // Transform the value if a filtering function is provided + if (n_args >= 3) + { + lua_pushvalue (L, 3); + lua_insert (L, -2); + lua_call (L, 1, LUA_MULTRET); + int n_ret = lua_gettop (L) - pre_filter_top; + + // When no value has been returned, keep the old one + if (n_ret < 1) + lua_pushvalue (L, pre_filter_top - 2); + + // Forward multiple return values to "string.format" + if (n_ret > 1) + { + lua_pushvalue (L, pre_filter_top - 1); + lua_insert (L, -n_ret - 1); + lua_call (L, n_ret, 1); + } + } + + lua_call (L, 2, 1); + app_lua_mark (self->offset + self->position, len, lua_tostring (L, -1)); + self->position += len; + lua_pop (L, 1); +} + +static int +app_lua_chunk_cstring (lua_State *L) +{ + struct app_lua_chunk *self = luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); + void *s = g_ctx.data + (self->offset - g_ctx.data_offset) + self->position; + + void *nil; + if (!(nil = memchr (s, '\0', self->len - self->position))) + return luaL_error (L, "unexpected EOF"); + + lua_pushlstring (L, s, nil - s); + app_lua_chunk_finish_read (L, self, nil - s + 1); + return 1; +} + +/// Decode "len" bytes as a number starting at the current position in "self" +static uint64_t +app_lua_chunk_decode_int (lua_State *L, struct app_lua_chunk *self, size_t len) +{ + if (self->position + (int64_t) len > self->len) + return luaL_error (L, "unexpected EOF"); + + void *s = g_ctx.data + (self->offset - g_ctx.data_offset) + self->position; + return app_decode (s, len, self->endianity); +} + +#define APP_LUA_CHUNK_INT(name, type) \ + static int \ + app_lua_chunk_ ## name (lua_State *L) \ + { \ + struct app_lua_chunk *self = \ + luaL_checkudata (L, 1, XLUA_CHUNK_METATABLE); \ + type v = app_lua_chunk_decode_int (L, self, sizeof v); \ + lua_pushinteger (L, v); \ + app_lua_chunk_finish_read (L, self, sizeof v); \ + return 1; \ + } + +APP_LUA_CHUNK_INT (u8, uint8_t) APP_LUA_CHUNK_INT (s8, int8_t) +APP_LUA_CHUNK_INT (u16, uint16_t) APP_LUA_CHUNK_INT (s16, int16_t) +APP_LUA_CHUNK_INT (u32, uint32_t) APP_LUA_CHUNK_INT (s32, int32_t) +APP_LUA_CHUNK_INT (u64, uint64_t) APP_LUA_CHUNK_INT (s64, int64_t) + +static luaL_Reg app_lua_chunk_table[] = +{ + { "__len", app_lua_chunk_len }, + { "__call", app_lua_chunk_call }, + { "__index", app_lua_chunk_index }, + { "__newindex", app_lua_chunk_newindex }, + { "mark", app_lua_chunk_mark }, + { "identify", app_lua_chunk_identify }, + { "decode", app_lua_chunk_decode }, + + { "read", app_lua_chunk_read }, + { "cstring", app_lua_chunk_cstring }, + { "u8", app_lua_chunk_u8 }, + { "s8", app_lua_chunk_s8 }, + { "u16", app_lua_chunk_u16 }, + { "s16", app_lua_chunk_s16 }, + { "u32", app_lua_chunk_u32 }, + { "s32", app_lua_chunk_s32 }, + { "u64", app_lua_chunk_u64 }, + { "s64", app_lua_chunk_s64 }, + { NULL, NULL } +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +app_lua_load_plugins (const char *plugin_dir) +{ + DIR *dir; + if (!(dir = opendir (plugin_dir))) + { + if (errno != ENOENT) + print_error ("cannot open directory `%s': %s", + plugin_dir, strerror (errno)); + return; + } + + struct dirent *iter; + while ((errno = 0, iter = readdir (dir))) + { + const char *dot = strrchr (iter->d_name, '.'); + if (!dot || strcmp (dot, ".lua")) + continue; + + char *path = xstrdup_printf ("%s/%s", plugin_dir, iter->d_name); + lua_pushcfunction (g_ctx.L, app_lua_error_handler); + if (luaL_loadfile (g_ctx.L, path) + || lua_pcall (g_ctx.L, 0, 0, -2)) + exit_fatal ("Lua: %s", lua_tostring (g_ctx.L, -1)); + lua_pop (g_ctx.L, 1); + free (path); + } + if (errno) + exit_fatal ("readdir: %s", strerror (errno)); + closedir (dir); +} + +static void +app_lua_init (void) +{ + if (!(g_ctx.L = lua_newstate (app_lua_alloc, NULL))) + exit_fatal ("Lua initialization failed"); + + str_map_init (&g_ctx.coders); + g_ctx.coders.free = app_lua_coder_free; + + lua_atpanic (g_ctx.L, app_lua_panic); + luaL_openlibs (g_ctx.L); + luaL_checkversion (g_ctx.L); + + // I don't want to reimplement this and the C function is not exported + hard_assert (lua_getglobal (g_ctx.L, LUA_STRLIBNAME)); + hard_assert (lua_getfield (g_ctx.L, -1, "format")); + g_ctx.ref_format = luaL_ref (g_ctx.L, LUA_REGISTRYINDEX); + + luaL_newlib (g_ctx.L, app_lua_library); + lua_setglobal (g_ctx.L, PROGRAM_NAME); + + luaL_newmetatable (g_ctx.L, XLUA_CHUNK_METATABLE); + luaL_setfuncs (g_ctx.L, app_lua_chunk_table, 0); + lua_pop (g_ctx.L, 1); + + struct str_vector v; + str_vector_init (&v); + get_xdg_data_dirs (&v); + for (size_t i = 0; i < v.len; i++) + { + char *path = xstrdup_printf + ("%s/%s", v.vector[i], PROGRAM_NAME "/plugins"); + app_lua_load_plugins (path); + free (path); + } + str_vector_free (&v); +} + +#endif // HAVE_LUA + // --- Actions ----------------------------------------------------------------- /// Checks what items are visible and returns if fixes were needed @@ -1299,12 +1799,16 @@ main (int argc, char *argv[]) { 'o', "offset", NULL, 0, "offset within the file" }, { 's', "size", NULL, 0, "size limit (1G by default)" }, +#ifdef HAVE_LUA + { 't', "type", NULL, 0, "force interpretation as the given type" }, +#endif // HAVE_LUA { 0, NULL, NULL, 0, NULL } }; struct opt_handler oh; opt_handler_init (&oh, argc, argv, opts, "[FILE]", "Hex viewer."); int64_t size_limit = 1 << 30; + const char *forced_type = NULL; int c; while ((c = opt_handler_get (&oh)) != -1) @@ -1328,6 +1832,9 @@ main (int argc, char *argv[]) if (!decode_size (optarg, &size_limit)) exit_fatal ("invalid size limit specified"); break; + case 't': + forced_type = optarg; + break; default: print_error ("wrong options"); opt_handler_usage (&oh, stderr); @@ -1337,6 +1844,21 @@ main (int argc, char *argv[]) argc -= optind; argv += optind; +#ifdef HAVE_LUA + // We do it at this questionable location to catch plugin failure before + // we read potentially hundreds of megabytes of data in + app_lua_init (); + + if (forced_type && !strcmp (forced_type, "list")) + { + struct str_map_iter iter; + str_map_iter_init (&iter, &g_ctx.coders); + while (str_map_iter_next (&iter)) + puts (iter.link->key); + exit (EXIT_SUCCESS); + } +#endif // HAVE_LUA + // When no filename is given, read from stdin and replace it with the tty int input_fd; if (argc == 0) @@ -1399,6 +1921,26 @@ main (int argc, char *argv[]) print_warning ("failed to set the locale"); app_init_context (); +#ifdef HAVE_LUA + // TODO: eventually we should do this in a separate thread after load + // as it may take a long time (-> responsivity) and once we allow the user + // to edit the file, each change will need a background rescan + lua_pushcfunction (g_ctx.L, app_lua_error_handler); + lua_pushcfunction (g_ctx.L, app_lua_chunk_decode); + + struct app_lua_chunk *chunk = app_lua_chunk_new (g_ctx.L); + chunk->offset = g_ctx.data_offset; + chunk->len = g_ctx.data_len; + + if (forced_type) + lua_pushstring (g_ctx.L, forced_type); + else + lua_pushnil (g_ctx.L); + if (lua_pcall (g_ctx.L, 2, 0, -4)) + exit_fatal ("Lua: decoding failed: %s", lua_tostring (g_ctx.L, -1)); + + lua_pop (g_ctx.L, 1); +#endif // HAVE_LUA app_flatten_marks (); app_load_configuration (); @@ -1418,5 +1960,10 @@ main (int argc, char *argv[]) endwin (); g_log_message_real = log_message_stdio; app_free_context (); + +#ifdef HAVE_LUA + str_map_free (&g_ctx.coders); +#endif // HAVE_LUA + return 0; } |