void initialize_event_loop(bool is_main_thread,
global_data_t *global_data,
event_loop_t *loop)
{
memset(loop, 0, sizeof(*loop));
h2o_context_init(&loop->h2o_ctx, h2o_evloop_create(), &global_data->h2o_config);
loop->h2o_accept_ctx.ctx = &loop->h2o_ctx;
loop->h2o_accept_ctx.hosts = global_data->h2o_config.hosts;
loop->h2o_accept_ctx.ssl_ctx = global_data->ssl_ctx;
int listener_sd;
if (is_main_thread)
listener_sd = global_data->listener_sd;
else {
int flags;
CHECK_ERRNO_RETURN(listener_sd, dup, global_data->listener_sd);
CHECK_ERRNO_RETURN(flags, fcntl, listener_sd, F_GETFD);
CHECK_ERRNO(fcntl, listener_sd, F_SETFD, flags | FD_CLOEXEC);
}
// Let all the threads race to call accept() on the socket; since the latter is
// non-blocking, that will effectively act as load balancing.
loop->h2o_socket = h2o_evloop_socket_create(loop->h2o_ctx.loop,
listener_sd,
H2O_SOCKET_FLAG_DONT_READ);
loop->h2o_socket->data = loop;
h2o_socket_read_start(loop->h2o_socket, accept_connection);
h2o_multithread_register_receiver(loop->h2o_ctx.queue,
&loop->h2o_receiver,
process_messages);
// libh2o's event loop does not support write polling unless it
// controls sending the data as well, so do read polling on the
// epoll file descriptor as a work-around.
CHECK_ERRNO_RETURN(loop->epoll_fd, epoll_create1, EPOLL_CLOEXEC);
loop->epoll_socket = h2o_evloop_socket_create(loop->h2o_ctx.loop,
loop->epoll_fd,
H2O_SOCKET_FLAG_DONT_READ);
loop->epoll_socket->data = loop;
h2o_socket_read_start(loop->epoll_socket, do_epoll_wait);
if (is_main_thread) {
global_data->signals = h2o_evloop_socket_create(loop->h2o_ctx.loop,
global_data->signal_fd,
H2O_SOCKET_FLAG_DONT_READ);
global_data->signals->data = loop;
h2o_socket_read_start(global_data->signals, shutdown_server);
}
}
static int on_config_port_complete(h2o_configurator_t *_conf, h2o_context_t *ctx)
{
struct port_configurator_t *conf = (void*)_conf;
struct sockaddr_in addr;
int fd, reuseaddr_flag = 1;
h2o_socket_t *sock;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(0);
addr.sin_port = htons(conf->port);
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1
|| setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_flag, sizeof(reuseaddr_flag)) != 0
|| bind(fd, (struct sockaddr*)&addr, sizeof(addr)) != 0
|| listen(fd, SOMAXCONN) != 0) {
fprintf(stderr, "failed to listen to port %hu:%s\n", conf->port, strerror(errno));
return -1;
}
sock = h2o_evloop_socket_create(ctx->loop, fd, H2O_SOCKET_FLAG_IS_ACCEPT);
sock->data = ctx;
h2o_socket_read_start(sock, on_config_port_accept);
return 0;
}
static void shutdown_ssl(h2o_socket_t *sock, int status)
{
int ret;
if (status != 0)
goto Close;
if ((ret = SSL_shutdown(sock->ssl->ssl)) == -1) {
goto Close;
}
if (sock->ssl->output.bufs.size != 0) {
h2o_socket_read_stop(sock);
flush_pending_ssl(sock, ret == 1 ? dispose_socket : shutdown_ssl);
} else if (ret == 2 && SSL_get_error(sock->ssl->ssl, ret) == SSL_ERROR_WANT_READ) {
h2o_socket_read_start(sock, shutdown_ssl);
} else {
status = ret == 1;
goto Close;
}
return;
Close:
dispose_socket(sock, status);
}
void initialize_event_loop(bool is_main_thread,
global_data_t *global_data,
h2o_multithread_receiver_t *h2o_receiver,
event_loop_t *loop)
{
h2o_socket_cb accept_cb = accept_connection;
const config_t * const config = global_data->global_thread_data->config;
memset(loop, 0, sizeof(*loop));
h2o_context_init(&loop->h2o_ctx, h2o_evloop_create(), &global_data->h2o_config);
loop->h2o_accept_ctx.ctx = &loop->h2o_ctx;
loop->h2o_accept_ctx.hosts = global_data->h2o_config.hosts;
if (global_data->ssl_ctx) {
loop->h2o_accept_ctx.ssl_ctx = global_data->ssl_ctx;
start_accept_polling(config, accept_connection, true, loop);
// Assume that the majority of the connections use HTTPS,
// so HTTP can take a few extra operations.
accept_cb = accept_http_connection;
}
start_accept_polling(config, accept_cb, false, loop);
h2o_multithread_register_receiver(loop->h2o_ctx.queue,
h2o_receiver,
process_messages);
if (is_main_thread) {
global_data->signals = h2o_evloop_socket_create(loop->h2o_ctx.loop,
global_data->signal_fd,
H2O_SOCKET_FLAG_DONT_READ);
global_data->signals->data = loop;
h2o_socket_read_start(global_data->signals, shutdown_server);
}
}
static void shutdown_ssl(h2o_socket_t *sock, const char *err)
{
int ret;
if (err != NULL)
goto Close;
if (sock->_cb.write != NULL) {
/* note: libuv calls the write callback after the socket is closed by uv_close (with status set to 0 if the write succeeded)
*/
sock->_cb.write = NULL;
goto Close;
}
if ((ret = SSL_shutdown(sock->ssl->ssl)) == -1) {
goto Close;
}
if (sock->ssl->output.bufs.size != 0) {
h2o_socket_read_stop(sock);
flush_pending_ssl(sock, ret == 1 ? dispose_socket : shutdown_ssl);
} else if (ret == 2 && SSL_get_error(sock->ssl->ssl, ret) == SSL_ERROR_WANT_READ) {
h2o_socket_read_start(sock, shutdown_ssl);
} else {
goto Close;
}
return;
Close:
dispose_socket(sock, err);
}
void h2o_socket_ssl_handshake(h2o_socket_t *sock, SSL_CTX *ssl_ctx, const char *server_name, h2o_socket_cb handshake_cb)
{
sock->ssl = h2o_mem_alloc(sizeof(*sock->ssl));
memset(sock->ssl, 0, offsetof(struct st_h2o_socket_ssl_t, output.pool));
/* setup the buffers; sock->input should be empty, sock->ssl->input.encrypted should contain the initial input, if any */
h2o_buffer_init(&sock->ssl->input.encrypted, &h2o_socket_buffer_prototype);
if (sock->input->size != 0) {
h2o_buffer_t *tmp = sock->input;
sock->input = sock->ssl->input.encrypted;
sock->ssl->input.encrypted = tmp;
}
h2o_mem_init_pool(&sock->ssl->output.pool);
create_ssl(sock, ssl_ctx);
sock->ssl->handshake.cb = handshake_cb;
if (server_name == NULL) {
/* is server */
if (SSL_CTX_sess_get_get_cb(ssl_ctx) != NULL)
sock->ssl->handshake.server.async_resumption.state = ASYNC_RESUMPTION_STATE_RECORD;
if (sock->ssl->input.encrypted->size != 0)
proceed_handshake(sock, 0);
else
h2o_socket_read_start(sock, proceed_handshake);
} else {
sock->ssl->handshake.client.server_name = h2o_strdup(NULL, server_name, SIZE_MAX).base;
SSL_set_tlsext_host_name(sock->ssl->ssl, sock->ssl->handshake.client.server_name);
proceed_handshake(sock, 0);
}
}
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 proceed_handshake(h2o_socket_t *sock, int status)
{
int ret;
sock->_cb.write = NULL;
if (status != 0) {
goto Complete;
}
ret = SSL_accept(sock->ssl->ssl);
if (ret == 2 || (ret < 0 && SSL_get_error(sock->ssl->ssl, ret) != SSL_ERROR_WANT_READ)) {
/* failed */
status = -1;
goto Complete;
}
if (sock->ssl->output.bufs.size != 0) {
h2o_socket_read_stop(sock);
flush_pending_ssl(sock, ret == 1 ? on_handshake_complete : proceed_handshake);
} else {
h2o_socket_read_start(sock, proceed_handshake);
}
return;
Complete:
h2o_socket_read_stop(sock);
on_handshake_complete(sock, status);
}
void h2o_websocket_proceed(h2o_websocket_conn_t *conn)
{
int handled;
/* run the loop until getting to a point where no more progress can be achieved */
do {
handled = 0;
if (!h2o_socket_is_writing(conn->sock) && wslay_event_want_write(conn->ws_ctx)) {
if (wslay_event_send(conn->ws_ctx) != 0) {
goto Close;
}
handled = 1;
}
if (conn->sock->input->size != 0 && wslay_event_want_read(conn->ws_ctx)) {
if (wslay_event_recv(conn->ws_ctx) != 0) {
goto Close;
}
handled = 1;
}
} while (handled);
if (wslay_event_want_read(conn->ws_ctx)) {
h2o_socket_read_start(conn->sock, on_recv);
} else if (h2o_socket_is_writing(conn->sock) || wslay_event_want_write(conn->ws_ctx)) {
h2o_socket_read_stop(conn->sock);
} else {
/* nothing is going on... close the socket */
goto Close;
}
return;
Close:
on_close(conn);
}
static void init_async(h2o_multithread_queue_t *queue, h2o_loop_t *loop)
{
#if defined(__linux__)
/**
* The kernel overhead of an eventfd file descriptor is
* much lower than that of a pipe, and only one file descriptor is required
*/
int fd;
fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
if (fd == -1) {
perror("eventfd");
abort();
}
queue->async.write = fd;
queue->async.read = h2o_evloop_socket_create(loop, fd, 0);
#else
int fds[2];
if (cloexec_pipe(fds) != 0) {
perror("pipe");
abort();
}
fcntl(fds[1], F_SETFL, O_NONBLOCK);
queue->async.write = fds[1];
queue->async.read = h2o_evloop_socket_create(loop, fds[0], 0);
#endif
queue->async.read->data = queue;
h2o_socket_read_start(queue->async.read, on_read);
}
void h2o_socket_ssl_handshake(h2o_socket_t *sock, SSL_CTX *ssl_ctx, const char *server_name, h2o_socket_cb handshake_cb)
{
sock->ssl = h2o_mem_alloc(sizeof(*sock->ssl));
memset(sock->ssl, 0, offsetof(struct st_h2o_socket_ssl_t, output.pool));
/* setup the buffers; sock->input should be empty, sock->ssl->input.encrypted should contain the initial input, if any */
h2o_buffer_init(&sock->ssl->input.encrypted, &h2o_socket_buffer_prototype);
if (sock->input->size != 0) {
h2o_buffer_t *tmp = sock->input;
sock->input = sock->ssl->input.encrypted;
sock->ssl->input.encrypted = tmp;
}
h2o_mem_init_pool(&sock->ssl->output.pool);
create_ssl(sock, ssl_ctx);
sock->ssl->handshake.cb = handshake_cb;
if (server_name == NULL) {
/* is server */
if (SSL_CTX_sess_get_get_cb(ssl_ctx) != NULL)
sock->ssl->handshake.server.async_resumption.state = ASYNC_RESUMPTION_STATE_RECORD;
if (sock->ssl->input.encrypted->size != 0)
proceed_handshake(sock, 0);
else
h2o_socket_read_start(sock, proceed_handshake);
} else {
h2o_cache_t *session_cache = h2o_socket_ssl_get_session_cache(ssl_ctx);
if (session_cache != NULL) {
struct sockaddr_storage sa;
int32_t port;
if (h2o_socket_getpeername(sock, (struct sockaddr *)&sa) != 0 &&
(port = h2o_socket_getport((struct sockaddr *)&sa)) != -1) {
/* session cache is available */
h2o_iovec_t session_cache_key;
session_cache_key.base = h2o_mem_alloc(strlen(server_name) + sizeof(":" H2O_UINT16_LONGEST_STR));
session_cache_key.len = sprintf(session_cache_key.base, "%s:%" PRIu16, server_name, (uint16_t)port);
sock->ssl->handshake.client.session_cache = session_cache;
sock->ssl->handshake.client.session_cache_key = session_cache_key;
sock->ssl->handshake.client.session_cache_key_hash =
h2o_cache_calchash(session_cache_key.base, session_cache_key.len);
/* fetch from session cache */
h2o_cache_ref_t *cacheref = h2o_cache_fetch(session_cache, h2o_now(h2o_socket_get_loop(sock)),
sock->ssl->handshake.client.session_cache_key,
sock->ssl->handshake.client.session_cache_key_hash);
if (cacheref != NULL) {
SSL_set_session(sock->ssl->ssl, (SSL_SESSION *)cacheref->value.base);
h2o_cache_release(session_cache, cacheref);
}
}
}
sock->ssl->handshake.client.server_name = h2o_strdup(NULL, server_name, SIZE_MAX).base;
SSL_set_tlsext_host_name(sock->ssl->ssl, sock->ssl->handshake.client.server_name);
proceed_handshake(sock, 0);
}
}
static void on_continue_sent(h2o_socket_t *sock, int status)
{
struct st_h2o_http1_conn_t *conn = sock->data;
if (status != 0) {
close_connection(conn, 1);
return;
}
h2o_socket_read_start(sock, reqread_on_read);
conn->_req_entity_reader->handle_incoming_entity(conn);
}
static int on_config_port_context_create(h2o_configurator_t *_conf, h2o_context_t *ctx)
{
struct port_configurator_t *conf = (void*)_conf;
h2o_socket_t *sock;
/* FIXME use dup to support multithread? */
sock = h2o_evloop_socket_create(ctx->loop, conf->fd, H2O_SOCKET_FLAG_IS_ACCEPT);
sock->data = ctx;
h2o_socket_read_start(sock, on_config_port_accept);
return 0;
}
h2o_tunnel_t *h2o_tunnel_establish(h2o_context_t *ctx, h2o_socket_t *sock1, h2o_socket_t *sock2, uint64_t timeout)
{
h2o_tunnel_t *tunnel = h2o_mem_alloc(sizeof(*tunnel));
tunnel->ctx = ctx;
tunnel->timeout = timeout;
tunnel->sock[0] = sock1;
tunnel->sock[1] = sock2;
sock1->data = tunnel;
sock2->data = tunnel;
h2o_timer_init(&tunnel->timeout_entry, on_timeout);
h2o_timer_link(tunnel->ctx->loop, timeout, &tunnel->timeout_entry);
/* Bring up the tunnel. Note. Upstream always ready first. */
if (sock2->input->size)
on_read(sock2, NULL);
if (sock1->input->size)
on_read(sock1, NULL);
h2o_socket_read_start(sock2, on_read);
h2o_socket_read_start(sock1, on_read);
return tunnel;
}
void h2o_accept(h2o_accept_ctx_t *ctx, h2o_socket_t *sock)
{
if (ctx->expect_proxy_line || ctx->ssl_ctx != NULL) {
create_accept_data(ctx, sock);
if (ctx->expect_proxy_line) {
h2o_socket_read_start(sock, on_read_proxy_line);
} else {
h2o_socket_ssl_server_handshake(sock, ctx->ssl_ctx, on_ssl_handshake_complete);
}
} else {
h2o_http1_accept(ctx, sock);
}
}
static void do_update_window(h2o_httpclient_t *_client)
{
struct st_h2o_http1client_t *client = (void *)_client;
if ((*client->super.buf)->size >= client->super.ctx->max_buffer_size) {
if (client->sock->_cb.read != NULL) {
client->reader = client->sock->_cb.read;
h2o_socket_read_stop(client->sock);
}
} else {
if (client->sock->_cb.read == NULL) {
h2o_socket_read_start(client->sock, client->reader);
}
}
}
static void init_async(h2o_multithread_queue_t *queue, h2o_loop_t *loop)
{
int fds[2];
if (cloexec_pipe(fds) != 0) {
perror("pipe");
abort();
}
fcntl(fds[1], F_SETFL, O_NONBLOCK);
queue->async.write = fds[1];
queue->async.read = h2o_evloop_socket_create(loop, fds[0], 0);
queue->async.read->data = queue;
h2o_socket_read_start(queue->async.read, on_read);
}
void h2o_accept(h2o_accept_ctx_t *ctx, h2o_socket_t *sock)
{
struct timeval connected_at = *h2o_get_timestamp(ctx->ctx, NULL, NULL);
if (ctx->expect_proxy_line || ctx->ssl_ctx != NULL) {
create_accept_data(ctx, sock, connected_at);
if (ctx->expect_proxy_line) {
h2o_socket_read_start(sock, on_read_proxy_line);
} else {
h2o_socket_ssl_server_handshake(sock, ctx->ssl_ctx, on_ssl_handshake_complete);
}
} else {
h2o_http1_accept(ctx, sock, connected_at);
}
}
static void *run_loop(void *_conf)
{
struct config_t *conf = _conf;
h2o_evloop_t *loop;
h2o_context_t ctx;
struct listener_ctx_t *listeners = alloca(sizeof(*listeners) * conf->num_listeners);
size_t i;
/* setup loop and context */
loop = h2o_evloop_create();
h2o_context_init(&ctx, loop, &conf->global_config);
/* setup listeners */
for (i = 0; i != conf->num_listeners; ++i) {
listeners[i].ctx = &ctx;
listeners[i].ssl_ctx = conf->listeners[i]->ssl_ctx;
listeners[i].sock = h2o_evloop_socket_create(
ctx.loop, conf->listeners[i]->fd,
(struct sockaddr*)&conf->listeners[i]->addr, conf->listeners[i]->addrlen,
H2O_SOCKET_FLAG_IS_ACCEPT);
listeners[i].sock->data = listeners + i;
}
/* the main loop */
while (1) {
/* start / stop trying to accept new connections */
if (conf->state.num_connections < conf->max_connections) {
for (i = 0; i != conf->num_listeners; ++i) {
if (! h2o_socket_is_reading(listeners[i].sock))
h2o_socket_read_start(listeners[i].sock, on_accept);
}
} else {
for (i = 0; i != conf->num_listeners; ++i) {
if (h2o_socket_is_reading(listeners[i].sock))
h2o_socket_read_stop(listeners[i].sock);
}
}
/* run the loop once */
h2o_evloop_run(loop);
}
return NULL;
}
void h2o_websocket_proceed(h2o_websocket_conn_t *conn)
{
int handled;
/* run the loop until getting to a point where no more progress can be achieved */
do {
handled = 0;
if (!h2o_socket_is_writing(conn->sock) && wslay_event_want_write(conn->ws_ctx)) {
if (wslay_event_send(conn->ws_ctx) != 0) {
goto Close;
}
/* avoid infinite loop when user want send more bufers count than ours in on_msg_callback() */
if (conn->_write_buf.cnt < sizeof(conn->_write_buf.bufs) / sizeof(conn->_write_buf.bufs[0])) {
handled = 1;
}
}
if (conn->sock->input->size != 0 && wslay_event_want_read(conn->ws_ctx)) {
if (wslay_event_recv(conn->ws_ctx) != 0) {
goto Close;
}
handled = 1;
}
} while (handled);
if (!h2o_socket_is_writing(conn->sock) && conn->_write_buf.cnt > 0) {
/* write */
h2o_socket_write(conn->sock, conn->_write_buf.bufs, conn->_write_buf.cnt, on_write_complete);
}
if (wslay_event_want_read(conn->ws_ctx)) {
h2o_socket_read_start(conn->sock, on_recv);
} else if (h2o_socket_is_writing(conn->sock) || wslay_event_want_write(conn->ws_ctx)) {
h2o_socket_read_stop(conn->sock);
} else {
/* nothing is going on... close the socket */
goto Close;
}
return;
Close:
on_close(conn);
}
static int create_listener(void)
{
struct sockaddr_in addr;
int fd, reuseaddr_flag = 1;
h2o_socket_t *sock;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(0x7f000001);
addr.sin_port = htons(7890);
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ||
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_flag, sizeof(reuseaddr_flag)) != 0 ||
bind(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0 || listen(fd, SOMAXCONN) != 0) {
return -1;
}
sock = h2o_evloop_socket_create(ctx.loop, fd, (void *)&addr, sizeof(addr), H2O_SOCKET_FLAG_DONT_READ);
h2o_socket_read_start(sock, on_accept);
return 0;
}
static void on_write_complete(h2o_socket_t *sock, const char *err)
{
struct st_h2o_tunnel_t *tunnel = sock->data;
h2o_socket_t *peer;
assert(tunnel != NULL);
assert(tunnel->sock[0] == sock || tunnel->sock[1] == sock);
if (err != NULL) {
close_connection(tunnel);
return;
}
reset_timeout(tunnel);
if (tunnel->sock[0] == sock)
peer = tunnel->sock[1];
else
peer = tunnel->sock[0];
h2o_buffer_consume(&peer->input, peer->input->size);
h2o_socket_read_start(peer, on_read);
}
static void start_accept_polling(const config_t *config,
h2o_socket_cb accept_cb,
bool is_https,
event_loop_t *loop)
{
const int listener_sd = get_listener_socket(config->bind_address,
is_https ? config->https_port : config->port);
// Let all the threads race to call accept() on the socket; since the latter is
// non-blocking, that will virtually act as load balancing, and SO_REUSEPORT
// will make it efficient.
h2o_socket_t * const h2o_socket = h2o_evloop_socket_create(loop->h2o_ctx.loop,
listener_sd,
H2O_SOCKET_FLAG_DONT_READ);
if (is_https)
loop->h2o_https_socket = h2o_socket;
else
loop->h2o_socket = h2o_socket;
h2o_socket->data = loop;
h2o_socket_read_start(h2o_socket, accept_cb);
}
static void on_send_request(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_t *client = sock->data;
h2o_timer_unlink(&client->super._timeout);
if (err != NULL) {
on_error_before_head(client, "I/O error (send request)");
return;
}
if (client->_is_chunked) {
client->_is_chunked = 0;
h2o_iovec_t last = h2o_iovec_init(H2O_STRLIT("0\r\n"));
h2o_socket_write(client->sock, &last, 1, on_send_request);
return;
}
client->super.timings.request_end_at = h2o_gettimeofday(client->super.ctx->loop);
h2o_socket_read_start(client->sock, on_head);
client->super._timeout.cb = on_head_timeout;
h2o_timer_link(client->super.ctx->loop, client->super.ctx->first_byte_timeout, &client->super._timeout);
}
static void on_head(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_t *client = sock->data;
int minor_version, version, http_status, rlen, is_eos;
const char *msg;
#define MAX_HEADERS 100
h2o_header_t *headers;
h2o_iovec_t *header_names;
size_t msg_len, num_headers, i;
h2o_socket_cb reader;
h2o_timer_unlink(&client->super._timeout);
if (err != NULL) {
on_error_before_head(client, "I/O error (head)");
return;
}
headers = h2o_mem_alloc_pool(client->super.pool, *headers, MAX_HEADERS);
header_names = h2o_mem_alloc_pool(client->super.pool, *header_names, MAX_HEADERS);
/* continue parsing the responses until we see a final one */
while (1) {
/* parse response */
struct phr_header src_headers[MAX_HEADERS];
num_headers = MAX_HEADERS;
rlen = phr_parse_response(sock->input->bytes, sock->input->size, &minor_version, &http_status, &msg, &msg_len, src_headers,
&num_headers, 0);
switch (rlen) {
case -1: /* error */
on_error_before_head(client, "failed to parse the response");
return;
case -2: /* incomplete */
h2o_timer_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->super._timeout);
return;
}
version = 0x100 | (minor_version != 0);
/* fill-in the headers */
for (i = 0; i != num_headers; ++i) {
const h2o_token_t *token;
char *orig_name = h2o_strdup(client->super.pool, src_headers[i].name, src_headers[i].name_len).base;
h2o_strtolower((char *)src_headers[i].name, src_headers[i].name_len);
token = h2o_lookup_token(src_headers[i].name, src_headers[i].name_len);
if (token != NULL) {
headers[i].name = (h2o_iovec_t *)&token->buf;
} else {
header_names[i] = h2o_iovec_init(src_headers[i].name, src_headers[i].name_len);
headers[i].name = &header_names[i];
}
headers[i].value = h2o_iovec_init(src_headers[i].value, src_headers[i].value_len);
headers[i].orig_name = orig_name;
headers[i].flags = (h2o_header_flags_t){0};
}
if (!(100 <= http_status && http_status <= 199 && http_status != 101))
break;
if (client->super.informational_cb != NULL &&
client->super.informational_cb(&client->super, version, http_status, h2o_iovec_init(msg, msg_len), headers,
num_headers) != 0) {
close_client(client);
return;
}
h2o_buffer_consume(&client->sock->input, rlen);
if (client->sock->input->size == 0) {
h2o_timer_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->super._timeout);
return;
}
}
client->super.timings.response_start_at = h2o_gettimeofday(client->super.ctx->loop);
/* parse the headers */
reader = on_body_until_close;
client->_do_keepalive = minor_version >= 1;
for (i = 0; i != num_headers; ++i) {
if (headers[i].name == &H2O_TOKEN_CONNECTION->buf) {
if (h2o_contains_token(headers[i].value.base, headers[i].value.len, H2O_STRLIT("keep-alive"), ',')) {
client->_do_keepalive = 1;
} else {
client->_do_keepalive = 0;
}
} else if (headers[i].name == &H2O_TOKEN_TRANSFER_ENCODING->buf) {
if (h2o_memis(headers[i].value.base, headers[i].value.len, H2O_STRLIT("chunked"))) {
/* precond: _body_decoder.chunked is zero-filled */
client->_body_decoder.chunked.decoder.consume_trailer = 1;
reader = on_req_chunked;
} else if (h2o_memis(headers[i].value.base, headers[i].value.len, H2O_STRLIT("identity"))) {
/* continue */
} else {
on_error_before_head(client, "unexpected type of transfer-encoding");
return;
}
} else if (headers[i].name == &H2O_TOKEN_CONTENT_LENGTH->buf) {
if ((client->_body_decoder.content_length.bytesleft = h2o_strtosize(headers[i].value.base, headers[i].value.len)) ==
SIZE_MAX) {
on_error_before_head(client, "invalid content-length");
return;
}
if (reader != on_req_chunked)
reader = on_body_content_length;
}
}
/* RFC 2616 4.4 */
if (client->_method_is_head || http_status == 101 || http_status == 204 || http_status == 304) {
is_eos = 1;
client->super.timings.response_end_at = h2o_gettimeofday(client->super.ctx->loop);
} else {
is_eos = 0;
/* close the connection if impossible to determine the end of the response (RFC 7230 3.3.3) */
if (reader == on_body_until_close)
client->_do_keepalive = 0;
}
/* call the callback. sock may be stealed */
client->bytes_to_consume = rlen;
client->super._cb.on_body =
client->super._cb.on_head(&client->super, is_eos ? h2o_httpclient_error_is_eos : NULL, version, http_status,
h2o_iovec_init(msg, msg_len), headers, num_headers, 1);
if (is_eos) {
close_client(client);
return;
} else if (client->super._cb.on_body == NULL) {
client->_do_keepalive = 0;
close_client(client);
return;
}
h2o_buffer_consume(&sock->input, client->bytes_to_consume);
client->bytes_to_consume = 0;
client->sock->bytes_read = client->sock->input->size;
client->super._timeout.cb = on_body_timeout;
h2o_socket_read_start(sock, reader);
reader(client->sock, 0);
#undef MAX_HEADERS
}
static void proceed_handshake(h2o_socket_t *sock, const char *err)
{
h2o_iovec_t first_input = {NULL};
int ret;
sock->_cb.write = NULL;
if (err != NULL) {
goto Complete;
}
if (sock->ssl->handshake.server.async_resumption.state == ASYNC_RESUMPTION_STATE_RECORD) {
if (sock->ssl->input.encrypted->size <= 1024) {
/* retain a copy of input if performing async resumption */
first_input = h2o_iovec_init(alloca(sock->ssl->input.encrypted->size), sock->ssl->input.encrypted->size);
memcpy(first_input.base, sock->ssl->input.encrypted->bytes, first_input.len);
} else {
sock->ssl->handshake.server.async_resumption.state = ASYNC_RESUMPTION_STATE_COMPLETE;
}
}
Redo:
if (SSL_is_server(sock->ssl->ssl)) {
ret = SSL_accept(sock->ssl->ssl);
} else {
ret = SSL_connect(sock->ssl->ssl);
}
switch (sock->ssl->handshake.server.async_resumption.state) {
case ASYNC_RESUMPTION_STATE_RECORD:
/* async resumption has not been triggered; proceed the state to complete */
sock->ssl->handshake.server.async_resumption.state = ASYNC_RESUMPTION_STATE_COMPLETE;
break;
case ASYNC_RESUMPTION_STATE_REQUEST_SENT: {
/* sent async request, reset the ssl state, and wait for async response */
assert(ret < 0);
SSL_CTX *ssl_ctx = SSL_get_SSL_CTX(sock->ssl->ssl);
SSL_free(sock->ssl->ssl);
create_ssl(sock, ssl_ctx);
clear_output_buffer(sock->ssl);
h2o_buffer_consume(&sock->ssl->input.encrypted, sock->ssl->input.encrypted->size);
h2o_buffer_reserve(&sock->ssl->input.encrypted, first_input.len);
memcpy(sock->ssl->input.encrypted->bytes, first_input.base, first_input.len);
sock->ssl->input.encrypted->size = first_input.len;
h2o_socket_read_stop(sock);
return;
}
default:
break;
}
if (ret == 0 || (ret < 0 && SSL_get_error(sock->ssl->ssl, ret) != SSL_ERROR_WANT_READ)) {
/* failed */
long verify_result = SSL_get_verify_result(sock->ssl->ssl);
if (verify_result != X509_V_OK) {
err = X509_verify_cert_error_string(verify_result);
} else {
err = "ssl handshake failure";
}
goto Complete;
}
if (sock->ssl->output.bufs.size != 0) {
h2o_socket_read_stop(sock);
flush_pending_ssl(sock, ret == 1 ? on_handshake_complete : proceed_handshake);
} else {
if (ret == 1) {
if (!SSL_is_server(sock->ssl->ssl)) {
X509 *cert = SSL_get_peer_certificate(sock->ssl->ssl);
if (cert != NULL) {
switch (validate_hostname(sock->ssl->handshake.client.server_name, cert)) {
case MatchFound:
/* ok */
break;
case MatchNotFound:
err = h2o_socket_error_ssl_cert_name_mismatch;
break;
default:
err = h2o_socket_error_ssl_cert_invalid;
break;
}
X509_free(cert);
} else {
err = h2o_socket_error_ssl_no_cert;
}
}
goto Complete;
}
if (sock->ssl->input.encrypted->size != 0)
goto Redo;
h2o_socket_read_start(sock, proceed_handshake);
}
return;
Complete:
h2o_socket_read_stop(sock);
on_handshake_complete(sock, err);
}
