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