python: Rewrote SSI handler as a reusable module, and in Python3.
[ashd.git] / src / htextauth.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 <stdio.h>
21 #include <unistd.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <sys/poll.h>
25 #include <sys/wait.h>
26 #include <time.h>
27 #include <signal.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 #include <proc.h>
36 #include <resp.h>
37
38 struct cache {
39     struct cache *next, *prev;
40     char *user, *pass;
41     time_t lastuse;
42 };
43
44 static int ch;
45 static char **authcmd;
46 static char *realm;
47 static int docache = 1, reqssl;
48 static struct cache *cache;
49 static time_t now, lastclean;
50
51 static int auth(struct hthead *req, int fd, char *user, char *pass);
52
53 static void reqauth(struct hthead *req, int fd)
54 {
55     struct charbuf buf;
56     FILE *out;
57     char *rn;
58     
59     rn = realm;
60     if(rn == NULL)
61         rn = "auth";
62     bufinit(buf);
63     bufcatstr(buf, "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n");
64     bufcatstr(buf, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\r\n");
65     bufcatstr(buf, "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en-US\" xml:lang=\"en-US\">\r\n");
66     bufcatstr(buf, "<head>\r\n");
67     bprintf(&buf, "<title>Authentication Required</title>\r\n");
68     bufcatstr(buf, "</head>\r\n");
69     bufcatstr(buf, "<body>\r\n");
70     bprintf(&buf, "<h1>Authentication Required</h1>\r\n");
71     bprintf(&buf, "<p>You need to authenticate to access the requested resource.</p>\r\n");
72     bufcatstr(buf, "</body>\r\n");
73     bufcatstr(buf, "</html>\r\n");
74     out = fdopen(dup(fd), "w");
75     fprintf(out, "HTTP/1.1 401 Authentication Required\n");
76     fprintf(out, "WWW-Authenticate: Basic realm=\"%s\"\n", rn);
77     fprintf(out, "Content-Type: text/html\n");
78     fprintf(out, "Content-Length: %zi\n", buf.d);
79     fprintf(out, "\n");
80     fwrite(buf.b, 1, buf.d, out);
81     fclose(out);
82     buffree(buf);
83 }
84
85 static void authinval(struct hthead *req, int fd, char *msg)
86 {
87     struct charbuf buf;
88     FILE *out;
89     char *rn;
90     
91     rn = realm;
92     if(rn == NULL)
93         rn = "auth";
94     bufinit(buf);
95     bufcatstr(buf, "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n");
96     bufcatstr(buf, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\r\n");
97     bufcatstr(buf, "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en-US\" xml:lang=\"en-US\">\r\n");
98     bufcatstr(buf, "<head>\r\n");
99     bprintf(&buf, "<title>Invalid authentication</title>\r\n");
100     bufcatstr(buf, "</head>\r\n");
101     bufcatstr(buf, "<body>\r\n");
102     bprintf(&buf, "<h1>Invalid authentication</h1>\r\n");
103     bprintf(&buf, "<p>%s</p>\r\n", htmlquote(msg));
104     bufcatstr(buf, "</body>\r\n");
105     bufcatstr(buf, "</html>\r\n");
106     out = fdopen(dup(fd), "w");
107     fprintf(out, "HTTP/1.1 401 Invalid authentication\n");
108     fprintf(out, "WWW-Authenticate: Basic realm=\"%s\"\n", rn);
109     fprintf(out, "Content-Type: text/html\n");
110     fprintf(out, "Content-Length: %zi\n", buf.d);
111     fprintf(out, "\n");
112     fwrite(buf.b, 1, buf.d, out);
113     fclose(out);
114     buffree(buf);
115 }
116
117 static void cleancache(int complete)
118 {
119     struct cache *c, *n;
120     
121     for(c = cache; c != NULL; c = n) {
122         n = c->next;
123         if(complete || (now - c->lastuse > 3600)) {
124             if(c->next)
125                 c->next->prev = c->prev;
126             if(c->prev)
127                 c->prev->next = c->next;
128             if(c == cache)
129                 cache = c->next;
130             memset(c->pass, 0, strlen(c->pass));
131             free(c->user);
132             free(c->pass);
133             free(c);
134         }
135     }
136     lastclean = now;
137 }
138
139 static int ckcache(char *user, char *pass)
140 {
141     struct cache *c;
142     
143     for(c = cache; c != NULL; c = c->next) {
144         if(!strcmp(user, c->user) && !strcmp(pass, c->pass)) {
145             c->lastuse = now;
146             return(1);
147         }
148     }
149     return(0);
150 }
151
152 static struct cache *addcache(char *user, char *pass)
153 {
154     struct cache *c;
155     
156     omalloc(c);
157     c->user = sstrdup(user);
158     c->pass = sstrdup(pass);
159     c->lastuse = now;
160     c->next = cache;
161     if(cache != NULL)
162         cache->prev = c;
163     cache = c;
164     return(c);
165 }
166
167 static void serve2(struct hthead *req, int fd, char *user)
168 {
169     headappheader(req, "X-Ash-Remote-User", user);
170     if(sendreq(ch, req, fd)) {
171         flog(LOG_ERR, "htextauth: could not pass request to child: %s", strerror(errno));
172         exit(1);
173     }
174 }
175
176 static void serve(struct hthead *req, int fd)
177 {
178     char *raw, *dec, *p;
179     size_t declen;
180     
181     now = time(NULL);
182     dec = NULL;
183     if(reqssl && (((raw = getheader(req, "X-Ash-Protocol")) == NULL) || strcmp(raw, "https"))) {
184         simpleerror(fd, 403, "Forbidden", "The requested resource must be requested over HTTPS.");
185         goto out;
186     }
187     if(((raw = getheader(req, "Authorization")) == NULL) || strncasecmp(raw, "basic ", 6)) {
188         reqauth(req, fd);
189         goto out;
190     }
191     if((dec = base64decode(raw + 6, &declen)) == NULL) {
192         simpleerror(fd, 400, "Invalid request", "The authentication data is not proper base64.");
193         goto out;
194     }
195     memset(raw, 0, strlen(raw));
196     headrmheader(req, "Authorization");
197     for(p = dec; *p; p++) {
198         if(*p < 32) {
199             simpleerror(fd, 400, "Invalid request", "The authentication data is invalid.");
200             goto out;
201         }
202     }
203     if((p = strchr(dec, ':')) == NULL) {
204         simpleerror(fd, 400, "Invalid request", "The authentication data is invalid.");
205         goto out;
206     }
207     *(p++) = 0;
208     if(docache && ckcache(dec, p)) {
209         serve2(req, fd, dec);
210         goto out;
211     }
212     if(auth(req, fd, dec, p)) {
213         if(docache)
214             addcache(dec, p);
215         serve2(req, fd, dec);
216         goto out;
217     }
218     
219 out:
220     if(dec != NULL) {
221         memset(dec, 0, declen);
222         free(dec);
223     }
224     if(docache && (now - lastclean > 60))
225         cleancache(0);
226 }
227
228 static int auth(struct hthead *req, int fd, char *user, char *pass)
229 {
230     int i, rv, status;
231     ssize_t len;
232     char *msg;
233     struct charbuf ebuf;
234     pid_t pid;
235     int pfd[2], efd[2];
236     FILE *out;
237     
238     rv = 0;
239     msg = "The supplied credentials are invalid.";
240     pipe(pfd);
241     pipe(efd);
242     if((pid = fork()) < 0) {
243         flog(LOG_ERR, "htextauth: could not fork: %s", strerror(errno));
244         simpleerror(fd, 500, "Server Error", "An internal error occurred.");
245         close(pfd[0]); close(pfd[1]);
246         close(efd[0]); close(efd[1]);
247         return(0);
248     }
249     if(pid == 0) {
250         dup2(pfd[0], 0);
251         dup2(efd[1], 1);
252         for(i = 3; i < FD_SETSIZE; i++)
253             close(i);
254         execvp(authcmd[0], authcmd);
255         flog(LOG_ERR, "htextauth: could not exec %s: %s", authcmd[0], strerror(errno));
256         exit(127);
257     }
258     close(pfd[0]);
259     close(efd[1]);
260     out = fdopen(pfd[1], "w");
261     fprintf(out, "%s\n", user);
262     fprintf(out, "%s\n", pass);
263     fclose(out);
264     bufinit(ebuf);
265     while(1) {
266         sizebuf(ebuf, ebuf.d + 128);
267         len = read(efd[0], ebuf.b + ebuf.d, ebuf.s - ebuf.d);
268         if(len < 0) {
269             if(errno == EINTR)
270                 continue;
271             break;
272         } else if(len == 0) {
273             break;
274         }
275         ebuf.d += len;
276     }
277     if(ebuf.d > 0) {
278         bufadd(ebuf, 0);
279         msg = ebuf.b;
280     }
281     close(efd[0]);
282     if(waitpid(pid, &status, 0) < 0) {
283         flog(LOG_ERR, "htextauth: could not wait: %s", strerror(errno));
284         simpleerror(fd, 500, "Server Error", "An internal error occurred.");
285         buffree(ebuf);
286         return(0);
287     }
288     if(WCOREDUMP(status))
289         flog(LOG_WARNING, "htextauth: authenticator process dumped core");
290     if(WIFEXITED(status) && (WEXITSTATUS(status) == 0))
291         rv = 1;
292     else
293         authinval(req, fd, msg);
294     buffree(ebuf);
295     return(rv);
296 }
297
298 static void usage(FILE *out)
299 {
300     fprintf(out, "usage: htextauth [-hCs] [-r REALM] AUTHCMD [ARGS...] -- CHILD [ARGS...]\n");
301 }
302
303 static void sighandler(int sig)
304 {
305 }
306
307 int main(int argc, char **argv)
308 {
309     int i, c, ret;
310     struct charvbuf cbuf;
311     struct pollfd pfd[2];
312     struct hthead *req;
313     int fd;
314     
315     while((c = getopt(argc, argv, "+hCsr:")) >= 0) {
316         switch(c) {
317         case 'h':
318             usage(stdout);
319             return(0);
320         case 'C':
321             docache = 0;
322             break;
323         case 's':
324             reqssl = 1;
325             break;
326         case 'r':
327             realm = optarg;
328             break;
329         default:
330             usage(stderr);
331             return(1);
332         }
333     }
334     bufinit(cbuf);
335     for(i = optind; i < argc; i++) {
336         if(!strcmp(argv[i], "--"))
337             break;
338         bufadd(cbuf, argv[i]);
339     }
340     if((cbuf.d == 0) || (i == argc)) {
341         usage(stderr);
342         return(1);
343     }
344     bufadd(cbuf, NULL);
345     authcmd = cbuf.b;
346     i++;
347     if(i == argc) {
348         usage(stderr);
349         return(1);
350     }
351     if((ch = stdmkchild(argv + i, NULL, NULL)) < 0) {
352         flog(LOG_ERR, "htextauth: could not fork child: %s", strerror(errno));
353         return(1);
354     }
355     signal(SIGCHLD, sighandler);
356     signal(SIGPIPE, sighandler);
357     while(1) {
358         memset(pfd, 0, sizeof(pfd));
359         pfd[0].fd = 0;
360         pfd[0].events = POLLIN;
361         pfd[1].fd = ch;
362         pfd[1].events = POLLHUP;
363         if((ret = poll(pfd, 2, -1)) < 0) {
364             if(errno != EINTR) {
365                 flog(LOG_ERR, "htextauth: error in poll: %s", strerror(errno));
366                 exit(1);
367             }
368         }
369         if(pfd[0].revents) {
370             if((fd = recvreq(0, &req)) < 0) {
371                 if(errno == 0)
372                     break;
373                 flog(LOG_ERR, "htextauth: error in recvreq: %s", strerror(errno));
374                 exit(1);
375             }
376             serve(req, fd);
377             freehthead(req);
378             close(fd);
379         }
380         if(pfd[1].revents & POLLHUP)
381             break;
382     }
383     cleancache(1);
384     return(0);
385 }