[ashd.git] / src / callcgi.c

/*
    ashd - A Sane HTTP Daemon
    Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <signal.h>
#include <sys/poll.h>
#include <sys/wait.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <utils.h>
#include <log.h>
#include <req.h>

static char **environ;

static int passdata(FILE *in, FILE *out)
{
    int ret;
    char buf[65536];
    struct pollfd pfds[2];
    
    while(!feof(in)) {
	memset(pfds, 0, sizeof(struct pollfd) * 2);
	pfds[0].fd = fileno(in);
	pfds[0].events = POLLIN;
	pfds[1].fd = fileno(out);
	pfds[1].events = POLLHUP;
	ret = poll(pfds, 2, -1);
	if(ret < 0) {
	    if(errno != EINTR) {
		flog(LOG_ERR, "callcgi: error in poll: %s", strerror(errno));
		return(1);
	    }
	}
	if(ret > 0) {
	    if(pfds[0].revents & (POLLIN | POLLERR | POLLHUP)) {
		ret = fread(buf, 1, 65536, in);
		if(ferror(in)) {
		    flog(LOG_ERR, "callcgi: could not read input: %s", strerror(errno));
		    return(1);
		}
		if(fwrite(buf, 1, ret, out) != ret) {
		    if(errno != EPIPE)
			flog(LOG_ERR, "callcgi: could not write output: %s", strerror(errno));
		    return(1);
		}
	    }
	    if(pfds[1].revents & POLLHUP)
		return(1);
	}
    }
    return(0);
}

static char *absolutify(char *file)
{
    char cwd[1024];
    
    if(*file != '/') {
	getcwd(cwd, sizeof(cwd));
	return(sprintf2("%s/%s", cwd, file));
    }
    return(sstrdup(file));
}

static pid_t forkchild(int inpath, char **prog, char *file, char *method, char *url, char *rest, int *infd, int *outfd)
{
    char *qp, **env, *name;
    int inp[2], outp[2];
    pid_t pid;
    char *pi;
    int (*execfun)(const char *, char *const []);

    pipe(inp);
    pipe(outp);
    if((pid = fork()) < 0) {
	flog(LOG_ERR, "callcgi: could not fork");
	exit(1);
    }
    if(pid == 0) {
	dup2(inp[0], 0);
	dup2(outp[1], 1);
	close(inp[0]);
	close(inp[1]);
	close(outp[0]);
	close(outp[1]);
	if((qp = strchr(url, '?')) != NULL)
	    *(qp++) = 0;
	putenv(sprintf2("SERVER_SOFTWARE=ashd/%s", VERSION));
	putenv("GATEWAY_INTERFACE=CGI/1.1");
	if(getenv("HTTP_VERSION"))
	    putenv(sprintf2("SERVER_PROTOCOL=%s", getenv("HTTP_VERSION")));
	putenv(sprintf2("REQUEST_METHOD=%s", method));
	name = url;
	/* XXX: This is an ugly hack (I think), but though I can think
	 * of several alternatives, none seem to be better. */
	if(*rest && (strlen(url) >= strlen(rest)) &&
	   !strcmp(rest, url + strlen(url) - strlen(rest))) {
	    name = sprintf2("%.*s", (int)(strlen(url) - strlen(rest)), url);
	}
	if((pi = unquoteurl(rest)) == NULL)
	    pi = rest;
	if(!strcmp(name, "/")) {
	    /*
	     * Normal CGI behavior appears to be to always let
	     * PATH_INFO begin with a slash and never let SCRIPT_NAME
	     * end with one. That conflicts, however, with some
	     * behaviors, such as "mounting" CGI applications on a
	     * directory element of the URI space -- a handler
	     * responding to "/foo/" would not be able to tell that it
	     * is not called "/foo", which makes a large difference,
	     * not least in relation to URI reconstruction and
	     * redirections. A common practical case is CGI-handled
	     * index files in directories. Therefore, this only
	     * handles the nonconditional case of the root directory
	     * and leaves other decisions to the previous handler
	     * handing over the request to callcgi. It is unclear if
	     * there is a better way to handle the problem.
	     */
	    name[0] = 0;
	    pi = sprintf2("/%s", pi);
	}
	putenv(sprintf2("PATH_INFO=%s", pi));
	putenv(sprintf2("SCRIPT_NAME=%s", name));
	putenv(sprintf2("QUERY_STRING=%s", qp?qp:""));
	if(getenv("REQ_HOST"))
	    putenv(sprintf2("SERVER_NAME=%s", getenv("REQ_HOST")));
	if(getenv("REQ_X_ASH_SERVER_ADDRESS"))
	    putenv(sprintf2("SERVER_ADDR=%s", getenv("REQ_X_ASH_SERVER_ADDRESS")));
	if(getenv("REQ_X_ASH_SERVER_PORT"))
	    putenv(sprintf2("SERVER_PORT=%s", getenv("REQ_X_ASH_SERVER_PORT")));
	if(getenv("REQ_X_ASH_PROTOCOL") && !strcmp(getenv("REQ_X_ASH_PROTOCOL"), "https"))
	    putenv("HTTPS=on");
	if(getenv("REQ_X_ASH_ADDRESS"))
	    putenv(sprintf2("REMOTE_ADDR=%s", getenv("REQ_X_ASH_ADDRESS")));
	if(getenv("REQ_X_ASH_PORT"))
	    putenv(sprintf2("REMOTE_PORT=%s", getenv("REQ_X_ASH_PORT")));
	if(getenv("REQ_X_ASH_REMOTE_USER"))
	    putenv(sprintf2("REMOTE_USER=%s", getenv("REQ_X_ASH_REMOTE_USER")));
	if(getenv("REQ_CONTENT_TYPE"))
	    putenv(sprintf2("CONTENT_TYPE=%s", getenv("REQ_CONTENT_TYPE")));
	if(getenv("REQ_CONTENT_LENGTH"))
	    putenv(sprintf2("CONTENT_LENGTH=%s", getenv("REQ_CONTENT_LENGTH")));
	for(env = environ; *env; env++) {
	    if(!strncmp(*env, "REQ_", 4))
		putenv(sprintf2("HTTP_%s", (*env) + 4));
	}
	/*
	 * This is (understandably) missing from the CGI
	 * specification, but PHP seems to require it.
	 */
	execfun = inpath?execvp:execv;
	if(file != NULL)
	    putenv(sprintf2("SCRIPT_FILENAME=%s", absolutify(file)));
	execfun(prog[0], prog);
	exit(127);
    }
    close(inp[0]);
    close(outp[1]);
    *infd = inp[1];
    *outfd = outp[0];
    return(pid);
}

