python: Added logging initialization to scgi-wsgi.
[ashd.git] / src / callscgi.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 /*
20  * XXX: All the various ways to start a child process makes this
21  * program quite ugly at the moment. It is unclear whether it is
22  * meaningfully possible to unify them better than they currently are.
23  */
24
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <unistd.h>
28 #include <string.h>
29 #include <fcntl.h>
30 #include <ctype.h>
31 #include <sys/socket.h>
32 #include <sys/un.h>
33 #include <netinet/in.h>
34 #include <netdb.h>
35 #include <sys/signal.h>
36 #include <errno.h>
37
38 #ifdef HAVE_CONFIG_H
39 #include <config.h>
40 #endif
41 #include <utils.h>
42 #include <req.h>
43 #include <log.h>
44 #include <mt.h>
45 #include <mtio.h>
46
47 static char **progspec;
48 static char *sockid, *unspec, *inspec;
49 static int nolisten;
50 static struct sockaddr *curaddr;
51 static size_t caddrlen;
52 static int cafamily, isanon;
53 static pid_t child;
54
55 static struct addrinfo *resolv(int flags)
56 {
57     int ret;
58     struct addrinfo *ai, h;
59     char *name, *srv, *p;
60     
61     if((p = strchr(inspec, ':')) != NULL) {
62         name = smalloc(p - inspec + 1);
63         memcpy(name, inspec, p - inspec);
64         name[p - inspec] = 0;
65         srv = p + 1;
66     } else {
67         name = sstrdup("localhost");
68         srv = inspec;
69     }
70     memset(&h, 0, sizeof(h));
71     h.ai_family = AF_UNSPEC;
72     h.ai_socktype = SOCK_STREAM;
73     h.ai_flags = flags;
74     ret = getaddrinfo(name, srv, &h, &ai);
75     free(name);
76     if(ret != 0) {
77         flog(LOG_ERR, "could not resolve TCP specification `%s': %s", inspec, gai_strerror(ret));
78         exit(1);
79     }
80     return(ai);
81 }
82
83 static char *mksockid(char *sockid)
84 {
85     char *home;
86     
87     home = getenv("HOME");
88     if(home && !access(sprintf3("%s/.ashd/sockets/", home), X_OK))
89         return(sprintf3("%s/.ashd/sockets/scgi-p-%s", home, sockid));
90     return(sprintf3("/tmp/scgi-%i-%s", getuid(), sockid));
91 }
92
93 static char *mkanonid(void)
94 {
95     char *home;
96     char *tmpl;
97     int fd;
98     
99     home = getenv("HOME");
100     if(home && !access(sprintf3("%s/.ashd/sockets/", home), X_OK))
101         tmpl = sprintf2("%s/.ashd/sockets/scgi-a-XXXXXX", home);
102     else
103         tmpl = sprintf2("/tmp/scgi-a-%i-XXXXXX", getuid());
104     if((fd = mkstemp(tmpl)) < 0) {
105         flog(LOG_ERR, "could not create anonymous socket `%s': %s", tmpl, strerror(errno));
106         exit(1);
107     }
108     close(fd);
109     unlink(tmpl);
110     return(tmpl);
111 }
112
113 static void startlisten(void)
114 {
115     int i, fd;
116     struct addrinfo *ai, *cai;
117     char *unpath;
118     struct sockaddr_un unm;
119     char *aname;
120     
121     isanon = 0;
122     if(inspec != NULL) {
123         fd = -1;
124         for(cai = ai = resolv(AI_PASSIVE); cai != NULL; cai = cai->ai_next) {
125             if((fd = socket(cai->ai_family, cai->ai_socktype, cai->ai_protocol)) < 0)
126                 continue;
127             if(bind(fd, cai->ai_addr, cai->ai_addrlen)) {
128                 close(fd);
129                 fd = -1;
130                 continue;
131             }
132             if(listen(fd, 128)) {
133                 close(fd);
134                 fd = -1;
135                 continue;
136             }
137             break;
138         }
139         freeaddrinfo(ai);
140         if(fd < 0) {
141             flog(LOG_ERR, "could not bind to specified TCP address: %s", strerror(errno));
142             exit(1);
143         }
144     } else if((unspec != NULL) || (sockid != NULL)) {
145         if((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
146             flog(LOG_ERR, "could not create Unix socket: %s", strerror(errno));
147             exit(1);
148         }
149         if(unspec != NULL)
150             unpath = unspec;
151         else
152             unpath = mksockid(sockid);
153         unlink(unpath);
154         unm.sun_family = AF_UNIX;
155         strcpy(unm.sun_path, unpath);
156         if(bind(fd, (struct sockaddr *)&unm, sizeof(unm))) {
157             flog(LOG_ERR, "could not bind Unix socket to `%s': %s", unspec, strerror(errno));
158             exit(1);
159         }
160         if(listen(fd, 128)) {
161             flog(LOG_ERR, "listen: %s", strerror(errno));
162             exit(1);
163         }
164     } else {
165         if((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
166             flog(LOG_ERR, "could not create Unix socket: %s", strerror(errno));
167             exit(1);
168         }
169         memset(&unm, 0, sizeof(unm));
170         aname = mkanonid();
171         unm.sun_family = AF_UNIX;
172         strcpy(unm.sun_path, aname);
173         free(aname);
174         if(bind(fd, (struct sockaddr *)&unm, sizeof(unm))) {
175             flog(LOG_ERR, "could not bind Unix socket to `%s': %s", unspec, strerror(errno));
176             exit(1);
177         }
178         if(listen(fd, 128)) {
179             flog(LOG_ERR, "listen: %s", strerror(errno));
180             exit(1);
181         }
182         
183         curaddr = smalloc(caddrlen = sizeof(unm));
184         memcpy(curaddr, &unm, sizeof(unm));
185         cafamily = AF_UNIX;
186         isanon = 1;
187     }
188     if((child = fork()) < 0) {
189         flog(LOG_ERR, "could not fork: %s", strerror(errno));
190         exit(1);
191     }
192     if(child == 0) {
193         dup2(fd, 0);
194         for(i = 3; i < FD_SETSIZE; i++)
195             close(i);
196         execvp(*progspec, progspec);
197         flog(LOG_ERR, "callscgi: %s: %s", *progspec, strerror(errno));
198         _exit(127);
199     }
200     close(fd);
201 }
202
203 static void startnolisten(void)
204 {
205     int i, fd;
206     
207     if((child = fork()) < 0) {
208         flog(LOG_ERR, "could not fork: %s", strerror(errno));
209         exit(1);
210     }
211     if(child == 0) {
212         for(i = 3; i < FD_SETSIZE; i++)
213             close(i);
214         if((fd = open("/dev/null", O_RDONLY)) < 0) {
215             flog(LOG_ERR, "/dev/null: %s", strerror(errno));
216             _exit(127);
217         }
218         dup2(fd, 0);
219         close(fd);
220         execvp(*progspec, progspec);
221         flog(LOG_ERR, "callscgi: %s: %s", *progspec, strerror(errno));
222         _exit(127);
223     }
224 }
225
226 static int sconnect(void)
227 {
228     int fd;
229     int err;
230     socklen_t errlen;
231
232     fd = socket(cafamily, SOCK_STREAM, 0);
233     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
234     while(1) {
235         if(connect(fd, curaddr, caddrlen)) {
236             if(errno == EINPROGRESS) {
237                 block(fd, EV_WRITE, 30);
238                 errlen = sizeof(err);
239                 if(getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) || ((errno = err) != 0)) {
240                     close(fd);
241                     return(-1);
242                 }
243                 return(fd);
244             }
245             close(fd);
246             return(-1);
247         }
248         return(fd);
249     }
250 }
251
252 static int econnect(void)
253 {
254     int fd;
255     struct addrinfo *ai, *cai;
256     int tries;
257     char *unpath;
258     struct sockaddr_un unm;
259     
260     tries = 0;
261 retry:
262     if(inspec != NULL) {
263         fd = -1;
264         for(cai = ai = resolv(0); cai != NULL; cai = cai->ai_next) {
265             if((fd = socket(cai->ai_family, cai->ai_socktype, cai->ai_protocol)) < 0)
266                 continue;
267             if(connect(fd, cai->ai_addr, cai->ai_addrlen)) {
268                 close(fd);
269                 fd = -1;
270                 continue;
271             }
272             break;
273         }
274         if(fd < 0) {
275             if(tries++ < nolisten) {
276                 sleep(1);
277                 goto retry;
278             }
279             flog(LOG_ERR, "could not connect to specified TCP address: %s", strerror(errno));
280             exit(1);
281         }
282         curaddr = smalloc(caddrlen = cai->ai_addrlen);
283         memcpy(curaddr, cai->ai_addr, caddrlen);
284         cafamily = cai->ai_family;
285         isanon = 0;
286         freeaddrinfo(ai);
287         return(fd);
288     } else if((unspec != NULL) || (sockid != NULL)) {
289         if((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
290             flog(LOG_ERR, "could not create Unix socket: %s", strerror(errno));
291             exit(1);
292         }
293         if(unspec != NULL)
294             unpath = unspec;
295         else
296             unpath = mksockid(sockid);
297         unlink(unpath);
298         unm.sun_family = AF_UNIX;
299         strcpy(unm.sun_path, unpath);
300         if(connect(fd, (struct sockaddr *)&unm, sizeof(unm))) {
301             close(fd);
302             if(tries++ < nolisten) {
303                 sleep(1);
304                 goto retry;
305             }
306             flog(LOG_ERR, "could not connect to Unix socket `%s': %s", unspec, strerror(errno));
307             exit(1);
308         }
309         curaddr = smalloc(caddrlen = sizeof(unm));
310         memcpy(curaddr, &unm, sizeof(unm));
311         cafamily = AF_UNIX;
312         isanon = 0;
313         return(fd);
314     } else {
315         flog(LOG_ERR, "callscgi: cannot use an anonymous socket without a program to start");
316         exit(1);
317     }
318 }
319
320 static int startconn(void)
321 {
322     if(*progspec) {
323         if(nolisten == 0)
324             startlisten();
325         else
326             startnolisten();
327     }
328     if(curaddr != NULL)
329         return(sconnect());
330     return(econnect());
331 }
332
333 static void killcuraddr(void)
334 {
335     if(curaddr == NULL)
336         return;
337     if(isanon) {
338         unlink(((struct sockaddr_un *)curaddr)->sun_path);
339         if(child > 0)
340             kill(child, SIGTERM);
341     }
342     free(curaddr);
343     curaddr = NULL;
344 }
345
346 static int reconn(void)
347 {
348     int fd;
349     
350     if(curaddr != NULL) {
351         if((fd = sconnect()) >= 0)
352             return(fd);
353         killcuraddr();
354     }
355     return(startconn());
356 }
357
358 static off_t passdata(FILE *in, FILE *out)
359 {
360     size_t read;
361     off_t total;
362     char buf[8192];
363     
364     total = 0;
365     while(!feof(in)) {
366         read = fread(buf, 1, sizeof(buf), in);
367         if(ferror(in))
368             return(-1);
369         if(fwrite(buf, 1, read, out) != read)
370             return(-1);
371         total += read;
372     }
373     return(total);
374 }
375
376 static void bufaddenv(struct charbuf *dst, char *name, char *fmt, ...)
377 {
378     va_list args;
379     
380     bufcatstr2(*dst, name);
381     va_start(args, fmt);
382     bvprintf(dst, fmt, args);
383     va_end(args);
384     bufadd(*dst, 0);
385 }
386
387 static char *absolutify(char *file)
388 {
389     static int inited = 0;
390     static char cwd[1024];
391     
392     if(*file != '/') {
393         if(!inited) {
394             getcwd(cwd, sizeof(cwd));
395             inited = 1;
396         }
397         return(sprintf2("%s/%s", cwd, file));
398     }
399     return(sstrdup(file));
400 }
401
402 /* Mostly copied from callcgi. */
403 static void mkcgienv(struct hthead *req, struct charbuf *dst)
404 {
405     int i;
406     char *url, *pi, *tmp, *qp, *h, *p;
407     
408     bufaddenv(dst, "SERVER_SOFTWARE", "ashd/%s", VERSION);
409     bufaddenv(dst, "GATEWAY_INTERFACE", "CGI/1.1");
410     bufaddenv(dst, "SCGI", "1");
411     bufaddenv(dst, "SERVER_PROTOCOL", "%s", req->ver);
412     bufaddenv(dst, "REQUEST_METHOD", "%s", req->method);
413     bufaddenv(dst, "REQUEST_URI", "%s", req->url);
414     url = sstrdup(req->url);
415     if((qp = strchr(url, '?')) != NULL)
416         *(qp++) = 0;
417     /* XXX: This is an ugly hack (I think), but though I can think of
418      * several alternatives, none seem to be better. */
419     if(*req->rest && (strlen(url) >= strlen(req->rest)) &&
420        !strcmp(req->rest, url + strlen(url) - strlen(req->rest))) {
421         url[strlen(url) - strlen(req->rest)] = 0;
422     }
423     if((pi = unquoteurl(req->rest)) == NULL)
424         pi = sstrdup(req->rest);
425     if(!strcmp(url, "/")) {
426         /* This seems to be normal CGI behavior, but see callcgi.c for
427          * details. */
428         url[0] = 0;
429         pi = sprintf2("/%s", tmp = pi);
430         free(tmp);
431     }
432     bufaddenv(dst, "PATH_INFO", pi);
433     bufaddenv(dst, "SCRIPT_NAME", url);
434     bufaddenv(dst, "QUERY_STRING", "%s", qp?qp:"");
435     free(pi);
436     free(url);
437     if((h = getheader(req, "Host")) != NULL)
438         bufaddenv(dst, "SERVER_NAME", "%s", h);
439     if((h = getheader(req, "X-Ash-Server-Port")) != NULL)
440         bufaddenv(dst, "SERVER_PORT", "%s", h);
441     if((h = getheader(req, "X-Ash-Remote-User")) != NULL)
442         bufaddenv(dst, "REMOTE_USER", "%s", h);
443     if(((h = getheader(req, "X-Ash-Protocol")) != NULL) && !strcmp(h, "https"))
444         bufaddenv(dst, "HTTPS", "on");
445     if((h = getheader(req, "X-Ash-Address")) != NULL)
446         bufaddenv(dst, "REMOTE_ADDR", "%s", h);
447     if((h = getheader(req, "Content-Type")) != NULL)
448         bufaddenv(dst, "CONTENT_TYPE", "%s", h);
449     if((h = getheader(req, "Content-Length")) != NULL)
450         bufaddenv(dst, "CONTENT_LENGTH", "%s", h);
451     else
452         bufaddenv(dst, "CONTENT_LENGTH", "0");
453     if((h = getheader(req, "X-Ash-File")) != NULL) {
454         h = absolutify(h);
455         bufaddenv(dst, "SCRIPT_FILENAME", "%s", h);
456         free(h);
457     }
458     for(i = 0; i < req->noheaders; i++) {
459         h = sprintf2("HTTP_%s", req->headers[i][0]);
460         for(p = h; *p; p++) {
461             if(isalnum(*p))
462                 *p = toupper(*p);
463             else
464                 *p = '_';
465         }
466         bufcatstr2(*dst, h);
467         free(h);
468         bufcatstr2(*dst, req->headers[i][1]);
469     }
470 }
471
472 static char *defstatus(int code)
473 {
474     if(code == 200)
475         return("OK");
476     else if(code == 201)
477         return("Created");
478     else if(code == 202)
479         return("Accepted");
480     else if(code == 204)
481         return("No Content");
482     else if(code == 300)
483         return("Multiple Choices");
484     else if(code == 301)
485         return("Moved Permanently");
486     else if(code == 302)
487         return("Found");
488     else if(code == 303)
489         return("See Other");
490     else if(code == 304)
491         return("Not Modified");
492     else if(code == 307)
493         return("Moved Temporarily");
494     else if(code == 400)
495         return("Bad Request");
496     else if(code == 401)
497         return("Unauthorized");
498     else if(code == 403)
499         return("Forbidden");
500     else if(code == 404)
501         return("Not Found");
502     else if(code == 500)
503         return("Internal Server Error");
504     else if(code == 501)
505         return("Not Implemented");
506     else if(code == 503)
507         return("Service Unavailable");
508     else
509         return("Unknown status");
510 }
511
512 static struct hthead *parseresp(FILE *in)
513 {
514     struct hthead *resp;
515     char *st, *p;
516     
517     omalloc(resp);
518     resp->ver = sstrdup("HTTP/1.1");
519     if(parseheaders(resp, in)) {
520         freehthead(resp);
521         return(NULL);
522     }
523     if((st = getheader(resp, "Status")) != NULL) {
524         if((p = strchr(st, ' ')) != NULL) {
525             *(p++) = 0;
526             resp->code = atoi(st);
527             resp->msg = sstrdup(p);
528         } else {
529             resp->code = atoi(st);
530             resp->msg = sstrdup(defstatus(resp->code));
531         }
532         headrmheader(resp, "Status");
533     } else if(getheader(resp, "Location")) {
534         resp->code = 303;
535         resp->msg = sstrdup("See Other");
536     } else {
537         resp->code = 200;
538         resp->msg = sstrdup("OK");
539     }
540     return(resp);
541 }
542
543 static void serve(struct muth *muth, va_list args)
544 {
545     vavar(struct hthead *, req);
546     vavar(int, fd);
547     vavar(int, sfd);
548     FILE *is, *os;
549     struct charbuf head;
550     struct hthead *resp;
551     
552     sfd = reconn();
553     is = mtstdopen(fd, 1, 60, "r+");
554     os = mtstdopen(sfd, 1, 600, "r+");
555     
556     bufinit(head);
557     mkcgienv(req, &head);
558     fprintf(os, "%zi:", head.d);
559     fwrite(head.b, head.d, 1, os);
560     fputc(',', os);
561     buffree(head);
562     if(passdata(is, os) < 0)
563         goto out;
564     
565     if((resp = parseresp(os)) == NULL)
566         goto out;
567     writeresp(is, resp);
568     freehthead(resp);
569     fputc('\n', is);
570     if(passdata(os, is) < 0)
571         goto out;
572     
573 out:
574     freehthead(req);
575     fclose(is);
576     fclose(os);
577 }
578
579 static void listenloop(struct muth *muth, va_list args)
580 {
581     vavar(int, lfd);
582     int fd;
583     struct hthead *req;
584     
585     while(1) {
586         block(0, EV_READ, 0);
587         if((fd = recvreq(lfd, &req)) < 0) {
588             if(errno != 0)
589                 flog(LOG_ERR, "recvreq: %s", strerror(errno));
590             break;
591         }
592         mustart(serve, req, fd);
593     }
594 }
595
596 static void sigign(int sig)
597 {
598 }
599
600 static void sigexit(int sig)
601 {
602     shutdown(0, SHUT_RDWR);
603     exit(0);
604 }
605
606 static void usage(FILE *out)
607 {
608     fprintf(out, "usage: callscgi [-h] [-N RETRIES] [-i ID] [-u UNIX-PATH] [-t [HOST:]TCP-PORT] [PROGRAM [ARGS...]]\n");
609 }
610
611 int main(int argc, char **argv)
612 {
613     int c;
614     
615     while((c = getopt(argc, argv, "+hN:i:u:t:")) >= 0) {
616         switch(c) {
617         case 'h':
618             usage(stdout);
619             exit(0);
620         case 'N':
621             nolisten = atoi(optarg);
622             break;
623         case 'i':
624             sockid = optarg;
625             break;
626         case 'u':
627             unspec = optarg;
628             break;
629         case 't':
630             inspec = optarg;
631             break;
632         default:
633             usage(stderr);
634             exit(1);
635         }
636     }
637     progspec = argv + optind;
638     if(((sockid != NULL) + (unspec != NULL) + (inspec != NULL)) > 1) {
639         flog(LOG_ERR, "callscgi: at most one of -i, -u or -t may be given");
640         exit(1);
641     }
642     signal(SIGCHLD, SIG_IGN);
643     signal(SIGPIPE, sigign);
644     signal(SIGINT, sigexit);
645     signal(SIGTERM, sigexit);
646     mustart(listenloop, 0);
647     atexit(killcuraddr);
648     ioloop();
649     return(0);
650 }