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