static void trim(struct charbuf *buf)
{
    char *p;
    
    for(p = buf->b; (p - buf->b < buf->d) && isspace(*p); p++);
    memmove(buf->b, p, buf->d -= (p - buf->b));
    for(p = buf->b + buf->d - 1; (p > buf->b) && isspace(*p); p--, buf->d--);
}

static char **parsecgiheaders(FILE *s)
{
    int c, state;
    struct charvbuf hbuf;
    struct charbuf buf;
    
    bufinit(hbuf);
    bufinit(buf);
    state = 0;
    while(1) {
	c = fgetc(s);
    again:
	if(state == 0) {
	    if(c == '\r') {
	    } else if(c == '\n') {
		break;
	    } else if(c == EOF) {
		goto fail;
	    } else {
		state = 1;
		goto again;
	    }
	} else if(state == 1) {
	    if(c == ':') {
		trim(&buf);
		bufadd(buf, 0);
		bufadd(hbuf, buf.b);
		bufinit(buf);
		state = 2;
	    } else if(c == '\r') {
	    } else if(c == '\n') {
		goto fail;
	    } else if(c == EOF) {
		goto fail;
	    } else {
		bufadd(buf, c);
	    }
	} else if(state == 2) {
	    if(c == '\r') {
	    } else if(c == '\n') {
		trim(&buf);
		bufadd(buf, 0);
		bufadd(hbuf, buf.b);
		bufinit(buf);
		state = 0;
	    } else if(c == EOF) {
		goto fail;
	    } else {
		bufadd(buf, c);
	    }
	}
    }
    bufadd(hbuf, NULL);
    return(hbuf.b);
    
fail:
    buffree(hbuf);
    buffree(buf);
    return(NULL);
}

