doc: Fixed typo.
[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 #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 }