mirror of
https://git.zx2c4.com/cgit
synced 2024-09-19 01:05:19 +00:00
7bd90b8048
Change the existing cgit_{open,close,fprintf}_filter functions to
delegate to filter-specific implementations accessed via function
pointers on the cgit_filter object.
We treat the "exec" filter type slightly specially here by putting its
structure definition in the header file and providing an "init" function
to set up the function pointers. This is required so that the
ui-snapshot.c code that applies a compression filter can continue to use
the filter interface to do so.
Signed-off-by: John Keeping <john@keeping.me.uk>
135 lines
3.3 KiB
C
135 lines
3.3 KiB
C
/* filter.c: filter framework functions
|
|
*
|
|
* Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
|
|
*
|
|
* Licensed under GNU General Public License v2
|
|
* (see COPYING for full license text)
|
|
*/
|
|
|
|
#include "cgit.h"
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
static int open_exec_filter(struct cgit_filter *base, va_list ap)
|
|
{
|
|
struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
|
|
int i;
|
|
|
|
for (i = 0; i < filter->extra_args; i++)
|
|
filter->argv[i+1] = va_arg(ap, char *);
|
|
|
|
filter->old_stdout = chk_positive(dup(STDOUT_FILENO),
|
|
"Unable to duplicate STDOUT");
|
|
chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess");
|
|
filter->pid = chk_non_negative(fork(), "Unable to create subprocess");
|
|
if (filter->pid == 0) {
|
|
close(filter->pipe_fh[1]);
|
|
chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO),
|
|
"Unable to use pipe as STDIN");
|
|
execvp(filter->cmd, filter->argv);
|
|
die_errno("Unable to exec subprocess %s", filter->cmd);
|
|
}
|
|
close(filter->pipe_fh[0]);
|
|
chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO),
|
|
"Unable to use pipe as STDOUT");
|
|
close(filter->pipe_fh[1]);
|
|
return 0;
|
|
}
|
|
|
|
static int close_exec_filter(struct cgit_filter *base)
|
|
{
|
|
struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
|
|
int i, exit_status;
|
|
|
|
chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO),
|
|
"Unable to restore STDOUT");
|
|
close(filter->old_stdout);
|
|
if (filter->pid < 0)
|
|
goto done;
|
|
waitpid(filter->pid, &exit_status, 0);
|
|
if (WIFEXITED(exit_status) && !WEXITSTATUS(exit_status))
|
|
goto done;
|
|
die("Subprocess %s exited abnormally", filter->cmd);
|
|
|
|
done:
|
|
for (i = 0; i < filter->extra_args; i++)
|
|
filter->argv[i+1] = NULL;
|
|
return 0;
|
|
|
|
}
|
|
|
|
static void fprintf_exec_filter(struct cgit_filter *base, FILE *f, const char *prefix)
|
|
{
|
|
struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
|
|
fprintf(f, "%s%s\n", prefix, filter->cmd);
|
|
}
|
|
|
|
int cgit_open_filter(struct cgit_filter *filter, ...)
|
|
{
|
|
int result;
|
|
va_list ap;
|
|
va_start(ap, filter);
|
|
result = filter->open(filter, ap);
|
|
va_end(ap);
|
|
return result;
|
|
}
|
|
|
|
int cgit_close_filter(struct cgit_filter *filter)
|
|
{
|
|
return filter->close(filter);
|
|
}
|
|
|
|
void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix)
|
|
{
|
|
filter->fprintf(filter, f, prefix);
|
|
}
|
|
|
|
void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv)
|
|
{
|
|
memset(filter, 0, sizeof(*filter));
|
|
filter->base.open = open_exec_filter;
|
|
filter->base.close = close_exec_filter;
|
|
filter->base.fprintf = fprintf_exec_filter;
|
|
filter->cmd = cmd;
|
|
filter->argv = argv;
|
|
}
|
|
|
|
static struct cgit_filter *new_exec_filter(const char *cmd, filter_type filtertype)
|
|
{
|
|
struct cgit_exec_filter *f;
|
|
int args_size = 0;
|
|
|
|
f = xmalloc(sizeof(*f));
|
|
/* We leave argv for now and assign it below. */
|
|
cgit_exec_filter_init(f, xstrdup(cmd), NULL);
|
|
|
|
switch (filtertype) {
|
|
case SOURCE:
|
|
case ABOUT:
|
|
f->extra_args = 1;
|
|
break;
|
|
|
|
case COMMIT:
|
|
default:
|
|
f->extra_args = 0;
|
|
break;
|
|
}
|
|
|
|
args_size = (2 + f->extra_args) * sizeof(char *);
|
|
f->argv = xmalloc(args_size);
|
|
memset(f->argv, 0, args_size);
|
|
f->argv[0] = f->cmd;
|
|
return &f->base;
|
|
}
|
|
|
|
struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype)
|
|
{
|
|
if (!cmd || !cmd[0])
|
|
return NULL;
|
|
|
|
return new_exec_filter(cmd, filtertype);
|
|
}
|