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 <sys/types.h>
 11#include <sys/wait.h>
 12#include <unistd.h>
 13#include <string.h>
 14#include <stdlib.h>
 15#include <dlfcn.h>
 16
 17static ssize_t (*libc_write)(int fd, const void *buf, size_t count);
 18static ssize_t (*filter_write)(struct cgit_filter *base, const void *buf, size_t count) = NULL;
 19static struct cgit_filter *current_write_filter = NULL;
 20
 21static inline void reap_filter(struct cgit_filter *filter)
 22{
 23	if (filter && filter->cleanup)
 24		filter->cleanup(filter);
 25}
 26
 27void cgit_cleanup_filters(void)
 28{
 29	int i;
 30	reap_filter(ctx.cfg.about_filter);
 31	reap_filter(ctx.cfg.commit_filter);
 32	reap_filter(ctx.cfg.source_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	}
 38}
 39
 40void cgit_init_filters(void)
 41{
 42	libc_write = dlsym(RTLD_NEXT, "write");
 43	if (!libc_write)
 44		die("Could not locate libc's write function");
 45}
 46
 47ssize_t write(int fd, const void *buf, size_t count)
 48{
 49	if (fd != STDOUT_FILENO || !filter_write)
 50		return libc_write(fd, buf, count);
 51	return filter_write(current_write_filter, buf, count);
 52}
 53
 54static inline void hook_write(struct cgit_filter *filter, ssize_t (*new_write)(struct cgit_filter *base, const void *buf, size_t count))
 55{
 56	/* We want to avoid buggy nested patterns. */
 57	assert(filter_write == NULL);
 58	assert(current_write_filter == NULL);
 59	current_write_filter = filter;
 60	filter_write = new_write;
 61}
 62
 63static inline void unhook_write()
 64{
 65	assert(filter_write != NULL);
 66	assert(current_write_filter != NULL);
 67	filter_write = NULL;
 68	current_write_filter = NULL;
 69}
 70
 71static int open_exec_filter(struct cgit_filter *base, va_list ap)
 72{
 73	struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
 74	int i;
 75
 76	for (i = 0; i < filter->base.argument_count; i++)
 77		filter->argv[i+1] = va_arg(ap, char *);
 78
 79	filter->old_stdout = chk_positive(dup(STDOUT_FILENO),
 80		"Unable to duplicate STDOUT");
 81	chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess");
 82	filter->pid = chk_non_negative(fork(), "Unable to create subprocess");
 83	if (filter->pid == 0) {
 84		close(filter->pipe_fh[1]);
 85		chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO),
 86			"Unable to use pipe as STDIN");
 87		execvp(filter->cmd, filter->argv);
 88		die_errno("Unable to exec subprocess %s", filter->cmd);
 89	}
 90	close(filter->pipe_fh[0]);
 91	chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO),
 92		"Unable to use pipe as STDOUT");
 93	close(filter->pipe_fh[1]);
 94	return 0;
 95}
 96
 97static int close_exec_filter(struct cgit_filter *base)
 98{
 99	struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
100	int i, exit_status;
101
102	chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO),
103		"Unable to restore STDOUT");
104	close(filter->old_stdout);
105	if (filter->pid < 0)
106		goto done;
107	waitpid(filter->pid, &exit_status, 0);
108	if (WIFEXITED(exit_status) && !WEXITSTATUS(exit_status))
109		goto done;
110	die("Subprocess %s exited abnormally", filter->cmd);
111
112done:
113	for (i = 0; i < filter->base.argument_count; i++)
114		filter->argv[i+1] = NULL;
115	return 0;
116
117}
118
119static void fprintf_exec_filter(struct cgit_filter *base, FILE *f, const char *prefix)
120{
121	struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
122	fprintf(f, "%sexec:%s\n", prefix, filter->cmd);
123}
124
125static void cleanup_exec_filter(struct cgit_filter *base)
126{
127	struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
128	if (filter->argv) {
129		free(filter->argv);
130		filter->argv = NULL;
131	}
132	if (filter->cmd) {
133		free(filter->cmd);
134		filter->cmd = NULL;
135	}
136}
137
138static struct cgit_filter *new_exec_filter(const char *cmd, int argument_count)
139{
140	struct cgit_exec_filter *f;
141	int args_size = 0;
142
143	f = xmalloc(sizeof(*f));
144	/* We leave argv for now and assign it below. */
145	cgit_exec_filter_init(f, xstrdup(cmd), NULL);
146	f->base.argument_count = argument_count;
147	args_size = (2 + argument_count) * sizeof(char *);
148	f->argv = xmalloc(args_size);
149	memset(f->argv, 0, args_size);
150	f->argv[0] = f->cmd;
151	return &f->base;
152}
153
154void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv)
155{
156	memset(filter, 0, sizeof(*filter));
157	filter->base.open = open_exec_filter;
158	filter->base.close = close_exec_filter;
159	filter->base.fprintf = fprintf_exec_filter;
160	filter->base.cleanup = cleanup_exec_filter;
161	filter->cmd = cmd;
162	filter->argv = argv;
163	/* The argument count for open_filter is zero by default, unless called from new_filter, above. */
164	filter->base.argument_count = 0;
165}
166
167int cgit_open_filter(struct cgit_filter *filter, ...)
168{
169	int result;
170	va_list ap;
171	va_start(ap, filter);
172	result = filter->open(filter, ap);
173	va_end(ap);
174	return result;
175}
176
177int cgit_close_filter(struct cgit_filter *filter)
178{
179	return filter->close(filter);
180}
181
182void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix)
183{
184	filter->fprintf(filter, f, prefix);
185}
186
187
188
189static const struct {
190	const char *prefix;
191	struct cgit_filter *(*ctor)(const char *cmd, int argument_count);
192} filter_specs[] = {
193	{ "exec", new_exec_filter },
194};
195
196struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype)
197{
198	char *colon;
199	int i;
200	size_t len;
201	int argument_count;
202
203	if (!cmd || !cmd[0])
204		return NULL;
205
206	colon = strchr(cmd, ':');
207	len = colon - cmd;
208	/*
209	 * In case we're running on Windows, don't allow a single letter before
210	 * the colon.
211	 */
212	if (len == 1)
213		colon = NULL;
214
215	switch (filtertype) {
216		case SOURCE:
217		case ABOUT:
218			argument_count = 1;
219			break;
220
221		case COMMIT:
222		default:
223			argument_count = 0;
224			break;
225	}
226
227	/* If no prefix is given, exec filter is the default. */
228	if (!colon)
229		return new_exec_filter(cmd, argument_count);
230
231	for (i = 0; i < ARRAY_SIZE(filter_specs); i++) {
232		if (len == strlen(filter_specs[i].prefix) &&
233		    !strncmp(filter_specs[i].prefix, cmd, len))
234			return filter_specs[i].ctor(colon + 1, argument_count);
235	}
236
237	die("Invalid filter type: %.*s", (int) len, cmd);
238}