source: trunk/third-party/shttpd/shttpd.c @ 6349

Last change on this file since 6349 was 6349, checked in by charles, 14 years ago

(third-party) upgrade shttpd from 1.39 to the latest, 1.41

File size: 48.2 KB
Line 
1/*
2 * Copyright (c) 2004-2005 Sergey Lyubka <valenok@gmail.com>
3 * All rights reserved
4 *
5 * "THE BEER-WARE LICENSE" (Revision 42):
6 * Sergey Lyubka wrote this file.  As long as you retain this notice you
7 * can do whatever you want with this stuff. If we meet some day, and you think
8 * this stuff is worth it, you can buy me a beer in return.
9 */
10
11/*
12 * Small and portable HTTP server, http://shttpd.sourceforge.net
13 * $Id: shttpd.c,v 1.44 2008/05/31 18:20:02 drozd Exp $
14 */
15
16#include "defs.h"
17
18time_t  current_time;   /* Current UTC time             */
19int     tz_offset;      /* Time zone offset from UTC    */
20int     exit_flag;      /* Program exit flag            */
21
22const struct vec known_http_methods[] = {
23        {"GET",         3},
24        {"POST",        4},
25        {"PUT",         3},
26        {"DELETE",      6},
27        {"HEAD",        4},
28        {NULL,          0}
29};
30
31/*
32 * This structure tells how HTTP headers must be parsed.
33 * Used by parse_headers() function.
34 */
35#define OFFSET(x)       offsetof(struct headers, x)
36static const struct http_header http_headers[] = {
37        {16, HDR_INT,    OFFSET(cl),            "Content-Length: "      },
38        {14, HDR_STRING, OFFSET(ct),            "Content-Type: "        },
39        {12, HDR_STRING, OFFSET(useragent),     "User-Agent: "          },
40        {19, HDR_DATE,   OFFSET(ims),           "If-Modified-Since: "   },
41        {15, HDR_STRING, OFFSET(auth),          "Authorization: "       },
42        {9,  HDR_STRING, OFFSET(referer),       "Referer: "             },
43        {8,  HDR_STRING, OFFSET(cookie),        "Cookie: "              },
44        {10, HDR_STRING, OFFSET(location),      "Location: "            },
45        {8,  HDR_INT,    OFFSET(status),        "Status: "              },
46        {7,  HDR_STRING, OFFSET(range),         "Range: "               },
47        {12, HDR_STRING, OFFSET(connection),    "Connection: "          },
48        {19, HDR_STRING, OFFSET(transenc),      "Transfer-Encoding: "   },
49        {0,  HDR_INT,    0,                     NULL                    }
50};
51
52struct shttpd_ctx *init_ctx(const char *config_file, int argc, char *argv[]);
53static void process_connection(struct conn *, int, int);
54
55int
56is_true(const char *str)
57{
58        static const char       *trues[] = {"1", "yes", "true", "jawohl", NULL};
59        const char              **p;
60
61        for (p = trues; *p != NULL; p++)
62                if (str && !strcmp(str, *p))
63                        return (TRUE);
64
65        return (FALSE);
66}
67
68static void
69free_list(struct llhead *head, void (*dtor)(struct llhead *))
70{
71        struct llhead   *lp, *tmp;
72
73        LL_FOREACH_SAFE(head, lp, tmp) {
74                LL_DEL(lp);
75                dtor(lp);
76        }
77}
78
79static void
80listener_destructor(struct llhead *lp)
81{
82        struct listener *listener = LL_ENTRY(lp, struct listener, link);
83
84        (void) closesocket(listener->sock);
85        free(listener);
86}
87
88static void
89registered_uri_destructor(struct llhead *lp)
90{
91        struct registered_uri *ruri = LL_ENTRY(lp, struct registered_uri, link);
92
93        free((void *) ruri->uri);
94        free(ruri);
95}
96
97static void
98acl_destructor(struct llhead *lp)
99{
100        struct acl      *acl = LL_ENTRY(lp, struct acl, link);
101        free(acl);
102}
103
104int
105url_decode(const char *src, int src_len, char *dst, int dst_len)
106{
107        int     i, j, a, b;
108#define HEXTOI(x)  (isdigit(x) ? x - '0' : x - 'W')
109
110        for (i = j = 0; i < src_len && j < dst_len - 1; i++, j++)
111                switch (src[i]) {
112                case '%':
113                        if (isxdigit(((unsigned char *) src)[i + 1]) &&
114                            isxdigit(((unsigned char *) src)[i + 2])) {
115                                a = tolower(((unsigned char *)src)[i + 1]);
116                                b = tolower(((unsigned char *)src)[i + 2]);
117                                dst[j] = (HEXTOI(a) << 4) | HEXTOI(b);
118                                i += 2;
119                        } else {
120                                dst[j] = '%';
121                        }
122                        break;
123                default:
124                        dst[j] = src[i];
125                        break;
126                }
127
128        dst[j] = '\0';  /* Null-terminate the destination */
129
130        return (j);
131}
132
133static const char *
134is_alias(struct shttpd_ctx *ctx, const char *uri,
135                struct vec *a_uri, struct vec *a_path)
136{
137        const char      *p, *s = ctx->options[OPT_ALIASES];
138        size_t          len;
139
140        DBG(("is_alias: aliases [%s]", s == NULL ? "" : s));
141
142        FOR_EACH_WORD_IN_LIST(s, len) {
143
144                if ((p = memchr(s, '=', len)) == NULL || p >= s + len || p == s)
145                        continue;
146
147                if (memcmp(uri, s, p - s) == 0) {
148                        a_uri->ptr = s;
149                        a_uri->len = p - s;
150                        a_path->ptr = ++p;
151                        a_path->len = (s + len) - p;
152                        return (s);
153                }
154        }
155
156        return (NULL);
157}
158
159void
160stop_stream(struct stream *stream)
161{
162        if (stream->io_class != NULL && stream->io_class->close != NULL)
163                stream->io_class->close(stream);
164
165        stream->io_class= NULL;
166        stream->flags |= FLAG_CLOSED;
167        stream->flags &= ~(FLAG_R | FLAG_W | FLAG_ALWAYS_READY);
168
169        DBG(("%d %s stopped. %lu of content data, %d now in a buffer",
170            stream->conn->rem.chan.sock, 
171            stream->io_class ? stream->io_class->name : "(null)",
172            (unsigned long) stream->io.total, (int) io_data_len(&stream->io)));
173}
174
175/*
176 * Setup listening socket on given port, return socket
177 */
178static int
179shttpd_open_listening_port(int port)
180{
181        int             sock, on = 1;
182        struct usa      sa;
183
184#ifdef _WIN32
185        {WSADATA data;  WSAStartup(MAKEWORD(2,2), &data);}
186#endif /* _WIN32 */
187
188        sa.len                          = sizeof(sa.u.sin);
189        sa.u.sin.sin_family             = AF_INET;
190        sa.u.sin.sin_port               = htons((uint16_t) port);
191        sa.u.sin.sin_addr.s_addr        = htonl(INADDR_ANY);
192
193        if ((sock = socket(PF_INET, SOCK_STREAM, 6)) == -1)
194                goto fail;
195        if (set_non_blocking_mode(sock) != 0)
196                goto fail;
197        if (setsockopt(sock, SOL_SOCKET,
198            SO_REUSEADDR,(char *) &on, sizeof(on)) != 0)
199                goto fail;
200        if (bind(sock, &sa.u.sa, sa.len) < 0)
201                goto fail;
202        if (listen(sock, 128) != 0)
203                goto fail;
204
205#ifndef _WIN32
206        (void) fcntl(sock, F_SETFD, FD_CLOEXEC);
207#endif /* !_WIN32 */
208
209        return (sock);
210fail:
211        if (sock != -1)
212                (void) closesocket(sock);
213        elog(E_LOG, NULL, "open_listening_port(%d): %s", port, strerror(errno));
214        return (-1);
215}
216
217/*
218 * Check whether full request is buffered Return headers length, or 0
219 */
220int
221get_headers_len(const char *buf, size_t buflen)
222{
223        const char      *s, *e;
224        int             len = 0;
225
226        for (s = buf, e = s + buflen - 1; len == 0 && s < e; s++)
227                /* Control characters are not allowed but >=128 is. */
228                if (!isprint(* (unsigned char *) s) && *s != '\r' &&
229                    *s != '\n' && * (unsigned char *) s < 128)
230                        len = -1;
231                else if (s[0] == '\n' && s[1] == '\n')
232                        len = s - buf + 2;
233                else if (s[0] == '\n' && &s[1] < e &&
234                    s[1] == '\r' && s[2] == '\n')
235                        len = s - buf + 3;
236
237        return (len);
238}
239
240/*
241 * Send error message back to a client.
242 */
243void
244send_server_error(struct conn *c, int status, const char *reason)
245{
246        struct llhead           *lp;
247        struct error_handler    *e;
248
249        LL_FOREACH(&c->ctx->error_handlers, lp) {
250                e = LL_ENTRY(lp, struct error_handler, link);
251
252                if (e->code == status) {
253                        if (c->loc.io_class != NULL &&
254                            c->loc.io_class->close != NULL)
255                                c->loc.io_class->close(&c->loc);
256                        io_clear(&c->loc.io);
257                        setup_embedded_stream(c, e->callback, e->callback_data);
258                        return;
259                }
260        }
261
262        io_clear(&c->loc.io);
263        c->loc.io.head = my_snprintf(c->loc.io.buf, c->loc.io.size,
264            "HTTP/1.1 %d %s\r\n"
265            "Content-Type: text/plain\r\n"
266            "Content-Length: 12\r\n"
267            "\r\n"
268            "Error: %03d\r\n",
269            status, reason, status);
270        c->loc.content_len = 10;
271        c->status = status;
272        stop_stream(&c->loc);
273}
274
275/*
276 * Convert month to the month number. Return -1 on error, or month number
277 */
278static int
279montoi(const char *s)
280{
281        static const char *ar[] = {
282                "Jan", "Feb", "Mar", "Apr", "May", "Jun",
283                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
284        };
285        size_t  i;
286
287        for (i = 0; i < sizeof(ar) / sizeof(ar[0]); i++)
288                if (!strcmp(s, ar[i]))
289                        return (i);
290
291        return (-1);
292}
293
294/*
295 * Parse date-time string, and return the corresponding time_t value
296 */
297static time_t
298date_to_epoch(const char *s)
299{
300        struct tm       tm, *tmp;
301        char            mon[32];
302        int             sec, min, hour, mday, month, year;
303
304        (void) memset(&tm, 0, sizeof(tm));
305        sec = min = hour = mday = month = year = 0;
306
307        if (((sscanf(s, "%d/%3s/%d %d:%d:%d",
308            &mday, mon, &year, &hour, &min, &sec) == 6) ||
309            (sscanf(s, "%d %3s %d %d:%d:%d",
310            &mday, mon, &year, &hour, &min, &sec) == 6) ||
311            (sscanf(s, "%*3s, %d %3s %d %d:%d:%d",
312            &mday, mon, &year, &hour, &min, &sec) == 6) ||
313            (sscanf(s, "%d-%3s-%d %d:%d:%d",
314            &mday, mon, &year, &hour, &min, &sec) == 6)) &&
315            (month = montoi(mon)) != -1) {
316                tm.tm_mday      = mday;
317                tm.tm_mon       = month;
318                tm.tm_year      = year;
319                tm.tm_hour      = hour;
320                tm.tm_min       = min;
321                tm.tm_sec       = sec;
322        }
323
324        if (tm.tm_year > 1900)
325                tm.tm_year -= 1900;
326        else if (tm.tm_year < 70)
327                tm.tm_year += 100;
328
329        /* Set Daylight Saving Time field */
330        tmp = localtime(&current_time);
331        tm.tm_isdst = tmp->tm_isdst;
332
333        return (mktime(&tm));
334}
335
336static void
337remove_double_dots(char *s)
338{
339        char    *p = s;
340
341        while (*s != '\0') {
342                *p++ = *s++;
343                if (s[-1] == '/' || s[-1] == '\\')
344                        while (*s == '.' || *s == '/' || *s == '\\')
345                                s++;
346        }
347        *p = '\0';
348}
349
350void
351parse_headers(const char *s, int len, struct headers *parsed)
352{
353        const struct http_header        *h;
354        union variant                   *v;
355        const char                      *p, *e = s + len;
356
357        DBG(("parsing headers (len %d): [%.*s]", len, len, s));
358
359        /* Loop through all headers in the request */
360        while (s < e) {
361
362                /* Find where this header ends */
363                for (p = s; p < e && *p != '\n'; ) p++;
364
365                /* Is this header known to us ? */
366                for (h = http_headers; h->len != 0; h++)
367                        if (e - s > h->len &&
368                            !my_strncasecmp(s, h->name, h->len))
369                                break;
370
371                /* If the header is known to us, store its value */
372                if (h->len != 0) {
373
374                        /* Shift to where value starts */
375                        s += h->len;
376
377                        /* Find place to store the value */
378                        v = (union variant *) ((char *) parsed + h->offset);
379
380                        /* Fetch header value into the connection structure */
381                        if (h->type == HDR_STRING) {
382                                v->v_vec.ptr = s;
383                                v->v_vec.len = p - s;
384                                if (p[-1] == '\r' && v->v_vec.len > 0)
385                                        v->v_vec.len--;
386                        } else if (h->type == HDR_INT) {
387                                v->v_big_int = strtoul(s, NULL, 10);
388                        } else if (h->type == HDR_DATE) {
389                                v->v_time = date_to_epoch(s);
390                        }
391                }
392
393                s = p + 1;      /* Shift to the next header */
394        }
395}
396
397static const struct {
398        const char      *extension;
399        int             ext_len;
400        const char      *mime_type;
401} builtin_mime_types[] = {
402        {"html",        4,      "text/html"                     },
403        {"htm",         3,      "text/html"                     },
404        {"txt",         3,      "text/plain"                    },
405        {"css",         3,      "text/css"                      },
406        {"ico",         3,      "image/x-icon"                  },
407        {"gif",         3,      "image/gif"                     },
408        {"jpg",         3,      "image/jpeg"                    },
409        {"jpeg",        4,      "image/jpeg"                    },
410        {"png",         3,      "image/png"                     },
411        {"svg",         3,      "image/svg+xml"                 },
412        {"torrent",     7,      "application/x-bittorrent"      },
413        {"wav",         3,      "audio/x-wav"                   },
414        {"mp3",         3,      "audio/x-mp3"                   },
415        {"mid",         3,      "audio/mid"                     },
416        {"m3u",         3,      "audio/x-mpegurl"               },
417        {"ram",         3,      "audio/x-pn-realaudio"          },
418        {"ra",          2,      "audio/x-pn-realaudio"          },
419        {"doc",         3,      "application/msword",           },
420        {"exe",         3,      "application/octet-stream"      },
421        {"zip",         3,      "application/x-zip-compressed"  },
422        {"xls",         3,      "application/excel"             },
423        {"tgz",         3,      "application/x-tar-gz"          },
424        {"tar.gz",      6,      "application/x-tar-gz"          },
425        {"tar",         3,      "application/x-tar"             },
426        {"gz",          2,      "application/x-gunzip"          },
427        {"arj",         3,      "application/x-arj-compressed"  },
428        {"rar",         3,      "application/x-arj-compressed"  },
429        {"rtf",         3,      "application/rtf"               },
430        {"pdf",         3,      "application/pdf"               },
431        {"swf",         3,      "application/x-shockwave-flash" },
432        {"mpg",         3,      "video/mpeg"                    },
433        {"mpeg",        4,      "video/mpeg"                    },
434        {"asf",         3,      "video/x-ms-asf"                },
435        {"avi",         3,      "video/x-msvideo"               },
436        {"bmp",         3,      "image/bmp"                     },
437        {NULL,          0,      NULL                            }
438};
439
440void
441get_mime_type(struct shttpd_ctx *ctx, const char *uri, int len, struct vec *vec)
442{
443        const char      *eq, *p = ctx->options[OPT_MIME_TYPES];
444        int             i, n, ext_len;
445
446        /* Firt, loop through the custom mime types if any */
447        FOR_EACH_WORD_IN_LIST(p, n) {
448                if ((eq = memchr(p, '=', n)) == NULL || eq >= p + n || eq == p)
449                        continue;
450                ext_len = eq - p;
451                if (len > ext_len && uri[len - ext_len - 1] == '.' &&
452                    !my_strncasecmp(p, &uri[len - ext_len], ext_len)) {
453                        vec->ptr = eq + 1;
454                        vec->len = p + n - vec->ptr;
455                        return;
456                }
457        }
458
459        /* If no luck, try built-in mime types */
460        for (i = 0; builtin_mime_types[i].extension != NULL; i++) {
461                ext_len = builtin_mime_types[i].ext_len;
462                if (len > ext_len && uri[len - ext_len - 1] == '.' &&
463                    !my_strncasecmp(builtin_mime_types[i].extension,
464                            &uri[len - ext_len], ext_len)) {
465                        vec->ptr = builtin_mime_types[i].mime_type;
466                        vec->len = strlen(vec->ptr);
467                        return;
468                }
469        }
470
471        /* Oops. This extension is unknown to us. Fallback to text/plain */
472        vec->ptr = "text/plain";
473        vec->len = strlen(vec->ptr);
474}
475
476/*
477 * For given directory path, substitute it to valid index file.
478 * Return 0 if index file has been found, -1 if not found
479 */
480static int
481find_index_file(struct conn *c, char *path, size_t maxpath, struct stat *stp)
482{
483        char            buf[FILENAME_MAX];
484        const char      *s = c->ctx->options[OPT_INDEX_FILES];
485        size_t          len;
486
487        FOR_EACH_WORD_IN_LIST(s, len) {
488                my_snprintf(buf, sizeof(buf), "%s%c%.*s",path, DIRSEP, len, s);
489                if (my_stat(buf, stp) == 0) {
490                        my_strlcpy(path, buf, maxpath);
491                        get_mime_type(c->ctx, s, len, &c->mime_type);
492                        return (0);
493                }
494        }
495
496        return (-1);
497}
498
499/*
500 * Try to open requested file, return 0 if OK, -1 if error.
501 * If the file is given arguments using PATH_INFO mechanism,
502 * initialize pathinfo pointer.
503 */
504static int
505get_path_info(struct conn *c, char *path, struct stat *stp)
506{
507        char    *p, *e;
508
509        if (my_stat(path, stp) == 0)
510                return (0);
511
512        p = path + strlen(path);
513        e = path + strlen(c->ctx->options[OPT_ROOT]) + 2;
514       
515        /* Strip directory parts of the path one by one */
516        for (; p > e; p--)
517                if (*p == '/') {
518                        *p = '\0';
519                        if (!my_stat(path, stp) && !S_ISDIR(stp->st_mode)) {
520                                c->path_info = p + 1;
521                                return (0);
522                        } else {
523                                *p = '/';
524                        }
525                }
526
527        return (-1);
528}
529
530static void
531decide_what_to_do(struct conn *c)
532{
533        char            path[URI_MAX], buf[1024], *root;
534        struct vec      alias_uri, alias_path;
535        struct stat     st;
536        int             rc;
537        struct registered_uri   *ruri;
538
539        DBG(("decide_what_to_do: [%s]", c->uri));
540
541        if ((c->query = strchr(c->uri, '?')) != NULL)
542                *c->query++ = '\0';
543
544        url_decode(c->uri, strlen(c->uri), c->uri, strlen(c->uri) + 1);
545        remove_double_dots(c->uri);
546       
547        root = c->ctx->options[OPT_ROOT];
548        if (strlen(c->uri) + strlen(root) >= sizeof(path)) {
549                send_server_error(c, 400, "URI is too long");
550                return;
551        }
552
553        (void) my_snprintf(path, sizeof(path), "%s%s", root, c->uri);
554
555        /* User may use the aliases - check URI for mount point */
556        if (is_alias(c->ctx, c->uri, &alias_uri, &alias_path) != NULL) {
557                (void) my_snprintf(path, sizeof(path), "%.*s%s",
558                    alias_path.len, alias_path.ptr, c->uri + alias_uri.len);
559                DBG(("using alias %.*s -> %.*s", alias_uri.len, alias_uri.ptr,
560                    alias_path.len, alias_path.ptr));
561        }
562
563#if !defined(NO_AUTH)
564        if (check_authorization(c, path) != 1) {
565                send_authorization_request(c);
566        } else
567#endif /* NO_AUTH */
568        if ((ruri = is_registered_uri(c->ctx, c->uri)) != NULL) {
569                setup_embedded_stream(c, ruri->callback, ruri->callback_data);
570        } else
571        if (strstr(path, HTPASSWD)) {
572                /* Do not allow to view passwords files */
573                send_server_error(c, 403, "Forbidden");
574        } else
575#if !defined(NO_AUTH)
576        if ((c->method == METHOD_PUT || c->method == METHOD_DELETE) &&
577            (c->ctx->options[OPT_AUTH_PUT] == NULL ||
578             !is_authorized_for_put(c))) {
579                send_authorization_request(c);
580        } else
581#endif /* NO_AUTH */
582        if (c->method == METHOD_PUT) {
583                c->status = my_stat(path, &st) == 0 ? 200 : 201;
584
585                if (c->ch.range.v_vec.len > 0) {
586                        send_server_error(c, 501, "PUT Range Not Implemented");
587                } else if ((rc = put_dir(path)) == 0) {
588                        send_server_error(c, 200, "OK");
589                } else if (rc == -1) {
590                        send_server_error(c, 500, "PUT Directory Error");
591                } else if (c->rem.content_len == 0) {
592                        send_server_error(c, 411, "Length Required");
593                } else if ((c->loc.chan.fd = my_open(path, O_WRONLY | O_BINARY |
594                    O_CREAT | O_NONBLOCK | O_TRUNC, 0644)) == -1) {
595                        send_server_error(c, 500, "PUT Error");
596                } else {
597                        DBG(("PUT file [%s]", c->uri));
598                        c->loc.io_class = &io_file;
599                        c->loc.flags |= FLAG_W | FLAG_ALWAYS_READY ;
600                }
601        } else if (c->method == METHOD_DELETE) {
602                DBG(("DELETE [%s]", c->uri));
603                if (my_remove(path) == 0)
604                        send_server_error(c, 200, "OK");
605                else
606                        send_server_error(c, 500, "DELETE Error");
607        } else if (get_path_info(c, path, &st) != 0) {
608                send_server_error(c, 404, "Not Found");
609        } else if (S_ISDIR(st.st_mode) && path[strlen(path) - 1] != '/') {
610                (void) my_snprintf(buf, sizeof(buf),
611                        "Moved Permanently\r\nLocation: %s/", c->uri);
612                send_server_error(c, 301, buf);
613        } else if (S_ISDIR(st.st_mode) &&
614            find_index_file(c, path, sizeof(path) - 1, &st) == -1 &&
615            !IS_TRUE(c->ctx, OPT_DIR_LIST)) {
616                send_server_error(c, 403, "Directory Listing Denied");
617        } else if (S_ISDIR(st.st_mode) && IS_TRUE(c->ctx, OPT_DIR_LIST)) {
618                if ((c->loc.chan.dir.path = my_strdup(path)) != NULL)
619                        get_dir(c);
620                else
621                        send_server_error(c, 500, "GET Directory Error");
622        } else if (S_ISDIR(st.st_mode) && !IS_TRUE(c->ctx, OPT_DIR_LIST)) {
623                send_server_error(c, 403, "Directory listing denied");
624#if !defined(NO_CGI)
625        } else if (match_extension(path, c->ctx->options[OPT_CGI_EXTENSIONS])) {
626                if (c->method != METHOD_POST && c->method != METHOD_GET) {
627                        send_server_error(c, 501, "Bad method ");
628                } else if ((run_cgi(c, path)) == -1) {
629                        send_server_error(c, 500, "Cannot exec CGI");
630                } else {
631                        do_cgi(c);
632                }
633#endif /* NO_CGI */
634#if !defined(NO_SSI)
635        } else if (match_extension(path, c->ctx->options[OPT_SSI_EXTENSIONS])) {
636                if ((c->loc.chan.fd = my_open(path,
637                    O_RDONLY | O_BINARY, 0644)) == -1) {
638                        send_server_error(c, 500, "SSI open error");
639                } else {
640                        do_ssi(c);
641                }
642#endif /* NO_CGI */
643        } else if (c->ch.ims.v_time && st.st_mtime <= c->ch.ims.v_time) {
644                send_server_error(c, 304, "Not Modified");
645        } else if ((c->loc.chan.fd = my_open(path,
646            O_RDONLY | O_BINARY, 0644)) != -1) {
647                get_file(c, &st);
648        } else {
649                send_server_error(c, 500, "Internal Error");
650        }
651}
652
653static int
654set_request_method(struct conn *c)
655{
656        const struct vec        *v;
657
658        /* Set the request method */
659        for (v = known_http_methods; v->ptr != NULL; v++)
660                if (!memcmp(c->rem.io.buf, v->ptr, v->len)) {
661                        c->method = v - known_http_methods;
662                        break;
663                }
664
665        return (v->ptr == NULL);
666}
667
668static void
669parse_http_request(struct conn *c)
670{
671        char    *s, *e, *p, *start;
672        int     uri_len, req_len, n;
673
674        s = io_data(&c->rem.io);;
675        req_len = c->rem.headers_len =
676            get_headers_len(s, io_data_len(&c->rem.io));
677
678        if (req_len == 0 && io_space_len(&c->rem.io) == 0) {
679                io_clear(&c->rem.io);
680                send_server_error(c, 400, "Request is too big");
681        }
682
683        if (req_len == 0) {
684                return;
685        } else if (req_len < 16) {      /* Minimal: "GET / HTTP/1.0\n\n" */
686                send_server_error(c, 400, "Bad request");
687        } else if (set_request_method(c)) {
688                send_server_error(c, 501, "Method Not Implemented");
689        } else if ((c->request = my_strndup(s, req_len)) == NULL) {
690                send_server_error(c, 500, "Cannot allocate request");
691        }
692
693        if (c->loc.flags & FLAG_CLOSED)
694                return;
695
696        io_inc_tail(&c->rem.io, req_len);
697
698        DBG(("Conn %d: parsing request: [%.*s]", c->rem.chan.sock, req_len, s));
699        c->rem.flags |= FLAG_HEADERS_PARSED;
700
701        /* Set headers pointer. Headers follow the request line */
702        c->headers = memchr(c->request, '\n', req_len);
703        assert(c->headers != NULL);
704        assert(c->headers < c->request + req_len);
705        if (c->headers > c->request && c->headers[-1] == '\r')
706                c->headers[-1] = '\0';
707        *c->headers++ = '\0';
708
709        /*
710         * Now make a copy of the URI, because it will be URL-decoded,
711         * and we need a copy of unmodified URI for the access log.
712         * First, we skip the REQUEST_METHOD and shift to the URI.
713         */
714        for (p = c->request, e = p + req_len; *p != ' ' && p < e; p++);
715        while (p < e && *p == ' ')
716                p++;
717
718        /* Now remember where URI starts, and shift to the end of URI */
719        for (start = p; p < e && !isspace((unsigned char)*p); ) p++;
720        uri_len = p - start;
721
722        /* Skip space following the URI */
723        while (p < e && *p == ' ')
724                p++;
725
726        /* Now comes the HTTP-Version in the form HTTP/<major>.<minor> */
727        if (sscanf(p, "HTTP/%lu.%lu%n",
728            &c->major_version, &c->minor_version, &n) != 2 || p[n] != '\0') {
729                send_server_error(c, 400, "Bad HTTP version");
730        } else if (c->major_version > 1 ||
731            (c->major_version == 1 && c->minor_version > 1)) {
732                send_server_error(c, 505, "HTTP version not supported");
733        } else if (uri_len <= 0) {
734                send_server_error(c, 400, "Bad URI");
735        } else if ((c->uri = malloc(uri_len + 1)) == NULL) {
736                send_server_error(c, 500, "Cannot allocate URI");
737        } else {
738                my_strlcpy(c->uri, (char *) start, uri_len + 1);
739                parse_headers(c->headers,
740                    (c->request + req_len) - c->headers, &c->ch);
741
742                /* Remove the length of request from total, count only data */
743                assert(c->rem.io.total >= (big_int_t) req_len);
744                c->rem.io.total -= req_len;
745                c->rem.content_len = c->ch.cl.v_big_int;
746                decide_what_to_do(c);
747        }
748}
749
750static void
751add_socket(struct worker *worker, int sock, int is_ssl)
752{
753        struct shttpd_ctx       *ctx = worker->ctx;
754        struct conn             *c;
755        struct usa              sa;
756        int                     l = IS_TRUE(ctx, OPT_INETD) ? E_FATAL : E_LOG;
757#if !defined(NO_SSL)
758        SSL             *ssl = NULL;
759#else
760        is_ssl = is_ssl;        /* supress warnings */
761#endif /* NO_SSL */
762
763        sa.len = sizeof(sa.u.sin);
764        (void) set_non_blocking_mode(sock);
765
766        if (getpeername(sock, &sa.u.sa, &sa.len)) {
767                elog(l, NULL, "add_socket: %s", strerror(errno));
768#if !defined(NO_SSL)
769        } else if (is_ssl && (ssl = SSL_new(ctx->ssl_ctx)) == NULL) {
770                elog(l, NULL, "add_socket: SSL_new: %s", strerror(ERRNO));
771                (void) closesocket(sock);
772        } else if (is_ssl && SSL_set_fd(ssl, sock) == 0) {
773                elog(l, NULL, "add_socket: SSL_set_fd: %s", strerror(ERRNO));
774                (void) closesocket(sock);
775                SSL_free(ssl);
776#endif /* NO_SSL */
777        } else if ((c = calloc(1, sizeof(*c) + 2 * URI_MAX)) == NULL) {
778#if !defined(NO_SSL)
779                if (ssl)
780                        SSL_free(ssl);
781#endif /* NO_SSL */
782                (void) closesocket(sock);
783                elog(l, NULL, "add_socket: calloc: %s", strerror(ERRNO));
784        } else {
785                c->rem.conn     = c->loc.conn = c;
786                c->ctx          = ctx;
787                c->worker       = worker;
788                c->sa           = sa;
789                c->birth_time   = current_time;
790                c->expire_time  = current_time + EXPIRE_TIME;
791
792                (void) getsockname(sock, &sa.u.sa, &sa.len);
793                c->loc_port = sa.u.sin.sin_port;
794
795                set_close_on_exec(sock);
796
797                c->loc.io_class = NULL;
798       
799                c->rem.io_class = &io_socket;
800                c->rem.chan.sock = sock;
801
802                /* Set IO buffers */
803                c->loc.io.buf   = (char *) (c + 1);
804                c->rem.io.buf   = c->loc.io.buf + URI_MAX;
805                c->loc.io.size  = c->rem.io.size = URI_MAX;
806
807#if !defined(NO_SSL)
808                if (is_ssl) {
809                        c->rem.io_class = &io_ssl;
810                        c->rem.chan.ssl.sock = sock;
811                        c->rem.chan.ssl.ssl = ssl;
812                        ssl_handshake(&c->rem);
813                }
814#endif /* NO_SSL */
815
816                LL_TAIL(&worker->connections, &c->link);
817                worker->num_conns++;
818               
819                DBG(("%s:%hu connected (socket %d)",
820                    inet_ntoa(* (struct in_addr *) &sa.u.sin.sin_addr.s_addr),
821                    ntohs(sa.u.sin.sin_port), sock));
822        }
823}
824
825static struct worker *
826first_worker(struct shttpd_ctx *ctx)
827{
828        return (LL_ENTRY(ctx->workers.next, struct worker, link));
829}
830
831static void
832pass_socket(struct shttpd_ctx *ctx, int sock, int is_ssl)
833{
834        struct llhead   *lp;
835        struct worker   *worker, *lazy;
836        int             buf[3];
837
838        lazy = first_worker(ctx);
839
840        /* Find least busy worker */
841        LL_FOREACH(&ctx->workers, lp) {
842                worker = LL_ENTRY(lp, struct worker, link);
843                if (worker->num_conns < lazy->num_conns)
844                        lazy = worker;
845        }
846
847        buf[0] = CTL_PASS_SOCKET;
848        buf[1] = sock;
849        buf[2] = is_ssl;
850
851        (void) send(lazy->ctl[1], (void *) buf, sizeof(buf), 0);
852}
853
854static void
855set_ports(struct shttpd_ctx *ctx, const char *p)
856{
857        int             sock, len, is_ssl, port;
858        struct listener *l;
859
860
861        free_list(&ctx->listeners, &listener_destructor);
862
863        FOR_EACH_WORD_IN_LIST(p, len) {
864
865                is_ssl  = p[len - 1] == 's' ? 1 : 0;
866                port    = atoi(p);
867
868                if ((sock = shttpd_open_listening_port(port)) == -1) {
869                        elog(E_FATAL, NULL, "cannot open port %d", port);
870                } else if ((l = calloc(1, sizeof(*l))) == NULL) {
871                        (void) closesocket(sock);
872                        elog(E_FATAL, NULL, "cannot allocate listener");
873                } else if (is_ssl && ctx->ssl_ctx == NULL) {
874                        (void) closesocket(sock);
875                        elog(E_FATAL, NULL, "cannot add SSL socket, "
876                            "please specify certificate file");
877                } else {
878                        l->is_ssl = is_ssl;
879                        l->sock = sock;
880                        l->ctx  = ctx;
881                        LL_TAIL(&ctx->listeners, &l->link);
882                        DBG(("shttpd_listen: added socket %d", sock));
883                }
884        }
885}
886
887static void
888read_stream(struct stream *stream)
889{
890        int     n, len;
891
892        len = io_space_len(&stream->io);
893        assert(len > 0);
894
895        /* Do not read more that needed */
896        if (stream->content_len > 0 &&
897            stream->io.total + len > stream->content_len)
898                len = stream->content_len - stream->io.total;
899
900        /* Read from underlying channel */
901        n = stream->io_class->read(stream, io_space(&stream->io), len);
902
903        if (n > 0)
904                io_inc_head(&stream->io, n);
905        else if (n == -1 && (ERRNO == EINTR || ERRNO == EWOULDBLOCK))
906                n = n;  /* Ignore EINTR and EAGAIN */
907        else if (!(stream->flags & FLAG_DONT_CLOSE))
908                stop_stream(stream);
909
910        DBG(("read_stream (%d %s): read %d/%d/%lu bytes (errno %d)",
911            stream->conn->rem.chan.sock,
912            stream->io_class ? stream->io_class->name : "(null)",
913            n, len, (unsigned long) stream->io.total, ERRNO));
914
915        /*
916         * Close the local stream if everything was read
917         * XXX We do not close the remote stream though! It may be
918         * a POST data completed transfer, we do not want the socket
919         * to be closed.
920         */
921        if (stream->content_len > 0 && stream == &stream->conn->loc) {
922                assert(stream->io.total <= stream->content_len);
923                if (stream->io.total == stream->content_len)
924                        stop_stream(stream);
925        }
926
927        stream->conn->expire_time = current_time + EXPIRE_TIME;
928}
929
930static void
931write_stream(struct stream *from, struct stream *to)
932{
933        int     n, len;
934
935        len = io_data_len(&from->io);
936        assert(len > 0);
937
938        /* TODO: should be assert on CAN_WRITE flag */
939        n = to->io_class->write(to, io_data(&from->io), len);
940        to->conn->expire_time = current_time + EXPIRE_TIME;
941        DBG(("write_stream (%d %s): written %d/%d bytes (errno %d)",
942            to->conn->rem.chan.sock,
943            to->io_class ? to->io_class->name : "(null)", n, len, ERRNO));
944
945        if (n > 0)
946                io_inc_tail(&from->io, n);
947        else if (n == -1 && (ERRNO == EINTR || ERRNO == EWOULDBLOCK))
948                n = n;  /* Ignore EINTR and EAGAIN */
949        else if (!(to->flags & FLAG_DONT_CLOSE))
950                stop_stream(to);
951}
952
953
954static void
955connection_desctructor(struct llhead *lp)
956{
957        struct conn             *c = LL_ENTRY(lp, struct conn, link);
958        static const struct vec vec = {"close", 5};
959        int                     do_close;
960
961        DBG(("Disconnecting %d (%.*s)", c->rem.chan.sock,
962            c->ch.connection.v_vec.len, c->ch.connection.v_vec.ptr));
963
964        if (c->request != NULL && c->ctx->access_log != NULL)
965                log_access(c->ctx->access_log, c);
966
967        /* In inetd mode, exit if request is finished. */
968        if (IS_TRUE(c->ctx, OPT_INETD))
969                exit(0);
970
971        if (c->loc.io_class != NULL && c->loc.io_class->close != NULL)
972                c->loc.io_class->close(&c->loc);
973
974        /*
975         * Check the "Connection: " header before we free c->request
976         * If it its 'keep-alive', then do not close the connection
977         */
978        do_close = (c->ch.connection.v_vec.len >= vec.len &&
979            !my_strncasecmp(vec.ptr, c->ch.connection.v_vec.ptr, vec.len)) ||
980            (c->major_version < 1 ||
981            (c->major_version >= 1 && c->minor_version < 1));
982
983        if (c->request)
984                free(c->request);
985        if (c->uri)
986                free(c->uri);
987
988        /* Keep the connection open only if we have Content-Length set */
989        if (!do_close && c->loc.content_len > 0) {
990                c->loc.io_class = NULL;
991                c->loc.flags = 0;
992                c->loc.content_len = 0;
993                c->rem.flags = FLAG_W | FLAG_R | FLAG_SSL_ACCEPTED;
994                c->query = c->request = c->uri = c->path_info = NULL;
995                c->mime_type.len = 0;
996                (void) memset(&c->ch, 0, sizeof(c->ch));
997                io_clear(&c->loc.io);
998                c->birth_time = current_time;
999                if (io_data_len(&c->rem.io) > 0)
1000                        process_connection(c, 0, 0);
1001        } else {
1002                if (c->rem.io_class != NULL)
1003                        c->rem.io_class->close(&c->rem);
1004
1005                LL_DEL(&c->link);
1006                c->worker->num_conns--;
1007                assert(c->worker->num_conns >= 0);
1008
1009                free(c);
1010        }
1011}
1012
1013static void
1014worker_destructor(struct llhead *lp)
1015{
1016        struct worker   *worker = LL_ENTRY(lp, struct worker, link);
1017
1018        free_list(&worker->connections, connection_desctructor);
1019        free(worker);
1020}
1021
1022static int
1023is_allowed(const struct shttpd_ctx *ctx, const struct usa *usa)
1024{
1025        const struct acl        *acl;
1026        const struct llhead     *lp;
1027        int                     allowed = '+';
1028        uint32_t                ip;
1029
1030        LL_FOREACH(&ctx->acl, lp) {
1031                acl = LL_ENTRY(lp, struct acl, link);
1032                (void) memcpy(&ip, &usa->u.sin.sin_addr, sizeof(ip));
1033                if (acl->ip == (ntohl(ip) & acl->mask))
1034                        allowed = acl->flag;
1035        }
1036
1037        return (allowed == '+');
1038}
1039
1040static void
1041add_to_set(int fd, fd_set *set, int *max_fd)
1042{
1043        FD_SET(fd, set);
1044        if (fd > *max_fd)
1045                *max_fd = fd;
1046}
1047
1048static void
1049process_connection(struct conn *c, int remote_ready, int local_ready)
1050{
1051        /* Read from remote end if it is ready */
1052        if (remote_ready && io_space_len(&c->rem.io))
1053                read_stream(&c->rem);
1054
1055        /* If the request is not parsed yet, do so */
1056        if (!(c->rem.flags & FLAG_HEADERS_PARSED))
1057                parse_http_request(c);
1058
1059        DBG(("loc: %d [%.*s]", (int) io_data_len(&c->loc.io),
1060            (int) io_data_len(&c->loc.io), io_data(&c->loc.io)));
1061        DBG(("rem: %d [%.*s]", (int) io_data_len(&c->rem.io),
1062            (int) io_data_len(&c->rem.io), io_data(&c->rem.io)));
1063
1064        /* Read from the local end if it is ready */
1065        if (local_ready && io_space_len(&c->loc.io))
1066                read_stream(&c->loc);
1067
1068        if (io_data_len(&c->rem.io) > 0 && (c->loc.flags & FLAG_W) &&
1069            c->loc.io_class != NULL && c->loc.io_class->write != NULL)
1070                write_stream(&c->rem, &c->loc);
1071
1072        if (io_data_len(&c->loc.io) > 0 && c->rem.io_class != NULL)
1073                write_stream(&c->loc, &c->rem); 
1074
1075        /* Check whether we should close this connection */
1076        if ((current_time > c->expire_time) ||
1077            (c->rem.flags & FLAG_CLOSED) ||
1078            ((c->loc.flags & FLAG_CLOSED) && !io_data_len(&c->loc.io)))
1079                connection_desctructor(&c->link);
1080}
1081
1082static int
1083num_workers(const struct shttpd_ctx *ctx)
1084{
1085        char    *p = ctx->options[OPT_THREADS];
1086        return (p ? atoi(p) : 1);
1087}
1088
1089static void
1090handle_connected_socket(struct shttpd_ctx *ctx,
1091                struct usa *sap, int sock, int is_ssl)
1092{
1093#if !defined(_WIN32)
1094        if (sock >= (int) FD_SETSIZE) {
1095                elog(E_LOG, NULL, "ctx %p: discarding "
1096                    "socket %d, too busy", ctx, sock);
1097                (void) closesocket(sock);
1098        } else
1099#endif /* !_WIN32 */
1100                if (!is_allowed(ctx, sap)) {
1101                elog(E_LOG, NULL, "%s is not allowed to connect",
1102                    inet_ntoa(sap->u.sin.sin_addr));
1103                (void) closesocket(sock);
1104        } else if (num_workers(ctx) > 1) {
1105                pass_socket(ctx, sock, is_ssl);
1106        } else {
1107                add_socket(first_worker(ctx), sock, is_ssl);
1108        }
1109}
1110
1111static int
1112do_select(int max_fd, fd_set *read_set, fd_set *write_set, int milliseconds)
1113{
1114        struct timeval  tv;
1115        int             n;
1116
1117        tv.tv_sec = milliseconds / 1000;
1118        tv.tv_usec = (milliseconds % 1000) * 1000;
1119
1120        /* Check IO readiness */
1121        if ((n = select(max_fd + 1, read_set, write_set, NULL, &tv)) < 0) {
1122#ifdef _WIN32
1123                /*
1124                 * On windows, if read_set and write_set are empty,
1125                 * select() returns "Invalid parameter" error
1126                 * (at least on my Windows XP Pro). So in this case,
1127                 * we sleep here.
1128                 */
1129                Sleep(milliseconds);
1130#endif /* _WIN32 */
1131                DBG(("select: %d", ERRNO));
1132        }
1133
1134        return (n);
1135}
1136
1137static void
1138multiplex_worker_sockets(const struct worker *worker, int *max_fd,
1139                fd_set *read_set, fd_set *write_set, int *milliseconds)
1140{
1141        struct llhead   *lp;
1142        struct conn     *c;
1143
1144        /* Add control socket */
1145        add_to_set(worker->ctl[0], read_set, max_fd);
1146
1147        /* Multiplex streams */
1148        LL_FOREACH(&worker->connections, lp) {
1149                c = LL_ENTRY(lp, struct conn, link);
1150               
1151                /* If there is a space in remote IO, check remote socket */
1152                if (io_space_len(&c->rem.io))
1153                        add_to_set(c->rem.chan.fd, read_set, max_fd);
1154
1155#if !defined(NO_CGI)
1156                /*
1157                 * If there is a space in local IO, and local endpoint is
1158                 * CGI, check local socket for read availability
1159                 */
1160                if (io_space_len(&c->loc.io) && (c->loc.flags & FLAG_R) &&
1161                    c->loc.io_class == &io_cgi)
1162                        add_to_set(c->loc.chan.fd, read_set, max_fd);
1163
1164                /*
1165                 * If there is some data read from remote socket, and
1166                 * local endpoint is CGI, check local for write availability
1167                 */
1168                if (io_data_len(&c->rem.io) && (c->loc.flags & FLAG_W) &&
1169                    c->loc.io_class == &io_cgi)
1170                        add_to_set(c->loc.chan.fd, write_set, max_fd);
1171#endif /* NO_CGI */
1172
1173                /*
1174                 * If there is some data read from local endpoint, check the
1175                 * remote socket for write availability
1176                 */
1177                if (io_data_len(&c->loc.io) && !(c->loc.flags & FLAG_SUSPEND))
1178                        add_to_set(c->rem.chan.fd, write_set, max_fd);
1179
1180                /*
1181                 * Set select wait interval to zero if FLAG_ALWAYS_READY set
1182                 */
1183                if (io_space_len(&c->loc.io) && (c->loc.flags & FLAG_R) &&
1184                    (c->loc.flags & FLAG_ALWAYS_READY))
1185                        *milliseconds = 0;
1186               
1187                if (io_data_len(&c->rem.io) && (c->loc.flags & FLAG_W) &&
1188                    (c->loc.flags & FLAG_ALWAYS_READY))
1189                        *milliseconds = 0;
1190        }
1191}
1192
1193static void
1194process_worker_sockets(struct worker *worker, fd_set *read_set)
1195{
1196        struct llhead   *lp, *tmp;
1197        int             cmd, skt[2], sock = worker->ctl[0];
1198        struct conn     *c;
1199
1200        /* Check if new socket is passed to us over the control socket */
1201        if (FD_ISSET(worker->ctl[0], read_set))
1202                while (recv(sock, (void *) &cmd, sizeof(cmd), 0) == sizeof(cmd))
1203                        switch (cmd) {
1204                        case CTL_PASS_SOCKET:
1205                                (void)recv(sock, (void *) &skt, sizeof(skt), 0);
1206                                add_socket(worker, skt[0], skt[1]);
1207                                break;
1208                        case CTL_WAKEUP:
1209                                (void)recv(sock, (void *) &c, sizeof(c), 0);
1210                                c->loc.flags &= FLAG_SUSPEND;
1211                                break;
1212                        default:
1213                                elog(E_FATAL, NULL, "ctx %p: ctl cmd %d",
1214                                    worker->ctx, cmd);
1215                                break;
1216                        }
1217
1218        /* Process all connections */
1219        LL_FOREACH_SAFE(&worker->connections, lp, tmp) {
1220                c = LL_ENTRY(lp, struct conn, link);
1221                process_connection(c, FD_ISSET(c->rem.chan.fd, read_set),
1222                    ((c->loc.flags & FLAG_ALWAYS_READY)
1223#if !defined(NO_CGI)
1224                    || (c->loc.io_class == &io_cgi &&
1225                     FD_ISSET(c->loc.chan.fd, read_set))
1226#endif /* NO_CGI */
1227                    ));
1228        }
1229}
1230
1231/*
1232 * One iteration of server loop. This is the core of the data exchange.
1233 */
1234void
1235shttpd_poll(struct shttpd_ctx *ctx, int milliseconds)
1236{
1237        struct llhead   *lp;
1238        struct listener *l;
1239        fd_set          read_set, write_set;
1240        int             sock, max_fd = -1;
1241        struct usa      sa;
1242
1243        current_time = time(0);
1244        FD_ZERO(&read_set);
1245        FD_ZERO(&write_set);
1246
1247        /* Add listening sockets to the read set */
1248        LL_FOREACH(&ctx->listeners, lp) {
1249                l = LL_ENTRY(lp, struct listener, link);
1250                add_to_set(l->sock, &read_set, &max_fd);
1251                DBG(("FD_SET(%d) (listening)", l->sock));
1252        }
1253
1254        if (num_workers(ctx) == 1)
1255                multiplex_worker_sockets(first_worker(ctx), &max_fd,
1256                                &read_set, &write_set, &milliseconds);
1257
1258        if (do_select(max_fd, &read_set, &write_set, milliseconds) < 0)
1259                return;;
1260
1261        /* Check for incoming connections on listener sockets */
1262        LL_FOREACH(&ctx->listeners, lp) {
1263                l = LL_ENTRY(lp, struct listener, link);
1264                if (!FD_ISSET(l->sock, &read_set))
1265                        continue;
1266                do {
1267                        sa.len = sizeof(sa.u.sin);
1268                        if ((sock = accept(l->sock, &sa.u.sa, &sa.len)) != -1)
1269                                handle_connected_socket(ctx,&sa,sock,l->is_ssl);
1270                } while (sock != -1);
1271        }
1272
1273        if (num_workers(ctx) == 1)
1274                process_worker_sockets(first_worker(ctx), &read_set);
1275}
1276
1277/*
1278 * Deallocate shttpd object, free up the resources
1279 */
1280void
1281shttpd_fini(struct shttpd_ctx *ctx)
1282{
1283        size_t  i;
1284
1285        free_list(&ctx->workers, worker_destructor);
1286        free_list(&ctx->registered_uris, registered_uri_destructor);
1287        free_list(&ctx->acl, acl_destructor);
1288        free_list(&ctx->listeners, listener_destructor);
1289#if !defined(NO_SSI)
1290        free_list(&ctx->ssi_funcs, ssi_func_destructor);
1291#endif /* !NO_SSI */
1292
1293        for (i = 0; i < NELEMS(ctx->options); i++)
1294                if (ctx->options[i] != NULL)
1295                        free(ctx->options[i]);
1296
1297        if (ctx->access_log)            (void) fclose(ctx->access_log);
1298        if (ctx->error_log)             (void) fclose(ctx->error_log);
1299
1300        /* TODO: free SSL context */
1301
1302        free(ctx);
1303}
1304
1305/*
1306 * UNIX socketpair() implementation. Why? Because Windows does not have it.
1307 * Return 0 on success, -1 on error.
1308 */
1309int
1310shttpd_socketpair(int sp[2])
1311{
1312        struct sockaddr_in      sa;
1313        int                     sock, ret = -1;
1314        socklen_t               len = sizeof(sa);
1315
1316        sp[0] = sp[1] = -1;
1317
1318        (void) memset(&sa, 0, sizeof(sa));
1319        sa.sin_family           = AF_INET;
1320        sa.sin_port             = htons(0);
1321        sa.sin_addr.s_addr      = htonl(INADDR_LOOPBACK);
1322
1323        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) != -1 &&
1324            !bind(sock, (struct sockaddr *) &sa, len) &&
1325            !listen(sock, 1) &&
1326            !getsockname(sock, (struct sockaddr *) &sa, &len) &&
1327            (sp[0] = socket(AF_INET, SOCK_STREAM, 6)) != -1 &&
1328            !connect(sp[0], (struct sockaddr *) &sa, len) &&
1329            (sp[1] = accept(sock,(struct sockaddr *) &sa, &len)) != -1) {
1330
1331                /* Success */
1332                ret = 0;
1333        } else {
1334
1335                /* Failure, close descriptors */
1336                if (sp[0] != -1)
1337                        (void) closesocket(sp[0]);
1338                if (sp[1] != -1)
1339                        (void) closesocket(sp[1]);
1340        }
1341
1342        (void) closesocket(sock);
1343        (void) set_non_blocking_mode(sp[0]);
1344        (void) set_non_blocking_mode(sp[1]);
1345
1346#ifndef _WIN32
1347        (void) fcntl(sp[0], F_SETFD, FD_CLOEXEC);
1348        (void) fcntl(sp[1], F_SETFD, FD_CLOEXEC);
1349#endif /* _WIN32*/
1350
1351        return (ret);
1352}
1353
1354static int isbyte(int n) { return (n >= 0 && n <= 255); }
1355
1356static void
1357set_inetd(struct shttpd_ctx *ctx, const char *flag)
1358{
1359        ctx = NULL; /* Unused */
1360
1361        if (is_true(flag)) {
1362                shttpd_set_option(ctx, "ports", NULL);
1363                (void) freopen("/dev/null", "a", stderr);
1364                add_socket(first_worker(ctx), 0, 0);
1365        }
1366}
1367
1368static void
1369set_uid(struct shttpd_ctx *ctx, const char *uid)
1370{
1371        struct passwd   *pw;
1372
1373        ctx = NULL; /* Unused */
1374
1375#if !defined(_WIN32)
1376        if ((pw = getpwnam(uid)) == NULL)
1377                elog(E_FATAL, 0, "%s: unknown user [%s]", __func__, uid);
1378        else if (setgid(pw->pw_gid) == -1)
1379                elog(E_FATAL, NULL, "%s: setgid(%s): %s",
1380                    __func__, uid, strerror(errno));
1381        else if (setuid(pw->pw_uid) == -1)
1382                elog(E_FATAL, NULL, "%s: setuid(%s): %s",
1383                    __func__, uid, strerror(errno));
1384#endif /* !_WIN32 */
1385}
1386
1387static void
1388set_acl(struct shttpd_ctx *ctx, const char *s)
1389{
1390        struct acl      *acl = NULL;
1391        char            flag;
1392        int             len, a, b, c, d, n, mask;
1393        struct llhead   *lp, *tmp;
1394
1395        /* Delete the old ACLs if any */
1396        LL_FOREACH_SAFE(&ctx->acl, lp, tmp)
1397                free(LL_ENTRY(lp, struct acl, link));
1398
1399        FOR_EACH_WORD_IN_LIST(s, len) {
1400
1401                mask = 32;
1402
1403                if (sscanf(s, "%c%d.%d.%d.%d%n",&flag,&a,&b,&c,&d,&n) != 5) {
1404                        elog(E_FATAL, NULL, "[%s]: subnet must be "
1405                            "[+|-]x.x.x.x[/x]", s);
1406                } else if (flag != '+' && flag != '-') {
1407                        elog(E_FATAL, NULL, "flag must be + or -: [%s]", s);
1408                } else if (!isbyte(a)||!isbyte(b)||!isbyte(c)||!isbyte(d)) {
1409                        elog(E_FATAL, NULL, "bad ip address: [%s]", s);
1410                } else  if ((acl = malloc(sizeof(*acl))) == NULL) {
1411                        elog(E_FATAL, NULL, "%s", "cannot malloc subnet");
1412                } else if (sscanf(s + n, "/%d", &mask) == 0) { 
1413                        /* Do nothing, no mask specified */
1414                } else if (mask < 0 || mask > 32) {
1415                        elog(E_FATAL, NULL, "bad subnet mask: %d [%s]", n, s);
1416                }
1417
1418                acl->ip = (a << 24) | (b << 16) | (c << 8) | d;
1419                acl->mask = mask ? 0xffffffffU << (32 - mask) : 0;
1420                acl->flag = flag;
1421                LL_TAIL(&ctx->acl, &acl->link);
1422        }
1423}
1424
1425#ifndef NO_SSL
1426/*
1427 * Dynamically load SSL library. Set up ctx->ssl_ctx pointer.
1428 */
1429static void
1430set_ssl(struct shttpd_ctx *ctx, const char *pem)
1431{
1432        SSL_CTX         *CTX;
1433        void            *lib;
1434        struct ssl_func *fp;
1435
1436        /* Load SSL library dynamically */
1437        if ((lib = dlopen(SSL_LIB, RTLD_LAZY)) == NULL)
1438                elog(E_FATAL, NULL, "set_ssl: cannot load %s", SSL_LIB);
1439
1440        for (fp = ssl_sw; fp->name != NULL; fp++)
1441                if ((fp->ptr.v_void = dlsym(lib, fp->name)) == NULL)
1442                        elog(E_FATAL, NULL,"set_ssl: cannot find %s", fp->name);
1443
1444        /* Initialize SSL crap */
1445        SSL_library_init();
1446
1447        if ((CTX = SSL_CTX_new(SSLv23_server_method())) == NULL)
1448                elog(E_FATAL, NULL, "SSL_CTX_new error");
1449        else if (SSL_CTX_use_certificate_file(CTX, pem, SSL_FILETYPE_PEM) == 0)
1450                elog(E_FATAL, NULL, "cannot open %s", pem);
1451        else if (SSL_CTX_use_PrivateKey_file(CTX, pem, SSL_FILETYPE_PEM) == 0)
1452                elog(E_FATAL, NULL, "cannot open %s", pem);
1453        ctx->ssl_ctx = CTX;
1454}
1455#endif /* NO_SSL */
1456
1457static void
1458open_log_file(FILE **fpp, const char *path)
1459{
1460        if (*fpp != NULL)
1461                (void) fclose(*fpp);
1462
1463        if (path == NULL) {
1464                *fpp = NULL;
1465        } else if ((*fpp = fopen(path, "a")) == NULL) {
1466                elog(E_FATAL, NULL, "cannot open log file %s: %s",
1467                    path, strerror(errno));
1468        }
1469}
1470
1471static void set_alog(struct shttpd_ctx *ctx, const char *path) {
1472        open_log_file(&ctx->access_log, path);
1473}
1474
1475static void set_elog(struct shttpd_ctx *ctx, const char *path) {
1476        open_log_file(&ctx->error_log, path);
1477}
1478
1479static void show_cfg_page(struct shttpd_arg *arg);
1480
1481static void
1482set_cfg_uri(struct shttpd_ctx *ctx, const char *uri)
1483{
1484        free_list(&ctx->registered_uris, &registered_uri_destructor);
1485
1486        if (uri != NULL)
1487                shttpd_register_uri(ctx, uri, &show_cfg_page, ctx);
1488}
1489
1490static struct worker *
1491add_worker(struct shttpd_ctx *ctx)
1492{
1493        struct worker   *worker;
1494
1495        if ((worker = calloc(1, sizeof(*worker))) == NULL)
1496                elog(E_FATAL, NULL, "Cannot allocate worker");
1497        LL_INIT(&worker->connections);
1498        worker->ctx = ctx;
1499        (void) shttpd_socketpair(worker->ctl);
1500        LL_TAIL(&ctx->workers, &worker->link);
1501
1502        return (worker);
1503}
1504
1505#if !defined(NO_THREADS)
1506static void
1507poll_worker(struct worker *worker, int milliseconds)
1508{
1509        fd_set          read_set, write_set;
1510        int             max_fd = -1;
1511
1512        FD_ZERO(&read_set);
1513        FD_ZERO(&write_set);
1514
1515        multiplex_worker_sockets(worker, &max_fd,
1516                        &read_set, &write_set, &milliseconds);
1517
1518        if (do_select(max_fd, &read_set, &write_set, milliseconds) < 0)
1519                return;;
1520
1521        process_worker_sockets(worker, &read_set);
1522}
1523
1524static void
1525worker_function(void *param)
1526{
1527        struct worker *worker = param;
1528
1529        while (worker->exit_flag == 0)
1530                poll_worker(worker, 1000 * 10);
1531
1532        free_list(&worker->connections, connection_desctructor);
1533        free(worker);
1534}
1535
1536static void
1537set_workers(struct shttpd_ctx *ctx, const char *value)
1538{
1539        int             new_num, old_num;
1540        struct llhead   *lp, *tmp;
1541        struct worker   *worker;
1542
1543        new_num = atoi(value);
1544        old_num = 0;
1545        LL_FOREACH(&ctx->workers, lp)
1546                old_num++;
1547
1548        if (new_num == 1) {
1549                if (old_num > 1)
1550                        /* Stop old threads */
1551                        LL_FOREACH_SAFE(&ctx->workers, lp, tmp) {
1552                                worker = LL_ENTRY(lp, struct worker, link);
1553                                LL_DEL(&worker->link);
1554                                worker = LL_ENTRY(lp, struct worker, link);
1555                                worker->exit_flag = 1;
1556                        }
1557                (void) add_worker(ctx);
1558        } else {
1559                /* FIXME: we cannot here reduce the number of threads */
1560                while (new_num > 1 && new_num > old_num) {
1561                        worker = add_worker(ctx);
1562                        _beginthread(worker_function, 0, worker);
1563                        old_num++;
1564                }
1565        }
1566}
1567#endif /* NO_THREADS */
1568
1569static const struct opt {
1570        int             index;          /* Index in shttpd_ctx          */
1571        const char      *name;          /* Option name in config file   */
1572        const char      *description;   /* Description                  */
1573        const char      *default_value; /* Default option value         */
1574        void (*setter)(struct shttpd_ctx *, const char *);
1575} known_options[] = {
1576        {OPT_ROOT, "root", "\tWeb root directory", ".", NULL},
1577        {OPT_INDEX_FILES, "index_files", "Index files", INDEX_FILES, NULL},
1578#ifndef NO_SSL
1579        {OPT_SSL_CERTIFICATE, "ssl_cert", "SSL certificate file", NULL,set_ssl},
1580#endif /* NO_SSL */
1581        {OPT_PORTS, "ports", "Listening ports", LISTENING_PORTS, set_ports},
1582        {OPT_DIR_LIST, "dir_list", "Directory listing", "yes", NULL},
1583        {OPT_CFG_URI, "cfg_uri", "Config uri", NULL, set_cfg_uri},
1584        {OPT_PROTECT, "protect", "URI to htpasswd mapping", NULL, NULL},
1585#ifndef NO_CGI
1586        {OPT_CGI_EXTENSIONS, "cgi_ext", "CGI extensions", CGI_EXT, NULL},
1587        {OPT_CGI_INTERPRETER, "cgi_interp", "CGI interpreter", NULL, NULL},
1588        {OPT_CGI_ENVIRONMENT, "cgi_env", "Additional CGI env vars", NULL, NULL},
1589#endif /* NO_CGI */
1590        {OPT_SSI_EXTENSIONS, "ssi_ext", "SSI extensions", SSI_EXT, NULL},
1591#ifndef NO_AUTH
1592        {OPT_AUTH_REALM, "auth_realm", "Authentication domain name",REALM,NULL},
1593        {OPT_AUTH_GPASSWD, "auth_gpass", "Global passwords file", NULL, NULL},
1594        {OPT_AUTH_PUT, "auth_PUT", "PUT,DELETE auth file", NULL, NULL},
1595#endif /* !NO_AUTH */
1596#ifdef _WIN32
1597        {OPT_SERVICE, "service", "Manage WinNNT service (install"
1598            "|uninstall)", NULL, set_nt_service},
1599        {OPT_HIDE, "systray", "Hide console, show icon on systray",
1600                "no", set_systray},
1601#else
1602        {OPT_INETD, "inetd", "Inetd mode", "no", set_inetd},
1603        {OPT_UID, "uid", "\tRun as user", NULL, set_uid},
1604#endif /* _WIN32 */
1605        {OPT_ACCESS_LOG, "access_log", "Access log file", NULL, set_alog},
1606        {OPT_ERROR_LOG, "error_log", "Error log file", NULL, set_elog},
1607        {OPT_MIME_TYPES, "mime_types", "Additional mime types list", NULL,NULL},
1608        {OPT_ALIASES, "aliases", "Path=URI mappings", NULL, NULL},
1609        {OPT_ACL, "acl", "\tAllow/deny IP addresses/subnets", NULL, set_acl},
1610#if !defined(NO_THREADS)
1611        {OPT_THREADS, "threads", "Number of worker threads", "1", set_workers},
1612#endif /* !NO_THREADS */
1613        {-1, NULL, NULL, NULL, NULL}
1614};
1615
1616static const struct opt *
1617find_opt(const char *opt_name)
1618{
1619        int     i;
1620
1621        for (i = 0; known_options[i].name != NULL; i++)
1622                if (!strcmp(opt_name, known_options[i].name))
1623                        return (known_options + i);
1624
1625        elog(E_FATAL, NULL, "no such option: [%s]", opt_name);
1626
1627        /* UNREACHABLE */
1628        return (NULL);
1629}
1630
1631void
1632shttpd_set_option(struct shttpd_ctx *ctx, const char *opt, const char *val)
1633{
1634        const struct opt        *o = find_opt(opt);
1635
1636        /* Call option setter first, so it can use both new and old values */
1637        if (o->setter != NULL)
1638                o->setter(ctx, val);
1639
1640        /* Free old value if any */
1641        if (ctx->options[o->index] != NULL)
1642                free(ctx->options[o->index]);
1643       
1644        /* Set new option value */
1645        ctx->options[o->index] = val ? my_strdup(val) : NULL;
1646}
1647
1648static void
1649show_cfg_page(struct shttpd_arg *arg)
1650{
1651        struct shttpd_ctx       *ctx = arg->user_data;
1652        char                    opt_name[20], value[BUFSIZ];
1653        const struct opt        *o;
1654
1655        opt_name[0] = value[0] = '\0';
1656
1657        if (!strcmp(shttpd_get_env(arg, "REQUEST_METHOD"), "POST")) {
1658                if (arg->flags & SHTTPD_MORE_POST_DATA)
1659                        return;
1660                (void) shttpd_get_var("o", arg->in.buf, arg->in.len,
1661                    opt_name, sizeof(opt_name));
1662                (void) shttpd_get_var("v", arg->in.buf, arg->in.len,
1663                    value, sizeof(value));
1664                shttpd_set_option(ctx, opt_name, value[0] ? value : NULL);
1665        }
1666
1667        shttpd_printf(arg, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"
1668            "<html><body><h1>SHTTPD v. %s</h1>", shttpd_version());
1669
1670        shttpd_printf(arg, "%s", "<table border=1"
1671            "<tr><th>Option</th><th>Description</th>"
1672            "<th colspan=2>Value</th></tr>");
1673
1674        if (opt_name[0] != '\0' && value[0] != '\0')
1675                shttpd_printf(arg, "<p style='color: green'>Saved: %s=%s</p>",
1676                    opt_name, value[0] ? value : "NULL");
1677
1678
1679        for (o = known_options; o->name != NULL; o++) {
1680                shttpd_printf(arg,
1681                    "<form method=post><tr><td>%s</td><td>%s</td>"
1682                    "<input type=hidden name=o value='%s'>"
1683                    "<td><input type=text name=v value='%s'></td>"
1684                    "<td><input type=submit value=save></td></form></tr>",
1685                    o->name, o->description, o->name,
1686                    ctx->options[o->index] ? ctx->options[o->index] : "");
1687        }
1688
1689        shttpd_printf(arg, "%s", "</table></body></html>");
1690        arg->flags |= SHTTPD_END_OF_OUTPUT;
1691}
1692
1693/*
1694 * Show usage string and exit.
1695 */
1696void
1697usage(const char *prog)
1698{
1699        const struct opt        *o;
1700
1701        (void) fprintf(stderr,
1702            "SHTTPD version %s (c) Sergey Lyubka\n"
1703            "usage: %s [options] [config_file]\n", VERSION, prog);
1704
1705#if !defined(NO_AUTH)
1706        fprintf(stderr, "  -A <htpasswd_file> <realm> <user> <passwd>\n");
1707#endif /* NO_AUTH */
1708
1709        for (o = known_options; o->name != NULL; o++) {
1710                (void) fprintf(stderr, "  -%s\t%s", o->name, o->description);
1711                if (o->default_value != NULL)
1712                        fprintf(stderr, " (default: %s)", o->default_value);
1713                fputc('\n', stderr);
1714        }
1715
1716        exit(EXIT_FAILURE);
1717}
1718
1719static void
1720set_opt(struct shttpd_ctx *ctx, const char *opt, const char *value)
1721{
1722        const struct opt        *o;
1723
1724        o = find_opt(opt);
1725        if (ctx->options[o->index] != NULL)
1726                free(ctx->options[o->index]);
1727        ctx->options[o->index] = my_strdup(value);
1728}
1729
1730static void
1731process_command_line_arguments(struct shttpd_ctx *ctx, char *argv[])
1732{
1733        const char              *config_file = CONFIG_FILE;
1734        char                    line[BUFSIZ], opt[BUFSIZ],
1735                                val[BUFSIZ], path[FILENAME_MAX], *p;
1736        FILE                    *fp;
1737        size_t                  i, line_no = 0;
1738
1739        /* First find out, which config file to open */
1740        for (i = 1; argv[i] != NULL && argv[i][0] == '-'; i += 2)
1741                if (argv[i + 1] == NULL)
1742                        usage(argv[0]);
1743
1744        if (argv[i] != NULL && argv[i + 1] != NULL) {
1745                /* More than one non-option arguments are given w*/
1746                usage(argv[0]);
1747        } else if (argv[i] != NULL) {
1748                /* Just one non-option argument is given, this is config file */
1749                config_file = argv[i];
1750        } else {
1751                /* No config file specified. Look for one where shttpd lives */
1752                if ((p = strrchr(argv[0], DIRSEP)) != 0) {
1753                        my_snprintf(path, sizeof(path), "%.*s%s",
1754                            p - argv[0] + 1, argv[0], config_file);
1755                        config_file = path;
1756                }
1757        }
1758
1759        fp = fopen(config_file, "r");
1760
1761        /* If config file was set in command line and open failed, exit */
1762        if (fp == NULL && argv[i] != NULL)
1763                elog(E_FATAL, NULL, "cannot open config file %s: %s",
1764                    config_file, strerror(errno));
1765
1766        if (fp != NULL) {
1767
1768                elog(E_LOG, NULL, "Loading config file %s", config_file);
1769
1770                /* Loop over the lines in config file */
1771                while (fgets(line, sizeof(line), fp) != NULL) {
1772
1773                        line_no++;
1774
1775                        /* Ignore empty lines and comments */
1776                        if (line[0] == '#' || line[0] == '\n')
1777                                continue;
1778
1779                        if (sscanf(line, "%s %[^\n#]", opt, val) != 2)
1780                                elog(E_FATAL, NULL, "line %d in %s is invalid",
1781                                    line_no, config_file);
1782
1783                        set_opt(ctx, opt, val);
1784                }
1785
1786                (void) fclose(fp);
1787        }
1788
1789        /* Now pass through the command line options */
1790        for (i = 1; argv[i] != NULL && argv[i][0] == '-'; i += 2)
1791                set_opt(ctx, &argv[i][1], argv[i + 1]);
1792}
1793
1794struct shttpd_ctx *
1795shttpd_init(int argc, char *argv[])
1796{
1797        struct shttpd_ctx       *ctx;
1798        struct tm               *tm;
1799        const struct opt        *o;
1800
1801        if ((ctx = calloc(1, sizeof(*ctx))) == NULL)
1802                elog(E_FATAL, NULL, "cannot allocate shttpd context");
1803
1804        LL_INIT(&ctx->registered_uris);
1805        LL_INIT(&ctx->error_handlers);
1806        LL_INIT(&ctx->acl);
1807        LL_INIT(&ctx->ssi_funcs);
1808        LL_INIT(&ctx->listeners);
1809        LL_INIT(&ctx->workers);
1810
1811        /* Initialize options. First pass: set default option values */
1812        for (o = known_options; o->name != NULL; o++)
1813                ctx->options[o->index] = o->default_value ?
1814                        my_strdup(o->default_value) : NULL;
1815
1816        /* Second and third passes: config file and argv */
1817        if (argc > 0 && argv != NULL)
1818                process_command_line_arguments(ctx, argv);
1819
1820        /* Call setter functions */
1821        for (o = known_options; o->name != NULL; o++)
1822                if (o->setter && ctx->options[o->index] != NULL)
1823                        o->setter(ctx, ctx->options[o->index]);
1824
1825        current_time = time(NULL);
1826        tm = localtime(&current_time);
1827        tz_offset = 0;
1828
1829        if (num_workers(ctx) == 1)
1830                (void) add_worker(ctx);
1831#if 0
1832        tm->tm_gmtoff - 3600 * (tm->tm_isdst > 0 ? 1 : 0);
1833#endif
1834
1835#ifdef _WIN32
1836        {WSADATA data;  WSAStartup(MAKEWORD(2,2), &data);}
1837#endif /* _WIN32 */
1838
1839        return (ctx);
1840}
Note: See TracBrowser for help on using the repository browser.