static void shutdown_server(h2o_socket_t *listener, const char *err)
{
if (err)
ERROR(err);
else {
thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
event_loop,
listener->data);
ctx->global_data->shutdown = true;
// Close the listening sockets immediately, so that if another instance
// of the application is started before the current one exits (e.g. when
// doing an update), it will accept all incoming connections.
if (ctx->event_loop.h2o_https_socket) {
h2o_socket_read_stop(ctx->event_loop.h2o_https_socket);
h2o_socket_close(ctx->event_loop.h2o_https_socket);
ctx->event_loop.h2o_https_socket = NULL;
}
if (ctx->event_loop.h2o_socket) {
h2o_socket_read_stop(ctx->event_loop.h2o_socket);
h2o_socket_close(ctx->event_loop.h2o_socket);
ctx->event_loop.h2o_socket = NULL;
}
for (size_t i = ctx->config->thread_num - 1; i > 0; i--)
h2o_multithread_send_message(&ctx->global_thread_data[i].h2o_receiver, NULL);
}
}
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);
}
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);
}
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);
}
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 on_read(h2o_socket_t *sock, const char *err)
{
struct st_h2o_tunnel_t *tunnel = sock->data;
h2o_socket_t *dst;
assert(tunnel != NULL);
assert(tunnel->sock[0] == sock || tunnel->sock[1] == sock);
if (err != NULL) {
close_connection(tunnel);
return;
}
if (sock->bytes_read == 0)
return;
h2o_socket_read_stop(sock);
reset_timeout(tunnel);
if (tunnel->sock[0] == sock)
dst = tunnel->sock[1];
else
dst = tunnel->sock[0];
h2o_iovec_t buf;
buf.base = sock->input->bytes;
buf.len = sock->input->size;
h2o_socket_write(dst, &buf, 1, on_write_complete);
}
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 entity_read_send_error(struct st_h2o_http1_conn_t *conn, int status, 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;
h2o_send_error(&conn->req, status, reason, body, H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION);
}
static void entity_read_send_error(h2o_http1_conn_t *conn, int status, 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;
h2o_send_error(&conn->req, status, reason, body);
}
static h2o_socket_t *do_steal_socket(h2o_httpclient_t *_client)
{
struct st_h2o_http1client_t *client = (void *)_client;
h2o_socket_t *sock = client->sock;
h2o_socket_read_stop(sock);
h2o_buffer_consume(&sock->input, client->bytes_to_consume);
client->bytes_to_consume = 0;
client->sock = NULL;
return sock;
}
static void process_messages(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages)
{
IGNORE_FUNCTION_PARAMETER(messages);
thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
event_loop.h2o_receiver,
receiver);
h2o_socket_read_stop(ctx->event_loop.h2o_socket);
}
void h2o_multithread_destroy_queue(h2o_multithread_queue_t *queue)
{
assert(h2o_linklist_is_empty(&queue->receivers.active));
assert(h2o_linklist_is_empty(&queue->receivers.inactive));
#if H2O_USE_LIBUV
uv_close((uv_handle_t *)&queue->async, (void *)free);
#else
h2o_socket_read_stop(queue->async.read);
h2o_socket_close(queue->async.read);
close(queue->async.write);
#endif
pthread_mutex_destroy(&queue->mutex);
}
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 shutdown_server(h2o_socket_t *listener, const char *err)
{
if (!err) {
thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
event_loop,
listener->data);
ctx->global_data->shutdown = true;
h2o_socket_read_stop(ctx->event_loop.h2o_socket);
for (size_t i = 1; i < ctx->global_data->config->thread_num; i++)
h2o_multithread_send_message(&ctx[i].event_loop.h2o_receiver, NULL);
}
}
static void process_messages(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages)
{
IGNORE_FUNCTION_PARAMETER(messages);
global_thread_data_t * const global_thread_data = H2O_STRUCT_FROM_MEMBER(global_thread_data_t,
h2o_receiver,
receiver);
// Close the listening sockets immediately, so that if another instance of
// the application is started before the current one exits (e.g. when doing
// an update), it will accept all incoming connections.
if (global_thread_data->ctx->event_loop.h2o_https_socket) {
h2o_socket_read_stop(global_thread_data->ctx->event_loop.h2o_https_socket);
h2o_socket_close(global_thread_data->ctx->event_loop.h2o_https_socket);
global_thread_data->ctx->event_loop.h2o_https_socket = NULL;
}
if (global_thread_data->ctx->event_loop.h2o_socket) {
h2o_socket_read_stop(global_thread_data->ctx->event_loop.h2o_socket);
h2o_socket_close(global_thread_data->ctx->event_loop.h2o_socket);
global_thread_data->ctx->event_loop.h2o_socket = NULL;
}
}
void h2o_multithread_destroy_queue(h2o_multithread_queue_t *queue)
{
assert(h2o_linklist_is_empty(&queue->receivers.active));
assert(h2o_linklist_is_empty(&queue->receivers.inactive));
pthread_mutex_destroy(&queue->mutex);
#if H2O_USE_LIBUV
uv_close((uv_handle_t *)&queue->async, libuv_destroy_delayed);
#else
h2o_socket_read_stop(queue->async.read);
h2o_socket_close(queue->async.read);
#ifndef __linux__
/* only one file descriptor is required for eventfd and already closed by h2o_socket_close() */
close(queue->async.write);
#endif
free(queue);
#endif
}
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 void send_bad_request(struct st_h2o_http1_conn_t *conn)
{
h2o_socket_read_stop(conn->sock);
h2o_send_error_400(&conn->req, "Bad Request", "Bad Request", H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION);
}
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(&conn->req, 417, "Expectation Failed", "unknown expectation",
H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION);
return;
}
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);
}
if (create_entity_reader(conn, headers + entity_body_header_index) != 0) {
return;
}
if (expect.base != NULL) {
/* 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) {
// request is too long (TODO notify)
close_connection(conn, 1);
}
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;
}
}
close_connection(conn, 1);
return;
}
}
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);
}
