Merging upstream version 1.46.3.

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

1 files changed, 0 insertions, 859 deletions

diff --git a/web/server/h2o/libh2o/lib/http1.c b/web/server/h2o/libh2o/lib/http1.c
deleted file mode 100644
index 98c4e55ab..000000000
--- a/web/server/h2o/libh2o/lib/http1.c
+++ /dev/null
@@ -1,859 +0,0 @@
-/*
- * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Shota Fukumori,
- *                         Fastly, Inc.
- *
- * 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 <inttypes.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "picohttpparser.h"
-#include "h2o.h"
-#include "h2o/http1.h"
-#include "h2o/http2.h"
-
-#define MAX_PULL_BUF_SZ 65536
-
-struct st_h2o_http1_finalostream_t {
-    h2o_ostream_t super;
-    int sent_headers;
-    struct {
-        void *buf;
-        h2o_ostream_pull_cb cb;
-    } pull;
-};
-
-struct st_h2o_http1_conn_t {
-    h2o_conn_t super;
-    h2o_socket_t *sock;
-    /* internal structure */
-    h2o_linklist_t _conns;
-    h2o_timeout_t *_timeout;
-    h2o_timeout_entry_t _timeout_entry;
-    uint64_t _req_index;
-    size_t _prevreqlen;
-    size_t _reqsize;
-    struct st_h2o_http1_req_entity_reader *_req_entity_reader;
-    struct st_h2o_http1_finalostream_t _ostr_final;
-    struct {
-        void *data;
-        h2o_http1_upgrade_cb cb;
-    } upgrade;
-    /* the HTTP request / response (intentionally placed at the last, since it is a large structure and has it's own ctor) */
-    h2o_req_t req;
-};
-
-struct st_h2o_http1_req_entity_reader {
-    void (*handle_incoming_entity)(struct st_h2o_http1_conn_t *conn);
-};
-
-struct st_h2o_http1_content_length_entity_reader {
-    struct st_h2o_http1_req_entity_reader super;
-    size_t content_length;
-};
-
-struct st_h2o_http1_chunked_entity_reader {
-    struct st_h2o_http1_req_entity_reader super;
-    struct phr_chunked_decoder decoder;
-    size_t prev_input_size;
-};
-
-static void proceed_pull(struct st_h2o_http1_conn_t *conn, size_t nfilled);
-static void finalostream_start_pull(h2o_ostream_t *_self, h2o_ostream_pull_cb cb);
-static void finalostream_send(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state);
-static void reqread_on_read(h2o_socket_t *sock, const char *err);
-static int foreach_request(h2o_context_t *ctx, int (*cb)(h2o_req_t *req, void *cbdata), void *cbdata);
-
-const h2o_protocol_callbacks_t H2O_HTTP1_CALLBACKS = {
-    NULL, /* graceful_shutdown (note: nothing special needs to be done for handling graceful shutdown) */
-    foreach_request};
-
-static int is_msie(h2o_req_t *req)
-{
-    ssize_t cursor = h2o_find_header(&req->headers, H2O_TOKEN_USER_AGENT, -1);
-    if (cursor == -1)
-        return 0;
-    if (h2o_strstr(req->headers.entries[cursor].value.base, req->headers.entries[cursor].value.len, H2O_STRLIT("; MSIE ")) ==
-        SIZE_MAX)
-        return 0;
-    return 1;
-}
-
-static void init_request(struct st_h2o_http1_conn_t *conn, int reinit)
-{
-    if (reinit)
-        h2o_dispose_request(&conn->req);
-    h2o_init_request(&conn->req, &conn->super, NULL);
-
-    ++conn->_req_index;
-    conn->req._ostr_top = &conn->_ostr_final.super;
-    conn->_ostr_final.super.do_send = finalostream_send;
-    conn->_ostr_final.super.start_pull = finalostream_start_pull;
-    conn->_ostr_final.sent_headers = 0;
-}
-
-static void close_connection(struct st_h2o_http1_conn_t *conn, int close_socket)
-{
-    h2o_timeout_unlink(&conn->_timeout_entry);
-    h2o_dispose_request(&conn->req);
-    if (conn->sock != NULL && close_socket)
-        h2o_socket_close(conn->sock);
-    h2o_linklist_unlink(&conn->_conns);
-    free(conn);
-}
-
-static void set_timeout(struct st_h2o_http1_conn_t *conn, h2o_timeout_t *timeout, h2o_timeout_cb cb)
-{
-    if (conn->_timeout != NULL) {
-        h2o_timeout_unlink(&conn->_timeout_entry);
-        conn->_timeout_entry.cb = NULL;
-    }
-    conn->_timeout = timeout;
-    if (timeout != NULL) {
-        h2o_timeout_link(conn->super.ctx->loop, timeout, &conn->_timeout_entry);
-        conn->_timeout_entry.cb = cb;
-    }
-}
-
-static void process_request(struct st_h2o_http1_conn_t *conn)
-{
-    if (conn->sock->ssl == NULL && conn->req.upgrade.base != NULL && conn->super.ctx->globalconf->http1.upgrade_to_http2 &&
-        conn->req.upgrade.len >= 3 && h2o_lcstris(conn->req.upgrade.base, 3, H2O_STRLIT("h2c")) &&
-        (conn->req.upgrade.len == 3 ||
-         (conn->req.upgrade.len == 6 && (memcmp(conn->req.upgrade.base + 3, H2O_STRLIT("-14")) == 0 ||
-                                         memcmp(conn->req.upgrade.base + 3, H2O_STRLIT("-16")) == 0)))) {
-        if (h2o_http2_handle_upgrade(&conn->req, conn->super.connected_at) == 0) {
-            return;
-        }
-    }
-    h2o_process_request(&conn->req);
-}
-
-#define DECL_ENTITY_READ_SEND_ERROR_XXX(status_)                                                                                   \
-    static void entity_read_send_error_##status_(struct st_h2o_http1_conn_t *conn, const char *reason, const char *body)           \
-    {                                                                                                                              \
-        conn->_req_entity_reader = NULL;                                                                                           \
-        set_timeout(conn, NULL, NULL);                                                                                             \
-        h2o_socket_read_stop(conn->sock);                                                                                          \
-        conn->req.http1_is_persistent = 0;                                                                                         \
-        conn->super.ctx->emitted_error_status[H2O_STATUS_ERROR_##status_]++;                                                       \
-        h2o_send_error_generic(&conn->req, status_, reason, body, H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION);                          \
-    }
-
-DECL_ENTITY_READ_SEND_ERROR_XXX(400)
-DECL_ENTITY_READ_SEND_ERROR_XXX(413)
-
-static void on_entity_read_complete(struct st_h2o_http1_conn_t *conn)
-{
-    conn->_req_entity_reader = NULL;
-    set_timeout(conn, NULL, NULL);
-    h2o_socket_read_stop(conn->sock);
-    process_request(conn);
-}
-
-static void handle_chunked_entity_read(struct st_h2o_http1_conn_t *conn)
-{
-    struct st_h2o_http1_chunked_entity_reader *reader = (void *)conn->_req_entity_reader;
-    h2o_buffer_t *inbuf = conn->sock->input;
-    size_t bufsz;
-    ssize_t ret;
-
-    /* decode the incoming data */
-    if ((bufsz = inbuf->size - reader->prev_input_size) == 0)
-        return;
-    ret = phr_decode_chunked(&reader->decoder, inbuf->bytes + reader->prev_input_size, &bufsz);
-    inbuf->size = reader->prev_input_size + bufsz;
-    reader->prev_input_size = inbuf->size;
-    if (ret != -1 && inbuf->size - conn->_reqsize >= conn->super.ctx->globalconf->max_request_entity_size) {
-        entity_read_send_error_413(conn, "Request Entity Too Large", "request entity is too large");
-        return;
-    }
-    if (ret < 0) {
-        if (ret == -2) {
-            /* incomplete */
-            return;
-        }
-        /* error */
-        entity_read_send_error_400(conn, "Invalid Request", "broken chunked-encoding");
-        return;
-    }
-    /* complete */
-    conn->req.entity = h2o_iovec_init(inbuf->bytes + conn->_reqsize, inbuf->size - conn->_reqsize);
-    conn->_reqsize = inbuf->size;
-    inbuf->size += ret; /* restore the number of extra bytes */
-
-    on_entity_read_complete(conn);
-}
-
-static int create_chunked_entity_reader(struct st_h2o_http1_conn_t *conn)
-{
-    struct st_h2o_http1_chunked_entity_reader *reader = h2o_mem_alloc_pool(&conn->req.pool, sizeof(*reader));
-    conn->_req_entity_reader = &reader->super;
-
-    reader->super.handle_incoming_entity = handle_chunked_entity_read;
-    memset(&reader->decoder, 0, sizeof(reader->decoder));
-    reader->decoder.consume_trailer = 1;
-    reader->prev_input_size = conn->_reqsize;
-
-    return 0;
-}
-
-static void handle_content_length_entity_read(struct st_h2o_http1_conn_t *conn)
-{
-    struct st_h2o_http1_content_length_entity_reader *reader = (void *)conn->_req_entity_reader;
-
-    /* wait until: reqsize == conn->_input.size */
-    if (conn->sock->input->size < conn->_reqsize)
-        return;
-
-    /* all input has arrived */
-    conn->req.entity = h2o_iovec_init(conn->sock->input->bytes + conn->_reqsize - reader->content_length, reader->content_length);
-    on_entity_read_complete(conn);
-}
-
-static int create_content_length_entity_reader(struct st_h2o_http1_conn_t *conn, size_t content_length)
-{
-    struct st_h2o_http1_content_length_entity_reader *reader = h2o_mem_alloc_pool(&conn->req.pool, sizeof(*reader));
-    conn->_req_entity_reader = &reader->super;
-
-    reader->super.handle_incoming_entity = handle_content_length_entity_read;
-    reader->content_length = content_length;
-    conn->_reqsize += content_length;
-
-    return 0;
-}
-
-static int create_entity_reader(struct st_h2o_http1_conn_t *conn, const struct phr_header *entity_header)
-{
-    /* strlen("content-length") is unequal to sizeof("transfer-encoding"), and thus checking the length only is sufficient */
-    if (entity_header->name_len == sizeof("transfer-encoding") - 1) {
-        /* transfer-encoding */
-        if (!h2o_lcstris(entity_header->value, entity_header->value_len, H2O_STRLIT("chunked"))) {
-            entity_read_send_error_400(conn, "Invalid Request", "unknown transfer-encoding");
-            return -1;
-        }
-        return create_chunked_entity_reader(conn);
-    } else {
-        /* content-length */
-        size_t content_length = h2o_strtosize(entity_header->value, entity_header->value_len);
-        if (content_length == SIZE_MAX) {
-            entity_read_send_error_400(conn, "Invalid Request", "broken content-length header");
-            return -1;
-        }
-        if (content_length > conn->super.ctx->globalconf->max_request_entity_size) {
-            entity_read_send_error_413(conn, "Request Entity Too Large", "request entity is too large");
-            return -1;
-        }
-        return create_content_length_entity_reader(conn, (size_t)content_length);
-    }
-    /* failed */
-    return -1;
-}
-
-static ssize_t init_headers(h2o_mem_pool_t *pool, h2o_headers_t *headers, const struct phr_header *src, size_t len,
-                            h2o_iovec_t *connection, h2o_iovec_t *host, h2o_iovec_t *upgrade, h2o_iovec_t *expect)
-{
-    ssize_t entity_header_index = -1;
-
-    assert(headers->size == 0);
-
-    /* setup */
-    if (len != 0) {
-        size_t i;
-        h2o_vector_reserve(pool, headers, len);
-        for (i = 0; i != len; ++i) {
-            const h2o_token_t *name_token;
-            char orig_case[src[i].name_len];
-
-            /* preserve the original case */
-            memcpy(orig_case, src[i].name, src[i].name_len);
-            /* convert to lower-case in-place */
-            h2o_strtolower((char *)src[i].name, src[i].name_len);
-            if ((name_token = h2o_lookup_token(src[i].name, src[i].name_len)) != NULL) {
-                if (name_token->is_init_header_special) {
-                    if (name_token == H2O_TOKEN_HOST) {
-                        host->base = (char *)src[i].value;
-                        host->len = src[i].value_len;
-                    } else if (name_token == H2O_TOKEN_CONTENT_LENGTH) {
-                        if (entity_header_index == -1)
-                            entity_header_index = i;
-                    } else if (name_token == H2O_TOKEN_TRANSFER_ENCODING) {
-                        entity_header_index = i;
-                    } else if (name_token == H2O_TOKEN_EXPECT) {
-                        expect->base = (char *)src[i].value;
-                        expect->len = src[i].value_len;
-                    } else if (name_token == H2O_TOKEN_UPGRADE) {
-                        upgrade->base = (char *)src[i].value;
-                        upgrade->len = src[i].value_len;
-                    } else {
-                        assert(!"logic flaw");
-                    }
-                } else {
-                    h2o_add_header(pool, headers, name_token, orig_case, src[i].value, src[i].value_len);
-                    if (name_token == H2O_TOKEN_CONNECTION)
-                        *connection = headers->entries[headers->size - 1].value;
-                }
-            } else {
-                h2o_add_header_by_str(pool, headers, src[i].name, src[i].name_len, 0, orig_case, src[i].value, src[i].value_len);
-            }
-        }
-    }
-
-    return entity_header_index;
-}
-
-static ssize_t fixup_request(struct st_h2o_http1_conn_t *conn, struct phr_header *headers, size_t num_headers, int minor_version,
-                             h2o_iovec_t *expect)
-{
-    ssize_t entity_header_index;
-    h2o_iovec_t connection = {NULL, 0}, host = {NULL, 0}, upgrade = {NULL, 0};
-
-    expect->base = NULL;
-    expect->len = 0;
-
-    conn->req.input.scheme = conn->sock->ssl != NULL ? &H2O_URL_SCHEME_HTTPS : &H2O_URL_SCHEME_HTTP;
-    conn->req.version = 0x100 | (minor_version != 0);
-
-    /* init headers */
-    entity_header_index =
-        init_headers(&conn->req.pool, &conn->req.headers, headers, num_headers, &connection, &host, &upgrade, expect);
-
-    /* copy the values to pool, since the buffer pointed by the headers may get realloced */
-    if (entity_header_index != -1) {
-        size_t i;
-        conn->req.input.method = h2o_strdup(&conn->req.pool, conn->req.input.method.base, conn->req.input.method.len);
-        conn->req.input.path = h2o_strdup(&conn->req.pool, conn->req.input.path.base, conn->req.input.path.len);
-        for (i = 0; i != conn->req.headers.size; ++i) {
-            h2o_header_t *header = conn->req.headers.entries + i;
-            if (!h2o_iovec_is_token(header->name)) {
-                *header->name = h2o_strdup(&conn->req.pool, header->name->base, header->name->len);
-            }
-            header->value = h2o_strdup(&conn->req.pool, header->value.base, header->value.len);
-        }
-        if (host.base != NULL)
-            host = h2o_strdup(&conn->req.pool, host.base, host.len);
-        if (upgrade.base != NULL)
-            upgrade = h2o_strdup(&conn->req.pool, upgrade.base, upgrade.len);
-    }
-
-    /* move host header to req->authority */
-    if (host.base != NULL)
-        conn->req.input.authority = host;
-
-    /* setup persistent flag (and upgrade info) */
-    if (connection.base != NULL) {
-        /* TODO contains_token function can be faster */
-        if (h2o_contains_token(connection.base, connection.len, H2O_STRLIT("keep-alive"), ',')) {
-            conn->req.http1_is_persistent = 1;
-        }
-        if (upgrade.base != NULL && h2o_contains_token(connection.base, connection.len, H2O_STRLIT("upgrade"), ',')) {
-            conn->req.upgrade = upgrade;
-        }
-    } else if (conn->req.version >= 0x101) {
-        /* defaults to keep-alive if >= HTTP/1.1 */
-        conn->req.http1_is_persistent = 1;
-    }
-    /* disable keep-alive if shutdown is requested */
-    if (conn->req.http1_is_persistent && conn->super.ctx->shutdown_requested)
-        conn->req.http1_is_persistent = 0;
-
-    return entity_header_index;
-}
-
-static void on_continue_sent(h2o_socket_t *sock, const char *err)
-{
-    struct st_h2o_http1_conn_t *conn = sock->data;
-
-    if (err != NULL) {
-        close_connection(conn, 1);
-        return;
-    }
-
-    h2o_socket_read_start(sock, reqread_on_read);
-    conn->_req_entity_reader->handle_incoming_entity(conn);
-}
-
-static int contains_crlf_only(const char *s, size_t len)
-{
-    for (; len != 0; ++s, --len)
-        if (!(*s == '\r' || *s == '\n'))
-            return 0;
-    return 1;
-}
-
-static void send_bad_request_on_complete(h2o_socket_t *sock, const char *err)
-{
-    struct st_h2o_http1_conn_t *conn = sock->data;
-    close_connection(conn, 1);
-}
-
-static void send_bad_request(struct st_h2o_http1_conn_t *conn)
-{
-    const static h2o_iovec_t resp = {H2O_STRLIT("HTTP/1.1 400 Bad Request\r\n"
-                                                "Content-Type: text/plain; charset=utf-8\r\n"
-                                                "Connection: close\r\n"
-                                                "Content-Length: 11\r\n"
-                                                "\r\n"
-                                                "Bad Request")};
-
-    assert(conn->req.version == 0 && "request has not been parsed successfully");
-    assert(conn->req.http1_is_persistent == 0);
-    h2o_socket_write(conn->sock, (h2o_iovec_t *)&resp, 1, send_bad_request_on_complete);
-    h2o_socket_read_stop(conn->sock);
-}
-
-static void handle_incoming_request(struct st_h2o_http1_conn_t *conn)
-{
-    size_t inreqlen = conn->sock->input->size < H2O_MAX_REQLEN ? conn->sock->input->size : H2O_MAX_REQLEN;
-    int reqlen, minor_version;
-    struct phr_header headers[H2O_MAX_HEADERS];
-    size_t num_headers = H2O_MAX_HEADERS;
-    ssize_t entity_body_header_index;
-    h2o_iovec_t expect;
-
-    /* need to set request_begin_at here for keep-alive connection */
-    if (conn->req.timestamps.request_begin_at.tv_sec == 0)
-        conn->req.timestamps.request_begin_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL);
-
-    reqlen = phr_parse_request(conn->sock->input->bytes, inreqlen, (const char **)&conn->req.input.method.base,
-                               &conn->req.input.method.len, (const char **)&conn->req.input.path.base, &conn->req.input.path.len,
-                               &minor_version, headers, &num_headers, conn->_prevreqlen);
-    conn->_prevreqlen = inreqlen;
-
-    switch (reqlen) {
-    default: // parse complete
-        conn->_reqsize = reqlen;
-        if ((entity_body_header_index = fixup_request(conn, headers, num_headers, minor_version, &expect)) != -1) {
-            conn->req.timestamps.request_body_begin_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL);
-            if (expect.base != NULL) {
-                if (!h2o_lcstris(expect.base, expect.len, H2O_STRLIT("100-continue"))) {
-                    set_timeout(conn, NULL, NULL);
-                    h2o_socket_read_stop(conn->sock);
-                    h2o_send_error_417(&conn->req, "Expectation Failed", "unknown expectation",
-                                       H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION);
-                    return;
-                }
-            }
-            if (create_entity_reader(conn, headers + entity_body_header_index) != 0) {
-                return;
-            }
-            if (expect.base != NULL) {
-                static const h2o_iovec_t res = {H2O_STRLIT("HTTP/1.1 100 Continue\r\n\r\n")};
-                h2o_socket_write(conn->sock, (void *)&res, 1, on_continue_sent);
-                /* processing of the incoming entity is postponed until the 100 response is sent */
-                h2o_socket_read_stop(conn->sock);
-                return;
-            }
-            conn->_req_entity_reader->handle_incoming_entity(conn);
-        } else {
-            set_timeout(conn, NULL, NULL);
-            h2o_socket_read_stop(conn->sock);
-            process_request(conn);
-        }
-        return;
-    case -2: // incomplete
-        if (inreqlen == H2O_MAX_REQLEN) {
-            send_bad_request(conn);
-        }
-        return;
-    case -1: // error
-        /* upgrade to HTTP/2 if the request starts with: PRI * HTTP/2 */
-        if (conn->super.ctx->globalconf->http1.upgrade_to_http2) {
-            /* should check up to the first octet that phr_parse_request returns an error */
-            static const h2o_iovec_t HTTP2_SIG = {H2O_STRLIT("PRI * HTTP/2")};
-            if (conn->sock->input->size >= HTTP2_SIG.len && memcmp(conn->sock->input->bytes, HTTP2_SIG.base, HTTP2_SIG.len) == 0) {
-                h2o_accept_ctx_t accept_ctx = {conn->super.ctx, conn->super.hosts};
-                h2o_socket_t *sock = conn->sock;
-                struct timeval connected_at = conn->super.connected_at;
-                /* destruct the connection after detatching the socket */
-                conn->sock = NULL;
-                close_connection(conn, 1);
-                /* and accept as http2 connection */
-                h2o_http2_accept(&accept_ctx, sock, connected_at);
-                return;
-            }
-        }
-        if (inreqlen <= 4 && contains_crlf_only(conn->sock->input->bytes, inreqlen)) {
-            close_connection(conn, 1);
-        } else {
-            send_bad_request(conn);
-        }
-        return;
-    }
-}
-
-void reqread_on_read(h2o_socket_t *sock, const char *err)
-{
-    struct st_h2o_http1_conn_t *conn = sock->data;
-
-    if (err != NULL) {
-        close_connection(conn, 1);
-        return;
-    }
-
-    if (conn->_req_entity_reader == NULL)
-        handle_incoming_request(conn);
-    else
-        conn->_req_entity_reader->handle_incoming_entity(conn);
-}
-
-static void reqread_on_timeout(h2o_timeout_entry_t *entry)
-{
-    struct st_h2o_http1_conn_t *conn = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1_conn_t, _timeout_entry, entry);
-
-    /* TODO log */
-    conn->req.http1_is_persistent = 0;
-    close_connection(conn, 1);
-}
-
-static inline void reqread_start(struct st_h2o_http1_conn_t *conn)
-{
-    set_timeout(conn, &conn->super.ctx->http1.req_timeout, reqread_on_timeout);
-    h2o_socket_read_start(conn->sock, reqread_on_read);
-    if (conn->sock->input->size != 0)
-        handle_incoming_request(conn);
-}
-
-static void on_send_next_push(h2o_socket_t *sock, const char *err)
-{
-    struct st_h2o_http1_conn_t *conn = sock->data;
-
-    if (err != NULL)
-        close_connection(conn, 1);
-    else
-        h2o_proceed_response(&conn->req);
-}
-
-static void on_send_next_pull(h2o_socket_t *sock, const char *err)
-{
-    struct st_h2o_http1_conn_t *conn = sock->data;
-
-    if (err != NULL)
-        close_connection(conn, 1);
-    else
-        proceed_pull(conn, 0);
-}
-
-static void on_send_complete(h2o_socket_t *sock, const char *err)
-{
-    struct st_h2o_http1_conn_t *conn = sock->data;
-
-    assert(conn->req._ostr_top == &conn->_ostr_final.super);
-
-    conn->req.timestamps.response_end_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL);
-
-    if (!conn->req.http1_is_persistent) {
-        /* TODO use lingering close */
-        close_connection(conn, 1);
-        return;
-    }
-
-    /* handle next request */
-    init_request(conn, 1);
-    h2o_buffer_consume(&conn->sock->input, conn->_reqsize);
-    conn->_prevreqlen = 0;
-    conn->_reqsize = 0;
-    reqread_start(conn);
-}
-
-static void on_upgrade_complete(h2o_socket_t *socket, const char *err)
-{
-    struct st_h2o_http1_conn_t *conn = socket->data;
-    h2o_http1_upgrade_cb cb = conn->upgrade.cb;
-    void *data = conn->upgrade.data;
-    h2o_socket_t *sock = NULL;
-    size_t reqsize = 0;
-
-    /* destruct the connection (after detaching the socket) */
-    if (err == 0) {
-        sock = conn->sock;
-        reqsize = conn->_reqsize;
-        close_connection(conn, 0);
-    } else {
-        close_connection(conn, 1);
-    }
-
-    cb(data, sock, reqsize);
-}
-
-static size_t flatten_headers_estimate_size(h2o_req_t *req, size_t server_name_and_connection_len)
-{
-    size_t len = sizeof("HTTP/1.1  \r\ndate: \r\nserver: \r\nconnection: \r\ncontent-length: \r\n\r\n") + 3 +
-                 strlen(req->res.reason) + H2O_TIMESTR_RFC1123_LEN + server_name_and_connection_len +
-                 sizeof(H2O_UINT64_LONGEST_STR) - 1 + sizeof("cache-control: private") - 1;
-    const h2o_header_t *header, *end;
-
-    for (header = req->res.headers.entries, end = header + req->res.headers.size; header != end; ++header)
-        len += header->name->len + header->value.len + 4;
-
-    return len;
-}
-
-static size_t flatten_headers(char *buf, h2o_req_t *req, const char *connection)
-{
-    h2o_context_t *ctx = req->conn->ctx;
-    h2o_timestamp_t ts;
-    char *dst = buf;
-
-    h2o_get_timestamp(ctx, &req->pool, &ts);
-
-    assert(req->res.status <= 999);
-
-    /* send essential headers with the first chars uppercased for max. interoperability (#72) */
-    if (req->res.content_length != SIZE_MAX) {
-        dst += sprintf(dst, "HTTP/1.1 %d %s\r\nDate: %s\r\nConnection: %s\r\nContent-Length: %zu\r\n", req->res.status,
-                       req->res.reason, ts.str->rfc1123, connection, req->res.content_length);
-    } else {
-        dst += sprintf(dst, "HTTP/1.1 %d %s\r\nDate: %s\r\nConnection: %s\r\n", req->res.status, req->res.reason, ts.str->rfc1123,
-                       connection);
-    }
-    if (ctx->globalconf->server_name.len) {
-        dst += sprintf(dst, "Server: %s\r\n", ctx->globalconf->server_name.base);
-    }
-
-    { /* flatten the normal headers */
-        size_t i;
-        for (i = 0; i != req->res.headers.size; ++i) {
-            const h2o_header_t *header = req->res.headers.entries + i;
-            if (header->name == &H2O_TOKEN_VARY->buf) {
-                /* replace Vary with Cache-Control: private; see the following URLs to understand why this is necessary
-                 * - http://blogs.msdn.com/b/ieinternals/archive/2009/06/17/vary-header-prevents-caching-in-ie.aspx
-                 * - https://www.igvita.com/2013/05/01/deploying-webp-via-accept-content-negotiation/
-                 */
-                if (is_msie(req)) {
-                    static h2o_header_t cache_control_private = {&H2O_TOKEN_CACHE_CONTROL->buf, NULL, {H2O_STRLIT("private")}};
-                    header = &cache_control_private;
-                }
-            }
-            memcpy(dst, header->orig_name ? header->orig_name : header->name->base, header->name->len);
-            dst += header->name->len;
-            *dst++ = ':';
-            *dst++ = ' ';
-            memcpy(dst, header->value.base, header->value.len);
-            dst += header->value.len;
-            *dst++ = '\r';
-            *dst++ = '\n';
-        }
-        *dst++ = '\r';
-        *dst++ = '\n';
-    }
-
-    return dst - buf;
-}
-
-static void proceed_pull(struct st_h2o_http1_conn_t *conn, size_t nfilled)
-{
-    h2o_iovec_t buf = {conn->_ostr_final.pull.buf, nfilled};
-    h2o_send_state_t send_state;
-
-    if (buf.len < MAX_PULL_BUF_SZ) {
-        h2o_iovec_t cbuf = {buf.base + buf.len, MAX_PULL_BUF_SZ - buf.len};
-        send_state = h2o_pull(&conn->req, conn->_ostr_final.pull.cb, &cbuf);
-        if (send_state == H2O_SEND_STATE_ERROR) {
-            conn->req.http1_is_persistent = 0;
-        }
-        buf.len += cbuf.len;
-        conn->req.bytes_sent += cbuf.len;
-    } else {
-        send_state = H2O_SEND_STATE_IN_PROGRESS;
-    }
-
-    /* write */
-    h2o_socket_write(conn->sock, &buf, 1, h2o_send_state_is_in_progress(send_state) ? on_send_next_pull : on_send_complete);
-}
-
-static void finalostream_start_pull(h2o_ostream_t *_self, h2o_ostream_pull_cb cb)
-{
-    struct st_h2o_http1_conn_t *conn = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1_conn_t, _ostr_final.super, _self);
-    const char *connection = conn->req.http1_is_persistent ? "keep-alive" : "close";
-    size_t bufsz, headers_len;
-
-    assert(conn->req._ostr_top == &conn->_ostr_final.super);
-    assert(!conn->_ostr_final.sent_headers);
-
-    conn->req.timestamps.response_start_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL);
-
-    /* register the pull callback */
-    conn->_ostr_final.pull.cb = cb;
-
-    /* setup the buffer */
-    bufsz = flatten_headers_estimate_size(&conn->req, conn->super.ctx->globalconf->server_name.len + strlen(connection));
-    if (bufsz < MAX_PULL_BUF_SZ) {
-        if (MAX_PULL_BUF_SZ - bufsz < conn->req.res.content_length) {
-            bufsz = MAX_PULL_BUF_SZ;
-        } else {
-            bufsz += conn->req.res.content_length;
-        }
-    }
-    conn->_ostr_final.pull.buf = h2o_mem_alloc_pool(&conn->req.pool, bufsz);
-
-    /* fill-in the header */
-    headers_len = flatten_headers(conn->_ostr_final.pull.buf, &conn->req, connection);
-    conn->_ostr_final.sent_headers = 1;
-
-    proceed_pull(conn, headers_len);
-}
-
-void finalostream_send(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t send_state)
-{
-    struct st_h2o_http1_finalostream_t *self = (void *)_self;
-    struct st_h2o_http1_conn_t *conn = (struct st_h2o_http1_conn_t *)req->conn;
-    h2o_iovec_t *bufs = alloca(sizeof(h2o_iovec_t) * (inbufcnt + 1));
-    int i;
-    int bufcnt = 0;
-
-    assert(self == &conn->_ostr_final);
-
-    /* count bytes_sent if other ostreams haven't counted */
-    if (req->bytes_counted_by_ostream == 0) {
-        for (i = 0; i != inbufcnt; ++i) {
-            req->bytes_sent += inbufs[i].len;
-        }
-    }
-
-    if (!self->sent_headers) {
-        conn->req.timestamps.response_start_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL);
-        /* build headers and send */
-        const char *connection = req->http1_is_persistent ? "keep-alive" : "close";
-        bufs[bufcnt].base = h2o_mem_alloc_pool(
-            &req->pool, flatten_headers_estimate_size(req, conn->super.ctx->globalconf->server_name.len + strlen(connection)));
-        bufs[bufcnt].len = flatten_headers(bufs[bufcnt].base, req, connection);
-        ++bufcnt;
-        self->sent_headers = 1;
-    }
-    memcpy(bufs + bufcnt, inbufs, sizeof(h2o_iovec_t) * inbufcnt);
-    bufcnt += inbufcnt;
-
-    if (send_state == H2O_SEND_STATE_ERROR) {
-        conn->req.http1_is_persistent = 0;
-    }
-
-    if (bufcnt != 0) {
-        h2o_socket_write(conn->sock, bufs, bufcnt,
-                         h2o_send_state_is_in_progress(send_state) ? on_send_next_push : on_send_complete);
-    } else {
-        on_send_complete(conn->sock, 0);
-    }
-}
-
-static socklen_t get_sockname(h2o_conn_t *_conn, struct sockaddr *sa)
-{
-    struct st_h2o_http1_conn_t *conn = (void *)_conn;
-    return h2o_socket_getsockname(conn->sock, sa);
-}
-
-static socklen_t get_peername(h2o_conn_t *_conn, struct sockaddr *sa)
-{
-    struct st_h2o_http1_conn_t *conn = (void *)_conn;
-    return h2o_socket_getpeername(conn->sock, sa);
-}
-
-static h2o_socket_t *get_socket(h2o_conn_t *_conn)
-{
-    struct st_h2o_http1_conn_t *conn = (void *)_conn;
-    return conn->sock;
-}
-
-#define DEFINE_TLS_LOGGER(name)                                                                                                    \
-    static h2o_iovec_t log_##name(h2o_req_t *req)                                                                                  \
-    {                                                                                                                              \
-        struct st_h2o_http1_conn_t *conn = (void *)req->conn;                                                                      \
-        return h2o_socket_log_ssl_##name(conn->sock, &req->pool);                                                                  \
-    }
-
-DEFINE_TLS_LOGGER(protocol_version)
-DEFINE_TLS_LOGGER(session_reused)
-DEFINE_TLS_LOGGER(cipher)
-DEFINE_TLS_LOGGER(cipher_bits)
-DEFINE_TLS_LOGGER(session_id)
-
-#undef DEFINE_TLS_LOGGER
-
-static h2o_iovec_t log_request_index(h2o_req_t *req)
-{
-    struct st_h2o_http1_conn_t *conn = (void *)req->conn;
-    char *s = h2o_mem_alloc_pool(&req->pool, sizeof(H2O_UINT64_LONGEST_STR));
-    size_t len = sprintf(s, "%" PRIu64, conn->_req_index);
-    return h2o_iovec_init(s, len);
-}
-
-static int foreach_request(h2o_context_t *ctx, int (*cb)(h2o_req_t *req, void *cbdata), void *cbdata)
-{
-    h2o_linklist_t *node;
-
-    for (node = ctx->http1._conns.next; node != &ctx->http1._conns; node = node->next) {
-        struct st_h2o_http1_conn_t *conn = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1_conn_t, _conns, node);
-        int ret = cb(&conn->req, cbdata);
-        if (ret != 0)
-            return ret;
-    }
-    return 0;
-}
-
-void h2o_http1_accept(h2o_accept_ctx_t *ctx, h2o_socket_t *sock, struct timeval connected_at)
-{
-    static const h2o_conn_callbacks_t callbacks = {
-        get_sockname, /* stringify address */
-        get_peername, /* ditto */
-        NULL,         /* push */
-        get_socket,   /* get underlying socket */
-        NULL,         /* get debug state */
-        {{
-            {log_protocol_version, log_session_reused, log_cipher, log_cipher_bits, log_session_id}, /* ssl */
-            {log_request_index},                                                                     /* http1 */
-            {NULL}                                                                                   /* http2 */
-        }}};
-    struct st_h2o_http1_conn_t *conn = (void *)h2o_create_connection(sizeof(*conn), ctx->ctx, ctx->hosts, connected_at, &callbacks);
-
-    /* zero-fill all properties expect req */
-    memset((char *)conn + sizeof(conn->super), 0, offsetof(struct st_h2o_http1_conn_t, req) - sizeof(conn->super));
-
-    /* init properties that need to be non-zero */
-    conn->super.ctx = ctx->ctx;
-    conn->super.hosts = ctx->hosts;
-    conn->super.connected_at = connected_at;
-    conn->super.callbacks = &callbacks;
-    conn->sock = sock;
-    sock->data = conn;
-    h2o_linklist_insert(&ctx->ctx->http1._conns, &conn->_conns);
-
-    init_request(conn, 0);
-    reqread_start(conn);
-}
-
-void h2o_http1_upgrade(h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_http1_upgrade_cb on_complete, void *user_data)
-{
-    struct st_h2o_http1_conn_t *conn = (void *)req->conn;
-
-    assert(req->version <= 0x200); /* TODO find a better way to assert instanceof(req->conn) == struct st_h2o_http1_conn_t */
-
-    h2o_iovec_t *bufs = alloca(sizeof(h2o_iovec_t) * (inbufcnt + 1));
-
-    conn->upgrade.data = user_data;
-    conn->upgrade.cb = on_complete;
-
-    bufs[0].base =
-        h2o_mem_alloc_pool(&conn->req.pool, flatten_headers_estimate_size(&conn->req, conn->super.ctx->globalconf->server_name.len +
-                                                                                          sizeof("upgrade") - 1));
-    bufs[0].len = flatten_headers(bufs[0].base, &conn->req, "upgrade");
-    h2o_memcpy(bufs + 1, inbufs, sizeof(h2o_iovec_t) * inbufcnt);
-
-    h2o_socket_write(conn->sock, bufs, inbufcnt + 1, on_upgrade_complete);
-}