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

Last change on this file since 6391 was 6391, checked in by charles, 13 years ago

possible fix for softwareelves' error

File size: 48.3 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        if( stream->io_class )
902            n = stream->io_class->read(stream, io_space(&stream->io), len);
903        else
904            n = 0;
905
906        if (n > 0)
907                io_inc_head(&stream->io, n);
908        else if (n == -1 && (ERRNO == EINTR || ERRNO == EWOULDBLOCK))
909                n = n;  /* Ignore EINTR and EAGAIN */
910        else if (!(stream->flags & FLAG_DONT_CLOSE))
911                stop_stream(stream);
912
913        DBG(("read_stream (%d %s): read %d/%d/%lu bytes (errno %d)",
914            stream->conn->rem.chan.sock,
915            stream->io_class ? stream->io_class->name : "(null)",
916            n, len, (unsigned long) stream->io.total, ERRNO));
917
918        /*
919         * Close the local stream if everything was read
920         * XXX We do not close the remote stream though! It may be
921         * a POST data completed transfer, we do not want the socket
922         * to be closed.
923         */
924        if (stream->content_len > 0 && stream == &stream->conn->loc) {
925                assert(stream->io.total <= stream->content_len);
926                if (stream->io.total == stream->content_len)
927                        stop_stream(stream);
928        }
929
930        stream->conn->expire_time = current_time + EXPIRE_TIME;
931}
932
933static void
934write_stream(struct stream *from, struct stream *to)
935{
936        int     n, len;
937
938        len = io_data_len(&from->io);
939        assert(len > 0);
940
941        /* TODO: should be assert on CAN_WRITE flag */
942        if( to->io_class )
943            n = to->io_class->write(to, io_data(&from->io), len);
944        else
945            n = 0;
946
947        to->conn->expire_time = current_time + EXPIRE_TIME;
948        DBG(("write_stream (%d %s): written %d/%d bytes (errno %d)",
949            to->conn->rem.chan.sock,
950            to->io_class ? to->io_class->name : "(null)", n, len, ERRNO));
951
952        if (n > 0)
953                io_inc_tail(&from->io, n);
954        else if (n == -1 && (ERRNO == EINTR || ERRNO == EWOULDBLOCK))
955                n = n;  /* Ignore EINTR and EAGAIN */
956        else if (!(to->flags & FLAG_DONT_CLOSE))
957                stop_stream(to);
958}
959
960
961static void
962connection_desctructor(struct llhead *lp)
963{
964        struct conn             *c = LL_ENTRY(lp, struct conn, link);
965        static const struct vec vec = {"close", 5};
966        int                     do_close;
967
968        DBG(("Disconnecting %d (%.*s)", c->rem.chan.sock,
969            c->ch.connection.v_vec.len, c->ch.connection.v_vec.ptr));
970
971        if (c->request != NULL && c->ctx->access_log != NULL)
972                log_access(c->ctx->access_log, c);
973
974        /* In inetd mode, exit if request is finished. */
975        if (IS_TRUE(c->ctx, OPT_INETD))
976                exit(0);
977
978        if (c->loc.io_class != NULL && c->loc.io_class->close != NULL)
979                c->loc.io_class->close(&c->loc);
980
981        /*
982         * Check the "Connection: " header before we free c->request
983         * If it its 'keep-alive', then do not close the connection
984         */
985        do_close = (c->ch.connection.v_vec.len >= vec.len &&
986            !my_strncasecmp(vec.ptr, c->ch.connection.v_vec.ptr, vec.len)) ||
987            (c->major_version < 1 ||
988            (c->major_version >= 1 && c->minor_version < 1));
989
990        if (c->request)
991                free(c->request);
992        if (c->uri)
993                free(c->uri);
994
995        /* Keep the connection open only if we have Content-Length set */
996        if (!do_close && c->loc.content_len > 0) {
997                c->loc.io_class = NULL;
998                c->loc.flags = 0;
999                c->loc.content_len = 0;
1000                c->rem.flags = FLAG_W | FLAG_R | FLAG_SSL_ACCEPTED;
1001                c->query = c->request = c->uri = c->path_info = NULL;
1002                c->mime_type.len = 0;
1003                (void) memset(&c->ch, 0, sizeof(c->ch));
1004                io_clear(&c->loc.io);
1005                c->birth_time = current_time;
1006                if (io_data_len(&c->rem.io) > 0)
1007                        process_connection(c, 0, 0);
1008        } else {
1009                if (c->rem.io_class != NULL)
1010                        c->rem.io_class->close(&c->rem);
1011
1012                LL_DEL(&c->link);
1013                c->worker->num_conns--;
1014                assert(c->worker->num_conns >= 0);
1015
1016                free(c);
1017        }
1018}
1019
1020static void
1021worker_destructor(struct llhead *lp)
1022{
1023        struct worker   *worker = LL_ENTRY(lp, struct worker, link);
1024
1025        free_list(&worker->connections, connection_desctructor);
1026        free(worker);
1027}
1028
1029static int
1030is_allowed(const struct shttpd_ctx *ctx, const struct usa *usa)
1031{
1032        const struct acl        *acl;
1033        const struct llhead     *lp;
1034        int                     allowed = '+';
1035        uint32_t                ip;
1036
1037        LL_FOREACH(&ctx->acl, lp) {
1038                acl = LL_ENTRY(lp, struct acl, link);
1039                (void) memcpy(&ip, &usa->u.sin.sin_addr, sizeof(ip));
1040                if (acl->ip == (ntohl(ip) & acl->mask))
1041                        allowed = acl->flag;
1042        }
1043
1044        return (allowed == '+');
1045}
1046
1047static void
1048add_to_set(int fd, fd_set *set, int *max_fd)
1049{
1050        FD_SET(fd, set);
1051        if (fd > *max_fd)
1052                *max_fd = fd;
1053}
1054
1055static void
1056process_connection(struct conn *c, int remote_ready, int local_ready)
1057{
1058        /* Read from remote end if it is ready */
1059        if (remote_ready && io_space_len(&c->rem.io))
1060                read_stream(&c->rem);
1061
1062        /* If the request is not parsed yet, do so */
1063        if (!(c->rem.flags & FLAG_HEADERS_PARSED))
1064                parse_http_request(c);
1065
1066        DBG(("loc: %d [%.*s]", (int) io_data_len(&c->loc.io),
1067            (int) io_data_len(&c->loc.io), io_data(&c->loc.io)));
1068        DBG(("rem: %d [%.*s]", (int) io_data_len(&c->rem.io),
1069            (int) io_data_len(&c->rem.io), io_data(&c->rem.io)));
1070
1071        /* Read from the local end if it is ready */
1072        if (local_ready && io_space_len(&c->loc.io))
1073                read_stream(&c->loc);
1074
1075        if (io_data_len(&c->rem.io) > 0 && (c->loc.flags & FLAG_W) &&
1076            c->loc.io_class != NULL && c->loc.io_class->write != NULL)
1077                write_stream(&c->rem, &c->loc);
1078
1079        if (io_data_len(&c->loc.io) > 0 && c->rem.io_class != NULL)
1080                write_stream(&c->loc, &c->rem); 
1081
1082        /* Check whether we should close this connection */
1083        if ((current_time > c->expire_time) ||
1084            (c->rem.flags & FLAG_CLOSED) ||
1085            ((c->loc.flags & FLAG_CLOSED) && !io_data_len(&c->loc.io)))
1086                connection_desctructor(&c->link);
1087}
1088
1089static int
1090num_workers(const struct shttpd_ctx *ctx)
1091{
1092        char    *p = ctx->options[OPT_THREADS];
1093        return (p ? atoi(p) : 1);
1094}
1095
1096static void
1097handle_connected_socket(struct shttpd_ctx *ctx,
1098                struct usa *sap, int sock, int is_ssl)
1099{
1100#if !defined(_WIN32)
1101        if (sock >= (int) FD_SETSIZE) {
1102                elog(E_LOG, NULL, "ctx %p: discarding "
1103                    "socket %d, too busy", ctx, sock);
1104                (void) closesocket(sock);
1105        } else
1106#endif /* !_WIN32 */
1107                if (!is_allowed(ctx, sap)) {
1108                elog(E_LOG, NULL, "%s is not allowed to connect",
1109                    inet_ntoa(sap->u.sin.sin_addr));
1110                (void) closesocket(sock);
1111        } else if (num_workers(ctx) > 1) {
1112                pass_socket(ctx, sock, is_ssl);
1113        } else {
1114                add_socket(first_worker(ctx), sock, is_ssl);
1115        }
1116}
1117
1118static int
1119do_select(int max_fd, fd_set *read_set, fd_set *write_set, int milliseconds)
1120{
1121        struct timeval  tv;
1122        int             n;
1123
1124        tv.tv_sec = milliseconds / 1000;
1125        tv.tv_usec = (milliseconds % 1000) * 1000;
1126
1127        /* Check IO readiness */
1128        if ((n = select(max_fd + 1, read_set, write_set, NULL, &tv)) < 0) {
1129#ifdef _WIN32
1130                /*
1131                 * On windows, if read_set and write_set are empty,
1132                 * select() returns "Invalid parameter" error
1133                 * (at least on my Windows XP Pro). So in this case,
1134                 * we sleep here.
1135                 */
1136                Sleep(milliseconds);
1137#endif /* _WIN32 */
1138                DBG(("select: %d", ERRNO));
1139        }
1140
1141        return (n);
1142}
1143
1144static void
1145multiplex_worker_sockets(const struct worker *worker, int *max_fd,
1146                fd_set *read_set, fd_set *write_set, int *milliseconds)
1147{
1148        struct llhead   *lp;
1149        struct conn     *c;
1150
1151        /* Add control socket */
1152        add_to_set(worker->ctl[0], read_set, max_fd);
1153
1154        /* Multiplex streams */
1155        LL_FOREACH(&worker->connections, lp) {
1156                c = LL_ENTRY(lp, struct conn, link);
1157               
1158                /* If there is a space in remote IO, check remote socket */
1159                if (io_space_len(&c->rem.io))
1160                        add_to_set(c->rem.chan.fd, read_set, max_fd);
1161
1162#if !defined(NO_CGI)
1163                /*
1164                 * If there is a space in local IO, and local endpoint is
1165                 * CGI, check local socket for read availability
1166                 */
1167                if (io_space_len(&c->loc.io) && (c->loc.flags & FLAG_R) &&
1168                    c->loc.io_class == &io_cgi)
1169                        add_to_set(c->loc.chan.fd, read_set, max_fd);
1170
1171                /*
1172                 * If there is some data read from remote socket, and
1173                 * local endpoint is CGI, check local for write availability
1174                 */
1175                if (io_data_len(&c->rem.io) && (c->loc.flags & FLAG_W) &&
1176                    c->loc.io_class == &io_cgi)
1177                        add_to_set(c->loc.chan.fd, write_set, max_fd);
1178#endif /* NO_CGI */
1179
1180                /*
1181                 * If there is some data read from local endpoint, check the
1182                 * remote socket for write availability
1183                 */
1184                if (io_data_len(&c->loc.io) && !(c->loc.flags & FLAG_SUSPEND))
1185                        add_to_set(c->rem.chan.fd, write_set, max_fd);
1186
1187                /*
1188                 * Set select wait interval to zero if FLAG_ALWAYS_READY set
1189                 */
1190                if (io_space_len(&c->loc.io) && (c->loc.flags & FLAG_R) &&
1191                    (c->loc.flags & FLAG_ALWAYS_READY))
1192                        *milliseconds = 0;
1193               
1194                if (io_data_len(&c->rem.io) && (c->loc.flags & FLAG_W) &&
1195                    (c->loc.flags & FLAG_ALWAYS_READY))
1196                        *milliseconds = 0;
1197        }
1198}
1199
1200static void
1201process_worker_sockets(struct worker *worker, fd_set *read_set)
1202{
1203        struct llhead   *lp, *tmp;
1204        int             cmd, skt[2], sock = worker->ctl[0];
1205        struct conn     *c;
1206
1207        /* Check if new socket is passed to us over the control socket */
1208        if (FD_ISSET(worker->ctl[0], read_set))
1209                while (recv(sock, (void *) &cmd, sizeof(cmd), 0) == sizeof(cmd))
1210                        switch (cmd) {
1211                        case CTL_PASS_SOCKET:
1212                                (void)recv(sock, (void *) &skt, sizeof(skt), 0);
1213                                add_socket(worker, skt[0], skt[1]);
1214                                break;
1215                        case CTL_WAKEUP:
1216                                (void)recv(sock, (void *) &c, sizeof(c), 0);
1217                                c->loc.flags &= FLAG_SUSPEND;
1218                                break;
1219                        default:
1220                                elog(E_FATAL, NULL, "ctx %p: ctl cmd %d",
1221                                    worker->ctx, cmd);
1222                                break;
1223                        }
1224
1225        /* Process all connections */
1226        LL_FOREACH_SAFE(&worker->connections, lp, tmp) {
1227                c = LL_ENTRY(lp, struct conn, link);
1228                process_connection(c, FD_ISSET(c->rem.chan.fd, read_set),
1229                    ((c->loc.flags & FLAG_ALWAYS_READY)
1230#if !defined(NO_CGI)
1231                    || (c->loc.io_class == &io_cgi &&
1232                     FD_ISSET(c->loc.chan.fd, read_set))
1233#endif /* NO_CGI */
1234                    ));
1235        }
1236}
1237
1238/*
1239 * One iteration of server loop. This is the core of the data exchange.
1240 */
1241void
1242shttpd_poll(struct shttpd_ctx *ctx, int milliseconds)
1243{
1244        struct llhead   *lp;
1245        struct listener *l;
1246        fd_set          read_set, write_set;
1247        int             sock, max_fd = -1;
1248        struct usa      sa;
1249
1250        current_time = time(0);
1251        FD_ZERO(&read_set);
1252        FD_ZERO(&write_set);
1253
1254        /* Add listening sockets to the read set */
1255        LL_FOREACH(&ctx->listeners, lp) {
1256                l = LL_ENTRY(lp, struct listener, link);
1257                add_to_set(l->sock, &read_set, &max_fd);
1258                DBG(("FD_SET(%d) (listening)", l->sock));
1259        }
1260
1261        if (num_workers(ctx) == 1)
1262                multiplex_worker_sockets(first_worker(ctx), &max_fd,
1263                                &read_set, &write_set, &milliseconds);
1264
1265        if (do_select(max_fd, &read_set, &write_set, milliseconds) < 0)
1266                return;;
1267
1268        /* Check for incoming connections on listener sockets */
1269        LL_FOREACH(&ctx->listeners, lp) {
1270                l = LL_ENTRY(lp, struct listener, link);
1271                if (!FD_ISSET(l->sock, &read_set))
1272                        continue;
1273                do {
1274                        sa.len = sizeof(sa.u.sin);
1275                        if ((sock = accept(l->sock, &sa.u.sa, &sa.len)) != -1)
1276                                handle_connected_socket(ctx,&sa,sock,l->is_ssl);
1277                } while (sock != -1);
1278        }
1279
1280        if (num_workers(ctx) == 1)
1281                process_worker_sockets(first_worker(ctx), &read_set);
1282}
1283
1284/*
1285 * Deallocate shttpd object, free up the resources
1286 */
1287void
1288shttpd_fini(struct shttpd_ctx *ctx)
1289{
1290        size_t  i;
1291
1292        free_list(&ctx->workers, worker_destructor);
1293        free_list(&ctx->registered_uris, registered_uri_destructor);
1294        free_list(&ctx->acl, acl_destructor);
1295        free_list(&ctx->listeners, listener_destructor);
1296#if !defined(NO_SSI)
1297        free_list(&ctx->ssi_funcs, ssi_func_destructor);
1298#endif /* !NO_SSI */
1299
1300        for (i = 0; i < NELEMS(ctx->options); i++)
1301                if (ctx->options[i] != NULL)
1302                        free(ctx->options[i]);
1303
1304        if (ctx->access_log)            (void) fclose(ctx->access_log);
1305        if (ctx->error_log)             (void) fclose(ctx->error_log);
1306
1307        /* TODO: free SSL context */
1308
1309        free(ctx);
1310}
1311
1312/*
1313 * UNIX socketpair() implementation. Why? Because Windows does not have it.
1314 * Return 0 on success, -1 on error.
1315 */
1316int
1317shttpd_socketpair(int sp[2])
1318{
1319        struct sockaddr_in      sa;
1320        int                     sock, ret = -1;
1321        socklen_t               len = sizeof(sa);
1322
1323        sp[0] = sp[1] = -1;
1324
1325        (void) memset(&sa, 0, sizeof(sa));
1326        sa.sin_family           = AF_INET;
1327        sa.sin_port             = htons(0);
1328        sa.sin_addr.s_addr      = htonl(INADDR_LOOPBACK);
1329
1330        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) != -1 &&
1331            !bind(sock, (struct sockaddr *) &sa, len) &&
1332            !listen(sock, 1) &&
1333            !getsockname(sock, (struct sockaddr *) &sa, &len) &&
1334            (sp[0] = socket(AF_INET, SOCK_STREAM, 6)) != -1 &&
1335            !connect(sp[0], (struct sockaddr *) &sa, len) &&
1336            (sp[1] = accept(sock,(struct sockaddr *) &sa, &len)) != -1) {
1337
1338                /* Success */
1339                ret = 0;
1340        } else {
1341
1342                /* Failure, close descriptors */
1343                if (sp[0] != -1)
1344                        (void) closesocket(sp[0]);
1345                if (sp[1] != -1)
1346                        (void) closesocket(sp[1]);
1347        }
1348
1349        (void) closesocket(sock);
1350        (void) set_non_blocking_mode(sp[0]);
1351        (void) set_non_blocking_mode(sp[1]);
1352
1353#ifndef _WIN32
1354        (void) fcntl(sp[0], F_SETFD, FD_CLOEXEC);
1355        (void) fcntl(sp[1], F_SETFD, FD_CLOEXEC);
1356#endif /* _WIN32*/
1357
1358        return (ret);
1359}
1360
1361static int isbyte(int n) { return (n >= 0 && n <= 255); }
1362
1363static void
1364set_inetd(struct shttpd_ctx *ctx, const char *flag)
1365{
1366        ctx = NULL; /* Unused */
1367
1368        if (is_true(flag)) {
1369                shttpd_set_option(ctx, "ports", NULL);
1370                (void) freopen("/dev/null", "a", stderr);
1371                add_socket(first_worker(ctx), 0, 0);
1372        }
1373}
1374
1375static void
1376set_uid(struct shttpd_ctx *ctx, const char *uid)
1377{
1378        struct passwd   *pw;
1379
1380        ctx = NULL; /* Unused */
1381
1382#if !defined(_WIN32)
1383        if ((pw = getpwnam(uid)) == NULL)
1384                elog(E_FATAL, 0, "%s: unknown user [%s]", __func__, uid);
1385        else if (setgid(pw->pw_gid) == -1)
1386                elog(E_FATAL, NULL, "%s: setgid(%s): %s",
1387                    __func__, uid, strerror(errno));
1388        else if (setuid(pw->pw_uid) == -1)
1389                elog(E_FATAL, NULL, "%s: setuid(%s): %s",
1390                    __func__, uid, strerror(errno));
1391#endif /* !_WIN32 */
1392}
1393
1394static void
1395set_acl(struct shttpd_ctx *ctx, const char *s)
1396{
1397        struct acl      *acl = NULL;
1398        char            flag;
1399        int             len, a, b, c, d, n, mask;
1400        struct llhead   *lp, *tmp;
1401
1402        /* Delete the old ACLs if any */
1403        LL_FOREACH_SAFE(&ctx->acl, lp, tmp)
1404                free(LL_ENTRY(lp, struct acl, link));
1405
1406        FOR_EACH_WORD_IN_LIST(s, len) {
1407
1408                mask = 32;
1409
1410                if (sscanf(s, "%c%d.%d.%d.%d%n",&flag,&a,&b,&c,&d,&n) != 5) {
1411                        elog(E_FATAL, NULL, "[%s]: subnet must be "
1412                            "[+|-]x.x.x.x[/x]", s);
1413                } else if (flag != '+' && flag != '-') {
1414                        elog(E_FATAL, NULL, "flag must be + or -: [%s]", s);
1415                } else if (!isbyte(a)||!isbyte(b)||!isbyte(c)||!isbyte(d)) {
1416                        elog(E_FATAL, NULL, "bad ip address: [%s]", s);
1417                } else  if ((acl = malloc(sizeof(*acl))) == NULL) {
1418                        elog(E_FATAL, NULL, "%s", "cannot malloc subnet");
1419                } else if (sscanf(s + n, "/%d", &mask) == 0) { 
1420                        /* Do nothing, no mask specified */
1421                } else if (mask < 0 || mask > 32) {
1422                        elog(E_FATAL, NULL, "bad subnet mask: %d [%s]", n, s);
1423                }
1424
1425                acl->ip = (a << 24) | (b << 16) | (c << 8) | d;
1426                acl->mask = mask ? 0xffffffffU << (32 - mask) : 0;
1427                acl->flag = flag;
1428                LL_TAIL(&ctx->acl, &acl->link);
1429        }
1430}
1431
1432#ifndef NO_SSL
1433/*
1434 * Dynamically load SSL library. Set up ctx->ssl_ctx pointer.
1435 */
1436static void
1437set_ssl(struct shttpd_ctx *ctx, const char *pem)
1438{
1439        SSL_CTX         *CTX;
1440        void            *lib;
1441        struct ssl_func *fp;
1442
1443        /* Load SSL library dynamically */
1444        if ((lib = dlopen(SSL_LIB, RTLD_LAZY)) == NULL)
1445                elog(E_FATAL, NULL, "set_ssl: cannot load %s", SSL_LIB);
1446
1447        for (fp = ssl_sw; fp->name != NULL; fp++)
1448                if ((fp->ptr.v_void = dlsym(lib, fp->name)) == NULL)
1449                        elog(E_FATAL, NULL,"set_ssl: cannot find %s", fp->name);
1450
1451        /* Initialize SSL crap */
1452        SSL_library_init();
1453
1454        if ((CTX = SSL_CTX_new(SSLv23_server_method())) == NULL)
1455                elog(E_FATAL, NULL, "SSL_CTX_new error");
1456        else if (SSL_CTX_use_certificate_file(CTX, pem, SSL_FILETYPE_PEM) == 0)
1457                elog(E_FATAL, NULL, "cannot open %s", pem);
1458        else if (SSL_CTX_use_PrivateKey_file(CTX, pem, SSL_FILETYPE_PEM) == 0)
1459                elog(E_FATAL, NULL, "cannot open %s", pem);
1460        ctx->ssl_ctx = CTX;
1461}
1462#endif /* NO_SSL */
1463
1464static void
1465open_log_file(FILE **fpp, const char *path)
1466{
1467        if (*fpp != NULL)
1468                (void) fclose(*fpp);
1469
1470        if (path == NULL) {
1471                *fpp = NULL;
1472        } else if ((*fpp = fopen(path, "a")) == NULL) {
1473                elog(E_FATAL, NULL, "cannot open log file %s: %s",
1474                    path, strerror(errno));
1475        }
1476}
1477
1478static void set_alog(struct shttpd_ctx *ctx, const char *path) {
1479        open_log_file(&ctx->access_log, path);
1480}
1481
1482static void set_elog(struct shttpd_ctx *ctx, const char *path) {
1483        open_log_file(&ctx->error_log, path);
1484}
1485
1486static void show_cfg_page(struct shttpd_arg *arg);
1487
1488static void
1489set_cfg_uri(struct shttpd_ctx *ctx, const char *uri)
1490{
1491        free_list(&ctx->registered_uris, &registered_uri_destructor);
1492
1493        if (uri != NULL)
1494                shttpd_register_uri(ctx, uri, &show_cfg_page, ctx);
1495}
1496
1497static struct worker *
1498add_worker(struct shttpd_ctx *ctx)
1499{
1500        struct worker   *worker;
1501
1502        if ((worker = calloc(1, sizeof(*worker))) == NULL)
1503                elog(E_FATAL, NULL, "Cannot allocate worker");
1504        LL_INIT(&worker->connections);
1505        worker->ctx = ctx;
1506        (void) shttpd_socketpair(worker->ctl);
1507        LL_TAIL(&ctx->workers, &worker->link);
1508
1509        return (worker);
1510}
1511
1512#if !defined(NO_THREADS)
1513static void
1514poll_worker(struct worker *worker, int milliseconds)
1515{
1516        fd_set          read_set, write_set;
1517        int             max_fd = -1;
1518
1519        FD_ZERO(&read_set);
1520        FD_ZERO(&write_set);
1521
1522        multiplex_worker_sockets(worker, &max_fd,
1523                        &read_set, &write_set, &milliseconds);
1524
1525        if (do_select(max_fd, &read_set, &write_set, milliseconds) < 0)
1526                return;;
1527
1528        process_worker_sockets(worker, &read_set);
1529}
1530
1531static void
1532worker_function(void *param)
1533{
1534        struct worker *worker = param;
1535
1536        while (worker->exit_flag == 0)
1537                poll_worker(worker, 1000 * 10);
1538
1539        free_list(&worker->connections, connection_desctructor);
1540        free(worker);
1541}
1542
1543static void
1544set_workers(struct shttpd_ctx *ctx, const char *value)
1545{
1546        int             new_num, old_num;
1547        struct llhead   *lp, *tmp;
1548        struct worker   *worker;
1549
1550        new_num = atoi(value);
1551        old_num = 0;
1552        LL_FOREACH(&ctx->workers, lp)
1553                old_num++;
1554
1555        if (new_num == 1) {
1556                if (old_num > 1)
1557                        /* Stop old threads */
1558                        LL_FOREACH_SAFE(&ctx->workers, lp, tmp) {
1559                                worker = LL_ENTRY(lp, struct worker, link);
1560                                LL_DEL(&worker->link);
1561                                worker = LL_ENTRY(lp, struct worker, link);
1562                                worker->exit_flag = 1;
1563                        }
1564                (void) add_worker(ctx);
1565        } else {
1566                /* FIXME: we cannot here reduce the number of threads */
1567                while (new_num > 1 && new_num > old_num) {
1568                        worker = add_worker(ctx);
1569                        _beginthread(worker_function, 0, worker);
1570                        old_num++;
1571                }
1572        }
1573}
1574#endif /* NO_THREADS */
1575
1576static const struct opt {
1577        int             index;          /* Index in shttpd_ctx          */
1578        const char      *name;          /* Option name in config file   */
1579        const char      *description;   /* Description                  */
1580        const char      *default_value; /* Default option value         */
1581        void (*setter)(struct shttpd_ctx *, const char *);
1582} known_options[] = {
1583        {OPT_ROOT, "root", "\tWeb root directory", ".", NULL},
1584        {OPT_INDEX_FILES, "index_files", "Index files", INDEX_FILES, NULL},
1585#ifndef NO_SSL
1586        {OPT_SSL_CERTIFICATE, "ssl_cert", "SSL certificate file", NULL,set_ssl},
1587#endif /* NO_SSL */
1588        {OPT_PORTS, "ports", "Listening ports", LISTENING_PORTS, set_ports},
1589        {OPT_DIR_LIST, "dir_list", "Directory listing", "yes", NULL},
1590        {OPT_CFG_URI, "cfg_uri", "Config uri", NULL, set_cfg_uri},
1591        {OPT_PROTECT, "protect", "URI to htpasswd mapping", NULL, NULL},
1592#ifndef NO_CGI
1593        {OPT_CGI_EXTENSIONS, "cgi_ext", "CGI extensions", CGI_EXT, NULL},
1594        {OPT_CGI_INTERPRETER, "cgi_interp", "CGI interpreter", NULL, NULL},
1595        {OPT_CGI_ENVIRONMENT, "cgi_env", "Additional CGI env vars", NULL, NULL},
1596#endif /* NO_CGI */
1597        {OPT_SSI_EXTENSIONS, "ssi_ext", "SSI extensions", SSI_EXT, NULL},
1598#ifndef NO_AUTH
1599        {OPT_AUTH_REALM, "auth_realm", "Authentication domain name",REALM,NULL},
1600        {OPT_AUTH_GPASSWD, "auth_gpass", "Global passwords file", NULL, NULL},
1601        {OPT_AUTH_PUT, "auth_PUT", "PUT,DELETE auth file", NULL, NULL},
1602#endif /* !NO_AUTH */
1603#ifdef _WIN32
1604        {OPT_SERVICE, "service", "Manage WinNNT service (install"
1605            "|uninstall)", NULL, set_nt_service},
1606        {OPT_HIDE, "systray", "Hide console, show icon on systray",
1607                "no", set_systray},
1608#else
1609        {OPT_INETD, "inetd", "Inetd mode", "no", set_inetd},
1610        {OPT_UID, "uid", "\tRun as user", NULL, set_uid},
1611#endif /* _WIN32 */
1612        {OPT_ACCESS_LOG, "access_log", "Access log file", NULL, set_alog},
1613        {OPT_ERROR_LOG, "error_log", "Error log file", NULL, set_elog},
1614        {OPT_MIME_TYPES, "mime_types", "Additional mime types list", NULL,NULL},
1615        {OPT_ALIASES, "aliases", "Path=URI mappings", NULL, NULL},
1616        {OPT_ACL, "acl", "\tAllow/deny IP addresses/subnets", NULL, set_acl},
1617#if !defined(NO_THREADS)
1618        {OPT_THREADS, "threads", "Number of worker threads", "1", set_workers},
1619#endif /* !NO_THREADS */
1620        {-1, NULL, NULL, NULL, NULL}
1621};
1622
1623static const struct opt *
1624find_opt(const char *opt_name)
1625{
1626        int     i;
1627
1628        for (i = 0; known_options[i].name != NULL; i++)
1629                if (!strcmp(opt_name, known_options[i].name))
1630                        return (known_options + i);
1631
1632        elog(E_FATAL, NULL, "no such option: [%s]", opt_name);
1633
1634        /* UNREACHABLE */
1635        return (NULL);
1636}
1637
1638void
1639shttpd_set_option(struct shttpd_ctx *ctx, const char *opt, const char *val)
1640{
1641        const struct opt        *o = find_opt(opt);
1642
1643        /* Call option setter first, so it can use both new and old values */
1644        if (o->setter != NULL)
1645                o->setter(ctx, val);
1646
1647        /* Free old value if any */
1648        if (ctx->options[o->index] != NULL)
1649                free(ctx->options[o->index]);
1650       
1651        /* Set new option value */
1652        ctx->options[o->index] = val ? my_strdup(val) : NULL;
1653}
1654
1655static void
1656show_cfg_page(struct shttpd_arg *arg)
1657{
1658        struct shttpd_ctx       *ctx = arg->user_data;
1659        char                    opt_name[20], value[BUFSIZ];
1660        const struct opt        *o;
1661
1662        opt_name[0] = value[0] = '\0';
1663
1664        if (!strcmp(shttpd_get_env(arg, "REQUEST_METHOD"), "POST")) {
1665                if (arg->flags & SHTTPD_MORE_POST_DATA)
1666                        return;
1667                (void) shttpd_get_var("o", arg->in.buf, arg->in.len,
1668                    opt_name, sizeof(opt_name));
1669                (void) shttpd_get_var("v", arg->in.buf, arg->in.len,
1670                    value, sizeof(value));
1671                shttpd_set_option(ctx, opt_name, value[0] ? value : NULL);
1672        }
1673
1674        shttpd_printf(arg, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"
1675            "<html><body><h1>SHTTPD v. %s</h1>", shttpd_version());
1676
1677        shttpd_printf(arg, "%s", "<table border=1"
1678            "<tr><th>Option</th><th>Description</th>"
1679            "<th colspan=2>Value</th></tr>");
1680
1681        if (opt_name[0] != '\0' && value[0] != '\0')
1682                shttpd_printf(arg, "<p style='color: green'>Saved: %s=%s</p>",
1683                    opt_name, value[0] ? value : "NULL");
1684
1685
1686        for (o = known_options; o->name != NULL; o++) {
1687                shttpd_printf(arg,
1688                    "<form method=post><tr><td>%s</td><td>%s</td>"
1689                    "<input type=hidden name=o value='%s'>"
1690                    "<td><input type=text name=v value='%s'></td>"
1691                    "<td><input type=submit value=save></td></form></tr>",
1692                    o->name, o->description, o->name,
1693                    ctx->options[o->index] ? ctx->options[o->index] : "");
1694        }
1695
1696        shttpd_printf(arg, "%s", "</table></body></html>");
1697        arg->flags |= SHTTPD_END_OF_OUTPUT;
1698}
1699
1700/*
1701 * Show usage string and exit.
1702 */
1703void
1704usage(const char *prog)
1705{
1706        const struct opt        *o;
1707
1708        (void) fprintf(stderr,
1709            "SHTTPD version %s (c) Sergey Lyubka\n"
1710            "usage: %s [options] [config_file]\n", VERSION, prog);
1711
1712#if !defined(NO_AUTH)
1713        fprintf(stderr, "  -A <htpasswd_file> <realm> <user> <passwd>\n");
1714#endif /* NO_AUTH */
1715
1716        for (o = known_options; o->name != NULL; o++) {
1717                (void) fprintf(stderr, "  -%s\t%s", o->name, o->description);
1718                if (o->default_value != NULL)
1719                        fprintf(stderr, " (default: %s)", o->default_value);
1720                fputc('\n', stderr);
1721        }
1722
1723        exit(EXIT_FAILURE);
1724}
1725
1726static void
1727set_opt(struct shttpd_ctx *ctx, const char *opt, const char *value)
1728{
1729        const struct opt        *o;
1730
1731        o = find_opt(opt);
1732        if (ctx->options[o->index] != NULL)
1733                free(ctx->options[o->index]);
1734        ctx->options[o->index] = my_strdup(value);
1735}
1736
1737static void
1738process_command_line_arguments(struct shttpd_ctx *ctx, char *argv[])
1739{
1740        const char              *config_file = CONFIG_FILE;
1741        char                    line[BUFSIZ], opt[BUFSIZ],
1742                                val[BUFSIZ], path[FILENAME_MAX], *p;
1743        FILE                    *fp;
1744        size_t                  i, line_no = 0;
1745
1746        /* First find out, which config file to open */
1747        for (i = 1; argv[i] != NULL && argv[i][0] == '-'; i += 2)
1748                if (argv[i + 1] == NULL)
1749                        usage(argv[0]);
1750
1751        if (argv[i] != NULL && argv[i + 1] != NULL) {
1752                /* More than one non-option arguments are given w*/
1753                usage(argv[0]);
1754        } else if (argv[i] != NULL) {
1755                /* Just one non-option argument is given, this is config file */
1756                config_file = argv[i];
1757        } else {
1758                /* No config file specified. Look for one where shttpd lives */
1759                if ((p = strrchr(argv[0], DIRSEP)) != 0) {
1760                        my_snprintf(path, sizeof(path), "%.*s%s",
1761                            p - argv[0] + 1, argv[0], config_file);
1762                        config_file = path;
1763                }
1764        }
1765
1766        fp = fopen(config_file, "r");
1767
1768        /* If config file was set in command line and open failed, exit */
1769        if (fp == NULL && argv[i] != NULL)
1770                elog(E_FATAL, NULL, "cannot open config file %s: %s",
1771                    config_file, strerror(errno));
1772
1773        if (fp != NULL) {
1774
1775                elog(E_LOG, NULL, "Loading config file %s", config_file);
1776
1777                /* Loop over the lines in config file */
1778                while (fgets(line, sizeof(line), fp) != NULL) {
1779
1780                        line_no++;
1781
1782                        /* Ignore empty lines and comments */
1783                        if (line[0] == '#' || line[0] == '\n')
1784                                continue;
1785
1786                        if (sscanf(line, "%s %[^\n#]", opt, val) != 2)
1787                                elog(E_FATAL, NULL, "line %d in %s is invalid",
1788                                    line_no, config_file);
1789
1790                        set_opt(ctx, opt, val);
1791                }
1792
1793                (void) fclose(fp);
1794        }
1795
1796        /* Now pass through the command line options */
1797        for (i = 1; argv[i] != NULL && argv[i][0] == '-'; i += 2)
1798                set_opt(ctx, &argv[i][1], argv[i + 1]);
1799}
1800
1801struct shttpd_ctx *
1802shttpd_init(int argc, char *argv[])
1803{
1804        struct shttpd_ctx       *ctx;
1805        struct tm               *tm;
1806        const struct opt        *o;
1807
1808        if ((ctx = calloc(1, sizeof(*ctx))) == NULL)
1809                elog(E_FATAL, NULL, "cannot allocate shttpd context");
1810
1811        LL_INIT(&ctx->registered_uris);
1812        LL_INIT(&ctx->error_handlers);
1813        LL_INIT(&ctx->acl);
1814        LL_INIT(&ctx->ssi_funcs);
1815        LL_INIT(&ctx->listeners);
1816        LL_INIT(&ctx->workers);
1817
1818        /* Initialize options. First pass: set default option values */
1819        for (o = known_options; o->name != NULL; o++)
1820                ctx->options[o->index] = o->default_value ?
1821                        my_strdup(o->default_value) : NULL;
1822
1823        /* Second and third passes: config file and argv */
1824        if (argc > 0 && argv != NULL)
1825                process_command_line_arguments(ctx, argv);
1826
1827        /* Call setter functions */
1828        for (o = known_options; o->name != NULL; o++)
1829                if (o->setter && ctx->options[o->index] != NULL)
1830                        o->setter(ctx, ctx->options[o->index]);
1831
1832        current_time = time(NULL);
1833        tm = localtime(&current_time);
1834        tz_offset = 0;
1835
1836        if (num_workers(ctx) == 1)
1837                (void) add_worker(ctx);
1838#if 0
1839        tm->tm_gmtoff - 3600 * (tm->tm_isdst > 0 ? 1 : 0);
1840#endif
1841
1842#ifdef _WIN32
1843        {WSADATA data;  WSAStartup(MAKEWORD(2,2), &data);}
1844#endif /* _WIN32 */
1845
1846        return (ctx);
1847}
Note: See TracBrowser for help on using the repository browser.