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