diff options
Diffstat (limited to '')
| -rw-r--r-- | web/server/h2o/libh2o/lib/http1.c | 859 |
1 files changed, 859 insertions, 0 deletions
diff --git a/web/server/h2o/libh2o/lib/http1.c b/web/server/h2o/libh2o/lib/http1.c new file mode 100644 index 00000000..98c4e55a --- /dev/null +++ b/web/server/h2o/libh2o/lib/http1.c @@ -0,0 +1,859 @@ +/* + * 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); +} |