execute_script.c

//#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

#include <sys/select.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>


#include "common.h"
#include "execute_script.h"

int execute_script(
			const char* directory,
			const char* script_name,
			const char*const* appended_params,
			const char*const* params,
			read_t stdin_fn, void* stdin_obj,
			write_t stdout_fn, void* stdout_obj
) {
	const char**	argv = NULL;
	int	ppcount=0;
	int	i;
	int	pcount=0;
	char	script_path[EXECFUSE_MAX_PATHLEN];

	int	child_stdout = -1;
	int	child_stdin = -1;

	int	to_be_written = -1;
	int	to_be_read = -1;

	sigset_t	mask;
	int	childpid = -1;

	if (appended_params) {
		for (i = 0; appended_params[i]; ++i)
			++ppcount;
	}

	if (params) {
		for (i = 0; params[i]; ++i)
			++pcount;
	}

	argv = (const char**)malloc((ppcount + pcount + 2) * sizeof(char*));
	assert(argv != NULL);

	sprintf(script_path, "%s/%s", directory, script_name);

	argv[0] = script_name;
	for (i = 0; i < pcount; ++i)
		argv[i+1] = params[i];
	for (i = 0; i < ppcount; ++i)
		argv[i+1+pcount] = appended_params[i];
	argv[1 + ppcount + pcount]=NULL;

	if (stdin_fn)
		{int p[2]; int ret = pipe(p); assert(ret==0); to_be_written=p[1]; child_stdin =p[0];}
	if (stdout_fn)
		{int p[2]; int ret = pipe(p); assert(ret==0); to_be_read   =p[0]; child_stdout=p[1];}

	sigemptyset(&mask);
	sigaddset(&mask, SIGPIPE);
	sigprocmask(SIG_BLOCK, &mask, NULL);

	childpid = fork();
	if(!childpid) {
		/* in child process */
		if (child_stdout != -1) {
			close(to_be_read);
			dup2(child_stdout, 1);
			close(child_stdout);
		}

		if (child_stdin != -1) {
			close(to_be_written);
			dup2(child_stdin, 0);
			close(child_stdin);
		}

		execv(script_path, (char**)argv);
		_exit(ENOSYS);
	} else {
		/* in parent process */
		int	maxfd = -1;
		int	status, exit_code;
		char	buf[EXECFUSE_CHUNKSIZE];
		fd_set	rfds, wfds;

		if (child_stdout != -1) {
			close(child_stdout);
		}

		if (child_stdin != -1) {
			close(child_stdin);
		}

		/* Event loop for feeding the script with input data, reading output and reading exit code */

		if (to_be_written != -1 && maxfd < to_be_written) maxfd = to_be_written;
		if (to_be_read    != -1 && maxfd < to_be_read   ) maxfd = to_be_read   ;
		++maxfd;

		for (;;) {
			int	ret;

			FD_ZERO(&rfds);
			FD_ZERO(&wfds);

			if (to_be_read    != -1) FD_SET(to_be_read, &rfds);
			if (to_be_written != -1) FD_SET(to_be_written, &wfds);

			if (to_be_read == -1 && to_be_written == -1)
				break;

			ret = select(maxfd+1, &rfds, &wfds, NULL, NULL);

			if (ret == -1) {
				if (errno==EINTR || errno==EAGAIN) continue;
				break;
			}

			if (to_be_read != -1 && FD_ISSET(to_be_read, &rfds)) {
				ret = read(to_be_read, buf, sizeof buf);
				if (ret == -1) {
					if (errno == EINTR || errno==EAGAIN) continue;
				}
				if (ret == 0 || ret == -1) {
					close(to_be_read);
					to_be_read = -1;
				} else {
					int	ret2 = (*stdout_fn)(stdout_obj, buf, ret);
					if (ret2 < ret) {
						close(to_be_read);
						to_be_read = -1;
					}
				}
			}

			if (to_be_written != -1 && FD_ISSET(to_be_written, &wfds)) {
				ret = (*stdin_fn)(stdin_obj, buf, sizeof buf);
				if (ret==-1) {
					if (errno == EINTR || errno==EAGAIN) continue;
				}
				if (!ret || ret == -1) {
					close(to_be_written);
					to_be_written=-1;
				} else {
					ret = write(to_be_written, buf, ret);
					if (ret == -1) {
						if (errno == EINTR || errno==EAGAIN) continue;
						}
					if (ret == 0 || ret == -1) {
						close(to_be_written);
						to_be_read = -1;
					}
				}
			}
		}

		if (to_be_read    != -1) close(to_be_read);
		if (to_be_written != -1) close(to_be_read);

		waitpid(childpid, &status, 0);
		exit_code = WEXITSTATUS(status);

		free(argv);
		return exit_code;
	}
}