[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>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <utils.h>
#include <log.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) {
		    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)
{
    int i;
    char *qp, **env, *name;
    int inp[2], outp[2];
    pid_t pid;

    pipe(inp);
    pipe(outp);
    if((pid = fork()) < 0) {
	flog(LOG_ERR, "callcgi: could not fork");
	exit(1);
    }
    if(pid == 0) {
	close(inp[1]);
	close(outp[0]);
	dup2(inp[0], 0);
	dup2(outp[1], 1);
	for(i = 3; i < FD_SETSIZE; i++)
	    close(i);
	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));
	putenv(sprintf2("PATH_INFO=%s", rest));
	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);
	}
	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_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_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.
	 */
	putenv(sprintf2("SCRIPT_FILENAME=%s", absolutify(file)));
	if(inpath)
	    execlp(prog, prog, file, NULL);
	else
	    execl(prog, prog, file, NULL);
	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 **parseheaders(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] METHOD URL REST");
}

int main(int argc, char **argv, char **envp)
{
    int c;
    char *file, *prog, *sp;
    int inpath, cd;
    int infd, outfd;
    FILE *in, *out;
    char **headers;
    pid_t child;
    
    environ = envp;
    signal(SIGPIPE, SIG_IGN);
    
    prog = NULL;
    inpath = 0;
    cd = 0;
    while((c = getopt(argc, argv, "cp:")) >= 0) {
	switch(c) {
	case 'c':
	    cd = 1;
	    break;
	case 'p':
	    prog = optarg;
	    inpath = 1;
	    break;
	default:
	    usage();
	    exit(1);
	}
    }
    
    if(argc - optind < 3) {
	usage();
	exit(1);
    }
    if((file = getenv("REQ_X_ASH_FILE")) == NULL) {
	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 == NULL)
	prog = file;
    child = forkchild(inpath, prog, 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 = parseheaders(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);
    return(0);
}
Commit	Line	Data
8cc51634 FT	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>
df96b222	26	#include <sys/poll.h>
8cc51634 FT	27
	28	#ifdef HAVE_CONFIG_H
	29	#include <config.h>
	30	#endif
	31	#include <utils.h>
	32	#include <log.h>
	33
	34	static char **environ;
	35
df96b222	36	static int passdata(FILE in, FILE out)
8cc51634 FT	37	{
8cc51634 FT	38	int ret;
df96b222 FT	39	char buf[65536];
df96b222 FT	40	struct pollfd pfds[2];
8cc51634	41
8cc51634	42	while(!feof(in)) {
df96b222 FT	43	memset(pfds, 0, sizeof(struct pollfd) * 2);
	44	pfds[0].fd = fileno(in);
	45	pfds[0].events = POLLIN;
	46	pfds[1].fd = fileno(out);
	47	pfds[1].events = POLLHUP;
	48	ret = poll(pfds, 2, -1);
	49	if(ret < 0) {
	50	if(errno != EINTR) {
	51	flog(LOG_ERR, "callcgi: error in poll: %s", strerror(errno));
	52	return(1);
	53	}
8cc51634	54	}
df96b222	55	if(ret > 0) {
19409e87	56	if(pfds[0].revents & (POLLIN \| POLLERR \| POLLHUP)) {
df96b222 FT	57	ret = fread(buf, 1, 65536, in);
	58	if(ferror(in)) {
	59	flog(LOG_ERR, "callcgi: could not read input: %s", strerror(errno));
	60	return(1);
	61	}
	62	if(fwrite(buf, 1, ret, out) != ret) {
	63	flog(LOG_ERR, "callcgi: could not write output: %s", strerror(errno));
	64	return(1);
	65	}
	66	}
	67	if(pfds[1].revents & POLLHUP)
	68	return(1);
8cc51634 FT	69	}
8cc51634 FT	70	}
df96b222	71	return(0);
8cc51634 FT	72	}
8cc51634 FT	73
bac8c1f9 FT	74	static char absolutify(char file)
	75	{
	76	char cwd[1024];
	77
	78	if(*file != '/') {
	79	getcwd(cwd, sizeof(cwd));
	80	return(sprintf2("%s/%s", cwd, file));
	81	}
	82	return(sstrdup(file));
	83	}
	84
df96b222	85	static pid_t forkchild(int inpath, char prog, char file, char method, char url, char rest, int infd, int *outfd)
8cc51634 FT	86	{
8cc51634 FT	87	int i;
85059e82	88	char qp, env, name;
8cc51634 FT	89	int inp[2], outp[2];
	90	pid_t pid;
	91
	92	pipe(inp);
	93	pipe(outp);
	94	if((pid = fork()) < 0) {
	95	flog(LOG_ERR, "callcgi: could not fork");
	96	exit(1);
	97	}
	98	if(pid == 0) {
	99	close(inp[1]);
	100	close(outp[0]);
	101	dup2(inp[0], 0);
	102	dup2(outp[1], 1);
	103	for(i = 3; i < FD_SETSIZE; i++)
	104	close(i);
	105	if((qp = strchr(url, '?')) != NULL)
	106	*(qp++) = 0;
8cc51634 FT	107	putenv(sprintf2("SERVER_SOFTWARE=ashd/%s", VERSION));
	108	putenv("GATEWAY_INTERFACE=CGI/1.1");
	109	if(getenv("HTTP_VERSION"))
147c2b51	110	putenv(sprintf2("SERVER_PROTOCOL=%s", getenv("HTTP_VERSION")));
8cc51634	111	putenv(sprintf2("REQUEST_METHOD=%s", method));
2d65add0	112	putenv(sprintf2("PATH_INFO=%s", rest));
85059e82 FT	113	name = url;
	114	/* XXX: This is an ugly hack (I think), but though I can think
	115	* of several alternatives, none seem to be better. */
2d65add0 FT	116	if(*rest && (strlen(url) >= strlen(rest)) &&
	117	!strcmp(rest, url + strlen(url) - strlen(rest))) {
	118	name = sprintf2("%.*s", (int)(strlen(url) - strlen(rest)), url);
85059e82 FT	119	}
85059e82 FT	120	putenv(sprintf2("SCRIPT_NAME=%s", name));
8cc51634 FT	121	putenv(sprintf2("QUERY_STRING=%s", qp?qp:""));
	122	if(getenv("REQ_HOST"))
	123	putenv(sprintf2("SERVER_NAME=%s", getenv("REQ_HOST")));
8626e489 FT	124	if(getenv("REQ_X_ASH_SERVER_PORT"))
	125	putenv(sprintf2("SERVER_PORT=%s", getenv("REQ_X_ASH_SERVER_PORT")));
	126	if(getenv("REQ_X_ASH_PROTOCOL") && !strcmp(getenv("REQ_X_ASH_PROTOCOL"), "https"))
f0a758cc	127	putenv("HTTPS=on");
8cc51634 FT	128	if(getenv("REQ_X_ASH_ADDRESS"))
8cc51634 FT	129	putenv(sprintf2("REMOTE_ADDR=%s", getenv("REQ_X_ASH_ADDRESS")));
381f9919 FT	130	if(getenv("REQ_X_ASH_REMOTE_USER"))
381f9919 FT	131	putenv(sprintf2("REMOTE_USER=%s", getenv("REQ_X_ASH_REMOTE_USER")));
8cc51634 FT	132	if(getenv("REQ_CONTENT_TYPE"))
	133	putenv(sprintf2("CONTENT_TYPE=%s", getenv("REQ_CONTENT_TYPE")));
	134	if(getenv("REQ_CONTENT_LENGTH"))
	135	putenv(sprintf2("CONTENT_LENGTH=%s", getenv("REQ_CONTENT_LENGTH")));
	136	for(env = environ; *env; env++) {
	137	if(!strncmp(*env, "REQ_", 4))
	138	putenv(sprintf2("HTTP_%s", (*env) + 4));
	139	}
	140	/*
	141	* This is (understandably) missing from the CGI
	142	* specification, but PHP seems to require it.
	143	*/
bac8c1f9	144	putenv(sprintf2("SCRIPT_FILENAME=%s", absolutify(file)));
341b3f0b FT	145	if(inpath)
	146	execlp(prog, prog, file, NULL);
	147	else
	148	execl(prog, prog, file, NULL);
8cc51634 FT	149	exit(127);
	150	}
	151	close(inp[0]);
	152	close(outp[1]);
	153	*infd = inp[1];
	154	*outfd = outp[0];
df96b222	155	return(pid);
8cc51634 FT	156	}
	157
	158	static void trim(struct charbuf *buf)
	159	{
	160	char *p;
	161
	162	for(p = buf->b; (p - buf->b < buf->d) && isspace(*p); p++);
	163	memmove(buf->b, p, buf->d -= (p - buf->b));
	164	for(p = buf->b + buf->d - 1; (p > buf->b) && isspace(*p); p--, buf->d--);
	165	}
	166
	167	static char *parseheaders(FILE s)
	168	{
	169	int c, state;
	170	struct charvbuf hbuf;
	171	struct charbuf buf;
	172
	173	bufinit(hbuf);
	174	bufinit(buf);
	175	state = 0;
	176	while(1) {
	177	c = fgetc(s);
	178	again:
	179	if(state == 0) {
	180	if(c == '\r') {
	181	} else if(c == '\n') {
	182	break;
	183	} else if(c == EOF) {
	184	goto fail;
	185	} else {
	186	state = 1;
	187	goto again;
	188	}
	189	} else if(state == 1) {
	190	if(c == ':') {
	191	trim(&buf);
	192	bufadd(buf, 0);
	193	bufadd(hbuf, buf.b);
	194	bufinit(buf);
	195	state = 2;
	196	} else if(c == '\r') {
	197	} else if(c == '\n') {
	198	goto fail;
	199	} else if(c == EOF) {
	200	goto fail;
	201	} else {
	202	bufadd(buf, c);
	203	}
	204	} else if(state == 2) {
	205	if(c == '\r') {
	206	} else if(c == '\n') {
	207	trim(&buf);
	208	bufadd(buf, 0);
	209	bufadd(hbuf, buf.b);
	210	bufinit(buf);
	211	state = 0;
	212	} else if(c == EOF) {
	213	goto fail;
	214	} else {
	215	bufadd(buf, c);
	216	}
	217	}
	218	}
	219	bufadd(hbuf, NULL);
220	return(hbuf.b);
221
222	fail:
223	buffree(hbuf);
224	buffree(buf);
225	return(NULL);
226	}
227
2e535ab0 FT	228	static char *defstatus(int code)
	229	{
	230	if(code == 200)
	231	return("OK");
	232	else if(code == 201)
	233	return("Created");
	234	else if(code == 202)
	235	return("Accepted");
	236	else if(code == 204)
	237	return("No Content");
	238	else if(code == 300)
	239	return("Multiple Choices");
	240	else if(code == 301)
	241	return("Moved Permanently");
	242	else if(code == 302)
	243	return("Found");
	244	else if(code == 303)
	245	return("See Other");
	246	else if(code == 304)
	247	return("Not Modified");
	248	else if(code == 307)
	249	return("Moved Temporarily");
	250	else if(code == 400)
	251	return("Bad Request");
	252	else if(code == 401)
	253	return("Unauthorized");
	254	else if(code == 403)
	255	return("Forbidden");
	256	else if(code == 404)
	257	return("Not Found");
	258	else if(code == 500)
	259	return("Internal Server Error");
	260	else if(code == 501)
	261	return("Not Implemented");
	262	else if(code == 503)
	263	return("Service Unavailable");
	264	else
	265	return("Unknown status");
	266	}
	267
8cc51634 FT	268	static void sendstatus(char *headers, FILE out)
	269	{
	270	char **hp;
	271	char status, location;
	272
	273	hp = headers;
	274	status = location = NULL;
	275	while(*hp) {
	276	if(!strcasecmp(hp[0], "status")) {
	277	status = hp[1];
	278	/* Clear this header, so that it is not transmitted by sendheaders. */
	279	**hp = 0;
	280	} else if(!strcasecmp(hp[0], "location")) {
	281	location = hp[1];
f9255ddd	282	hp += 2;
8cc51634 FT	283	} else {
	284	hp += 2;
	285	}
	286	}
	287	if(status) {
2e535ab0	288	if(strchr(status, ' '))
81cfca6c	289	fprintf(out, "HTTP/1.1 %s\n", status);
2e535ab0	290	else
81cfca6c	291	fprintf(out, "HTTP/1.1 %i %s\n", atoi(status), defstatus(atoi(status)));
8cc51634	292	} else if(location) {
81cfca6c	293	fprintf(out, "HTTP/1.1 303 See Other\n");
8cc51634	294	} else {
81cfca6c	295	fprintf(out, "HTTP/1.1 200 OK\n");
8cc51634 FT	296	}
	297	}
	298
	299	static void sendheaders(char *headers, FILE out)
	300	{
	301	while(*headers) {
	302	if(**headers)
81cfca6c	303	fprintf(out, "%s: %s\n", headers[0], headers[1]);
8cc51634 FT	304	headers += 2;
	305	}
	306	}
	307
341b3f0b FT	308	static void usage(void)
341b3f0b FT	309	{
5e74f3f1	310	flog(LOG_ERR, "usage: callcgi [-c] [-p PROGRAM] METHOD URL REST");
341b3f0b FT	311	}
341b3f0b FT	312
8cc51634 FT	313	int main(int argc, char argv, char envp)
8cc51634 FT	314	{
341b3f0b	315	int c;
5e74f3f1 FT	316	char file, prog, *sp;
5e74f3f1 FT	317	int inpath, cd;
341b3f0b FT	318	int infd, outfd;
341b3f0b FT	319	FILE in, out;
8cc51634	320	char **headers;
df96b222	321	pid_t child;
8cc51634 FT	322
	323	environ = envp;
	324	signal(SIGPIPE, SIG_IGN);
341b3f0b FT	325
	326	prog = NULL;
	327	inpath = 0;
5e74f3f1 FT	328	cd = 0;
5e74f3f1 FT	329	while((c = getopt(argc, argv, "cp:")) >= 0) {
341b3f0b	330	switch(c) {
5e74f3f1 FT	331	case 'c':
	332	cd = 1;
	333	break;
341b3f0b FT	334	case 'p':
	335	prog = optarg;
	336	inpath = 1;
	337	break;
	338	default:
	339	usage();
	340	exit(1);
	341	}
	342	}
	343
	344	if(argc - optind < 3) {
	345	usage();
8cc51634 FT	346	exit(1);
	347	}
	348	if((file = getenv("REQ_X_ASH_FILE")) == NULL) {
	349	flog(LOG_ERR, "callcgi: needs to be called with the X-Ash-File header");
	350	exit(1);
	351	}
5e74f3f1 FT	352
	353	if(cd) {
	354	/* This behavior is encouraged by the CGI specification (RFC 3875, 7.2),
	355	* but not strictly required, and I get the feeling it might break some
	356	* relative paths here or there, so it's not the default for now. */
	357	if((sp = strrchr(file, '/')) != NULL) {
	358	*sp = 0;
	359	if(chdir(file)) {
	360	*sp = '/';
	361	} else {
	362	file = sp + 1;
	363	}
	364	}
	365	}
	366
341b3f0b FT	367	if(prog == NULL)
341b3f0b FT	368	prog = file;
df96b222	369	child = forkchild(inpath, prog, file, argv[optind], argv[optind + 1], argv[optind + 2], &infd, &outfd);
341b3f0b	370	in = fdopen(infd, "w");
df96b222	371	passdata(stdin, in); /* Ignore errors, perhaps? */
341b3f0b FT	372	fclose(in);
	373	out = fdopen(outfd, "r");
	374	if((headers = parseheaders(out)) == NULL) {
8cc51634 FT	375	flog(LOG_WARNING, "CGI handler returned invalid headers");
	376	exit(1);
	377	}
	378	sendstatus(headers, stdout);
	379	sendheaders(headers, stdout);
81cfca6c	380	printf("\n");
df96b222 FT	381	if(passdata(out, stdout))
df96b222 FT	382	kill(child, SIGINT);
8cc51634 FT	383	return(0);
8cc51634 FT	384	}