filter.c

   1 /* filter.c: filter framework functions
   2  *
   3  * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
   4  *
   5  * Licensed under GNU General Public License v2
   6  *   (see COPYING for full license text)
   7  */
   8
   9 #include "cgit.h"
  10 #include "html.h"
  11 #ifndef NO_LUA
  12 #include <dlfcn.h>
  13 #include <lua.h>
  14 #include <lualib.h>
  15 #include <lauxlib.h>
  16 #endif
  17
  18 static inline void reap_filter(struct cgit_filter *filter)
  19 {
  20         if (filter && filter->cleanup)
  21                 filter->cleanup(filter);
  22 }
  23
  24 void cgit_cleanup_filters(void)
  25 {
  26         int i;
  27         reap_filter(ctx.cfg.about_filter);
  28         reap_filter(ctx.cfg.commit_filter);
  29         reap_filter(ctx.cfg.source_filter);
  30         reap_filter(ctx.cfg.email_filter);
  31         reap_filter(ctx.cfg.owner_filter);
  32         reap_filter(ctx.cfg.auth_filter);
  33         for (i = 0; i < cgit_repolist.count; ++i) {
  34                 reap_filter(cgit_repolist.repos[i].about_filter);
  35                 reap_filter(cgit_repolist.repos[i].commit_filter);
  36                 reap_filter(cgit_repolist.repos[i].source_filter);
  37                 reap_filter(cgit_repolist.repos[i].email_filter);
  38                 reap_filter(cgit_repolist.repos[i].owner_filter);
  39         }
  40 }
  41
  42 static int open_exec_filter(struct cgit_filter *base, va_list ap)
  43 {
  44         struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
  45         int i;
  46
  47         for (i = 0; i < filter->base.argument_count; i++)
  48                 filter->argv[i + 1] = va_arg(ap, char *);
  49
  50         filter->old_stdout = chk_positive(dup(STDOUT_FILENO),
  51                 "Unable to duplicate STDOUT");
  52         chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess");
  53         filter->pid = chk_non_negative(fork(), "Unable to create subprocess");
  54         if (filter->pid == 0) {
  55                 close(filter->pipe_fh[1]);
  56                 chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO),
  57                         "Unable to use pipe as STDIN");
  58                 execvp(filter->cmd, filter->argv);
  59                 die_errno("Unable to exec subprocess %s", filter->cmd);
  60         }
  61         close(filter->pipe_fh[0]);
  62         chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO),
  63                 "Unable to use pipe as STDOUT");
  64         close(filter->pipe_fh[1]);
  65         return 0;
  66 }
  67
  68 static int close_exec_filter(struct cgit_filter *base)
  69 {
  70         struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
  71         int i, exit_status = 0;
  72
  73         chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO),
  74                 "Unable to restore STDOUT");
  75         close(filter->old_stdout);
  76         if (filter->pid < 0)
  77                 goto done;
  78         waitpid(filter->pid, &exit_status, 0);
  79         if (WIFEXITED(exit_status))
  80                 goto done;
  81         die("Subprocess %s exited abnormally", filter->cmd);
  82
  83 done:
  84         for (i = 0; i < filter->base.argument_count; i++)
  85                 filter->argv[i + 1] = NULL;
  86         return WEXITSTATUS(exit_status);
  87
  88 }
  89
  90 static void fprintf_exec_filter(struct cgit_filter *base, FILE *f, const char *prefix)
  91 {
  92         struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
  93         fprintf(f, "%sexec:%s\n", prefix, filter->cmd);
  94 }
  95
  96 static void cleanup_exec_filter(struct cgit_filter *base)
  97 {
  98         struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
  99         if (filter->argv) {
 100                 free(filter->argv);
 101                 filter->argv = NULL;
 102         }
 103         if (filter->cmd) {
 104                 free(filter->cmd);
 105                 filter->cmd = NULL;
 106         }
 107 }
 108
 109 static struct cgit_filter *new_exec_filter(const char *cmd, int argument_count)
 110 {
 111         struct cgit_exec_filter *f;
 112         int args_size = 0;
 113
 114         f = xmalloc(sizeof(*f));
 115         /* We leave argv for now and assign it below. */
 116         cgit_exec_filter_init(f, xstrdup(cmd), NULL);
 117         f->base.argument_count = argument_count;
 118         args_size = (2 + argument_count) * sizeof(char *);
 119         f->argv = xmalloc(args_size);
 120         memset(f->argv, 0, args_size);
 121         f->argv[0] = f->cmd;
 122         return &f->base;
 123 }
 124
 125 void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv)
 126 {
 127         memset(filter, 0, sizeof(*filter));
 128         filter->base.open = open_exec_filter;
 129         filter->base.close = close_exec_filter;
 130         filter->base.fprintf = fprintf_exec_filter;
 131         filter->base.cleanup = cleanup_exec_filter;
 132         filter->cmd = cmd;
 133         filter->argv = argv;
 134         /* The argument count for open_filter is zero by default, unless called from new_filter, above. */
 135         filter->base.argument_count = 0;
 136 }
 137
 138 #ifdef NO_LUA
 139 void cgit_init_filters(void)
 140 {
 141 }
 142 #endif
 143
 144 #ifndef NO_LUA
 145 static ssize_t (*libc_write)(int fd, const void *buf, size_t count);
 146 static ssize_t (*filter_write)(struct cgit_filter *base, const void *buf, size_t count) = NULL;
 147 static struct cgit_filter *current_write_filter = NULL;
 148
 149 void cgit_init_filters(void)
 150 {
 151         libc_write = dlsym(RTLD_NEXT, "write");
 152         if (!libc_write)
 153                 die("Could not locate libc's write function");
 154 }
 155
 156 ssize_t write(int fd, const void *buf, size_t count)
 157 {
 158         if (fd != STDOUT_FILENO || !filter_write)
 159                 return libc_write(fd, buf, count);
 160         return filter_write(current_write_filter, buf, count);
 161 }
 162
 163 static inline void hook_write(struct cgit_filter *filter, ssize_t (*new_write)(struct cgit_filter *base, const void *buf, size_t count))
 164 {
 165         /* We want to avoid buggy nested patterns. */
 166         assert(filter_write == NULL);
 167         assert(current_write_filter == NULL);
 168         current_write_filter = filter;
 169         filter_write = new_write;
 170 }
 171
 172 static inline void unhook_write(void)
 173 {
 174         assert(filter_write != NULL);
 175         assert(current_write_filter != NULL);
 176         filter_write = NULL;
 177         current_write_filter = NULL;
 178 }
 179
 180 struct lua_filter {
 181         struct cgit_filter base;
 182         char *script_file;
 183         lua_State *lua_state;
 184 };
 185
 186 static void error_lua_filter(struct lua_filter *filter)
 187 {
 188         die("Lua error in %s: %s", filter->script_file, lua_tostring(filter->lua_state, -1));
 189         lua_pop(filter->lua_state, 1);
 190 }
 191
 192 static ssize_t write_lua_filter(struct cgit_filter *base, const void *buf, size_t count)
 193 {
 194         struct lua_filter *filter = (struct lua_filter *)base;
 195
 196         lua_getglobal(filter->lua_state, "filter_write");
 197         lua_pushlstring(filter->lua_state, buf, count);
 198         if (lua_pcall(filter->lua_state, 1, 0, 0)) {
 199                 error_lua_filter(filter);
 200                 errno = EIO;
 201                 return -1;
 202         }
 203         return count;
 204 }
 205
 206 static inline int hook_lua_filter(lua_State *lua_state, void (*fn)(const char *txt))
 207 {
 208         const char *str;
 209         ssize_t (*save_filter_write)(struct cgit_filter *base, const void *buf, size_t count);
 210         struct cgit_filter *save_filter;
 211
 212         str = lua_tostring(lua_state, 1);
 213         if (!str)
 214                 return 0;
 215
 216         save_filter_write = filter_write;
 217         save_filter = current_write_filter;
 218         unhook_write();
 219         fn(str);
 220         hook_write(save_filter, save_filter_write);
 221
 222         return 0;
 223 }
 224
 225 static int html_lua_filter(lua_State *lua_state)
 226 {
 227         return hook_lua_filter(lua_state, html);
 228 }
 229
 230 static int html_txt_lua_filter(lua_State *lua_state)
 231 {
 232         return hook_lua_filter(lua_state, html_txt);
 233 }
 234
 235 static int html_attr_lua_filter(lua_State *lua_state)
 236 {
 237         return hook_lua_filter(lua_state, html_attr);
 238 }
 239
 240 static int html_url_path_lua_filter(lua_State *lua_state)
 241 {
 242         return hook_lua_filter(lua_state, html_url_path);
 243 }
 244
 245 static int html_url_arg_lua_filter(lua_State *lua_state)
 246 {
 247         return hook_lua_filter(lua_state, html_url_arg);
 248 }
 249
 250 static int html_include_lua_filter(lua_State *lua_state)
 251 {
 252         return hook_lua_filter(lua_state, (void (*)(const char *))html_include);
 253 }
 254
 255 static void cleanup_lua_filter(struct cgit_filter *base)
 256 {
 257         struct lua_filter *filter = (struct lua_filter *)base;
 258
 259         if (!filter->lua_state)
 260                 return;
 261
 262         lua_close(filter->lua_state);
 263         filter->lua_state = NULL;
 264         if (filter->script_file) {
 265                 free(filter->script_file);
 266                 filter->script_file = NULL;
 267         }
 268 }
 269
 270 static int init_lua_filter(struct lua_filter *filter)
 271 {
 272         if (filter->lua_state)
 273                 return 0;
 274
 275         if (!(filter->lua_state = luaL_newstate()))
 276                 return 1;
 277
 278         luaL_openlibs(filter->lua_state);
 279
 280         lua_pushcfunction(filter->lua_state, html_lua_filter);
 281         lua_setglobal(filter->lua_state, "html");
 282         lua_pushcfunction(filter->lua_state, html_txt_lua_filter);
 283         lua_setglobal(filter->lua_state, "html_txt");
 284         lua_pushcfunction(filter->lua_state, html_attr_lua_filter);
 285         lua_setglobal(filter->lua_state, "html_attr");
 286         lua_pushcfunction(filter->lua_state, html_url_path_lua_filter);
 287         lua_setglobal(filter->lua_state, "html_url_path");
 288         lua_pushcfunction(filter->lua_state, html_url_arg_lua_filter);
 289         lua_setglobal(filter->lua_state, "html_url_arg");
 290         lua_pushcfunction(filter->lua_state, html_include_lua_filter);
 291         lua_setglobal(filter->lua_state, "html_include");
 292
 293         if (luaL_dofile(filter->lua_state, filter->script_file)) {
 294                 error_lua_filter(filter);
 295                 lua_close(filter->lua_state);
 296                 filter->lua_state = NULL;
 297                 return 1;
 298         }
 299         return 0;
 300 }
 301
 302 static int open_lua_filter(struct cgit_filter *base, va_list ap)
 303 {
 304         struct lua_filter *filter = (struct lua_filter *)base;
 305         int i;
 306
 307         if (init_lua_filter(filter))
 308                 return 1;
 309
 310         hook_write(base, write_lua_filter);
 311
 312         lua_getglobal(filter->lua_state, "filter_open");
 313         for (i = 0; i < filter->base.argument_count; ++i)
 314                 lua_pushstring(filter->lua_state, va_arg(ap, char *));
 315         if (lua_pcall(filter->lua_state, filter->base.argument_count, 0, 0)) {
 316                 error_lua_filter(filter);
 317                 return 1;
 318         }
 319         return 0;
 320 }
 321
 322 static int close_lua_filter(struct cgit_filter *base)
 323 {
 324         struct lua_filter *filter = (struct lua_filter *)base;
 325         int ret = 0;
 326
 327         lua_getglobal(filter->lua_state, "filter_close");
 328         if (lua_pcall(filter->lua_state, 0, 1, 0)) {
 329                 error_lua_filter(filter);
 330                 ret = -1;
 331         } else {
 332                 ret = lua_tonumber(filter->lua_state, -1);
 333                 lua_pop(filter->lua_state, 1);
 334         }
 335
 336         unhook_write();
 337         return ret;
 338 }
 339
 340 static void fprintf_lua_filter(struct cgit_filter *base, FILE *f, const char *prefix)
 341 {
 342         struct lua_filter *filter = (struct lua_filter *)base;
 343         fprintf(f, "%slua:%s\n", prefix, filter->script_file);
 344 }
 345
 346
 347 static struct cgit_filter *new_lua_filter(const char *cmd, int argument_count)
 348 {
 349         struct lua_filter *filter;
 350
 351         filter = xmalloc(sizeof(*filter));
 352         memset(filter, 0, sizeof(*filter));
 353         filter->base.open = open_lua_filter;
 354         filter->base.close = close_lua_filter;
 355         filter->base.fprintf = fprintf_lua_filter;
 356         filter->base.cleanup = cleanup_lua_filter;
 357         filter->base.argument_count = argument_count;
 358         filter->script_file = xstrdup(cmd);
 359
 360         return &filter->base;
 361 }
 362
 363 #endif
 364
 365
 366 int cgit_open_filter(struct cgit_filter *filter, ...)
 367 {
 368         int result;
 369         va_list ap;
 370         if (!filter)
 371                 return 0;
 372         va_start(ap, filter);
 373         result = filter->open(filter, ap);
 374         va_end(ap);
 375         return result;
 376 }
 377
 378 int cgit_close_filter(struct cgit_filter *filter)
 379 {
 380         if (!filter)
 381                 return 0;
 382         return filter->close(filter);
 383 }
 384
 385 void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix)
 386 {
 387         filter->fprintf(filter, f, prefix);
 388 }
 389
 390
 391
 392 static const struct {
 393         const char *prefix;
 394         struct cgit_filter *(*ctor)(const char *cmd, int argument_count);
 395 } filter_specs[] = {
 396         { "exec", new_exec_filter },
 397 #ifndef NO_LUA
 398         { "lua", new_lua_filter },
 399 #endif
 400 };
 401
 402 struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype)
 403 {
 404         char *colon;
 405         int i;
 406         size_t len;
 407         int argument_count;
 408
 409         if (!cmd || !cmd[0])
 410                 return NULL;
 411
 412         colon = strchr(cmd, ':');
 413         len = colon - cmd;
 414         /*
 415          * In case we're running on Windows, don't allow a single letter before
 416          * the colon.
 417          */
 418         if (len == 1)
 419                 colon = NULL;
 420
 421         switch (filtertype) {
 422                 case AUTH:
 423                         argument_count = 12;
 424                         break;
 425
 426                 case EMAIL:
 427                         argument_count = 2;
 428                         break;
 429
 430                 case OWNER:
 431                         argument_count = 0;
 432                         break;
 433
 434                 case SOURCE:
 435                 case ABOUT:
 436                         argument_count = 1;
 437                         break;
 438
 439                 case COMMIT:
 440                 default:
 441                         argument_count = 0;
 442                         break;
 443         }
 444
 445         /* If no prefix is given, exec filter is the default. */
 446         if (!colon)
 447                 return new_exec_filter(cmd, argument_count);
 448
 449         for (i = 0; i < ARRAY_SIZE(filter_specs); i++) {
 450                 if (len == strlen(filter_specs[i].prefix) &&
 451                     !strncmp(filter_specs[i].prefix, cmd, len))
 452                         return filter_specs[i].ctor(colon + 1, argument_count);
 453         }
 454
 455         die("Invalid filter type: %.*s", (int) len, cmd);
 456 }