projects / project / uhttpd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add lua plugin support
[project/uhttpd.git] / file.c
diff --git a/file.c b/file.c
index 7091ef7..372696c 100644 (file)
--- a/file.c
+++ b/file.c
@@ -18,36 +18,30 @@
  */
 
 #define _BSD_SOURCE
  */
 
 #define _BSD_SOURCE
+#define _DARWIN_C_SOURCE
 #define _XOPEN_SOURCE 700
 
 #include <sys/types.h>
 #include <sys/dir.h>
 #include <time.h>
 #include <strings.h>
 #define _XOPEN_SOURCE 700
 
 #include <sys/types.h>
 #include <sys/dir.h>
 #include <time.h>
 #include <strings.h>
+#include <dirent.h>
 
 #include <libubox/blobmsg.h>
 
 #include "uhttpd.h"
 
 #include <libubox/blobmsg.h>
 
 #include "uhttpd.h"
-#include "uhttpd-mimetypes.h"
+#include "mimetypes.h"
 
 static LIST_HEAD(index_files);
 
 static LIST_HEAD(index_files);
+static LIST_HEAD(dispatch_handlers);
 
 struct index_file {
        struct list_head list;
        const char *name;
 };
 
 
 struct index_file {
        struct list_head list;
        const char *name;
 };
 
