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