1 /* filter.c: filter framework functions
3 * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text)
18 static inline void reap_filter(struct cgit_filter *filter)
20 if (filter && filter->cleanup)
21 filter->cleanup(filter);
24 void cgit_cleanup_filters(void)
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);
42 static int open_exec_filter(struct cgit_filter *base, va_list ap)
44 struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
48 for (i = 0; i < filter->base.argument_count; i++)
49 filter->argv[i + 1] = va_arg(ap, char *);
51 filter->old_stdout = chk_positive(dup(STDOUT_FILENO),
52 "Unable to duplicate STDOUT");
53 chk_zero(pipe(pipe_fh), "Unable to create pipe to subprocess");
54 filter->pid = chk_non_negative(fork(), "Unable to create subprocess");
55 if (filter->pid == 0) {
57 chk_non_negative(dup2(pipe_fh[0], STDIN_FILENO),
58 "Unable to use pipe as STDIN");
59 execvp(filter->cmd, filter->argv);
60 die_errno("Unable to exec subprocess %s", filter->cmd);
63 chk_non_negative(dup2(pipe_fh[1], STDOUT_FILENO),
64 "Unable to use pipe as STDOUT");
69 static int close_exec_filter(struct cgit_filter *base)
71 struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
72 int i, exit_status = 0;
74 chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO),
75 "Unable to restore STDOUT");
76 close(filter->old_stdout);
79 waitpid(filter->pid, &exit_status, 0);
80 if (WIFEXITED(exit_status))
82 die("Subprocess %s exited abnormally", filter->cmd);
85 for (i = 0; i < filter->base.argument_count; i++)
86 filter->argv[i + 1] = NULL;
87 return WEXITSTATUS(exit_status);
91 static void fprintf_exec_filter(struct cgit_filter *base, FILE *f, const char *prefix)
93 struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
94 fprintf(f, "%sexec:%s\n", prefix, filter->cmd);
97 static void cleanup_exec_filter(struct cgit_filter *base)
99 struct cgit_exec_filter *filter = (struct cgit_exec_filter *)base;
110 static struct cgit_filter *new_exec_filter(const char *cmd, int argument_count)
112 struct cgit_exec_filter *f;
115 f = xmalloc(sizeof(*f));
116 /* We leave argv for now and assign it below. */
117 cgit_exec_filter_init(f, xstrdup(cmd), NULL);
118 f->base.argument_count = argument_count;
119 args_size = (2 + argument_count) * sizeof(char *);
120 f->argv = xmalloc(args_size);
121 memset(f->argv, 0, args_size);
126 void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv)
128 memset(filter, 0, sizeof(*filter));
129 filter->base.open = open_exec_filter;
130 filter->base.close = close_exec_filter;
131 filter->base.fprintf = fprintf_exec_filter;
132 filter->base.cleanup = cleanup_exec_filter;
135 /* The argument count for open_filter is zero by default, unless called from new_filter, above. */
136 filter->base.argument_count = 0;
140 void cgit_init_filters(void)
146 static ssize_t (*libc_write)(int fd, const void *buf, size_t count);
147 static ssize_t (*filter_write)(struct cgit_filter *base, const void *buf, size_t count) = NULL;
148 static struct cgit_filter *current_write_filter = NULL;
150 void cgit_init_filters(void)
152 libc_write = dlsym(RTLD_NEXT, "write");
154 die("Could not locate libc's write function");
157 ssize_t write(int fd, const void *buf, size_t count)
159 if (fd != STDOUT_FILENO || !filter_write)
160 return libc_write(fd, buf, count);
161 return filter_write(current_write_filter, buf, count);
164 static inline void hook_write(struct cgit_filter *filter, ssize_t (*new_write)(struct cgit_filter *base, const void *buf, size_t count))
166 /* We want to avoid buggy nested patterns. */
167 assert(filter_write == NULL);
168 assert(current_write_filter == NULL);
169 current_write_filter = filter;
170 filter_write = new_write;
173 static inline void unhook_write(void)
175 assert(filter_write != NULL);
176 assert(current_write_filter != NULL);
178 current_write_filter = NULL;
182 struct cgit_filter base;
184 lua_State *lua_state;
187 static void error_lua_filter(struct lua_filter *filter)
189 die("Lua error in %s: %s", filter->script_file, lua_tostring(filter->lua_state, -1));
190 lua_pop(filter->lua_state, 1);
193 static ssize_t write_lua_filter(struct cgit_filter *base, const void *buf, size_t count)
195 struct lua_filter *filter = (struct lua_filter *)base;
197 lua_getglobal(filter->lua_state, "filter_write");
198 lua_pushlstring(filter->lua_state, buf, count);
199 if (lua_pcall(filter->lua_state, 1, 0, 0)) {
200 error_lua_filter(filter);
207 static inline int hook_lua_filter(lua_State *lua_state, void (*fn)(const char *txt))
210 ssize_t (*save_filter_write)(struct cgit_filter *base, const void *buf, size_t count);
211 struct cgit_filter *save_filter;
213 str = lua_tostring(lua_state, 1);
217 save_filter_write = filter_write;
218 save_filter = current_write_filter;
221 hook_write(save_filter, save_filter_write);
226 static int html_lua_filter(lua_State *lua_state)
228 return hook_lua_filter(lua_state, html);
231 static int html_txt_lua_filter(lua_State *lua_state)
233 return hook_lua_filter(lua_state, html_txt);
236 static int html_attr_lua_filter(lua_State *lua_state)
238 return hook_lua_filter(lua_state, html_attr);
241 static int html_url_path_lua_filter(lua_State *lua_state)
243 return hook_lua_filter(lua_state, html_url_path);
246 static int html_url_arg_lua_filter(lua_State *lua_state)
248 return hook_lua_filter(lua_state, html_url_arg);
251 static int html_include_lua_filter(lua_State *lua_state)
253 return hook_lua_filter(lua_state, (void (*)(const char *))html_include);
256 static void cleanup_lua_filter(struct cgit_filter *base)
258 struct lua_filter *filter = (struct lua_filter *)base;
260 if (!filter->lua_state)
263 lua_close(filter->lua_state);
264 filter->lua_state = NULL;
265 if (filter->script_file) {
266 free(filter->script_file);
267 filter->script_file = NULL;
271 static int init_lua_filter(struct lua_filter *filter)
273 if (filter->lua_state)
276 if (!(filter->lua_state = luaL_newstate()))
279 luaL_openlibs(filter->lua_state);
281 lua_pushcfunction(filter->lua_state, html_lua_filter);
282 lua_setglobal(filter->lua_state, "html");
283 lua_pushcfunction(filter->lua_state, html_txt_lua_filter);
284 lua_setglobal(filter->lua_state, "html_txt");
285 lua_pushcfunction(filter->lua_state, html_attr_lua_filter);
286 lua_setglobal(filter->lua_state, "html_attr");
287 lua_pushcfunction(filter->lua_state, html_url_path_lua_filter);
288 lua_setglobal(filter->lua_state, "html_url_path");
289 lua_pushcfunction(filter->lua_state, html_url_arg_lua_filter);
290 lua_setglobal(filter->lua_state, "html_url_arg");
291 lua_pushcfunction(filter->lua_state, html_include_lua_filter);
292 lua_setglobal(filter->lua_state, "html_include");
294 if (luaL_dofile(filter->lua_state, filter->script_file)) {
295 error_lua_filter(filter);
296 lua_close(filter->lua_state);
297 filter->lua_state = NULL;
303 static int open_lua_filter(struct cgit_filter *base, va_list ap)
305 struct lua_filter *filter = (struct lua_filter *)base;
308 if (init_lua_filter(filter))
311 hook_write(base, write_lua_filter);
313 lua_getglobal(filter->lua_state, "filter_open");
314 for (i = 0; i < filter->base.argument_count; ++i)
315 lua_pushstring(filter->lua_state, va_arg(ap, char *));
316 if (lua_pcall(filter->lua_state, filter->base.argument_count, 0, 0)) {
317 error_lua_filter(filter);
323 static int close_lua_filter(struct cgit_filter *base)
325 struct lua_filter *filter = (struct lua_filter *)base;
328 lua_getglobal(filter->lua_state, "filter_close");
329 if (lua_pcall(filter->lua_state, 0, 1, 0)) {
330 error_lua_filter(filter);
333 ret = lua_tonumber(filter->lua_state, -1);
334 lua_pop(filter->lua_state, 1);
341 static void fprintf_lua_filter(struct cgit_filter *base, FILE *f, const char *prefix)
343 struct lua_filter *filter = (struct lua_filter *)base;
344 fprintf(f, "%slua:%s\n", prefix, filter->script_file);
348 static struct cgit_filter *new_lua_filter(const char *cmd, int argument_count)
350 struct lua_filter *filter;
352 filter = xmalloc(sizeof(*filter));
353 memset(filter, 0, sizeof(*filter));
354 filter->base.open = open_lua_filter;
355 filter->base.close = close_lua_filter;
356 filter->base.fprintf = fprintf_lua_filter;
357 filter->base.cleanup = cleanup_lua_filter;
358 filter->base.argument_count = argument_count;
359 filter->script_file = xstrdup(cmd);
361 return &filter->base;
367 int cgit_open_filter(struct cgit_filter *filter, ...)
373 va_start(ap, filter);
374 result = filter->open(filter, ap);
379 int cgit_close_filter(struct cgit_filter *filter)
383 return filter->close(filter);
386 void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix)
388 filter->fprintf(filter, f, prefix);
393 static const struct {
395 struct cgit_filter *(*ctor)(const char *cmd, int argument_count);
397 { "exec", new_exec_filter },
399 { "lua", new_lua_filter },
403 struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype)
413 colon = strchr(cmd, ':');
416 * In case we're running on Windows, don't allow a single letter before
422 switch (filtertype) {
446 /* If no prefix is given, exec filter is the default. */
448 return new_exec_filter(cmd, argument_count);
450 for (i = 0; i < ARRAY_SIZE(filter_specs); i++) {
451 if (len == strlen(filter_specs[i].prefix) &&
452 !strncmp(filter_specs[i].prefix, cmd, len))
453 return filter_specs[i].ctor(colon + 1, argument_count);
456 die("Invalid filter type: %.*s", (int) len, cmd);