-struct path_info {
-       char *root;
-       char *phys;
-       char *name;
-       char *info;
-       char *query;
-       int redirected;
-       struct stat stat;
-};
-
 enum file_hdr {
 enum file_hdr {
+       HDR_AUTHORIZATION,
        HDR_IF_MODIFIED_SINCE,
        HDR_IF_UNMODIFIED_SINCE,
        HDR_IF_MATCH,
        HDR_IF_MODIFIED_SINCE,
        HDR_IF_UNMODIFIED_SINCE,
        HDR_IF_MATCH,
@@ -67,21 +61,14 @@ void uh_index_add(const char *filename)
 
 static char * canonpath(const char *path, char *path_resolved)
 {
 
 static char * canonpath(const char *path, char *path_resolved)
 {
-       char path_copy[PATH_MAX];
-       char *path_cpy = path_copy;
+       const char *path_cpy = path;
        char *path_res = path_resolved;
 
        char *path_res = path_resolved;
 
-       /* relative -> absolute */
-       if (*path != '/') {
-               getcwd(path_copy, PATH_MAX);
-               strncat(path_copy, "/", PATH_MAX - strlen(path_copy));
-               strncat(path_copy, path, PATH_MAX - strlen(path_copy));
-       } else {
-               strncpy(path_copy, path, PATH_MAX);
-       }
+       if (conf.no_symlinks)
+               return realpath(path, path_resolved);
 
        /* normalize */
 
        /* normalize */
-       while ((*path_cpy != '\0') && (path_cpy < (path_copy + PATH_MAX - 2))) {
+       while ((*path_cpy != '\0') && (path_cpy < (path + PATH_MAX - 2))) {
                if (*path_cpy != '/')
                        goto next;
 
                if (*path_cpy != '/')
                        goto next;
 
@@ -127,19 +114,20 @@ next:
 /* Returns NULL on error.
 ** NB: improperly encoded URL should give client 400 [Bad Syntax]; returning
 ** NULL here causes 404 [Not Found], but that's not too unreasonable. */
 /* Returns NULL on error.
 ** NB: improperly encoded URL should give client 400 [Bad Syntax]; returning
 ** NULL here causes 404 [Not Found], but that's not too unreasonable. */
-struct path_info * uh_path_lookup(struct client *cl, const char *url)
+static struct path_info *
+uh_path_lookup(struct client *cl, const char *url)
 {
        static char path_phys[PATH_MAX];
        static char path_info[PATH_MAX];
        static struct path_info p;
 
 {
        static char path_phys[PATH_MAX];
        static char path_info[PATH_MAX];
        static struct path_info p;
 
-       char buffer[UH_LIMIT_MSGHEAD];
-       char *docroot = conf.docroot;
+       const char *docroot = conf.docroot;
+       int docroot_len = strlen(docroot);
        char *pathptr = NULL;
        char *pathptr = NULL;
+       bool slash;
 
 
-       int slash = 0;
-       int no_sym = conf.no_symlinks;
        int i = 0;
        int i = 0;
+       int len;
        struct stat s;
        struct index_file *idx;
 
        struct stat s;
        struct index_file *idx;
 
@@ -147,14 +135,11 @@ struct path_info * uh_path_lookup(struct client *cl, const char *url)
        if (url == NULL)
                return NULL;
 
        if (url == NULL)
                return NULL;
 
-       memset(path_phys, 0, sizeof(path_phys));
-       memset(path_info, 0, sizeof(path_info));
-       memset(buffer, 0, sizeof(buffer));
        memset(&p, 0, sizeof(p));
        memset(&p, 0, sizeof(p));
+       path_phys[0] = 0;
+       path_info[0] = 0;
 
 
-       /* copy docroot */
-       memcpy(buffer, docroot,
-                  min(strlen(docroot), sizeof(buffer) - 1));
+       strcpy(uh_buf, docroot);
 
        /* separate query string from url */
        if ((pathptr = strchr(url, '?')) != NULL) {
 
        /* separate query string from url */
        if ((pathptr = strchr(url, '?')) != NULL) {
@@ -162,104 +147,112 @@ struct path_info * uh_path_lookup(struct client *cl, const char *url)
 
                /* urldecode component w/o query */
                if (pathptr > url) {
 
                /* urldecode component w/o query */
                if (pathptr > url) {
-                       if (uh_urldecode(&buffer[strlen(docroot)],
-                                                        sizeof(buffer) - strlen(docroot) - 1,
-                                                        url, pathptr - url ) < 0)
-                               return NULL; /* bad URL */
+                       if (uh_urldecode(&uh_buf[docroot_len],
+                                        sizeof(uh_buf) - docroot_len - 1,
+                                        url, pathptr - url ) < 0)
+                               return NULL;
                }
        }
 
        /* no query string, decode all of url */
                }
        }
 
        /* no query string, decode all of url */
-       else if (uh_urldecode(&buffer[strlen(docroot)],
-                             sizeof(buffer) - strlen(docroot) - 1,
+       else if (uh_urldecode(&uh_buf[docroot_len],
+                             sizeof(uh_buf) - docroot_len - 1,
                              url, strlen(url) ) < 0)
                              url, strlen(url) ) < 0)
-               return NULL; /* bad URL */
+               return NULL;
 
        /* create canon path */
 
        /* create canon path */
-       for (i = strlen(buffer), slash = (buffer[max(0, i-1)] == '/'); i >= 0; i--) {
-               if ((buffer[i] == 0) || (buffer[i] == '/')) {
-                       memset(path_info, 0, sizeof(path_info));
-                       memcpy(path_info, buffer, min(i + 1, sizeof(path_info) - 1));
-
-                       if (no_sym ? realpath(path_info, path_phys)
-                                  : canonpath(path_info, path_phys)) {
-                               memset(path_info, 0, sizeof(path_info));
-                               memcpy(path_info, &buffer[i],
-                                          min(strlen(buffer) - i, sizeof(path_info) - 1));
-
-                               break;
-                       }
-               }
+       len = strlen(uh_buf);
+       slash = len && uh_buf[len - 1] == '/';
+       len = min(len, sizeof(path_phys) - 1);
+
+       for (i = len; i >= 0; i--) {
+               char ch = uh_buf[i];
+               bool exists;
+
+               if (ch != 0 && ch != '/')
+                       continue;
+
+               uh_buf[i] = 0;
+               exists = !!canonpath(uh_buf, path_phys);
+               uh_buf[i] = ch;
+
+               snprintf(path_info, sizeof(path_info), "%s", uh_buf + i);
+               break;
        }
 
        /* check whether found path is within docroot */
        }
 
        /* check whether found path is within docroot */
-       if (strncmp(path_phys, docroot, strlen(docroot)) ||
-               ((path_phys[strlen(docroot)] != 0) &&
-                (path_phys[strlen(docroot)] != '/')))
+       if (strncmp(path_phys, docroot, docroot_len) != 0 ||
+           (path_phys[docroot_len] != 0 &&
+            path_phys[docroot_len] != '/'))
                return NULL;
 
        /* test current path */
                return NULL;
 
        /* test current path */
-       if (!stat(path_phys, &p.stat)) {
-               /* is a regular file */
-               if (p.stat.st_mode & S_IFREG) {
-                       p.root = docroot;
-                       p.phys = path_phys;
-                       p.name = &path_phys[strlen(docroot)];
-                       p.info = path_info[0] ? path_info : NULL;
-               }
+       if (stat(path_phys, &p.stat))
+               return NULL;
 
 
-               /* is a directory */
-               else if ((p.stat.st_mode & S_IFDIR) && !strlen(path_info)) {
-                       /* ensure trailing slash */
-                       if (path_phys[strlen(path_phys)-1] != '/')
-                               path_phys[strlen(path_phys)] = '/';
-
-                       /* try to locate index file */
-                       memset(buffer, 0, sizeof(buffer));
-                       memcpy(buffer, path_phys, sizeof(buffer));
-                       pathptr = &buffer[strlen(buffer)];
-
-                       /* if requested url resolves to a directory and a trailing slash
-                          is missing in the request url, redirect the client to the same
-                          url with trailing slash appended */
-                       if (!slash) {
-                               uh_http_header(cl, 302, "Found");
-                               ustream_printf(cl->us, "Location: %s%s%s\r\n\r\n",
-                                               &path_phys[strlen(docroot)],
-                                               p.query ? "?" : "",
-                                               p.query ? p.query : "");
-                               uh_request_done(cl);
-                               p.redirected = 1;
-                       } else {
-                               list_for_each_entry(idx, &index_files, list) {
-                                       strncat(buffer, idx->name, sizeof(buffer));
-
-                                       if (!stat(buffer, &s) && (s.st_mode & S_IFREG)) {
-                                               memcpy(path_phys, buffer, sizeof(path_phys));
-                                               memcpy(&p.stat, &s, sizeof(p.stat));
-                                               break;
-                                       }
-
-                                       *pathptr = 0;
-                               }
-                       }
+       /* is a regular file */
+       if (p.stat.st_mode & S_IFREG) {
+               p.root = docroot;
+               p.phys = path_phys;
+               p.name = &path_phys[docroot_len];
+               p.info = path_info[0] ? path_info : NULL;
+               return &p;
+       }
+
+       if (!(p.stat.st_mode & S_IFDIR))
+               return NULL;
+
+       if (path_info[0])
+           return NULL;
+
+       pathptr = path_phys + strlen(path_phys);
+
+       /* ensure trailing slash */
+       if (pathptr[-1] != '/') {
+               pathptr[0] = '/';
+               pathptr[1] = 0;
+               pathptr++;
+       }
 
 
-                       p.root = docroot;
-                       p.phys = path_phys;
-                       p.name = &path_phys[strlen(docroot)];
+       /* if requested url resolves to a directory and a trailing slash
+          is missing in the request url, redirect the client to the same
+          url with trailing slash appended */
+       if (!slash) {
+               uh_http_header(cl, 302, "Found");
+               ustream_printf(cl->us, "Location: %s%s%s\r\n\r\n",
+                               &path_phys[docroot_len],
+                               p.query ? "?" : "",
+                               p.query ? p.query : "");
+               uh_request_done(cl);
+               p.redirected = 1;
+               return &p;
+       }
+
+       /* try to locate index file */
+       len = path_phys + sizeof(path_phys) - pathptr - 1;
+       list_for_each_entry(idx, &index_files, list) {
+               if (strlen(idx->name) > len)
+                       continue;
+
+               strcpy(pathptr, idx->name);
+               if (!stat(path_phys, &s) && (s.st_mode & S_IFREG)) {
+                       memcpy(&p.stat, &s, sizeof(p.stat));
+                       break;
                }
                }
+
+               *pathptr = 0;
        }
 
        }
 
+       p.root = docroot;
+       p.phys = path_phys;
+       p.name = &path_phys[docroot_len];
+
        return p.phys ? &p : NULL;
 }
 
        return p.phys ? &p : NULL;
 }
 
-#ifdef __APPLE__
-time_t timegm (struct tm *tm);
-#endif
-
 static const char * uh_file_mime_lookup(const char *path)
 {
 static const char * uh_file_mime_lookup(const char *path)
 {
-       struct mimetype *m = &uh_mime_types[0];
+       const struct mimetype *m = &uh_mime_types[0];
        const char *e;
 
        while (m->extn) {
        const char *e;
 
        while (m->extn) {
@@ -278,16 +271,14 @@ static const char * uh_file_mime_lookup(const char *path)
        return "application/octet-stream";
 }
 
        return "application/octet-stream";
 }
 
-static const char * uh_file_mktag(struct stat *s)
+static const char * uh_file_mktag(struct stat *s, char *buf)
 {
 {
-       static char tag[128];
-
-       snprintf(tag, sizeof(tag), "\"%x-%x-%x\"",
+       snprintf(buf, sizeof(buf), "\"%x-%x-%x\"",
                         (unsigned int) s->st_ino,
                         (unsigned int) s->st_size,
                         (unsigned int) s->st_mtime);
 
                         (unsigned int) s->st_ino,
                         (unsigned int) s->st_size,
                         (unsigned int) s->st_mtime);
 
-       return tag;
+       return buf;
 }
 
 static time_t uh_file_date2unix(const char *date)
 }
 
 static time_t uh_file_date2unix(const char *date)
@@ -302,32 +293,34 @@ static time_t uh_file_date2unix(const char *date)
        return 0;
 }
 
        return 0;
 }
 
-static char * uh_file_unix2date(time_t ts)
+static char * uh_file_unix2date(time_t ts, char *buf, int len)
 {
 {
-       static char str[128];
        struct tm *t = gmtime(&ts);
 
        struct tm *t = gmtime(&ts);
 
-       strftime(str, sizeof(str), "%a, %d %b %Y %H:%M:%S GMT", t);
+       strftime(buf, len, "%a, %d %b %Y %H:%M:%S GMT", t);
 
 
-       return str;
+       return buf;
 }
 
 static char *uh_file_header(struct client *cl, int idx)
 {
 }
 
 static char *uh_file_header(struct client *cl, int idx)
 {
-       if (!cl->data.file.hdr[idx])
+       if (!cl->dispatch.file.hdr[idx])
                return NULL;
 
                return NULL;
 
-       return (char *) blobmsg_data(cl->data.file.hdr[idx]);
+       return (char *) blobmsg_data(cl->dispatch.file.hdr[idx]);
 }
 
 static void uh_file_response_ok_hdrs(struct client *cl, struct stat *s)
 {
 }
 
 static void uh_file_response_ok_hdrs(struct client *cl, struct stat *s)
 {
+       char buf[128];
+
        if (s) {
        if (s) {
-               ustream_printf(cl->us, "ETag: %s\r\n", uh_file_mktag(s));
+               ustream_printf(cl->us, "ETag: %s\r\n", uh_file_mktag(s, buf));
                ustream_printf(cl->us, "Last-Modified: %s\r\n",
                ustream_printf(cl->us, "Last-Modified: %s\r\n",
-                              uh_file_unix2date(s->st_mtime));
+                              uh_file_unix2date(s->st_mtime, buf, sizeof(buf)));
        }
        }
-       ustream_printf(cl->us, "Date: %s\r\n", uh_file_unix2date(time(NULL)));
+       ustream_printf(cl->us, "Date: %s\r\n",
+                      uh_file_unix2date(time(NULL), buf, sizeof(buf)));
 }
 
 static void uh_file_response_200(struct client *cl, struct stat *s)
 }
 
 static void uh_file_response_200(struct client *cl, struct stat *s)
@@ -350,7 +343,8 @@ static void uh_file_response_412(struct client *cl)
 
 static bool uh_file_if_match(struct client *cl, struct stat *s)
 {
 
 static bool uh_file_if_match(struct client *cl, struct stat *s)
 {
-       const char *tag = uh_file_mktag(s);
+       char buf[128];
+       const char *tag = uh_file_mktag(s, buf);
        char *hdr = uh_file_header(cl, HDR_IF_MATCH);
        char *p;
        int i;
        char *hdr = uh_file_header(cl, HDR_IF_MATCH);
        char *p;
        int i;
@@ -390,7 +384,8 @@ static int uh_file_if_modified_since(struct client *cl, struct stat *s)
 
 static int uh_file_if_none_match(struct client *cl, struct stat *s)
 {
 
 static int uh_file_if_none_match(struct client *cl, struct stat *s)
 {
-       const char *tag = uh_file_mktag(s);
+       char buf[128];
+       const char *tag = uh_file_mktag(s, buf);
        char *hdr = uh_file_header(cl, HDR_IF_NONE_MATCH);
        char *p;
        int i;
        char *hdr = uh_file_header(cl, HDR_IF_NONE_MATCH);
        char *p;
        int i;
@@ -441,20 +436,69 @@ static int uh_file_if_unmodified_since(struct client *cl, struct stat *s)
        return true;
 }
 
        return true;
 }
 
+static int dirent_cmp(const struct dirent **a, const struct dirent **b)
+{
+       bool dir_a = !!((*a)->d_type & DT_DIR);
+       bool dir_b = !!((*b)->d_type & DT_DIR);
+
+       /* directories first */
+       if (dir_a != dir_b)
+               return dir_b - dir_a;
+
+       return alphasort(a, b);
+}
 
 
-static int uh_file_scandir_filter_dir(const struct dirent *e)
+static void list_entries(struct client *cl, struct dirent **files, int count,
+                        const char *path, char *local_path)
 {
 {
-       return strcmp(e->d_name, ".") ? 1 : 0;
+       const char *suffix = "/";
+       const char *type = "directory";
+       unsigned int mode = S_IXOTH;
+       struct stat s;
+       char *file;
+       char buf[128];
+       int i;
+
+       file = local_path + strlen(local_path);
+       for (i = 0; i < count; i++) {
+               const char *name = files[i]->d_name;
+               bool dir = !!(files[i]->d_type & DT_DIR);
+
+               if (name[0] == '.' && name[1] == 0)
+                       continue;
+
+               sprintf(file, "%s", name);
+               if (stat(local_path, &s))
+                       continue;
+
+               if (!dir) {
+                       suffix = "";
+                       mode = S_IROTH;
+                       type = uh_file_mime_lookup(local_path);
+               }
+
+               if (!(s.st_mode & mode))
+                       continue;
+
+               uh_chunk_printf(cl,
+                               "<li><strong><a href='%s%s%s'>%s</a>%s"
+                               "</strong><br /><small>modified: %s"
+                               "<br />%s - %.02f kbyte<br />"
+                               "<br /></small></li>",
+                               path, name, suffix,
+                               name, suffix,
+                               uh_file_unix2date(s.st_mtime, buf, sizeof(buf)),
+                               type, s.st_size / 1024.0);
+
+               *file = 0;
+               free(files[i]);
+       }
 }
 
 static void uh_file_dirlist(struct client *cl, struct path_info *pi)
 {
 }
 
 static void uh_file_dirlist(struct client *cl, struct path_info *pi)
 {
-       int i;
-       int count = 0;
-       char filename[PATH_MAX];
-       char *pathptr;
        struct dirent **files = NULL;
        struct dirent **files = NULL;
-       struct stat s;
+       int count = 0;
 
        uh_file_response_200(cl, NULL);
        ustream_printf(cl->us, "Content-Type: text/html\r\n\r\n");
 
        uh_file_response_200(cl, NULL);
        ustream_printf(cl->us, "Content-Type: text/html\r\n\r\n");
@@ -464,75 +508,24 @@ static void uh_file_dirlist(struct client *cl, struct path_info *pi)
                "<body><h1>Index of %s</h1><hr /><ol>",
                pi->name, pi->name);
 
                "<body><h1>Index of %s</h1><hr /><ol>",
                pi->name, pi->name);
 
-       if ((count = scandir(pi->phys, &files, uh_file_scandir_filter_dir,
-                                                alphasort)) > 0)
-       {
-               memset(filename, 0, sizeof(filename));
-               memcpy(filename, pi->phys, sizeof(filename));
-               pathptr = &filename[strlen(filename)];
-
-               /* list subdirs */
-               for (i = 0; i < count; i++) {
-                       strncat(filename, files[i]->d_name,
-                                       sizeof(filename) - strlen(files[i]->d_name));
-
-                       if (!stat(filename, &s) &&
-                               (s.st_mode & S_IFDIR) && (s.st_mode & S_IXOTH))
-                               uh_chunk_printf(cl,
-                                       "<li><strong><a href='%s%s'>%s</a>/"
-                                       "</strong><br /><small>modified: %s"
-                                       "<br />directory - %.02f kbyte<br />"
-                                       "<br /></small></li>",
-                                       pi->name, files[i]->d_name,
-                                       files[i]->d_name,
-                                       uh_file_unix2date(s.st_mtime),
-                                       s.st_size / 1024.0);
-
-                       *pathptr = 0;
-               }
-
-               /* list files */
-               for (i = 0; i < count; i++) {
-                       strncat(filename, files[i]->d_name,
-                                       sizeof(filename) - strlen(files[i]->d_name));
-
-                       if (!stat(filename, &s) &&
-                               !(s.st_mode & S_IFDIR) && (s.st_mode & S_IROTH))
-                               uh_chunk_printf(cl,
-                                       "<li><strong><a href='%s%s'>%s</a>"
-                                       "</strong><br /><small>modified: %s"
-                                       "<br />%s - %.02f kbyte<br />"
-                                       "<br /></small></li>",
-                                       pi->name, files[i]->d_name,
-                                       files[i]->d_name,
-                                       uh_file_unix2date(s.st_mtime),
-                                       uh_file_mime_lookup(filename),
-                                       s.st_size / 1024.0);
-
-                       *pathptr = 0;
-               }
+       count = scandir(pi->phys, &files, NULL, dirent_cmp);
+       if (count > 0) {
+               strcpy(uh_buf, pi->phys);
+               list_entries(cl, files, count, pi->name, uh_buf);
        }
        }
+       free(files);
 
        uh_chunk_printf(cl, "</ol><hr /></body></html>");
        uh_request_done(cl);
 
        uh_chunk_printf(cl, "</ol><hr /></body></html>");
        uh_request_done(cl);
-
-       if (files)
-       {
-               for (i = 0; i < count; i++)
-                       free(files[i]);
-
-               free(files);
-       }
 }
 
 static void file_write_cb(struct client *cl)
 {
 }
 
 static void file_write_cb(struct client *cl)
 {
-       char buf[512];
-       int fd = cl->data.file.fd;
+       int fd = cl->dispatch.file.fd;
        int r;
 
        while (cl->us->w.data_bytes < 256) {
        int r;
 
        while (cl->us->w.data_bytes < 256) {
-               r = read(fd, buf, sizeof(buf));
+               r = read(fd, uh_buf, sizeof(uh_buf));
                if (r < 0) {
                        if (errno == EINTR)
                                continue;
                if (r < 0) {
                        if (errno == EINTR)
                                continue;
@@ -543,13 +536,13 @@ static void file_write_cb(struct client *cl)
                        return;
                }
 
                        return;
                }
 
-               uh_chunk_write(cl, buf, r);
+               uh_chunk_write(cl, uh_buf, r);
        }
 }
 
 static void uh_file_free(struct client *cl)
 {
        }
 }
 
 static void uh_file_free(struct client *cl)
 {
-       close(cl->data.file.fd);
+       close(cl->dispatch.file.fd);
 }
 
 static void uh_file_data(struct client *cl, struct path_info *pi, int fd)
 }
 
 static void uh_file_data(struct client *cl, struct path_info *pi, int fd)
@@ -582,28 +575,18 @@ static void uh_file_data(struct client *cl, struct path_info *pi, int fd)
                return;
        }
 
                return;
        }
 
-       cl->data.file.fd = fd;
-       cl->dispatch_write_cb = file_write_cb;
-       cl->dispatch_free = uh_file_free;
+       cl->dispatch.file.fd = fd;
+       cl->dispatch.write_cb = file_write_cb;
+       cl->dispatch.free = uh_file_free;
+       cl->dispatch.close_fds = uh_file_free;
        file_write_cb(cl);
 }
 
        file_write_cb(cl);
 }
 
-static void uh_file_request(struct client *cl, struct path_info *pi, const char *url)
+static void uh_file_request(struct client *cl, const char *url,
+                           struct path_info *pi, struct blob_attr **tb)
 {
 {
-       static const struct blobmsg_policy hdr_policy[__HDR_MAX] = {
-               [HDR_IF_MODIFIED_SINCE] = { "if-modified-since", BLOBMSG_TYPE_STRING },
-               [HDR_IF_UNMODIFIED_SINCE] = { "if-unmodified-since", BLOBMSG_TYPE_STRING },
-               [HDR_IF_MATCH] = { "if-match", BLOBMSG_TYPE_STRING },
-               [HDR_IF_NONE_MATCH] = { "if-none-match", BLOBMSG_TYPE_STRING },
-               [HDR_IF_RANGE] = { "if-range", BLOBMSG_TYPE_STRING },
-       };
-       struct blob_attr *tb[__HDR_MAX];
        int fd;
 
        int fd;
 
-       blobmsg_parse(hdr_policy, __HDR_MAX, tb, blob_data(cl->hdr.head), blob_len(cl->hdr.head));
-
-       cl->data.file.hdr = tb;
-
        if (!(pi->stat.st_mode & S_IROTH))
                goto error;
 
        if (!(pi->stat.st_mode & S_IROTH))
                goto error;
 
@@ -612,45 +595,106 @@ static void uh_file_request(struct client *cl, struct path_info *pi, const char
                if (fd < 0)
                        goto error;
 
                if (fd < 0)
                        goto error;
 
+               cl->dispatch.file.hdr = tb;
                uh_file_data(cl, pi, fd);
                uh_file_data(cl, pi, fd);
-       } else if ((pi->stat.st_mode & S_IFDIR)) {
+               cl->dispatch.file.hdr = NULL;
+               return;
+       }
+
+       if ((pi->stat.st_mode & S_IFDIR)) {
                if (conf.no_dirlists)
                        goto error;
 
                uh_file_dirlist(cl, pi);
                if (conf.no_dirlists)
                        goto error;
 
                uh_file_dirlist(cl, pi);
-       } else {
-               goto error;
+               return;
        }
 
        }
 
-       return;
-
 error:
        uh_client_error(cl, 403, "Forbidden",
                        "You don't have permission to access %s on this server.",
                        url);
 }
 
 error:
        uh_client_error(cl, 403, "Forbidden",
                        "You don't have permission to access %s on this server.",
                        url);
 }
 
+void uh_dispatch_add(struct dispatch_handler *d)
+{
+       list_add_tail(&d->list, &dispatch_handlers);
+}
+
+static struct dispatch_handler *
+dispatch_find(const char *url, struct path_info *pi)
+{
+       struct dispatch_handler *d;
+
+       list_for_each_entry(d, &dispatch_handlers, list) {
+               if (pi) {
+                       if (d->check_url)
+                               continue;
+
+                       if (d->check_path(pi, url))
+                               return d;
+               } else {
+                       if (d->check_path)
+                               continue;
+
+                       if (d->check_url(url))
+                               return d;
+               }
+       }
+
+       return NULL;
+}
+
 static bool __handle_file_request(struct client *cl, const char *url)
 {
 static bool __handle_file_request(struct client *cl, const char *url)
 {
+       static const struct blobmsg_policy hdr_policy[__HDR_MAX] = {
+               [HDR_AUTHORIZATION] = { "authorization", BLOBMSG_TYPE_STRING },
+               [HDR_IF_MODIFIED_SINCE] = { "if-modified-since", BLOBMSG_TYPE_STRING },
+               [HDR_IF_UNMODIFIED_SINCE] = { "if-unmodified-since", BLOBMSG_TYPE_STRING },
+               [HDR_IF_MATCH] = { "if-match", BLOBMSG_TYPE_STRING },
+               [HDR_IF_NONE_MATCH] = { "if-none-match", BLOBMSG_TYPE_STRING },
+               [HDR_IF_RANGE] = { "if-range", BLOBMSG_TYPE_STRING },
+       };
+       struct dispatch_handler *d;
+       struct blob_attr *tb[__HDR_MAX];
        struct path_info *pi;
 
        pi = uh_path_lookup(cl, url);
        if (!pi)
                return false;
 
        struct path_info *pi;
 
        pi = uh_path_lookup(cl, url);
        if (!pi)
                return false;
 
-       if (!pi->redirected) {
-               uh_file_request(cl, pi, url);
-               cl->data.file.hdr = NULL;
-       }
+       if (pi->redirected)
+               return true;
+
+       blobmsg_parse(hdr_policy, __HDR_MAX, tb, blob_data(cl->hdr.head), blob_len(cl->hdr.head));
+       if (tb[HDR_AUTHORIZATION])
+               pi->auth = blobmsg_data(tb[HDR_AUTHORIZATION]);
+
+       if (!uh_auth_check(cl, pi))
+               return true;
+
+       d = dispatch_find(url, pi);
+       if (d)
+               d->handle_request(cl, url, pi);
+       else
+               uh_file_request(cl, url, pi, tb);
 
        return true;
 }
 
 
        return true;
 }
 
-void uh_handle_file_request(struct client *cl)
+void uh_handle_request(struct client *cl)
 {
 {
-       if (__handle_file_request(cl, cl->request.url) ||
+       struct dispatch_handler *d;
+       const char *url = blobmsg_data(blob_data(cl->hdr.head));;
+
+       d = dispatch_find(url, NULL);
+       if (d) {
+               d->handle_request(cl, url, NULL);
+               return;
+       }
+
+       if (__handle_file_request(cl, url) ||
            __handle_file_request(cl, conf.error_handler))
                return;
 
            __handle_file_request(cl, conf.error_handler))
                return;
 
-       uh_client_error(cl, 404, "Not Found", "The requested URL %s was not found on this server.", cl->request.url);
+       uh_client_error(cl, 404, "Not Found", "The requested URL %s was not found on this server.", url);
 }
 }
Tiny HTTP server