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