Diffstat (limited to 'filter.c')
| -rw-r--r-- | filter.c | 358 |
1 files changed, 45 insertions, 313 deletions
@@ -1,23 +1,17 @@ /* filter.c: filter framework functions * * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com> - * Copyright (C) 2026 Saya Andy <saya.andy@posteo.com> - * - * Modified 2026 by Saya Andy: - * Integrate ci filter * * Licensed under GNU General Public License v2 * (see COPYING for full license text) */ #include "cgit.h" -#include "html.h" -#ifndef NO_LUA -#include <dlfcn.h> -#include <lua.h> -#include <lualib.h> -#include <lauxlib.h> -#endif +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> +#include <string.h> +#include <stdlib.h> static inline void reap_filter(struct cgit_filter *filter) { @@ -31,51 +25,43 @@ 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); - reap_filter(ctx.cfg.ci_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); - reap_filter(cgit_repolist.repos[i].ci_filter); } } static int open_exec_filter(struct cgit_filter *base, va_list ap) { - struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base; - int pipe_fh[2]; + struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base; int i; - for (i = 0; i < filter->base.argument_count; i++) - filter->argv[i + 1] = va_arg(ap, char *); + for (i = 0; i < filter->extra_args; i++) + filter->argv[i+1] = va_arg(ap, char *); filter->old_stdout = chk_positive(dup(STDOUT_FILENO), "Unable to duplicate STDOUT"); - chk_zero(pipe(pipe_fh), "Unable to create pipe to subprocess"); + chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess"); filter->pid = chk_non_negative(fork(), "Unable to create subprocess"); if (filter->pid == 0) { - close(pipe_fh[1]); - chk_non_negative(dup2(pipe_fh[0], STDIN_FILENO), + close(filter->pipe_fh[1]); + chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO), "Unable to use pipe as STDIN"); execvp(filter->cmd, filter->argv); die_errno("Unable to exec subprocess %s", filter->cmd); } - close(pipe_fh[0]); - chk_non_negative(dup2(pipe_fh[1], STDOUT_FILENO), + close(filter->pipe_fh[0]); + chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO), "Unable to use pipe as STDOUT"); - close(pipe_fh[1]); + close(filter->pipe_fh[1]); return 0; } static int close_exec_filter(struct cgit_filter *base) { - struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base; - int i, exit_status = 0; + struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base; + int i, exit_status; chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO), "Unable to restore STDOUT"); @@ -83,26 +69,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)) + if (WIFEXITED(exit_status) && !WEXITSTATUS(exit_status)) goto done; die("Subprocess %s exited abnormally", filter->cmd); done: - for (i = 0; i < filter->base.argument_count; i++) - filter->argv[i + 1] = NULL; - return WEXITSTATUS(exit_status); + for (i = 0; i < filter->extra_args; i++) + filter->argv[i+1] = NULL; + return 0; } 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; @@ -113,16 +99,28 @@ static void cleanup_exec_filter(struct cgit_filter *base) } } -static struct cgit_filter *new_exec_filter(const char *cmd, int argument_count) +static struct cgit_filter *new_exec_filter(const char *cmd, filter_type filtertype) { struct cgit_exec_filter *f; int args_size = 0; f = xmalloc(sizeof(*f)); /* We leave argv for now and assign it below. */ - cgit_exec_filter_init(f, strdup_first_line(cmd), NULL); - f->base.argument_count = argument_count; - args_size = (2 + argument_count) * sizeof(char *); + 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->argv = xmalloc(args_size); memset(f->argv, 0, args_size); f->argv[0] = f->cmd; @@ -134,248 +132,16 @@ void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **ar memset(filter, 0, sizeof(*filter)); filter->base.open = open_exec_filter; filter->base.close = close_exec_filter; - filter->base.fprintfp = fprintf_exec_filter; + filter->base.fprintf = fprintf_exec_filter; 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; -} - -#ifdef NO_LUA -void cgit_init_filters(void) -{ -} -#endif - -#ifndef NO_LUA -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; - -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; -} - -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.fprintfp = fprintf_lua_filter; - filter->base.cleanup = cleanup_lua_filter; - filter->base.argument_count = argument_count; - filter->script_file = strdup_first_line(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); @@ -384,35 +150,28 @@ int cgit_open_filter(struct cgit_filter *filter, ...) int cgit_close_filter(struct cgit_filter *filter) { - if (!filter) - return 0; return filter->close(filter); } void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix) { - filter->fprintfp(filter, f, prefix); + filter->fprintf(filter, f, prefix); } static const struct { const char *prefix; - struct cgit_filter *(*ctor)(const char *cmd, int argument_count); + struct cgit_filter *(*ctor)(const char *cmd, filter_type filtertype); } 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) { - const char *colon; + char *colon; int i; size_t len; - int argument_count; - if (!cmd || !cmd[0]) return NULL; @@ -425,43 +184,16 @@ 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 CI: - argument_count = 3; - 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, argument_count); + return new_exec_filter(cmd, filtertype); 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, argument_count); + return filter_specs[i].ctor(colon + 1, filtertype); } die("Invalid filter type: %.*s", (int) len, cmd); } + |