static char *defstatus(int code)
{
    if(code == 200)
	return("OK");
    else if(code == 201)
	return("Created");
    else if(code == 202)
	return("Accepted");
    else if(code == 204)
	return("No Content");
    else if(code == 300)
	return("Multiple Choices");
    else if(code == 301)
	return("Moved Permanently");
    else if(code == 302)
	return("Found");
    else if(code == 303)
	return("See Other");
    else if(code == 304)
	return("Not Modified");
    else if(code == 307)
	return("Moved Temporarily");
    else if(code == 400)
	return("Bad Request");
    else if(code == 401)
	return("Unauthorized");
    else if(code == 403)
	return("Forbidden");
    else if(code == 404)
	return("Not Found");
    else if(code == 500)
	return("Internal Server Error");
    else if(code == 501)
	return("Not Implemented");
    else if(code == 503)
	return("Service Unavailable");
    else
	return("Unknown status");
}

static void sendstatus(char **headers, FILE *out)
{
    char **hp;
    char *status, *location;
    
    hp = headers;
    status = location = NULL;
    while(*hp) {
	if(!strcasecmp(hp[0], "status")) {
	    status = hp[1];
	    /* Clear this header, so that it is not transmitted by sendheaders. */
	    **hp = 0;
	} else if(!strcasecmp(hp[0], "location")) {
	    location = hp[1];
	    hp += 2;
	} else {
	    hp += 2;
	}
    }
    if(status) {
	if(strchr(status, ' '))
	    fprintf(out, "HTTP/1.1 %s\n", status);
	else
	    fprintf(out, "HTTP/1.1 %i %s\n", atoi(status), defstatus(atoi(status)));
    } else if(location) {
	fprintf(out, "HTTP/1.1 303 See Other\n");
    } else {
	fprintf(out, "HTTP/1.1 200 OK\n");
    }
}

static void sendheaders(char **headers, FILE *out)
{
    while(*headers) {
	if(**headers)
	    fprintf(out, "%s: %s\n", headers[0], headers[1]);
	headers += 2;
    }
}

static void usage(void)
{
    flog(LOG_ERR, "usage: callcgi [-c] [-p PROGRAM] [-P PROGRAM ARGS... ;] METHOD URL REST");
}

