X-Git-Url: https://git.cameronkatri.com/cgit.git/blobdiff_plain/d750c7a2c9bb83cfc47c0d74fcee61f0a5042aa9..0f23d4651c80170574c0ab2f091c0718150631ce:/filter.c diff --git a/filter.c b/filter.c index 30bc74b..ebf4937 100644 --- a/filter.c +++ b/filter.c @@ -7,11 +7,23 @@ */ #include "cgit.h" +#include "html.h" #include #include #include #include #include +#include +#include +#ifndef NO_LUA +#include +#include +#include +#endif + +static ssize_t (*libc_write)(int fd, const void *buf, size_t count); +static ssize_t (*filter_write)(struct cgit_filter *base, const void *buf, size_t count) = NULL; +static struct cgit_filter *current_write_filter = NULL; static inline void reap_filter(struct cgit_filter *filter) { @@ -25,20 +37,56 @@ void cgit_cleanup_filters(void) reap_filter(ctx.cfg.about_filter); reap_filter(ctx.cfg.commit_filter); reap_filter(ctx.cfg.source_filter); + reap_filter(ctx.cfg.email_filter); + reap_filter(ctx.cfg.owner_filter); + reap_filter(ctx.cfg.auth_filter); for (i = 0; i < cgit_repolist.count; ++i) { reap_filter(cgit_repolist.repos[i].about_filter); reap_filter(cgit_repolist.repos[i].commit_filter); reap_filter(cgit_repolist.repos[i].source_filter); + reap_filter(cgit_repolist.repos[i].email_filter); + reap_filter(cgit_repolist.repos[i].owner_filter); } } +void cgit_init_filters(void) +{ + libc_write = dlsym(RTLD_NEXT, "write"); + if (!libc_write) + die("Could not locate libc's write function"); +} + +ssize_t write(int fd, const void *buf, size_t count) +{ + if (fd != STDOUT_FILENO || !filter_write) + return libc_write(fd, buf, count); + return filter_write(current_write_filter, buf, count); +} + +static inline void hook_write(struct cgit_filter *filter, ssize_t (*new_write)(struct cgit_filter *base, const void *buf, size_t count)) +{ + /* We want to avoid buggy nested patterns. */ + assert(filter_write == NULL); + assert(current_write_filter == NULL); + current_write_filter = filter; + filter_write = new_write; +} + +static inline void unhook_write(void) +{ + assert(filter_write != NULL); + assert(current_write_filter != NULL); + filter_write = NULL; + current_write_filter = NULL; +} + static int open_exec_filter(struct cgit_filter *base, va_list ap) { - struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base; + struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base; int i; - for (i = 0; i < filter->extra_args; i++) - filter->argv[i+1] = va_arg(ap, char *); + for (i = 0; i < filter->base.argument_count; i++) + filter->argv[i + 1] = va_arg(ap, char *); filter->old_stdout = chk_positive(dup(STDOUT_FILENO), "Unable to duplicate STDOUT"); @@ -60,8 +108,8 @@ static int open_exec_filter(struct cgit_filter *base, va_list ap) static int close_exec_filter(struct cgit_filter *base) { - struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base; - int i, exit_status; + struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base; + int i, exit_status = 0; chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO), "Unable to restore STDOUT"); @@ -69,26 +117,26 @@ static int close_exec_filter(struct cgit_filter *base) if (filter->pid < 0) goto done; waitpid(filter->pid, &exit_status, 0); - if (WIFEXITED(exit_status) && !WEXITSTATUS(exit_status)) + if (WIFEXITED(exit_status)) goto done; die("Subprocess %s exited abnormally", filter->cmd); done: - for (i = 0; i < filter->extra_args; i++) - filter->argv[i+1] = NULL; - return 0; + for (i = 0; i < filter->base.argument_count; i++) + filter->argv[i + 1] = NULL; + return WEXITSTATUS(exit_status); } static void fprintf_exec_filter(struct cgit_filter *base, FILE *f, const char *prefix) { - struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base; + struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base; fprintf(f, "%sexec:%s\n", prefix, filter->cmd); } static void cleanup_exec_filter(struct cgit_filter *base) { - struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base; + struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base; if (filter->argv) { free(filter->argv); filter->argv = NULL; @@ -99,7 +147,7 @@ static void cleanup_exec_filter(struct cgit_filter *base) } } -static struct cgit_filter *new_exec_filter(const char *cmd, filter_type filtertype) +static struct cgit_filter *new_exec_filter(const char *cmd, int argument_count) { struct cgit_exec_filter *f; int args_size = 0; @@ -107,20 +155,8 @@ static struct cgit_filter *new_exec_filter(const char *cmd, filter_type filterty f = xmalloc(sizeof(*f)); /* We leave argv for now and assign it below. */ cgit_exec_filter_init(f, xstrdup(cmd), NULL); - - switch (filtertype) { - case SOURCE: - case ABOUT: - f->extra_args = 1; - break; - - case COMMIT: - default: - f->extra_args = 0; - break; - } - - args_size = (2 + f->extra_args) * sizeof(char *); + f->base.argument_count = argument_count; + args_size = (2 + argument_count) * sizeof(char *); f->argv = xmalloc(args_size); memset(f->argv, 0, args_size); f->argv[0] = f->cmd; @@ -136,12 +172,203 @@ void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **ar filter->base.cleanup = cleanup_exec_filter; filter->cmd = cmd; filter->argv = argv; + /* The argument count for open_filter is zero by default, unless called from new_filter, above. */ + filter->base.argument_count = 0; +} + +#ifndef NO_LUA +struct lua_filter { + struct cgit_filter base; + char *script_file; + lua_State *lua_state; +}; + +static void error_lua_filter(struct lua_filter *filter) +{ + die("Lua error in %s: %s", filter->script_file, lua_tostring(filter->lua_state, -1)); + lua_pop(filter->lua_state, 1); +} + +static ssize_t write_lua_filter(struct cgit_filter *base, const void *buf, size_t count) +{ + struct lua_filter *filter = (struct lua_filter *)base; + + lua_getglobal(filter->lua_state, "filter_write"); + lua_pushlstring(filter->lua_state, buf, count); + if (lua_pcall(filter->lua_state, 1, 0, 0)) { + error_lua_filter(filter); + errno = EIO; + return -1; + } + return count; +} + +static inline int hook_lua_filter(lua_State *lua_state, void (*fn)(const char *txt)) +{ + const char *str; + ssize_t (*save_filter_write)(struct cgit_filter *base, const void *buf, size_t count); + struct cgit_filter *save_filter; + + str = lua_tostring(lua_state, 1); + if (!str) + return 0; + + save_filter_write = filter_write; + save_filter = current_write_filter; + unhook_write(); + fn(str); + hook_write(save_filter, save_filter_write); + + return 0; +} + +static int html_lua_filter(lua_State *lua_state) +{ + return hook_lua_filter(lua_state, html); +} + +static int html_txt_lua_filter(lua_State *lua_state) +{ + return hook_lua_filter(lua_state, html_txt); +} + +static int html_attr_lua_filter(lua_State *lua_state) +{ + return hook_lua_filter(lua_state, html_attr); +} + +static int html_url_path_lua_filter(lua_State *lua_state) +{ + return hook_lua_filter(lua_state, html_url_path); +} + +static int html_url_arg_lua_filter(lua_State *lua_state) +{ + return hook_lua_filter(lua_state, html_url_arg); +} + +static int html_include_lua_filter(lua_State *lua_state) +{ + return hook_lua_filter(lua_state, (void (*)(const char *))html_include); } +static void cleanup_lua_filter(struct cgit_filter *base) +{ + struct lua_filter *filter = (struct lua_filter *)base; + + if (!filter->lua_state) + return; + + lua_close(filter->lua_state); + filter->lua_state = NULL; + if (filter->script_file) { + free(filter->script_file); + filter->script_file = NULL; + } +} + +static int init_lua_filter(struct lua_filter *filter) +{ + if (filter->lua_state) + return 0; + + if (!(filter->lua_state = luaL_newstate())) + return 1; + + luaL_openlibs(filter->lua_state); + + lua_pushcfunction(filter->lua_state, html_lua_filter); + lua_setglobal(filter->lua_state, "html"); + lua_pushcfunction(filter->lua_state, html_txt_lua_filter); + lua_setglobal(filter->lua_state, "html_txt"); + lua_pushcfunction(filter->lua_state, html_attr_lua_filter); + lua_setglobal(filter->lua_state, "html_attr"); + lua_pushcfunction(filter->lua_state, html_url_path_lua_filter); + lua_setglobal(filter->lua_state, "html_url_path"); + lua_pushcfunction(filter->lua_state, html_url_arg_lua_filter); + lua_setglobal(filter->lua_state, "html_url_arg"); + lua_pushcfunction(filter->lua_state, html_include_lua_filter); + lua_setglobal(filter->lua_state, "html_include"); + + if (luaL_dofile(filter->lua_state, filter->script_file)) { + error_lua_filter(filter); + lua_close(filter->lua_state); + filter->lua_state = NULL; + return 1; + } + return 0; +} + +static int open_lua_filter(struct cgit_filter *base, va_list ap) +{ + struct lua_filter *filter = (struct lua_filter *)base; + int i; + + if (init_lua_filter(filter)) + return 1; + + hook_write(base, write_lua_filter); + + lua_getglobal(filter->lua_state, "filter_open"); + for (i = 0; i < filter->base.argument_count; ++i) + lua_pushstring(filter->lua_state, va_arg(ap, char *)); + if (lua_pcall(filter->lua_state, filter->base.argument_count, 0, 0)) { + error_lua_filter(filter); + return 1; + } + return 0; +} + +static int close_lua_filter(struct cgit_filter *base) +{ + struct lua_filter *filter = (struct lua_filter *)base; + int ret = 0; + + lua_getglobal(filter->lua_state, "filter_close"); + if (lua_pcall(filter->lua_state, 0, 1, 0)) { + error_lua_filter(filter); + ret = -1; + } else { + ret = lua_tonumber(filter->lua_state, -1); + lua_pop(filter->lua_state, 1); + } + + unhook_write(); + return ret; +} + +static void fprintf_lua_filter(struct cgit_filter *base, FILE *f, const char *prefix) +{ + struct lua_filter *filter = (struct lua_filter *)base; + fprintf(f, "%slua:%s\n", prefix, filter->script_file); +} + + +static struct cgit_filter *new_lua_filter(const char *cmd, int argument_count) +{ + struct lua_filter *filter; + + filter = xmalloc(sizeof(*filter)); + memset(filter, 0, sizeof(*filter)); + filter->base.open = open_lua_filter; + filter->base.close = close_lua_filter; + filter->base.fprintf = fprintf_lua_filter; + filter->base.cleanup = cleanup_lua_filter; + filter->base.argument_count = argument_count; + filter->script_file = xstrdup(cmd); + + return &filter->base; +} + +#endif + + int cgit_open_filter(struct cgit_filter *filter, ...) { int result; va_list ap; + if (!filter) + return 0; va_start(ap, filter); result = filter->open(filter, ap); va_end(ap); @@ -150,6 +377,8 @@ int cgit_open_filter(struct cgit_filter *filter, ...) int cgit_close_filter(struct cgit_filter *filter) { + if (!filter) + return 0; return filter->close(filter); } @@ -162,9 +391,12 @@ void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix static const struct { const char *prefix; - struct cgit_filter *(*ctor)(const char *cmd, filter_type filtertype); + struct cgit_filter *(*ctor)(const char *cmd, int argument_count); } filter_specs[] = { { "exec", new_exec_filter }, +#ifndef NO_LUA + { "lua", new_lua_filter }, +#endif }; struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype) @@ -172,6 +404,8 @@ struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype) char *colon; int i; size_t len; + int argument_count; + if (!cmd || !cmd[0]) return NULL; @@ -184,16 +418,39 @@ struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype) if (len == 1) colon = NULL; + switch (filtertype) { + case AUTH: + argument_count = 12; + break; + + case EMAIL: + argument_count = 2; + break; + + case OWNER: + argument_count = 0; + break; + + case SOURCE: + case ABOUT: + argument_count = 1; + break; + + case COMMIT: + default: + argument_count = 0; + break; + } + /* If no prefix is given, exec filter is the default. */ if (!colon) - return new_exec_filter(cmd, filtertype); + return new_exec_filter(cmd, argument_count); for (i = 0; i < ARRAY_SIZE(filter_specs); i++) { if (len == strlen(filter_specs[i].prefix) && !strncmp(filter_specs[i].prefix, cmd, len)) - return filter_specs[i].ctor(colon + 1, filtertype); + return filter_specs[i].ctor(colon + 1, argument_count); } die("Invalid filter type: %.*s", (int) len, cmd); } -