Changeset 5881

Timestamp:

03/20/10 00:10:03 (3 years ago)

Author:

Cyrus

Message:

zhttpd: Complete static file & CGI serving, TODO: UCI configuration

Location:

luci2/zhttpd

Files:

• env.c (modified) (3 diffs)
• env.h (modified) (1 diff)
• handler (added)
• handler/cgi.c (added)
• handler/file.c (added)
• http.c (modified) (3 diffs)
• http.h (modified) (2 diffs)
• Makefile (modified) (1 diff)
• request.c (modified) (4 diffs)
• request.h (modified) (1 diff)
• tcp.h (modified) (1 diff)
• test (added)
• test/localhost.crt (added)
• test/localhost.key (added)
• zhttpd.c (modified) (8 diffs)
• zhttpd.h (modified) (4 diffs)

luci2/zhttpd/env.c

@@ -18 +18 @@
 }
 
-const char* zhttpd_env_get(uhtbl_t *tbl, const char *key) {
+unsigned int zhttpd_env_count(uhtbl_t *tbl) {
+    return tbl->used;
+}
+
+char* zhttpd_env_next(uhtbl_t *tbl, uint32_t *iter, const char **key) {
+    zhttpd_env_bucket_t *bucket = (zhttpd_env_bucket_t*)uhtbl_next(tbl, iter);
+    if (bucket) {
+        uhtbl_key((uhtbl_bucket_t*)bucket, (void**)key, NULL);
+        return bucket->value;
+    } else {
+        return NULL;
+    }
+}
+
+char* zhttpd_env_get(uhtbl_t *tbl, const char *key) {
     zhttpd_env_bucket_t *bucket =
-            (zhttpd_env_bucket_t*)uhtbl_get(tbl, (const void*)key, strlen(key));
+            (zhttpd_env_bucket_t*)uhtbl_get(tbl, key, strlen(key));
     return (bucket) ? bucket->value : NULL;
 }
@@ -31 +45 @@
 
     if (!(ekey = strdup(key)) || !(evalue = malloc(len + 1))
-    || !(bucket = (zhttpd_env_bucket_t*)uhtbl_set(tbl, ekey, strlen(key)))) {
+    || !(bucket = (zhttpd_env_bucket_t*)uhtbl_set(tbl, ekey, strlen(ekey)))) {
         free(ekey);
         free(evalue);
@@ -42 +56 @@
 }
 
+void zhttpd_env_clear_custom(uhtbl_t *tbl) {
+    uint32_t iter = 0;
+    uhtbl_bucket_t *bucket;
+    while ((bucket = uhtbl_next(tbl, &iter))) {
+        void *key;
+        long len;
+        uhtbl_key(bucket, &key, &len);
+        if (!strncmp((char*)key, "HTTP_", 5)) {
+            uhtbl_unset(tbl, key, len);
+        }
+    }
+}
+
 int zhttpd_env_set_int(uhtbl_t *tbl, const char *key, long long value) {
     char buf[32];

luci2/zhttpd/env.h

@@ -11 +11 @@
 
 int zhttpd_env_init(uhtbl_t *tbl, uint32_t sizehint);
-const char* zhttpd_env_get(uhtbl_t *tbl, const char *key);
+char* zhttpd_env_get(uhtbl_t *tbl, const char *key);
 int zhttpd_env_set
 (uhtbl_t *tbl, const char *name, const char *value, size_t len);
 int zhttpd_env_set_int(uhtbl_t *tbl, const char *key, long long value);
 int zhttpd_env_unset(uhtbl_t *tbl, const char *key);
+char* zhttpd_env_next(uhtbl_t *tbl, uint32_t *iter, const char **key);
+unsigned int zhttpd_env_count(uhtbl_t *tbl);
+void zhttpd_env_clear_custom(uhtbl_t *tbl);
 
 

luci2/zhttpd/http.c

@@ +1 @@
+#define _XOPEN_SOURCE
+#define _SVID_SOURCE
 #include <time.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
 #include "http.h"
 
 static zhttpd_error_t errors[] = {
+        {ZHTTPD_STATUS_OK, "OK"},
+        {ZHTTPD_STATUS_NOT_MODIFIED, "Not Modified"},
+        {ZHTTPD_STATUS_TEMPORARY_REDIRECT, "Temporary Redirect"},
         {ZHTTPD_STATUS_BAD_REQUEST, "Bad Request"},
         {ZHTTPD_STATUS_FORBIDDEN, "Forbidden"},
         {ZHTTPD_STATUS_NOT_FOUND, "Not Found"},
         {ZHTTPD_STATUS_METHOD_NOT_ALLOWED, "Method Not Allowed"},
+        {ZHTTPD_STATUS_LENGTH_REQUIRED, "Length Required"},
+        {ZHTTPD_STATUS_REQUEST_ENTITY_TOO_LARGE, "Request Entity Too Large"},
+        {ZHTTPD_STATUS_REQUEST_URI_TOO_LONG, "Request-URI Too Long"},
+        {ZHTTPD_STATUS_INTERNAL_SERVER_ERROR, "Internal Server Error"},
         {0, NULL}
 };
@@ -19 +31 @@
 }
 
+int zhttpd_http_urldecode(char *url) {
+    char *c = url;
+    unsigned char *d;
+    char dec[3] = "00";
+    while ((d = (unsigned char*)strchr(c, '%'))) {
+        if (!isxdigit(d[1]) || !isxdigit(d[2])) {
+            return -1;
+        }
+        dec[0] = d[1];
+        dec[1] = d[2];
+        *d = (unsigned char)strtol(dec, NULL, 16);
+        memmove(d + 1, &d[3], strlen((char*)&d[3]) + 1);
+        c = (char*)d + 1;
+    }
+    return 0;
+}
+
 int zhttpd_http_date(time_t timestamp, char *buffer, size_t size) {
     if (!timestamp) {
@@ -27 +56 @@
     return strftime(buffer, size, "%a, %d %h %Y %T GMT", &t);
 }
+
+time_t zhttpd_http_timestamp(char *buffer) {
+    struct tm t;
+    return (strptime(buffer, "%a, %d %h %Y %T GMT", &t)) ? timegm(&t) : 0;
+}

luci2/zhttpd/http.h

@@ -2 +2 @@
 #define ERROR_H_
 
-
+#define ZHTTPD_STATUS_OK 200
+#define ZHTTPD_STATUS_NOT_MODIFIED 304
+#define ZHTTPD_STATUS_TEMPORARY_REDIRECT 307
 #define ZHTTPD_STATUS_BAD_REQUEST 400
 #define ZHTTPD_STATUS_FORBIDDEN 403
 #define ZHTTPD_STATUS_NOT_FOUND 404
 #define ZHTTPD_STATUS_METHOD_NOT_ALLOWED 405
-
+#define ZHTTPD_STATUS_LENGTH_REQUIRED 411
+#define ZHTTPD_STATUS_REQUEST_ENTITY_TOO_LARGE 413
+#define ZHTTPD_STATUS_REQUEST_URI_TOO_LONG 414
+#define ZHTTPD_STATUS_INTERNAL_SERVER_ERROR 500
 
 typedef struct zhttpd_error {
@@ -16 +21 @@
 const char* zhttpd_http_status(int code);
 int zhttpd_http_date(const time_t timestamp, char *buffer, size_t size);
+time_t zhttpd_http_timestamp(char *buffer);
+int zhttpd_http_urldecode(char *url);
 
 #endif /* ERROR_H_ */

luci2/zhttpd/Makefile

@@ -19 +19 @@
 all: $(BINARY)
 
-$(BINARY): *.c
+$(BINARY): *.c handler/*.c
     $(CC) $(CFLAGS) $(TLSCFLAGS) $(SFLAGS) $(WFLAGS) $(LDFLAGS) -I.. -o $@ $+
 

luci2/zhttpd/request.c

@@ -10 +10 @@
 #include "env.h"
 
+static int zhttpd_request_headers(zthread_t *thread);
+static int zhttpd_request_dispatch(zthread_t *thread);
+
 int zhttpd_request_magic(zthread_t *thread) {
     char buffer[4096];
@@ -52 +55 @@
         goto error;
     }
+    req->size += c - buffer;
 
     zhttpd_env_set(&req->env, "REQUEST_METHOD", method, strlen(method));
@@ -62 +66 @@
     }
 
+    char *query = strchr(url, '?');
+    if (query) {
+        *query = 0;
+        if (zhttpd_http_urldecode(url)) {
+            goto error;
+        }
+        zhttpd_env_set(&req->env, "SCRIPT_NAME", url, query - url);
+        zhttpd_env_set(&req->env, "QUERY_STRING", query + 1, strlen(query + 1));
+    } else {
+        zhttpd_env_set(&req->env, "SCRIPT_NAME", url, strlen(url));
+        zhttpd_env_unset(&req->env, "QUERY_STRING");
+    }
+
     thread->state = zhttpd_request_headers;
-    return ZTHREAD_READY;
+    return zhttpd_request_headers(thread);
 error:
     return zhttpd_request_error(thread, ZHTTPD_STATUS_BAD_REQUEST);
 }
 
-int zhttpd_request_headers(zthread_t *thread) {
-    return ZTHREAD_DONE;
-}
-
-int zhttpd_request_status(zthread_t *thread, int status) {
+static int zhttpd_request_headers(zthread_t *thread) {
+    char buffer[4096] = "HTTP_";
+    zhttpd_request_t *req = thread->context;
+
+    while (fgets(buffer + 5, sizeof(buffer) - 5, req->streamin)) {
+        char *c = buffer + 5, *key = buffer, *value;
+        if (!isalnum(*c)) {
+            if (*c == '\r' || *c == '\n') {
+                return zhttpd_request_dispatch(thread);
+            } else {
+                goto error;
+            }
+        }
+        for (; isalnum(*c) || *c == '-'; c++) {
+            *c = (*c == '-') ? '_' : toupper(*c);
+        }
+        if (*c == ':') {
+            *c++ = 0;
+        } else {
+            goto error;
+        }
+        for(; isblank(*c); c++);
+        value = c;
+        for (c = value + strlen(value) - 1; isspace(*c); c--);
+
+        if ((req->size += c - buffer) > zhttpd.reqhlimit) {
+            return zhttpd_request_error(thread,
+                    ZHTTPD_STATUS_REQUEST_ENTITY_TOO_LARGE);
+        }
+
+        if (!strcmp(key, "HTTP_CONNECTION")) {
+            if (req->flags & ZHTTPD_FLAG_RECYCLE && strstr(value, "close")) {
+                req->flags &= ~ZHTTPD_FLAG_RECYCLE;
+            } else if (req->flags & ZHTTPD_FLAG_RECYCLE
+            && (strstr(value, "keep-alive") || strstr(value, "Keep-Alive"))) {
+                req->flags |= ZHTTPD_FLAG_RECYCLE;
+            }
+        } else if (!strncmp(key, "HTTP_CONTENT_", 13)) {
+            key = buffer + 5;
+        }
+        zhttpd_env_set(&req->env, key, value, 1 + (c - value));
+    }
+
+    return (errno == EAGAIN) ? ZTHREAD_BLOCKED : ZTHREAD_DONE;
+    error:
+        return zhttpd_request_error(thread, ZHTTPD_STATUS_BAD_REQUEST);
+}
+
+static int zhttpd_request_dispatch(zthread_t *thread) {
+    zhttpd_request_t *req = thread->context;
+    char *url = zhttpd_env_get(&req->env, "SCRIPT_NAME");
+    size_t size = 0, matchlen = 0, urllen = strlen(url);
+
+    zhttpd_vfs_t *vfs = NULL;
+    for (zhttpd_vfs_t *c = zhttpd.vfs; c; c = c->next) {
+        matchlen = c->patternlen - 1;
+        if (size < c->patternlen && urllen >= matchlen
+        && !memcmp(url, c->pattern, matchlen)
+        && (url[matchlen] == c->pattern[matchlen] || !url[matchlen])) {
+            vfs = c;
+            size = c->patternlen;
+        }
+    }
+
+    if (!vfs) {
+        return zhttpd_request_error(thread, ZHTTPD_STATUS_NOT_FOUND);
+    } else {
+        matchlen = size - 1;
+        if (urllen > matchlen) {
+            zhttpd_env_set(&req->env, "PATH_INFO", url + matchlen + 1,
+                    urllen - matchlen - 1);
+        } else {
+            zhttpd_env_set(&req->env, "PATH_INFO", "", 1);
+        }
+        req->virtual = vfs;
+        thread->state = vfs->handler->entrypoint;
+        return ZTHREAD_READY;
+    }
+}
+
+int zhttpd_request_status(zthread_t *thread, int status, const char *msg) {
     char date[32];
     zhttpd_request_t *req = thread->context;
-    const char *http = zhttpd_env_get(&req->env, "HTTP_VERSION");
+    const char *http = zhttpd_env_get(&req->env, "SERVER_PROTOCOL");
     if (!http) {
         http = "HTTP/1.0";
     }
+    const char *statusmsg = (msg) ? msg : zhttpd_http_status(status);
+    zhttpd_http_date(0, date, sizeof(date));
+    if (req->flags & ZHTTPD_FLAG_RECYCLE) {
+        return fprintf(req->streamout, "%s %i %s\r\nServer: %s\r\nDate: %s\r\n"
+            "Connection: Keep-Alive\r\nKeep-Alive: timeout=%i\r\n",
+            http, status, statusmsg, ZHTTPD_COPYMARK, date, zhttpd.timeout);
+    } else {
+        return fprintf(req->streamout,
+        "%s %i %s\r\nServer: %s\r\nDate: %s\r\nConnection: close\r\n",
+                http, status, statusmsg, ZHTTPD_COPYMARK, date);
+    }
+}
+
+int zhttpd_request_simple(zthread_t *thread, int status) {
+    zhttpd_request_t *req = thread->context;
+    zhttpd_request_status(thread, status, NULL);
+    fputs("\r\n", req->streamout);
+    thread->state = zhttpd_request_recycle;
+    return zhttpd_request_recycle(thread);
+}
+
+int zhttpd_request_error(zthread_t *thread, int status) {
+    zhttpd_request_t *req = thread->context;
+    zhttpd_request_status(thread, status, NULL);
     const char *statusmsg = zhttpd_http_status(status);
-    zhttpd_http_date(0, date, sizeof(date));
-    return fprintf(req->streamout, "%s %i %s\r\nServer: %s\r\nDate: %s\r\n",
-            http, status, statusmsg, ZHTTPD_COPYMARK, date);
-}
-
-int zhttpd_request_error(zthread_t *thread, int status) {
-    zhttpd_request_t *req = thread->context;
-    zhttpd_request_status(thread, status);
-    const char *statusmsg = zhttpd_http_status(status);
-    fprintf(req->streamout, "Connection: close\r\nContent-Type: text/plain\r\n"
+    fprintf(req->streamout, "Content-Type: text/plain\r\n"
     "Content-Length: %i\r\n\r\n%s\r\n", (int)strlen(statusmsg) + 2, statusmsg);
     thread->state = zhttpd_request_recycle;
-    return ZTHREAD_READY;
+    return zhttpd_request_recycle(thread);
 }
 
@@ -103 +211 @@
     if (req->flags & ZHTTPD_FLAG_RECYCLE) {
         req->flags &= ~ZHTTPD_FLAG_RECYCLE;
+        if (req->handlergc) {
+            req->handlergc(req->handlercontext);
+        }
+        req->handlercontext = NULL;
+        req->handlergc = NULL;
+        zhttpd_env_clear_custom(&req->env);
         thread->state = zhttpd_request_magic;
         return ZTHREAD_READY;

luci2/zhttpd/request.h

@@ -7 +7 @@
 int zhttpd_request_error(zthread_t *thread, int status);
 int zhttpd_request_recycle(zthread_t *thread);
-int zhttpd_request_headers(zthread_t *thread);
+int zhttpd_request_simple(zthread_t *thread, int status);
+int zhttpd_request_status(zthread_t *thread, int status, const char *msg);
 
 #endif /* REQUEST_H_ */

luci2/zhttpd/tcp.h

@@ -26 +26 @@
 const char *tlskey, const char *tlscert, int pem);
 int zhttpd_tcp_shutdown(zthread_t *thread);
+ssize_t zhttpd_tcp_sendfile(zhttpd_request_t *req, int fdin, size_t count);
 
 #endif /* TCP_H_ */

luci2/zhttpd/zhttpd.c

@@ -6 +6 @@
 #include <sys/epoll.h>
 #include <sys/types.h>
+#include <sys/wait.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -11 +12 @@
 #include "zhttpd.h"
 #include "tcp.h"
+#include "env.h"
 
 static volatile int running;
@@ -41 +43 @@
 
 static void sighandler(int signal) {
-    if (signal == SIGHUP) {
-        running = 2;
-    } else {
-        running = 0;
+    switch (signal) {
+        case SIGCHLD:
+            while (waitpid(-1, NULL, WNOHANG) > 0);
+
+        case SIGPIPE:
+            return;
+
+        case SIGHUP:
+            running = 2;
+
+        default:
+            running = 0;
     }
 }
 
 static void configure() {
+    zhttpd_env_init(&zhttpd.mime, 16);
+
+    zhttpd_env_set(&zhttpd.mime, "htm", ZHTTPD_LITERAL_PTRSIZE("text/html"));
+    zhttpd_env_set(&zhttpd.mime, "html", ZHTTPD_LITERAL_PTRSIZE("text/html"));
+    zhttpd_env_set(&zhttpd.mime, "css", ZHTTPD_LITERAL_PTRSIZE("text/css"));
+    zhttpd_env_set(&zhttpd.mime, "js", ZHTTPD_LITERAL_PTRSIZE("text/javascript"));
+    zhttpd_env_set(&zhttpd.mime, "xml", ZHTTPD_LITERAL_PTRSIZE("application/xml"));
+    zhttpd_env_set(&zhttpd.mime, "xsl", ZHTTPD_LITERAL_PTRSIZE("application/xml"));
+    zhttpd_env_set(&zhttpd.mime, "gif", ZHTTPD_LITERAL_PTRSIZE("image/gif"));
+    zhttpd_env_set(&zhttpd.mime, "png", ZHTTPD_LITERAL_PTRSIZE("image/png"));
+    zhttpd_env_set(&zhttpd.mime, "jpg", ZHTTPD_LITERAL_PTRSIZE("image/jpeg"));
+    zhttpd_env_set(&zhttpd.mime, "jpeg", ZHTTPD_LITERAL_PTRSIZE("image/jpeg"));
+    zhttpd_env_set(&zhttpd.mime, "svg", ZHTTPD_LITERAL_PTRSIZE("image/svg+xml"));
+
+    zhttpd_options_t opt3 = {.key = (char*)"virtual", .value=(char*)"/", .next=NULL};
+    zhttpd_options_t opt2 = {.key = (char*)"physical", .value=(char*)"/tmp", .next=&opt3};
+    zhttpd_options_t opt1 = {.key = (char*)"handler", .value=(char*)"file", .next=&opt2};
+    zhttpd_vfs_mount(&opt1);
+
+    zhttpd_options_t opt13 = {.key = (char*)"virtual", .value=(char*)"/cgi-bin", .next=NULL};
+    zhttpd_options_t opt12 = {.key = (char*)"physical", .value=(char*)"/tmp", .next=&opt13};
+    zhttpd_options_t opt11 = {.key = (char*)"handler", .value=(char*)"cgi", .next=&opt12};
+    zhttpd_vfs_mount(&opt11);
+
     zhttpd.threads = 32;
     zhttpd.timeout = 5;
     zhttpd.daemonize = 0;
+    zhttpd.reqhlimit = 8192;
 
     zhttpd.threadpool = zthread_create(zhttpd.threads);
@@ -65 +100 @@
     close(zhttpd.epollfd);
     zthread_destroy(zhttpd.threadpool);
+    uhtbl_finalize(&zhttpd.mime);
     zhttpd_vfs_t *d = NULL;
     for (zhttpd_vfs_t *c = zhttpd.vfs; c; c = d) {
@@ -97 +133 @@
     sigaction(SIGINT, &action, NULL);
     sigaction(SIGTERM, &action, NULL);
-    action.sa_handler = SIG_IGN;
     sigaction(SIGPIPE, &action, NULL);
+    sigaction(SIGCHLD, &action, NULL);
 
     zhttpd.pidfile = "/var/run/zhttpd.pid";
@@ -114 +150 @@
 }
 
-int zhttpd_vfs_mount(const char *point, zhttpd_options_t *options) {
+int zhttpd_vfs_mount(zhttpd_options_t *options) {
+    const char *handlername = zhttpd_options_get(options, "handler");
+    const char *point = zhttpd_options_get(options, "virtual");
+    if (!handlername || !point) {
+        return ZHTTPD_EINVAL;
+    }
+
     size_t pointlen = strlen(point);
-    const char *handlername = zhttpd_options_get(options, "handler");
-    if (!handlername) {
-        return ZHTTPD_EINVAL;
-    }
-
     zhttpd_handler_t *handler = NULL;
     for (zhttpd_handler_t *c = zhttpd.handler; c; c = c->next) {
@@ -146 +183 @@
     mount->context = handler->vfs_context_create(options);
     mount->next = zhttpd.vfs;
+
+    if (!mount->context) {
+        free(mount);
+        return ZHTTPD_EINVAL;
+    }
+
     zhttpd.vfs = mount;
 
@@ -152 +195 @@
 
 const char* zhttpd_options_get(zhttpd_options_t *options, const char *key) {
-    size_t keylen = strlen(key);
     for (; options; options = options->next) {
-        if (!strcmp(key, options->option) && options->option[keylen] == '=') {
-            return &options->option[keylen + 1];
+        if (!strcmp(key, options->key)) {
+            return options->value;
         }
     }

luci2/zhttpd/zhttpd.h

@@ -36 +36 @@
 struct zhttpd_options {
     zhttpd_options_t *next;
-    char option[];
+    char *key;
+    char *value;
 };
 
@@ -42 +43 @@
     int flags;
     int fd;
+    int size;
     void *ioctx;
     uhtbl_t env;
@@ -62 +64 @@
     zhttpd_handler_t *next;
     zthread_state_t *entrypoint;
-    zthread_state_t *cleanup;
     void* (*vfs_context_create)(zhttpd_options_t*);
     void (*vfs_context_destroy)(void*);
-    char name[];
+    char *name;
 };
 
@@ -72 +73 @@
     zthread_context_t *threadpool;
     zhttpd_handler_t *handler;
+    uhtbl_t mime;
     int epollfd;
     int timeout;
     int threads;
     int daemonize;
+    int reqhlimit;
     char *pidfile;
 };
 
-#define ZHTTPD_REGISTER(handler) __attribute__((constructor (5))) \
-    void __zhttpd_register() { zhttpd_register(handler); }
+#define ZHTTPD_HANDLER_REGISTER(name, handler) \
+        void  __attribute__ ((constructor)) name##start(void) { \
+                handler.next = zhttpd.handler; \
+                zhttpd.handler = &handler; \
+        }
+
+#define ZHTTPD_LITERAL_PTRSIZE(x) x, (sizeof(x) - 1)
 
 extern zhttpd_context_t zhttpd;
 
+void zhttpd_register(zhttpd_handler_t *handler);
+int zhttpd_vfs_mount(zhttpd_options_t *options);
 const char* zhttpd_options_get(zhttpd_options_t *options, const char *key);