int main(int argc, char **argv, char **envp)
{
    int c;
    char *file, *sp;
    struct charvbuf prog;
    int inpath, addfile, cd;
    int infd, outfd;
    FILE *in, *out;
    char **headers;
    pid_t child;
    int estat;
    
    environ = envp;
    signal(SIGPIPE, SIG_IGN);
    
    bufinit(prog);
    inpath = 0;
    addfile = 1;
    cd = 0;
    while((c = getopt(argc, argv, "cp:P:")) >= 0) {
	switch(c) {
	case 'c':
	    cd = 1;
	    break;
	case 'p':
	    bufadd(prog, optarg);
	    inpath = 1;
	    break;
	case 'P':
	    prog.d = 0;
	    bufadd(prog, optarg);
	    while(1) {
		if(optind >= argc) {
		    flog(LOG_ERR, "callcgi: unterminated argument list for -P");
		    exit(1);
		}
		if(!strcmp(argv[optind], ";")) {
		    optind++;
		    break;
		}
		bufadd(prog, argv[optind++]);
	    }
	    if(prog.d == 0) {
		flog(LOG_ERR, "callcgi: -P option needs at least a program name");
		exit(1);
	    }
	    inpath = 1;
	    addfile = 0;
	    break;
	default:
	    usage();
	    exit(1);
	}
    }
    
    if(argc - optind < 3) {
	usage();
	exit(1);
    }
    if(((file = getenv("REQ_X_ASH_FILE")) == NULL) && (prog.d == 0)) {
	flog(LOG_ERR, "callcgi: needs to be called with the X-Ash-File header");
	exit(1);
    }
    
    if(cd) {
	/* This behavior is encouraged by the CGI specification (RFC 3875, 7.2),
	 * but not strictly required, and I get the feeling it might break some
	 * relative paths here or there, so it's not the default for now. */
	if((sp = strrchr(file, '/')) != NULL) {
	    *sp = 0;
	    if(chdir(file)) {
		*sp = '/';
	    } else {
		file = sp + 1;
	    }
	}
    }
    
    if(prog.d == 0)
	bufadd(prog, file);
    if(addfile && (file != NULL))
	bufadd(prog, file);
    bufadd(prog, NULL);
    child = forkchild(inpath, prog.b, file, argv[optind], argv[optind + 1], argv[optind + 2], &infd, &outfd);
    in = fdopen(infd, "w");
    passdata(stdin, in);	/* Ignore errors, perhaps? */
    fclose(in);
    out = fdopen(outfd, "r");
    if((headers = parsecgiheaders(out)) == NULL) {
	flog(LOG_WARNING, "CGI handler returned invalid headers");
	exit(1);
    }
    sendstatus(headers, stdout);
    sendheaders(headers, stdout);
    printf("\n");
    if(passdata(out, stdout))
	kill(child, SIGINT);
    if(waitpid(child, &estat, 0) == child) {
	if(WCOREDUMP(estat))
	    flog(LOG_WARNING, "CGI handler `%s' dumped core", prog.b[0]);
	if(WIFEXITED(estat) && !WEXITSTATUS(estat))
	    return(0);
	else
	    return(1);
    }
    flog(LOG_WARNING, "could not wait for CGI handler: %s", strerror(errno));
    return(1);
}
Commit	Line	Data
	1	/*
	2	ashd - A Sane HTTP Daemon
	3	Copyright (C) 2008 Fredrik Tolf <fredrik@dolda2000.com>
	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation, either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#include <stdlib.h>
	20	#include <string.h>
	21	#include <stdio.h>
	22	#include <unistd.h>
	23	#include <errno.h>
	24	#include <ctype.h>
	25	#include <signal.h>
	26	#include <sys/poll.h>
	27	#include <sys/wait.h>
	28
	29	#ifdef HAVE_CONFIG_H
	30	#include <config.h>
	31	#endif
	32	#include <utils.h>
	33	#include <log.h>
	34	#include <req.h>
	35
	36	static char **environ;
	37
	38	static int passdata(FILE in, FILE out)
	39	{
	40	int ret;
	41	char buf[65536];
	42	struct pollfd pfds[2];
	43
	44	while(!feof(in)) {
	45	memset(pfds, 0, sizeof(struct pollfd) * 2);
	46	pfds[0].fd = fileno(in);
	47	pfds[0].events = POLLIN;
	48	pfds[1].fd = fileno(out);
	49	pfds[1].events = POLLHUP;
	50	ret = poll(pfds, 2, -1);
	51	if(ret < 0) {
	52	if(errno != EINTR) {
	53	flog(LOG_ERR, "callcgi: error in poll: %s", strerror(errno));
	54	return(1);
	55	}
	56	}
	57	if(ret > 0) {
	58	if(pfds[0].revents & (POLLIN \| POLLERR \| POLLHUP)) {
	59	ret = fread(buf, 1, 65536, in);
	60	if(ferror(in)) {
	61	flog(LOG_ERR, "callcgi: could not read input: %s", strerror(errno));
	62	return(1);
	63	}
	64	if(fwrite(buf, 1, ret, out) != ret) {
	65	if(errno != EPIPE)
	66	flog(LOG_ERR, "callcgi: could not write output: %s", strerror(errno));
	67	return(1);
	68	}
	69	}
	70	if(pfds[1].revents & POLLHUP)
	71	return(1);
	72	}
	73	}
	74	return(0);
	75	}
	76
	77	static char absolutify(char file)
	78	{
	79	char cwd[1024];
	80
	81	if(*file != '/') {
	82	getcwd(cwd, sizeof(cwd));
	83	return(sprintf2("%s/%s", cwd, file));
	84	}
	85	return(sstrdup(file));
	86	}
	87
	88	static pid_t forkchild(int inpath, char *prog, char file, char method, char url, char rest, int infd, int *outfd)
	89	{
	90	char qp, env, name;
	91	int inp[2], outp[2];
	92	pid_t pid;
	93	char *pi;
	94	int (execfun)(const char , char *const []);
	95
	96	pipe(inp);
	97	pipe(outp);
	98	if((pid = fork()) < 0) {
	99	flog(LOG_ERR, "callcgi: could not fork");
	100	exit(1);
	101	}
	102	if(pid == 0) {
	103	dup2(inp[0], 0);
	104	dup2(outp[1], 1);
	105	close(inp[0]);
	106	close(inp[1]);
	107	close(outp[0]);
	108	close(outp[1]);
	109	if((qp = strchr(url, '?')) != NULL)
	110	*(qp++) = 0;
	111	putenv(sprintf2("SERVER_SOFTWARE=ashd/%s", VERSION));
	112	putenv("GATEWAY_INTERFACE=CGI/1.1");
	113	if(getenv("HTTP_VERSION"))
	114	putenv(sprintf2("SERVER_PROTOCOL=%s", getenv("HTTP_VERSION")));
	115	putenv(sprintf2("REQUEST_METHOD=%s", method));
	116	name = url;
	117	/* XXX: This is an ugly hack (I think), but though I can think
	118	* of several alternatives, none seem to be better. */
	119	if(*rest && (strlen(url) >= strlen(rest)) &&
	120	!strcmp(rest, url + strlen(url) - strlen(rest))) {
	121	name = sprintf2("%.*s", (int)(strlen(url) - strlen(rest)), url);
	122	}
	123	if((pi = unquoteurl(rest)) == NULL)
	124	pi = rest;
	125	if(!strcmp(name, "/")) {
	126	/*
	127	* Normal CGI behavior appears to be to always let
	128	* PATH_INFO begin with a slash and never let SCRIPT_NAME
	129	* end with one. That conflicts, however, with some
	130	* behaviors, such as "mounting" CGI applications on a
	131	* directory element of the URI space -- a handler
	132	* responding to "/foo/" would not be able to tell that it
	133	* is not called "/foo", which makes a large difference,
	134	* not least in relation to URI reconstruction and
	135	* redirections. A common practical case is CGI-handled
	136	* index files in directories. Therefore, this only
	137	* handles the nonconditional case of the root directory
	138	* and leaves other decisions to the previous handler
	139	* handing over the request to callcgi. It is unclear if
	140	* there is a better way to handle the problem.
	141	*/
	142	name[0] = 0;
	143	pi = sprintf2("/%s", pi);
	144	}
	145	putenv(sprintf2("PATH_INFO=%s", pi));
	146	putenv(sprintf2("SCRIPT_NAME=%s", name));
	147	putenv(sprintf2("QUERY_STRING=%s", qp?qp:""));
	148	if(getenv("REQ_HOST"))
	149	putenv(sprintf2("SERVER_NAME=%s", getenv("REQ_HOST")));
	150	if(getenv("REQ_X_ASH_SERVER_ADDRESS"))
	151	putenv(sprintf2("SERVER_ADDR=%s", getenv("REQ_X_ASH_SERVER_ADDRESS")));
	152	if(getenv("REQ_X_ASH_SERVER_PORT"))
	153	putenv(sprintf2("SERVER_PORT=%s", getenv("REQ_X_ASH_SERVER_PORT")));
	154	if(getenv("REQ_X_ASH_PROTOCOL") && !strcmp(getenv("REQ_X_ASH_PROTOCOL"), "https"))
	155	putenv("HTTPS=on");
	156	if(getenv("REQ_X_ASH_ADDRESS"))
	157	putenv(sprintf2("REMOTE_ADDR=%s", getenv("REQ_X_ASH_ADDRESS")));
	158	if(getenv("REQ_X_ASH_PORT"))
	159	putenv(sprintf2("REMOTE_PORT=%s", getenv("REQ_X_ASH_PORT")));
	160	if(getenv("REQ_X_ASH_REMOTE_USER"))
	161	putenv(sprintf2("REMOTE_USER=%s", getenv("REQ_X_ASH_REMOTE_USER")));
	162	if(getenv("REQ_CONTENT_TYPE"))
	163	putenv(sprintf2("CONTENT_TYPE=%s", getenv("REQ_CONTENT_TYPE")));
	164	if(getenv("REQ_CONTENT_LENGTH"))
	165	putenv(sprintf2("CONTENT_LENGTH=%s", getenv("REQ_CONTENT_LENGTH")));
	166	for(env = environ; *env; env++) {
	167	if(!strncmp(*env, "REQ_", 4))
	168	putenv(sprintf2("HTTP_%s", (*env) + 4));
	169	}
	170	/*
	171	* This is (understandably) missing from the CGI
	172	* specification, but PHP seems to require it.
	173	*/
	174	execfun = inpath?execvp:execv;
	175	if(file != NULL)
	176	putenv(sprintf2("SCRIPT_FILENAME=%s", absolutify(file)));
	177	execfun(prog[0], prog);
	178	exit(127);
	179	}
	180	close(inp[0]);
	181	close(outp[1]);
	182	*infd = inp[1];
	183	*outfd = outp[0];
	184	return(pid);
	185	}
	186
	187	static void trim(struct charbuf *buf)
	188	{
	189	char *p;
	190
	191	for(p = buf->b; (p - buf->b < buf->d) && isspace(*p); p++);
	192	memmove(buf->b, p, buf->d -= (p - buf->b));
	193	for(p = buf->b + buf->d - 1; (p > buf->b) && isspace(*p); p--, buf->d--);
	194	}
	195
	196	static char *parsecgiheaders(FILE s)
	197	{
	198	int c, state;
	199	struct charvbuf hbuf;
	200	struct charbuf buf;
	201
	202	bufinit(hbuf);
	203	bufinit(buf);
	204	state = 0;
	205	while(1) {
	206	c = fgetc(s);
	207	again:
	208	if(state == 0) {
	209	if(c == '\r') {
	210	} else if(c == '\n') {
	211	break;
	212	} else if(c == EOF) {
	213	goto fail;
	214	} else {
	215	state = 1;
	216	goto again;
	217	}
	218	} else if(state == 1) {
	219	if(c == ':') {
	220	trim(&buf);
	221	bufadd(buf, 0);
	222	bufadd(hbuf, buf.b);
	223	bufinit(buf);
	224	state = 2;
	225	} else if(c == '\r') {
	226	} else if(c == '\n') {
	227	goto fail;
	228	} else if(c == EOF) {
	229	goto fail;
	230	} else {
	231	bufadd(buf, c);
	232	}
	233	} else if(state == 2) {
	234	if(c == '\r') {
	235	} else if(c == '\n') {
	236	trim(&buf);
	237	bufadd(buf, 0);
	238	bufadd(hbuf, buf.b);
	239	bufinit(buf);
	240	state = 0;
	241	} else if(c == EOF) {
	242	goto fail;
	243	} else {
	244	bufadd(buf, c);
	245	}
	246	}
	247	}
	248	bufadd(hbuf, NULL);
	249	return(hbuf.b);
	250
	251	fail:
	252	buffree(hbuf);
	253	buffree(buf);
	254	return(NULL);
	255	}
	256
	257	static char *defstatus(int code)
	258	{
	259	if(code == 200)
	260	return("OK");
	261	else if(code == 201)
	262	return("Created");
	263	else if(code == 202)
	264	return("Accepted");
	265	else if(code == 204)
	266	return("No Content");
	267	else if(code == 300)
	268	return("Multiple Choices");
	269	else if(code == 301)
	270	return("Moved Permanently");
	271	else if(code == 302)
	272	return("Found");
	273	else if(code == 303)
	274	return("See Other");
	275	else if(code == 304)
	276	return("Not Modified");
	277	else if(code == 307)
	278	return("Moved Temporarily");
	279	else if(code == 400)
	280	return("Bad Request");
	281	else if(code == 401)
	282	return("Unauthorized");
	283	else if(code == 403)
	284	return("Forbidden");
	285	else if(code == 404)
	286	return("Not Found");
	287	else if(code == 500)
	288	return("Internal Server Error");
	289	else if(code == 501)
	290	return("Not Implemented");
	291	else if(code == 503)
	292	return("Service Unavailable");
	293	else
	294	return("Unknown status");
	295	}
	296
	297	static void sendstatus(char *headers, FILE out)
	298	{
	299	char **hp;
	300	char status, location;
	301
	302	hp = headers;
	303	status = location = NULL;
	304	while(*hp) {
	305	if(!strcasecmp(hp[0], "status")) {
	306	status = hp[1];
	307	/* Clear this header, so that it is not transmitted by sendheaders. */
	308	**hp = 0;
	309	} else if(!strcasecmp(hp[0], "location")) {
	310	location = hp[1];
	311	hp += 2;
	312	} else {
	313	hp += 2;
	314	}
	315	}
	316	if(status) {
	317	if(strchr(status, ' '))
	318	fprintf(out, "HTTP/1.1 %s\n", status);
	319	else
	320	fprintf(out, "HTTP/1.1 %i %s\n", atoi(status), defstatus(atoi(status)));
	321	} else if(location) {
	322	fprintf(out, "HTTP/1.1 303 See Other\n");
	323	} else {
	324	fprintf(out, "HTTP/1.1 200 OK\n");
	325	}
	326	}
	327
	328	static void sendheaders(char *headers, FILE out)
	329	{
	330	while(*headers) {
	331	if(**headers)
	332	fprintf(out, "%s: %s\n", headers[0], headers[1]);
	333	headers += 2;
	334	}
	335	}
	336
	337	static void usage(void)
	338	{
	339	flog(LOG_ERR, "usage: callcgi [-c] [-p PROGRAM] [-P PROGRAM ARGS... ;] METHOD URL REST");
	340	}
	341
	342	int main(int argc, char argv, char envp)
	343	{
	344	int c;
	345	char file, sp;
	346	struct charvbuf prog;
	347	int inpath, addfile, cd;
	348	int infd, outfd;
	349	FILE in, out;
	350	char **headers;
	351	pid_t child;
	352	int estat;
	353
	354	environ = envp;
	355	signal(SIGPIPE, SIG_IGN);
	356
	357	bufinit(prog);
	358	inpath = 0;
	359	addfile = 1;
	360	cd = 0;
	361	while((c = getopt(argc, argv, "cp:P:")) >= 0) {
	362	switch(c) {
	363	case 'c':
	364	cd = 1;
	365	break;
	366	case 'p':
	367	bufadd(prog, optarg);
	368	inpath = 1;
	369	break;
	370	case 'P':
	371	prog.d = 0;
	372	bufadd(prog, optarg);
	373	while(1) {
	374	if(optind >= argc) {
	375	flog(LOG_ERR, "callcgi: unterminated argument list for -P");
	376	exit(1);
	377	}
	378	if(!strcmp(argv[optind], ";")) {
	379	optind++;
	380	break;
	381	}
	382	bufadd(prog, argv[optind++]);
	383	}
	384	if(prog.d == 0) {
	385	flog(LOG_ERR, "callcgi: -P option needs at least a program name");
	386	exit(1);
	387	}
	388	inpath = 1;
	389	addfile = 0;
	390	break;
	391	default:
	392	usage();
	393	exit(1);
	394	}
	395	}
	396
	397	if(argc - optind < 3) {
	398	usage();
	399	exit(1);
	400	}
	401	if(((file = getenv("REQ_X_ASH_FILE")) == NULL) && (prog.d == 0)) {
	402	flog(LOG_ERR, "callcgi: needs to be called with the X-Ash-File header");
	403	exit(1);
	404	}
	405
	406	if(cd) {
	407	/* This behavior is encouraged by the CGI specification (RFC 3875, 7.2),
	408	* but not strictly required, and I get the feeling it might break some
	409	* relative paths here or there, so it's not the default for now. */
	410	if((sp = strrchr(file, '/')) != NULL) {
	411	*sp = 0;
	412	if(chdir(file)) {
	413	*sp = '/';
	414	} else {
	415	file = sp + 1;
	416	}
	417	}
	418	}
	419
	420	if(prog.d == 0)
	421	bufadd(prog, file);
	422	if(addfile && (file != NULL))
	423	bufadd(prog, file);
	424	bufadd(prog, NULL);
	425	child = forkchild(inpath, prog.b, file, argv[optind], argv[optind + 1], argv[optind + 2], &infd, &outfd);
	426	in = fdopen(infd, "w");
	427	passdata(stdin, in); /* Ignore errors, perhaps? */
	428	fclose(in);
	429	out = fdopen(outfd, "r");
	430	if((headers = parsecgiheaders(out)) == NULL) {
	431	flog(LOG_WARNING, "CGI handler returned invalid headers");
	432	exit(1);
	433	}
	434	sendstatus(headers, stdout);
	435	sendheaders(headers, stdout);
	436	printf("\n");
	437	if(passdata(out, stdout))
	438	kill(child, SIGINT);
	439	if(waitpid(child, &estat, 0) == child) {
	440	if(WCOREDUMP(estat))
	441	flog(LOG_WARNING, "CGI handler `%s' dumped core", prog.b[0]);
	442	if(WIFEXITED(estat) && !WEXITSTATUS(estat))
	443	return(0);
	444	else
	445	return(1);
	446	}
	447	flog(LOG_WARNING, "could not wait for CGI handler: %s", strerror(errno));
	448	return(1);
	449	}