Merging upstream version 1.45.3+dfsg.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 0 insertions, 966 deletions

diff --git a/web/server/h2o/libh2o/lib/handler/file.c b/web/server/h2o/libh2o/lib/handler/file.c
deleted file mode 100644
index 5d7c7a2a4..000000000
--- a/web/server/h2o/libh2o/lib/handler/file.c
+++ /dev/null
@@ -1,966 +0,0 @@
-/*
- * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Domingo Alvarez Duarte,
- *                         Tatsuhiko Kubo, Nick Desaulniers, Marc Hoersken,
- *                         Justin Zhu, Tatsuhiro Tsujikawa
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <time.h>
-#include <unistd.h>
-
-#include "h2o.h"
-
-#define MAX_BUF_SIZE 65000
-#define BOUNDARY_SIZE 20
-#define FIXED_PART_SIZE (sizeof("\r\n--") - 1 + BOUNDARY_SIZE + sizeof("\r\nContent-Range: bytes=-/\r\nContent-Type: \r\n\r\n") - 1)
-
-struct st_h2o_sendfile_generator_t {
-    h2o_generator_t super;
-    struct {
-        h2o_filecache_ref_t *ref;
-        off_t off;
-    } file;
-    h2o_req_t *req;
-    size_t bytesleft;
-    h2o_iovec_t content_encoding;
-    unsigned send_vary : 1;
-    unsigned send_etag : 1;
-    unsigned gunzip : 1;
-    char *buf;
-    struct {
-        size_t filesize;
-        size_t range_count;
-        size_t *range_infos;  /* size_t shows in pair. first is start offset, then length */
-        h2o_iovec_t boundary; /* boundary used for multipart/byteranges */
-        h2o_iovec_t mimetype; /* original mimetype for multipart */
-        size_t current_range; /* range that processing now */
-    } ranged;
-    struct {
-        char last_modified[H2O_TIMESTR_RFC1123_LEN + 1];
-        char etag[H2O_FILECACHE_ETAG_MAXLEN + 1];
-    } header_bufs;
-};
-
-struct st_h2o_file_handler_t {
-    h2o_handler_t super;
-    h2o_iovec_t conf_path; /* has "/" appended at last */
-    h2o_iovec_t real_path; /* has "/" appended at last */
-    h2o_mimemap_t *mimemap;
-    int flags;
-    size_t max_index_file_len;
-    h2o_iovec_t index_files[1];
-};
-
-struct st_h2o_specific_file_handler_t {
-    h2o_handler_t super;
-    h2o_iovec_t real_path;
-    h2o_mimemap_type_t *mime_type;
-    int flags;
-};
-
-struct st_gzip_decompress_t {
-    h2o_ostream_t super;
-    h2o_compress_context_t *decompressor;
-};
-
-static const char *default_index_files[] = {"index.html", "index.htm", "index.txt", NULL};
-
-const char **h2o_file_default_index_files = default_index_files;
-
-#include "file/templates.c.h"
-
-static int tm_is_lessthan(struct tm *x, struct tm *y)
-{
-#define CMP(f)                                                                                                                     \
-    if (x->f < y->f)                                                                                                               \
-        return 1;                                                                                                                  \
-    else if (x->f > y->f)                                                                                                          \
-        return 0;
-    CMP(tm_year);
-    CMP(tm_mon);
-    CMP(tm_mday);
-    CMP(tm_hour);
-    CMP(tm_min);
-    CMP(tm_sec);
-    return 0;
-#undef CMP
-}
-
-static void do_close(h2o_generator_t *_self, h2o_req_t *req)
-{
-    struct st_h2o_sendfile_generator_t *self = (void *)_self;
-    h2o_filecache_close_file(self->file.ref);
-}
-
-static void do_proceed(h2o_generator_t *_self, h2o_req_t *req)
-{
-    struct st_h2o_sendfile_generator_t *self = (void *)_self;
-    size_t rlen;
-    ssize_t rret;
-    h2o_iovec_t vec;
-    h2o_send_state_t send_state;
-
-    /* read the file */
-    rlen = self->bytesleft;
-    if (rlen > MAX_BUF_SIZE)
-        rlen = MAX_BUF_SIZE;
-    while ((rret = pread(self->file.ref->fd, self->buf, rlen, self->file.off)) == -1 && errno == EINTR)
-        ;
-    if (rret == -1) {
-        h2o_send(req, NULL, 0, H2O_SEND_STATE_ERROR);
-        do_close(&self->super, req);
-        return;
-    }
-    self->file.off += rret;
-    self->bytesleft -= rret;
-    if (self->bytesleft == 0) {
-        send_state = H2O_SEND_STATE_FINAL;
-    } else {
-        send_state = H2O_SEND_STATE_IN_PROGRESS;
-    }
-
-    /* send (and close if done) */
-    vec.base = self->buf;
-    vec.len = rret;
-    h2o_send(req, &vec, 1, send_state);
-    if (send_state == H2O_SEND_STATE_FINAL)
-        do_close(&self->super, req);
-}
-
-static void do_multirange_proceed(h2o_generator_t *_self, h2o_req_t *req)
-{
-    struct st_h2o_sendfile_generator_t *self = (void *)_self;
-    size_t rlen, used_buf = 0;
-    ssize_t rret, vecarrsize;
-    h2o_iovec_t vec[2];
-    h2o_send_state_t send_state;
-
-    if (self->bytesleft == 0) {
-        size_t *range_cur = self->ranged.range_infos + 2 * self->ranged.current_range;
-        size_t range_end = *range_cur + *(range_cur + 1) - 1;
-        if (H2O_LIKELY(self->ranged.current_range != 0))
-            used_buf =
-                sprintf(self->buf, "\r\n--%s\r\nContent-Type: %s\r\nContent-Range: bytes %zd-%zd/%zd\r\n\r\n",
-                        self->ranged.boundary.base, self->ranged.mimetype.base, *range_cur, range_end, self->ranged.filesize);
-        else
-            used_buf =
-                sprintf(self->buf, "--%s\r\nContent-Type: %s\r\nContent-Range: bytes %zd-%zd/%zd\r\n\r\n",
-                        self->ranged.boundary.base, self->ranged.mimetype.base, *range_cur, range_end, self->ranged.filesize);
-        self->ranged.current_range++;
-        self->file.off = *range_cur;
-        self->bytesleft = *++range_cur;
-    }
-    rlen = self->bytesleft;
-    if (rlen + used_buf > MAX_BUF_SIZE)
-        rlen = MAX_BUF_SIZE - used_buf;
-    while ((rret = pread(self->file.ref->fd, self->buf + used_buf, rlen, self->file.off)) == -1 && errno == EINTR)
-        ;
-    if (rret == -1)
-        goto Error;
-    self->file.off += rret;
-    self->bytesleft -= rret;
-
-    vec[0].base = self->buf;
-    vec[0].len = rret + used_buf;
-    if (self->ranged.current_range == self->ranged.range_count && self->bytesleft == 0) {
-        vec[1].base = h2o_mem_alloc_pool(&req->pool, sizeof("\r\n--") - 1 + BOUNDARY_SIZE + sizeof("--\r\n"));
-        vec[1].len = sprintf(vec[1].base, "\r\n--%s--\r\n", self->ranged.boundary.base);
-        vecarrsize = 2;
-        send_state = H2O_SEND_STATE_FINAL;
-    } else {
-        vecarrsize = 1;
-        send_state = H2O_SEND_STATE_IN_PROGRESS;
-    }
-    h2o_send(req, vec, vecarrsize, send_state);
-    if (send_state == H2O_SEND_STATE_FINAL)
-        do_close(&self->super, req);
-    return;
-
-Error:
-    h2o_send(req, NULL, 0, H2O_SEND_STATE_ERROR);
-    do_close(&self->super, req);
-    return;
-}
-
-static h2o_send_state_t do_pull(h2o_generator_t *_self, h2o_req_t *req, h2o_iovec_t *buf)
-{
-    struct st_h2o_sendfile_generator_t *self = (void *)_self;
-    ssize_t rret;
-
-    if (self->bytesleft < buf->len)
-        buf->len = self->bytesleft;
-    while ((rret = pread(self->file.ref->fd, buf->base, buf->len, self->file.off)) == -1 && errno == EINTR)
-        ;
-    if (rret <= 0) {
-        buf->len = 0;
-        self->bytesleft = 0;
-        do_close(&self->super, req);
-        return H2O_SEND_STATE_ERROR;
-    } else {
-        buf->len = rret;
-        self->file.off += rret;
-        self->bytesleft -= rret;
-    }
-
-    if (self->bytesleft != 0)
-        return H2O_SEND_STATE_IN_PROGRESS;
-    do_close(&self->super, req);
-    return H2O_SEND_STATE_FINAL;
-}
-
-static struct st_h2o_sendfile_generator_t *create_generator(h2o_req_t *req, const char *path, size_t path_len, int *is_dir,
-                                                            int flags)
-{
-    struct st_h2o_sendfile_generator_t *self;
-    h2o_filecache_ref_t *fileref;
-    h2o_iovec_t content_encoding = (h2o_iovec_t){NULL};
-    unsigned gunzip = 0;
-
-    *is_dir = 0;
-
-    if ((flags & H2O_FILE_FLAG_SEND_COMPRESSED) != 0 && req->version >= 0x101) {
-        int compressible_types = h2o_get_compressible_types(&req->headers);
-        if (compressible_types != 0) {
-            char *variant_path = h2o_mem_alloc_pool(&req->pool, path_len + sizeof(".gz"));
-            memcpy(variant_path, path, path_len);
-#define TRY_VARIANT(mask, enc, ext)                                                                                                \
-    if ((compressible_types & mask) != 0) {                                                                                        \
-        strcpy(variant_path + path_len, ext);                                                                                      \
-        if ((fileref = h2o_filecache_open_file(req->conn->ctx->filecache, variant_path, O_RDONLY | O_CLOEXEC)) != NULL) {          \
-            content_encoding = h2o_iovec_init(enc, sizeof(enc) - 1);                                                               \
-            goto Opened;                                                                                                           \
-        }                                                                                                                          \
-    }
-            TRY_VARIANT(H2O_COMPRESSIBLE_BROTLI, "br", ".br");
-            TRY_VARIANT(H2O_COMPRESSIBLE_GZIP, "gzip", ".gz");
-#undef TRY_VARIANT
-        }
-    }
-    if ((fileref = h2o_filecache_open_file(req->conn->ctx->filecache, path, O_RDONLY | O_CLOEXEC)) != NULL) {
-        goto Opened;
-    }
-    if ((flags & H2O_FILE_FLAG_GUNZIP) != 0 && req->version >= 0x101) {
-        char *variant_path = h2o_mem_alloc_pool(&req->pool, path_len + sizeof(".gz"));
-        memcpy(variant_path, path, path_len);
-        strcpy(variant_path + path_len, ".gz");
-        if ((fileref = h2o_filecache_open_file(req->conn->ctx->filecache, variant_path, O_RDONLY | O_CLOEXEC)) != NULL) {
-            gunzip = 1;
-            goto Opened;
-        }
-    }
-    return NULL;
-
-Opened:
-    if (S_ISDIR(fileref->st.st_mode)) {
-        h2o_filecache_close_file(fileref);
-        *is_dir = 1;
-        return NULL;
-    }
-
-    self = h2o_mem_alloc_pool(&req->pool, sizeof(*self));
-    self->super.proceed = do_proceed;
-    self->super.stop = do_close;
-    self->file.ref = fileref;
-    self->file.off = 0;
-    self->req = NULL;
-    self->bytesleft = self->file.ref->st.st_size;
-    self->ranged.range_count = 0;
-    self->ranged.range_infos = NULL;
-    self->content_encoding = content_encoding;
-    self->send_vary = (flags & H2O_FILE_FLAG_SEND_COMPRESSED) != 0;
-    self->send_etag = (flags & H2O_FILE_FLAG_NO_ETAG) == 0;
-    self->gunzip = gunzip;
-
-    return self;
-}
-
-static void add_headers_unconditional(struct st_h2o_sendfile_generator_t *self, h2o_req_t *req)
-{
-    /* RFC 7232 4.1: The server generating a 304 response MUST generate any of the following header fields that would have been sent
-     * in a 200 (OK) response to the same request: Cache-Control, Content-Location, Date, ETag, Expires, and Vary (snip) a sender
-     * SHOULD NOT generate representation metadata other than the above listed fields unless said metadata exists for the purpose of
-     * guiding cache updates. */
-    if (self->send_etag) {
-        size_t etag_len = h2o_filecache_get_etag(self->file.ref, self->header_bufs.etag);
-        h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_ETAG, NULL, self->header_bufs.etag, etag_len);
-    }
-    if (self->send_vary)
-        h2o_set_header_token(&req->pool, &req->res.headers, H2O_TOKEN_VARY, H2O_STRLIT("accept-encoding"));
-}
-
-static void send_decompressed(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state)
-{
-    struct st_gzip_decompress_t *self = (void *)_self;
-    h2o_iovec_t *outbufs;
-    size_t outbufcnt;
-
-    self->decompressor->transform(self->decompressor, inbufs, inbufcnt, state, &outbufs, &outbufcnt);
-    h2o_ostream_send_next(&self->super, req, outbufs, outbufcnt, state);
-}
-
-static void do_send_file(struct st_h2o_sendfile_generator_t *self, h2o_req_t *req, int status, const char *reason,
-                         h2o_iovec_t mime_type, h2o_mime_attributes_t *mime_attr, int is_get)
-{
-    /* link the request */
-    self->req = req;
-
-    /* setup response */
-    req->res.status = status;
-    req->res.reason = reason;
-    req->res.content_length = self->gunzip ? SIZE_MAX : self->bytesleft;
-    req->res.mime_attr = mime_attr;
-
-    if (self->ranged.range_count > 1) {
-        mime_type.base = h2o_mem_alloc_pool(&req->pool, 52);
-        mime_type.len = sprintf(mime_type.base, "multipart/byteranges; boundary=%s", self->ranged.boundary.base);
-    }
-    h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, mime_type.base, mime_type.len);
-    h2o_filecache_get_last_modified(self->file.ref, self->header_bufs.last_modified);
-    h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_LAST_MODIFIED, NULL, self->header_bufs.last_modified,
-                   H2O_TIMESTR_RFC1123_LEN);
-    add_headers_unconditional(self, req);
-    if (self->content_encoding.base != NULL)
-        h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_ENCODING, NULL, self->content_encoding.base,
-                       self->content_encoding.len);
-    if (self->ranged.range_count == 0)
-        h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_ACCEPT_RANGES, NULL, H2O_STRLIT("bytes"));
-    else if (self->ranged.range_count == 1) {
-        h2o_iovec_t content_range;
-        content_range.base = h2o_mem_alloc_pool(&req->pool, 128);
-        content_range.len = sprintf(content_range.base, "bytes %zd-%zd/%zd", self->ranged.range_infos[0],
-                                    self->ranged.range_infos[0] + self->ranged.range_infos[1] - 1, self->ranged.filesize);
-        h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_RANGE, NULL, content_range.base, content_range.len);
-    }
-
-    /* special path for cases where we do not need to send any data */
-    if (!is_get || self->bytesleft == 0) {
-        static h2o_generator_t generator = {NULL, NULL};
-        h2o_start_response(req, &generator);
-        h2o_send(req, NULL, 0, H2O_SEND_STATE_FINAL);
-        do_close(&self->super, req);
-        return;
-    }
-
-    /* send data */
-    h2o_start_response(req, &self->super);
-
-    /* dynamically setup gzip decompress ostream */
-    if (self->gunzip) {
-        struct st_gzip_decompress_t *decoder = (void *)h2o_add_ostream(req, sizeof(struct st_gzip_decompress_t), &req->_ostr_top);
-        decoder->decompressor = h2o_compress_gunzip_open(&req->pool);
-        decoder->super.do_send = send_decompressed;
-    }
-
-    if (self->ranged.range_count == 1)
-        self->file.off = self->ranged.range_infos[0];
-    if (req->_ostr_top->start_pull != NULL && self->ranged.range_count < 2) {
-        req->_ostr_top->start_pull(req->_ostr_top, do_pull);
-    } else {
-        size_t bufsz = MAX_BUF_SIZE;
-        if (self->bytesleft < bufsz)
-            bufsz = self->bytesleft;
-        self->buf = h2o_mem_alloc_pool(&req->pool, bufsz);
-        if (self->ranged.range_count < 2)
-            do_proceed(&self->super, req);
-        else {
-            self->bytesleft = 0;
-            self->super.proceed = do_multirange_proceed;
-            do_multirange_proceed(&self->super, req);
-        }
-    }
-}
-
-int h2o_file_send(h2o_req_t *req, int status, const char *reason, const char *path, h2o_iovec_t mime_type, int flags)
-{
-    struct st_h2o_sendfile_generator_t *self;
-    int is_dir;
-
-    if ((self = create_generator(req, path, strlen(path), &is_dir, flags)) == NULL)
-        return -1;
-    /* note: is_dir is not handled */
-    do_send_file(self, req, status, reason, mime_type, NULL, 1);
-    return 0;
-}
-
-static int send_dir_listing(h2o_req_t *req, const char *path, size_t path_len, int is_get)
-{
-    static h2o_generator_t generator = {NULL, NULL};
-    DIR *dp;
-    h2o_buffer_t *body;
-    h2o_iovec_t bodyvec;
-
-    /* build html */
-    if ((dp = opendir(path)) == NULL)
-        return -1;
-    body = build_dir_listing_html(&req->pool, req->path_normalized, dp);
-    closedir(dp);
-
-    bodyvec = h2o_iovec_init(body->bytes, body->size);
-    h2o_buffer_link_to_pool(body, &req->pool);
-
-    /* send response */
-    req->res.status = 200;
-    req->res.reason = "OK";
-    h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, H2O_STRLIT("text/html; charset=utf-8"));
-
-    /* send headers */
-    if (!is_get) {
-        h2o_send_inline(req, NULL, 0);
-        return 0;
-    }
-
-    /* send data */
-    h2o_start_response(req, &generator);
-    h2o_send(req, &bodyvec, 1, H2O_SEND_STATE_FINAL);
-    return 0;
-}
-
-static size_t *process_range(h2o_mem_pool_t *pool, h2o_iovec_t *range_value, size_t file_size, size_t *ret)
-{
-#define CHECK_EOF()                                                                                                                \
-    if (buf == buf_end)                                                                                                            \
-        return NULL;
-
-#define CHECK_OVERFLOW(range)                                                                                                      \
-    if (range == SIZE_MAX)                                                                                                         \
-        return NULL;
-
-    size_t range_start = SIZE_MAX, range_count = 0;
-    char *buf = range_value->base, *buf_end = buf + range_value->len;
-    int needs_comma = 0;
-    H2O_VECTOR(size_t) ranges = {NULL};
-
-    if (range_value->len < 6 || memcmp(buf, "bytes=", 6) != 0)
-        return NULL;
-
-    buf += 6;
-    CHECK_EOF();
-
-    /* most range requests contain only one range */
-    do {
-        while (1) {
-            if (*buf != ',') {
-                if (needs_comma)
-                    return NULL;
-                break;
-            }
-            needs_comma = 0;
-            buf++;
-            while (H2O_UNLIKELY(*buf == ' ') || H2O_UNLIKELY(*buf == '\t')) {
-                buf++;
-                CHECK_EOF();
-            }
-        }
-        if (H2O_UNLIKELY(buf == buf_end))
-            break;
-        if (H2O_LIKELY((range_start = h2o_strtosizefwd(&buf, buf_end - buf)) != SIZE_MAX)) {
-            CHECK_EOF();
-            if (*buf++ != '-')
-                return NULL;
-            range_count = h2o_strtosizefwd(&buf, buf_end - buf);
-            if (H2O_UNLIKELY(range_start >= file_size)) {
-                range_start = SIZE_MAX;
-            } else if (H2O_LIKELY(range_count != SIZE_MAX)) {
-                if (H2O_UNLIKELY(range_count > file_size - 1))
-                    range_count = file_size - 1;
-                if (H2O_LIKELY(range_start <= range_count))
-                    range_count -= range_start - 1;
-                else
-                    range_start = SIZE_MAX;
-            } else {
-                range_count = file_size - range_start;
-            }
-        } else if (H2O_LIKELY(*buf++ == '-')) {
-            CHECK_EOF();
-            range_count = h2o_strtosizefwd(&buf, buf_end - buf);
-            if (H2O_UNLIKELY(range_count == SIZE_MAX))
-                return NULL;
-            if (H2O_LIKELY(range_count != 0)) {
-                if (H2O_UNLIKELY(range_count > file_size))
-                    range_count = file_size;
-                range_start = file_size - range_count;
-            } else {
-                range_start = SIZE_MAX;
-            }
-        } else {
-            return NULL;
-        }
-
-        if (H2O_LIKELY(range_start != SIZE_MAX)) {
-            h2o_vector_reserve(pool, &ranges, ranges.size + 2);
-            ranges.entries[ranges.size++] = range_start;
-            ranges.entries[ranges.size++] = range_count;
-        }
-        if (buf != buf_end)
-            while (H2O_UNLIKELY(*buf == ' ') || H2O_UNLIKELY(*buf == '\t')) {
-                buf++;
-                CHECK_EOF();
-            }
-        needs_comma = 1;
-    } while (H2O_UNLIKELY(buf < buf_end));
-    *ret = ranges.size / 2;
-    return ranges.entries;
-#undef CHECK_EOF
-#undef CHECK_OVERFLOW
-}
-
-static void gen_rand_string(h2o_iovec_t *s)
-{
-    int i;
-    static const char alphanum[] = "0123456789"
-                                   "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                   "abcdefghijklmnopqrstuvwxyz";
-
-    for (i = 0; i < s->len; ++i) {
-        s->base[i] = alphanum[h2o_rand() % (sizeof(alphanum) - 1)];
-    }
-
-    s->base[s->len] = 0;
-}
-
-static int delegate_dynamic_request(h2o_req_t *req, h2o_iovec_t script_name, h2o_iovec_t path_info, const char *local_path,
-                                    size_t local_path_len, h2o_mimemap_type_t *mime_type)
-{
-    h2o_filereq_t *filereq;
-    h2o_handler_t *handler;
-
-    assert(mime_type->data.dynamic.pathconf.handlers.size == 1);
-
-    filereq = h2o_mem_alloc_pool(&req->pool, sizeof(*filereq));
-    filereq->script_name = script_name;
-    filereq->path_info = path_info;
-    filereq->local_path = h2o_strdup(&req->pool, local_path, local_path_len);
-
-    h2o_req_bind_conf(req, req->hostconf, &mime_type->data.dynamic.pathconf);
-    req->filereq = filereq;
-
-    handler = mime_type->data.dynamic.pathconf.handlers.entries[0];
-    return handler->on_req(handler, req);
-}
-
-static int try_dynamic_request(h2o_file_handler_t *self, h2o_req_t *req, char *rpath, size_t rpath_len)
-{
-    /* we have full local path in {rpath,rpath_len}, and need to split it into name and path_info */
-    struct stat st;
-    size_t slash_at = self->real_path.len;
-
-    while (1) {
-        /* find the next slash (or return -1 if failed) */
-        for (++slash_at;; ++slash_at) {
-            if (slash_at >= rpath_len)
-                return -1;
-            if (rpath[slash_at] == '/')
-                break;
-        }
-        /* change the slash to '\0', and check if the file exists */
-        rpath[slash_at] = '\0';
-        if (stat(rpath, &st) != 0)
-            return -1;
-        if (!S_ISDIR(st.st_mode))
-            break;
-        /* restore slash, and continue the search */
-        rpath[slash_at] = '/';
-    }
-
-    /* file found! */
-    h2o_mimemap_type_t *mime_type = h2o_mimemap_get_type_by_extension(self->mimemap, h2o_get_filext(rpath, slash_at));
-    switch (mime_type->type) {
-    case H2O_MIMEMAP_TYPE_MIMETYPE:
-        return -1;
-    case H2O_MIMEMAP_TYPE_DYNAMIC: {
-        h2o_iovec_t script_name = h2o_iovec_init(req->path_normalized.base, self->conf_path.len + slash_at - self->real_path.len);
-        h2o_iovec_t path_info =
-            h2o_iovec_init(req->path_normalized.base + script_name.len, req->path_normalized.len - script_name.len);
-        return delegate_dynamic_request(req, script_name, path_info, rpath, slash_at, mime_type);
-    }
-    }
-    fprintf(stderr, "unknown h2o_miemmap_type_t::type (%d)\n", (int)mime_type->type);
-    abort();
-}
-
-static void send_method_not_allowed(h2o_req_t *req)
-{
-    h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_ALLOW, NULL, H2O_STRLIT("GET, HEAD"));
-    h2o_send_error_405(req, "Method Not Allowed", "method not allowed", H2O_SEND_ERROR_KEEP_HEADERS);
-}
-
-static int serve_with_generator(struct st_h2o_sendfile_generator_t *generator, h2o_req_t *req, h2o_iovec_t resolved_path,
-                                const char *rpath, size_t rpath_len, h2o_mimemap_type_t *mime_type)
-{
-    enum { METHOD_IS_GET, METHOD_IS_HEAD, METHOD_IS_OTHER } method_type;
-    size_t if_modified_since_header_index, if_none_match_header_index;
-    size_t range_header_index;
-
-    /* determine the method */
-    if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("GET"))) {
-        method_type = METHOD_IS_GET;
-    } else if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("HEAD"))) {
-        method_type = METHOD_IS_HEAD;
-    } else {
-        method_type = METHOD_IS_OTHER;
-    }
-
-    /* obtain mime type */
-    if (mime_type->type == H2O_MIMEMAP_TYPE_DYNAMIC) {
-        do_close(&generator->super, req);
-        return delegate_dynamic_request(req, resolved_path, h2o_iovec_init(NULL, 0), rpath, rpath_len, mime_type);
-    }
-    assert(mime_type->type == H2O_MIMEMAP_TYPE_MIMETYPE);
-
-    /* if-non-match and if-modified-since */
-    if ((if_none_match_header_index = h2o_find_header(&req->headers, H2O_TOKEN_IF_NONE_MATCH, SIZE_MAX)) != -1) {
-        h2o_iovec_t *if_none_match = &req->headers.entries[if_none_match_header_index].value;
-        char etag[H2O_FILECACHE_ETAG_MAXLEN + 1];
-        size_t etag_len = h2o_filecache_get_etag(generator->file.ref, etag);
-        if (h2o_memis(if_none_match->base, if_none_match->len, etag, etag_len))
-            goto NotModified;
-    } else if ((if_modified_since_header_index = h2o_find_header(&req->headers, H2O_TOKEN_IF_MODIFIED_SINCE, SIZE_MAX)) != -1) {
-        h2o_iovec_t *ims_vec = &req->headers.entries[if_modified_since_header_index].value;
-        struct tm ims_tm, *last_modified_tm;
-        if (h2o_time_parse_rfc1123(ims_vec->base, ims_vec->len, &ims_tm) == 0) {
-            last_modified_tm = h2o_filecache_get_last_modified(generator->file.ref, NULL);
-            if (!tm_is_lessthan(&ims_tm, last_modified_tm))
-                goto NotModified;
-        }
-    }
-
-    /* only allow GET or POST for static files */
-    if (method_type == METHOD_IS_OTHER) {
-        do_close(&generator->super, req);
-        send_method_not_allowed(req);
-        return 0;
-    }
-
-    /* if-range */
-    if ((range_header_index = h2o_find_header(&req->headers, H2O_TOKEN_RANGE, SIZE_MAX)) != -1) {
-        h2o_iovec_t *range = &req->headers.entries[range_header_index].value;
-        size_t *range_infos, range_count;
-        range_infos = process_range(&req->pool, range, generator->bytesleft, &range_count);
-        if (range_infos == NULL) {
-            h2o_iovec_t content_range;
-            content_range.base = h2o_mem_alloc_pool(&req->pool, 32);
-            content_range.len = sprintf(content_range.base, "bytes */%zu", generator->bytesleft);
-            h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_RANGE, NULL, content_range.base, content_range.len);
-            h2o_send_error_416(req, "Request Range Not Satisfiable", "requested range not satisfiable",
-                               H2O_SEND_ERROR_KEEP_HEADERS);
-            goto Close;
-        }
-        generator->ranged.range_count = range_count;
-        generator->ranged.range_infos = range_infos;
-        generator->ranged.current_range = 0;
-        generator->ranged.filesize = generator->bytesleft;
-
-        /* set content-length according to range */
-        if (range_count == 1)
-            generator->bytesleft = range_infos[1];
-        else {
-            generator->ranged.mimetype = h2o_strdup(&req->pool, mime_type->data.mimetype.base, mime_type->data.mimetype.len);
-            size_t final_content_len = 0, size_tmp = 0, size_fixed_each_part, i;
-            generator->ranged.boundary.base = h2o_mem_alloc_pool(&req->pool, BOUNDARY_SIZE + 1);
-            generator->ranged.boundary.len = BOUNDARY_SIZE;
-            gen_rand_string(&generator->ranged.boundary);
-            i = generator->bytesleft;
-            while (i) {
-                i /= 10;
-                size_tmp++;
-            }
-            size_fixed_each_part = FIXED_PART_SIZE + mime_type->data.mimetype.len + size_tmp;
-            for (i = 0; i < range_count; i++) {
-                size_tmp = *range_infos++;
-                if (size_tmp == 0)
-                    final_content_len++;
-                while (size_tmp) {
-                    size_tmp /= 10;
-                    final_content_len++;
-                }
-
-                size_tmp = *(range_infos - 1);
-                final_content_len += *range_infos;
-
-                size_tmp += *range_infos++ - 1;
-                if (size_tmp == 0)
-                    final_content_len++;
-                while (size_tmp) {
-                    size_tmp /= 10;
-                    final_content_len++;
-                }
-            }
-            final_content_len += sizeof("\r\n--") - 1 + BOUNDARY_SIZE + sizeof("--\r\n") - 1 + size_fixed_each_part * range_count -
-                                 (sizeof("\r\n") - 1);
-            generator->bytesleft = final_content_len;
-        }
-        do_send_file(generator, req, 206, "Partial Content", mime_type->data.mimetype, &h2o_mime_attributes_as_is,
-                     method_type == METHOD_IS_GET);
-        return 0;
-    }
-
-    /* return file */
-    do_send_file(generator, req, 200, "OK", mime_type->data.mimetype, &mime_type->data.attr, method_type == METHOD_IS_GET);
-    return 0;
-
-NotModified:
-    req->res.status = 304;
-    req->res.reason = "Not Modified";
-    add_headers_unconditional(generator, req);
-    h2o_send_inline(req, NULL, 0);
-Close:
-    do_close(&generator->super, req);
-    return 0;
-}
-
-static int on_req(h2o_handler_t *_self, h2o_req_t *req)
-{
-    h2o_file_handler_t *self = (void *)_self;
-    char *rpath;
-    size_t rpath_len, req_path_prefix;
-    struct st_h2o_sendfile_generator_t *generator = NULL;
-    int is_dir;
-
-    if (req->path_normalized.len < self->conf_path.len) {
-        h2o_iovec_t dest = h2o_uri_escape(&req->pool, self->conf_path.base, self->conf_path.len, "/");
-        if (req->query_at != SIZE_MAX)
-            dest = h2o_concat(&req->pool, dest, h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at));
-        h2o_send_redirect(req, 301, "Moved Permanently", dest.base, dest.len);
-        return 0;
-    }
-
-    /* build path (still unterminated at the end of the block) */
-    req_path_prefix = self->conf_path.len;
-    rpath = alloca(self->real_path.len + (req->path_normalized.len - req_path_prefix) + self->max_index_file_len + 1);
-    rpath_len = 0;
-    memcpy(rpath + rpath_len, self->real_path.base, self->real_path.len);
-    rpath_len += self->real_path.len;
-    memcpy(rpath + rpath_len, req->path_normalized.base + req_path_prefix, req->path_normalized.len - req_path_prefix);
-    rpath_len += req->path_normalized.len - req_path_prefix;
-
-    h2o_iovec_t resolved_path = req->path_normalized;
-
-    /* build generator (as well as terminating the rpath and its length upon success) */
-    if (rpath[rpath_len - 1] == '/') {
-        h2o_iovec_t *index_file;
-        for (index_file = self->index_files; index_file->base != NULL; ++index_file) {
-            memcpy(rpath + rpath_len, index_file->base, index_file->len);
-            rpath[rpath_len + index_file->len] = '\0';
-            if ((generator = create_generator(req, rpath, rpath_len + index_file->len, &is_dir, self->flags)) != NULL) {
-                rpath_len += index_file->len;
-                resolved_path = h2o_concat(&req->pool, req->path_normalized, *index_file);
-                goto Opened;
-            }
-            if (is_dir) {
-                /* note: apache redirects "path/" to "path/index.txt/" if index.txt is a dir */
-                h2o_iovec_t dest = h2o_concat(&req->pool, req->path_normalized, *index_file, h2o_iovec_init(H2O_STRLIT("/")));
-                dest = h2o_uri_escape(&req->pool, dest.base, dest.len, "/");
-                if (req->query_at != SIZE_MAX)
-                    dest =
-                        h2o_concat(&req->pool, dest, h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at));
-                h2o_send_redirect(req, 301, "Moved Permantently", dest.base, dest.len);
-                return 0;
-            }
-            if (errno != ENOENT)
-                break;
-        }
-        if (index_file->base == NULL && (self->flags & H2O_FILE_FLAG_DIR_LISTING) != 0) {
-            rpath[rpath_len] = '\0';
-            int is_get = 0;
-            if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("GET"))) {
-                is_get = 1;
-            } else if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("HEAD"))) {
-                /* ok */
-            } else {
-                send_method_not_allowed(req);
-                return 0;
-            }
-            if (send_dir_listing(req, rpath, rpath_len, is_get) == 0)
-                return 0;
-        }
-    } else {
-        rpath[rpath_len] = '\0';
-        if ((generator = create_generator(req, rpath, rpath_len, &is_dir, self->flags)) != NULL)
-            goto Opened;
-        if (is_dir) {
-            h2o_iovec_t dest = h2o_concat(&req->pool, req->path_normalized, h2o_iovec_init(H2O_STRLIT("/")));
-            dest = h2o_uri_escape(&req->pool, dest.base, dest.len, "/");
-            if (req->query_at != SIZE_MAX)
-                dest = h2o_concat(&req->pool, dest, h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at));
-            h2o_send_redirect(req, 301, "Moved Permanently", dest.base, dest.len);
-            return 0;
-        }
-    }
-    /* failed to open */
-
-    if (errno == ENFILE || errno == EMFILE) {
-        h2o_send_error_503(req, "Service Unavailable", "please try again later", 0);
-    } else {
-        if (h2o_mimemap_has_dynamic_type(self->mimemap) && try_dynamic_request(self, req, rpath, rpath_len) == 0)
-            return 0;
-        if (errno == ENOENT || errno == ENOTDIR) {
-            return -1;
-        } else {
-            h2o_send_error_403(req, "Access Forbidden", "access forbidden", 0);
-        }
-    }
-    return 0;
-
-Opened:
-    return serve_with_generator(generator, req, resolved_path, rpath, rpath_len,
-                                h2o_mimemap_get_type_by_extension(self->mimemap, h2o_get_filext(rpath, rpath_len)));
-}
-
-static void on_context_init(h2o_handler_t *_self, h2o_context_t *ctx)
-{
-    h2o_file_handler_t *self = (void *)_self;
-
-    h2o_mimemap_on_context_init(self->mimemap, ctx);
-}
-
-static void on_context_dispose(h2o_handler_t *_self, h2o_context_t *ctx)
-{
-    h2o_file_handler_t *self = (void *)_self;
-
-    h2o_mimemap_on_context_dispose(self->mimemap, ctx);
-}
-
-static void on_dispose(h2o_handler_t *_self)
-{
-    h2o_file_handler_t *self = (void *)_self;
-    size_t i;
-
-    free(self->conf_path.base);
-    free(self->real_path.base);
-    h2o_mem_release_shared(self->mimemap);
-    for (i = 0; self->index_files[i].base != NULL; ++i)
-        free(self->index_files[i].base);
-}
-
-h2o_file_handler_t *h2o_file_register(h2o_pathconf_t *pathconf, const char *real_path, const char **index_files,
-                                      h2o_mimemap_t *mimemap, int flags)
-{
-    h2o_file_handler_t *self;
-    size_t i;
-
-    if (index_files == NULL)
-        index_files = default_index_files;
-
-    /* allocate memory */
-    for (i = 0; index_files[i] != NULL; ++i)
-        ;
-    self =
-        (void *)h2o_create_handler(pathconf, offsetof(h2o_file_handler_t, index_files[0]) + sizeof(self->index_files[0]) * (i + 1));
-
-    /* setup callbacks */
-    self->super.on_context_init = on_context_init;
-    self->super.on_context_dispose = on_context_dispose;
-    self->super.dispose = on_dispose;
-    self->super.on_req = on_req;
-
-    /* setup attributes */
-    self->conf_path = h2o_strdup_slashed(NULL, pathconf->path.base, pathconf->path.len);
-    self->real_path = h2o_strdup_slashed(NULL, real_path, SIZE_MAX);
-    if (mimemap != NULL) {
-        h2o_mem_addref_shared(mimemap);
-        self->mimemap = mimemap;
-    } else {
-        self->mimemap = h2o_mimemap_create();
-    }
-    self->flags = flags;
-    for (i = 0; index_files[i] != NULL; ++i) {
-        self->index_files[i] = h2o_strdup(NULL, index_files[i], SIZE_MAX);
-        if (self->max_index_file_len < self->index_files[i].len)
-            self->max_index_file_len = self->index_files[i].len;
-    }
-
-    return self;
-}
-
-h2o_mimemap_t *h2o_file_get_mimemap(h2o_file_handler_t *handler)
-{
-    return handler->mimemap;
-}
-
-static void specific_handler_on_context_init(h2o_handler_t *_self, h2o_context_t *ctx)
-{
-    struct st_h2o_specific_file_handler_t *self = (void *)_self;
-
-    if (self->mime_type->type == H2O_MIMEMAP_TYPE_DYNAMIC)
-        h2o_context_init_pathconf_context(ctx, &self->mime_type->data.dynamic.pathconf);
-}
-
-static void specific_handler_on_context_dispose(h2o_handler_t *_self, h2o_context_t *ctx)
-{
-    struct st_h2o_specific_file_handler_t *self = (void *)_self;
-
-    if (self->mime_type->type == H2O_MIMEMAP_TYPE_DYNAMIC)
-        h2o_context_dispose_pathconf_context(ctx, &self->mime_type->data.dynamic.pathconf);
-}
-
-static void specific_handler_on_dispose(h2o_handler_t *_self)
-{
-    struct st_h2o_specific_file_handler_t *self = (void *)_self;
-
-    free(self->real_path.base);
-    h2o_mem_release_shared(self->mime_type);
-}
-
-static int specific_handler_on_req(h2o_handler_t *_self, h2o_req_t *req)
-{
-    struct st_h2o_specific_file_handler_t *self = (void *)_self;
-    struct st_h2o_sendfile_generator_t *generator;
-    int is_dir;
-
-    /* open file (or send error or return -1) */
-    if ((generator = create_generator(req, self->real_path.base, self->real_path.len, &is_dir, self->flags)) == NULL) {
-        if (is_dir) {
-            h2o_send_error_403(req, "Access Forbidden", "access forbidden", 0);
-        } else if (errno == ENOENT) {
-            return -1;
-        } else if (errno == ENFILE || errno == EMFILE) {
-            h2o_send_error_503(req, "Service Unavailable", "please try again later", 0);
-        } else {
-            h2o_send_error_403(req, "Access Forbidden", "access forbidden", 0);
-        }
-        return 0;
-    }
-
-    return serve_with_generator(generator, req, req->path_normalized, self->real_path.base, self->real_path.len, self->mime_type);
-}
-
-h2o_handler_t *h2o_file_register_file(h2o_pathconf_t *pathconf, const char *real_path, h2o_mimemap_type_t *mime_type, int flags)
-{
-    struct st_h2o_specific_file_handler_t *self = (void *)h2o_create_handler(pathconf, sizeof(*self));
-
-    self->super.on_context_init = specific_handler_on_context_init;
-    self->super.on_context_dispose = specific_handler_on_context_dispose;
-    self->super.dispose = specific_handler_on_dispose;
-    self->super.on_req = specific_handler_on_req;
-
-    self->real_path = h2o_strdup(NULL, real_path, SIZE_MAX);
-    h2o_mem_addref_shared(mime_type);
-    self->mime_type = mime_type;
-    self->flags = flags;
-
-    return &self->super;
-}