diff options
Diffstat (limited to 'debian/vendor-h2o/lib/common/socket.c')
| -rw-r--r-- | debian/vendor-h2o/lib/common/socket.c | 1448 |
1 files changed, 0 insertions, 1448 deletions
diff --git a/debian/vendor-h2o/lib/common/socket.c b/debian/vendor-h2o/lib/common/socket.c deleted file mode 100644 index 2572233..0000000 --- a/debian/vendor-h2o/lib/common/socket.c +++ /dev/null @@ -1,1448 +0,0 @@ -/* - * Copyright (c) 2015 DeNA Co., Ltd., Kazuho Oku, Justin Zhu - * - * 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 <errno.h> -#include <fcntl.h> -#include <inttypes.h> -#include <limits.h> -#include <netdb.h> -#include <netinet/in.h> -#include <netinet/tcp.h> -#include <string.h> -#include <sys/un.h> -#include <unistd.h> -#include <openssl/err.h> -#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) -#include <sys/ioctl.h> -#endif -#if H2O_USE_PICOTLS -#include "picotls.h" -#endif -#include "h2o/socket.h" -#include "h2o/timeout.h" - -#if defined(__APPLE__) && defined(__clang__) -#pragma clang diagnostic ignored "-Wdeprecated-declarations" -#endif - -#ifndef IOV_MAX -#define IOV_MAX UIO_MAXIOV -#endif - -/* kernel-headers bundled with Ubuntu 14.04 does not have the constant defined in netinet/tcp.h */ -#if defined(__linux__) && !defined(TCP_NOTSENT_LOWAT) -#define TCP_NOTSENT_LOWAT 25 -#endif - -#define OPENSSL_HOSTNAME_VALIDATION_LINKAGE static -#include "../../deps/ssl-conservatory/openssl/openssl_hostname_validation.c" - -struct st_h2o_socket_ssl_t { - SSL_CTX *ssl_ctx; - SSL *ossl; -#if H2O_USE_PICOTLS - ptls_t *ptls; -#endif - int *did_write_in_read; /* used for detecting and closing the connection upon renegotiation (FIXME implement renegotiation) */ - size_t record_overhead; - struct { - h2o_socket_cb cb; - union { - struct { - struct { - enum { - ASYNC_RESUMPTION_STATE_COMPLETE = 0, /* just pass thru */ - ASYNC_RESUMPTION_STATE_RECORD, /* record first input, restore SSL state if it changes to REQUEST_SENT - */ - ASYNC_RESUMPTION_STATE_REQUEST_SENT /* async request has been sent, and is waiting for response */ - } state; - SSL_SESSION *session_data; - } async_resumption; - } server; - struct { - char *server_name; - h2o_cache_t *session_cache; - h2o_iovec_t session_cache_key; - h2o_cache_hashcode_t session_cache_key_hash; - } client; - }; - } handshake; - struct { - h2o_buffer_t *encrypted; - } input; - struct { - H2O_VECTOR(h2o_iovec_t) bufs; - h2o_mem_pool_t pool; /* placed at the last */ - } output; -}; - -struct st_h2o_ssl_context_t { - SSL_CTX *ctx; - const h2o_iovec_t *protocols; - h2o_iovec_t _npn_list_of_protocols; -}; - -/* backend functions */ -static void do_dispose_socket(h2o_socket_t *sock); -static void do_write(h2o_socket_t *sock, h2o_iovec_t *bufs, size_t bufcnt, h2o_socket_cb cb); -static void do_read_start(h2o_socket_t *sock); -static void do_read_stop(h2o_socket_t *sock); -static int do_export(h2o_socket_t *_sock, h2o_socket_export_t *info); -static h2o_socket_t *do_import(h2o_loop_t *loop, h2o_socket_export_t *info); -static socklen_t get_peername_uncached(h2o_socket_t *sock, struct sockaddr *sa); - -/* internal functions called from the backend */ -static const char *decode_ssl_input(h2o_socket_t *sock); -static void on_write_complete(h2o_socket_t *sock, const char *err); - -#if H2O_USE_LIBUV -#include "socket/uv-binding.c.h" -#else -#include "socket/evloop.c.h" -#endif - -h2o_buffer_mmap_settings_t h2o_socket_buffer_mmap_settings = { - 32 * 1024 * 1024, /* 32MB, should better be greater than max frame size of HTTP2 for performance reasons */ - "/tmp/h2o.b.XXXXXX"}; - -__thread h2o_buffer_prototype_t h2o_socket_buffer_prototype = { - {16}, /* keep 16 recently used chunks */ - {H2O_SOCKET_INITIAL_INPUT_BUFFER_SIZE * 2}, /* minimum initial capacity */ - &h2o_socket_buffer_mmap_settings}; - -const char *h2o_socket_error_out_of_memory = "out of memory"; -const char *h2o_socket_error_io = "I/O error"; -const char *h2o_socket_error_closed = "socket closed by peer"; -const char *h2o_socket_error_conn_fail = "connection failure"; -const char *h2o_socket_error_ssl_no_cert = "no certificate"; -const char *h2o_socket_error_ssl_cert_invalid = "invalid certificate"; -const char *h2o_socket_error_ssl_cert_name_mismatch = "certificate name mismatch"; -const char *h2o_socket_error_ssl_decode = "SSL decode error"; - -static void (*resumption_get_async)(h2o_socket_t *sock, h2o_iovec_t session_id); -static void (*resumption_new)(h2o_iovec_t session_id, h2o_iovec_t session_data); - -static int read_bio(BIO *b, char *out, int len) -{ - h2o_socket_t *sock = BIO_get_data(b); - - if (len == 0) - return 0; - - if (sock->ssl->input.encrypted->size == 0) { - BIO_set_retry_read(b); - return -1; - } - - if (sock->ssl->input.encrypted->size < len) { - len = (int)sock->ssl->input.encrypted->size; - } - memcpy(out, sock->ssl->input.encrypted->bytes, len); - h2o_buffer_consume(&sock->ssl->input.encrypted, len); - - return len; -} - -static void write_ssl_bytes(h2o_socket_t *sock, const void *in, size_t len) -{ - if (len != 0) { - void *bytes_alloced = h2o_mem_alloc_pool(&sock->ssl->output.pool, len); - memcpy(bytes_alloced, in, len); - h2o_vector_reserve(&sock->ssl->output.pool, &sock->ssl->output.bufs, sock->ssl->output.bufs.size + 1); - sock->ssl->output.bufs.entries[sock->ssl->output.bufs.size++] = h2o_iovec_init(bytes_alloced, len); - } -} - -static int write_bio(BIO *b, const char *in, int len) -{ - h2o_socket_t *sock = BIO_get_data(b); - - /* FIXME no support for SSL renegotiation (yet) */ - if (sock->ssl->did_write_in_read != NULL) { - *sock->ssl->did_write_in_read = 1; - return -1; - } - - write_ssl_bytes(sock, in, len); - return len; -} - -static int puts_bio(BIO *b, const char *str) -{ - return write_bio(b, str, (int)strlen(str)); -} - -static long ctrl_bio(BIO *b, int cmd, long num, void *ptr) -{ - switch (cmd) { - case BIO_CTRL_GET_CLOSE: - return BIO_get_shutdown(b); - case BIO_CTRL_SET_CLOSE: - BIO_set_shutdown(b, (int)num); - return 1; - case BIO_CTRL_FLUSH: - return 1; - default: - return 0; - } -} - -static void setup_bio(h2o_socket_t *sock) -{ - static BIO_METHOD *bio_methods = NULL; - if (bio_methods == NULL) { - static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER; - pthread_mutex_lock(&init_lock); - if (bio_methods == NULL) { - BIO_METHOD *biom = BIO_meth_new(BIO_TYPE_FD, "h2o_socket"); - BIO_meth_set_write(biom, write_bio); - BIO_meth_set_read(biom, read_bio); - BIO_meth_set_puts(biom, puts_bio); - BIO_meth_set_ctrl(biom, ctrl_bio); - __sync_synchronize(); - bio_methods = biom; - } - pthread_mutex_unlock(&init_lock); - } - - BIO *bio = BIO_new(bio_methods); - if (bio == NULL) - h2o_fatal("no memory"); - BIO_set_data(bio, sock); - BIO_set_init(bio, 1); - SSL_set_bio(sock->ssl->ossl, bio, bio); -} - -const char *decode_ssl_input(h2o_socket_t *sock) -{ - assert(sock->ssl != NULL); - assert(sock->ssl->handshake.cb == NULL); - -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - if (sock->ssl->input.encrypted->size != 0) { - const char *src = sock->ssl->input.encrypted->bytes, *src_end = src + sock->ssl->input.encrypted->size; - h2o_iovec_t reserved; - ptls_buffer_t rbuf; - int ret; - if ((reserved = h2o_buffer_reserve(&sock->input, sock->ssl->input.encrypted->size)).base == NULL) - return h2o_socket_error_out_of_memory; - ptls_buffer_init(&rbuf, reserved.base, reserved.len); - do { - size_t consumed = src_end - src; - if ((ret = ptls_receive(sock->ssl->ptls, &rbuf, src, &consumed)) != 0) - break; - src += consumed; - } while (src != src_end); - h2o_buffer_consume(&sock->ssl->input.encrypted, sock->ssl->input.encrypted->size - (src_end - src)); - if (rbuf.is_allocated) { - if ((reserved = h2o_buffer_reserve(&sock->input, rbuf.off)).base == NULL) - return h2o_socket_error_out_of_memory; - memcpy(reserved.base, rbuf.base, rbuf.off); - sock->input->size += rbuf.off; - ptls_buffer_dispose(&rbuf); - } else { - sock->input->size += rbuf.off; - } - if (!(ret == 0 || ret == PTLS_ERROR_IN_PROGRESS)) - return h2o_socket_error_ssl_decode; - } - return NULL; - } -#endif - - while (sock->ssl->input.encrypted->size != 0 || SSL_pending(sock->ssl->ossl)) { - int rlen; - h2o_iovec_t buf = h2o_buffer_reserve(&sock->input, 4096); - if (buf.base == NULL) - return h2o_socket_error_out_of_memory; - { /* call SSL_read (while detecting SSL renegotiation and reporting it as error) */ - int did_write_in_read = 0; - sock->ssl->did_write_in_read = &did_write_in_read; - ERR_clear_error(); - rlen = SSL_read(sock->ssl->ossl, buf.base, (int)buf.len); - sock->ssl->did_write_in_read = NULL; - if (did_write_in_read) - return "ssl renegotiation not supported"; - } - if (rlen == -1) { - if (SSL_get_error(sock->ssl->ossl, rlen) != SSL_ERROR_WANT_READ) { - return h2o_socket_error_ssl_decode; - } - break; - } else if (rlen == 0) { - break; - } else { - sock->input->size += rlen; - } - } - - return 0; -} - -static void flush_pending_ssl(h2o_socket_t *sock, h2o_socket_cb cb) -{ - do_write(sock, sock->ssl->output.bufs.entries, sock->ssl->output.bufs.size, cb); -} - -static void clear_output_buffer(struct st_h2o_socket_ssl_t *ssl) -{ - memset(&ssl->output.bufs, 0, sizeof(ssl->output.bufs)); - h2o_mem_clear_pool(&ssl->output.pool); -} - -static void destroy_ssl(struct st_h2o_socket_ssl_t *ssl) -{ -#if H2O_USE_PICOTLS - if (ssl->ptls != NULL) { - ptls_free(ssl->ptls); - ssl->ptls = NULL; - } -#endif - if (ssl->ossl != NULL) { - if (!SSL_is_server(ssl->ossl)) { - free(ssl->handshake.client.server_name); - free(ssl->handshake.client.session_cache_key.base); - } - SSL_free(ssl->ossl); - ssl->ossl = NULL; - } - h2o_buffer_dispose(&ssl->input.encrypted); - clear_output_buffer(ssl); - free(ssl); -} - -static void dispose_socket(h2o_socket_t *sock, const char *err) -{ - void (*close_cb)(void *data); - void *close_cb_data; - - if (sock->ssl != NULL) { - destroy_ssl(sock->ssl); - sock->ssl = NULL; - } - h2o_buffer_dispose(&sock->input); - if (sock->_peername != NULL) { - free(sock->_peername); - sock->_peername = NULL; - } - - close_cb = sock->on_close.cb; - close_cb_data = sock->on_close.data; - - do_dispose_socket(sock); - - if (close_cb != NULL) - close_cb(close_cb_data); -} - -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 H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - ptls_buffer_t wbuf; - uint8_t wbuf_small[32]; - ptls_buffer_init(&wbuf, wbuf_small, sizeof(wbuf_small)); - if ((ret = ptls_send_alert(sock->ssl->ptls, &wbuf, PTLS_ALERT_LEVEL_WARNING, PTLS_ALERT_CLOSE_NOTIFY)) != 0) - goto Close; - write_ssl_bytes(sock, wbuf.base, wbuf.off); - ptls_buffer_dispose(&wbuf); - ret = 1; /* close the socket after sending close_notify */ - } else -#endif - if (sock->ssl->ossl != NULL) { - ERR_clear_error(); - if ((ret = SSL_shutdown(sock->ssl->ossl)) == -1) - goto Close; - } else { - 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->ossl, ret) == SSL_ERROR_WANT_READ) { - h2o_socket_read_start(sock, shutdown_ssl); - } else { - goto Close; - } - - return; -Close: - dispose_socket(sock, err); -} - -void h2o_socket_dispose_export(h2o_socket_export_t *info) -{ - assert(info->fd != -1); - if (info->ssl != NULL) { - destroy_ssl(info->ssl); - info->ssl = NULL; - } - h2o_buffer_dispose(&info->input); - close(info->fd); - info->fd = -1; -} - -int h2o_socket_export(h2o_socket_t *sock, h2o_socket_export_t *info) -{ - static h2o_buffer_prototype_t nonpooling_prototype; - - assert(!h2o_socket_is_writing(sock)); - - if (do_export(sock, info) == -1) - return -1; - - if ((info->ssl = sock->ssl) != NULL) { - sock->ssl = NULL; - h2o_buffer_set_prototype(&info->ssl->input.encrypted, &nonpooling_prototype); - } - info->input = sock->input; - h2o_buffer_set_prototype(&info->input, &nonpooling_prototype); - h2o_buffer_init(&sock->input, &h2o_socket_buffer_prototype); - - h2o_socket_close(sock); - - return 0; -} - -h2o_socket_t *h2o_socket_import(h2o_loop_t *loop, h2o_socket_export_t *info) -{ - h2o_socket_t *sock; - - assert(info->fd != -1); - - sock = do_import(loop, info); - info->fd = -1; /* just in case */ - if ((sock->ssl = info->ssl) != NULL) { - setup_bio(sock); - h2o_buffer_set_prototype(&sock->ssl->input.encrypted, &h2o_socket_buffer_prototype); - } - sock->input = info->input; - h2o_buffer_set_prototype(&sock->input, &h2o_socket_buffer_prototype); - return sock; -} - -void h2o_socket_close(h2o_socket_t *sock) -{ - if (sock->ssl == NULL) { - dispose_socket(sock, 0); - } else { - shutdown_ssl(sock, 0); - } -} - -static uint16_t calc_suggested_tls_payload_size(h2o_socket_t *sock, uint16_t suggested_tls_record_size) -{ - uint16_t ps = suggested_tls_record_size; - if (sock->ssl != NULL && sock->ssl->record_overhead < ps) - ps -= sock->ssl->record_overhead; - return ps; -} - -static void disable_latency_optimized_write(h2o_socket_t *sock, int (*adjust_notsent_lowat)(h2o_socket_t *, unsigned)) -{ - if (sock->_latency_optimization.notsent_is_minimized) { - adjust_notsent_lowat(sock, 0); - sock->_latency_optimization.notsent_is_minimized = 0; - } - sock->_latency_optimization.state = H2O_SOCKET_LATENCY_OPTIMIZATION_STATE_DISABLED; - sock->_latency_optimization.suggested_tls_payload_size = 16384; - sock->_latency_optimization.suggested_write_size = SIZE_MAX; -} - -static inline void prepare_for_latency_optimized_write(h2o_socket_t *sock, - const h2o_socket_latency_optimization_conditions_t *conditions, uint32_t rtt, - uint32_t mss, uint32_t cwnd_size, uint32_t cwnd_avail, uint64_t loop_time, - int (*adjust_notsent_lowat)(h2o_socket_t *, unsigned)) -{ - /* check RTT */ - if (rtt < conditions->min_rtt * (uint64_t)1000) - goto Disable; - if (rtt * conditions->max_additional_delay < loop_time * 1000 * 100) - goto Disable; - - /* latency-optimization is enabled */ - sock->_latency_optimization.state = H2O_SOCKET_LATENCY_OPTIMIZATION_STATE_DETERMINED; - - /* no need to: - * 1) adjust the write size if single_write_size << cwnd_size - * 2) align TLS record boundary to TCP packet boundary if packet loss-rate is low and BW isn't small (implied by cwnd size) - */ - if (mss * cwnd_size < conditions->max_cwnd) { - if (!sock->_latency_optimization.notsent_is_minimized) { - if (adjust_notsent_lowat(sock, 1 /* cannot be set to zero on Linux */) != 0) - goto Disable; - sock->_latency_optimization.notsent_is_minimized = 1; - } - sock->_latency_optimization.suggested_tls_payload_size = calc_suggested_tls_payload_size(sock, mss); - sock->_latency_optimization.suggested_write_size = - cwnd_avail * (size_t)sock->_latency_optimization.suggested_tls_payload_size; - } else { - if (sock->_latency_optimization.notsent_is_minimized) { - if (adjust_notsent_lowat(sock, 0) != 0) - goto Disable; - sock->_latency_optimization.notsent_is_minimized = 0; - } - sock->_latency_optimization.suggested_tls_payload_size = 16384; - sock->_latency_optimization.suggested_write_size = SIZE_MAX; - } - return; - -Disable: - disable_latency_optimized_write(sock, adjust_notsent_lowat); -} - -/** - * Obtains RTT, MSS, size of CWND (in the number of packets). - * Also writes to cwnd_avail minimum number of packets (of MSS size) sufficient to shut up poll-for-write under the precondition - * that TCP_NOTSENT_LOWAT is set to 1. - */ -static int obtain_tcp_info(int fd, uint32_t *rtt, uint32_t *mss, uint32_t *cwnd_size, uint32_t *cwnd_avail) -{ -#define CALC_CWND_PAIR_FROM_BYTE_UNITS(cwnd_bytes, inflight_bytes) \ - do { \ - *cwnd_size = (cwnd_bytes + *mss / 2) / *mss; \ - *cwnd_avail = cwnd_bytes > inflight_bytes ? (cwnd_bytes - inflight_bytes) / *mss + 2 : 2; \ - } while (0) - -#if defined(__linux__) && defined(TCP_INFO) - - struct tcp_info tcpi; - socklen_t tcpisz = sizeof(tcpi); - if (getsockopt(fd, IPPROTO_TCP, TCP_INFO, &tcpi, &tcpisz) != 0) - return -1; - *rtt = tcpi.tcpi_rtt; - *mss = tcpi.tcpi_snd_mss; - *cwnd_size = tcpi.tcpi_snd_cwnd; - *cwnd_avail = tcpi.tcpi_snd_cwnd > tcpi.tcpi_unacked ? tcpi.tcpi_snd_cwnd - tcpi.tcpi_unacked + 2 : 2; - return 0; - -#elif defined(__FreeBSD__) && defined(TCP_INFO) && 0 /* disabled since we wouldn't use it anyways; OS lacks TCP_NOTSENT_LOWAT */ - - struct tcp_info tcpi; - socklen_t tcpisz = sizeof(tcpi); - int bytes_inflight; - if (getsockopt(fd, IPPROTO_TCP, TCP_INFO, &tcpi, &tcpisz) != 0 || ioctl(fd, FIONWRITE, &bytes_inflight) == -1) - return -1; - *rtt = tcpi.tcpi_rtt; - *mss = tcpi.tcpi_snd_mss; - CALC_CWND_PAIR_FROM_BYTE_UNITS(tcpi.tcpi_snd_cwnd, bytes_inflight); - return 0; - -#elif defined(__APPLE__) && defined(TCP_CONNECTION_INFO) - - struct tcp_connection_info tcpi; - socklen_t tcpisz = sizeof(tcpi); - if (getsockopt(fd, IPPROTO_TCP, TCP_CONNECTION_INFO, &tcpi, &tcpisz) != 0 || tcpi.tcpi_maxseg == 0) - return -1; - *rtt = tcpi.tcpi_srtt * 1000; - *mss = tcpi.tcpi_maxseg; - CALC_CWND_PAIR_FROM_BYTE_UNITS(tcpi.tcpi_snd_cwnd, tcpi.tcpi_snd_sbbytes); - return 0; - -#else - /* TODO add support for NetBSD; note that the OS returns the number of packets for tcpi_snd_cwnd; see - * http://twitter.com/n_soda/status/740719125878575105 - */ - return -1; -#endif - -#undef CALC_CWND_PAIR_FROM_BYTE_UNITS -} - -#ifdef TCP_NOTSENT_LOWAT -static int adjust_notsent_lowat(h2o_socket_t *sock, unsigned notsent_lowat) -{ - return setsockopt(h2o_socket_get_fd(sock), IPPROTO_TCP, TCP_NOTSENT_LOWAT, ¬sent_lowat, sizeof(notsent_lowat)); -} -#else -#define adjust_notsent_lowat NULL -#endif - -size_t h2o_socket_do_prepare_for_latency_optimized_write(h2o_socket_t *sock, - const h2o_socket_latency_optimization_conditions_t *conditions) -{ - uint32_t rtt = 0, mss = 0, cwnd_size = 0, cwnd_avail = 0; - uint64_t loop_time = UINT64_MAX; - int can_prepare = 1; - -#if !defined(TCP_NOTSENT_LOWAT) - /* the feature cannot be setup unless TCP_NOTSENT_LOWAT is available */ - can_prepare = 0; -#endif - -#if H2O_USE_LIBUV - /* poll-then-write is impossible with libuv */ - can_prepare = 0; -#else - if (can_prepare) - loop_time = h2o_evloop_get_execution_time(h2o_socket_get_loop(sock)); -#endif - - /* obtain TCP states */ - if (can_prepare && obtain_tcp_info(h2o_socket_get_fd(sock), &rtt, &mss, &cwnd_size, &cwnd_avail) != 0) - can_prepare = 0; - - /* determine suggested_write_size, suggested_tls_record_size and adjust TCP_NOTSENT_LOWAT based on the obtained information */ - if (can_prepare) { - prepare_for_latency_optimized_write(sock, conditions, rtt, mss, cwnd_size, cwnd_avail, loop_time, adjust_notsent_lowat); - } else { - disable_latency_optimized_write(sock, adjust_notsent_lowat); - } - - return sock->_latency_optimization.suggested_write_size; - -#undef CALC_CWND_PAIR_FROM_BYTE_UNITS -} - -void h2o_socket_write(h2o_socket_t *sock, h2o_iovec_t *bufs, size_t bufcnt, h2o_socket_cb cb) -{ - size_t i, prev_bytes_written = sock->bytes_written; - - for (i = 0; i != bufcnt; ++i) { - sock->bytes_written += bufs[i].len; -#if H2O_SOCKET_DUMP_WRITE - fprintf(stderr, "writing %zu bytes to fd:%d\n", bufs[i].len, h2o_socket_get_fd(sock)); - h2o_dump_memory(stderr, bufs[i].base, bufs[i].len); -#endif - } - - if (sock->ssl == NULL) { - do_write(sock, bufs, bufcnt, cb); - } else { - assert(sock->ssl->output.bufs.size == 0); - /* fill in the data */ - size_t ssl_record_size; - switch (sock->_latency_optimization.state) { - case H2O_SOCKET_LATENCY_OPTIMIZATION_STATE_TBD: - case H2O_SOCKET_LATENCY_OPTIMIZATION_STATE_DISABLED: - ssl_record_size = prev_bytes_written < 200 * 1024 ? calc_suggested_tls_payload_size(sock, 1400) : 16384; - break; - case H2O_SOCKET_LATENCY_OPTIMIZATION_STATE_DETERMINED: - sock->_latency_optimization.state = H2O_SOCKET_LATENCY_OPTIMIZATION_STATE_NEEDS_UPDATE; - /* fallthru */ - default: - ssl_record_size = sock->_latency_optimization.suggested_tls_payload_size; - break; - } - for (; bufcnt != 0; ++bufs, --bufcnt) { - size_t off = 0; - while (off != bufs[0].len) { - int ret; - size_t sz = bufs[0].len - off; - if (sz > ssl_record_size) - sz = ssl_record_size; -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - size_t dst_size = sz + ptls_get_record_overhead(sock->ssl->ptls); - void *dst = h2o_mem_alloc_pool(&sock->ssl->output.pool, dst_size); - ptls_buffer_t wbuf; - ptls_buffer_init(&wbuf, dst, dst_size); - ret = ptls_send(sock->ssl->ptls, &wbuf, bufs[0].base + off, sz); - assert(ret == 0); - assert(!wbuf.is_allocated); - h2o_vector_reserve(&sock->ssl->output.pool, &sock->ssl->output.bufs, sock->ssl->output.bufs.size + 1); - sock->ssl->output.bufs.entries[sock->ssl->output.bufs.size++] = h2o_iovec_init(dst, wbuf.off); - } else -#endif - { - ret = SSL_write(sock->ssl->ossl, bufs[0].base + off, (int)sz); - if (ret != sz) { - /* The error happens if SSL_write is called after SSL_read returns a fatal error (e.g. due to corrupt TCP - * packet being received). We need to take care of this since some protocol implementations send data after - * the read-side of the connection gets closed (note that protocol implementations are (yet) incapable of - * distinguishing a normal shutdown and close due to an error using the `status` value of the read - * callback). - */ - clear_output_buffer(sock->ssl); - flush_pending_ssl(sock, cb); -#ifndef H2O_USE_LIBUV - ((struct st_h2o_evloop_socket_t *)sock)->_flags |= H2O_SOCKET_FLAG_IS_WRITE_ERROR; -#endif - return; - } - } - off += sz; - } - } - flush_pending_ssl(sock, cb); - } -} - -void on_write_complete(h2o_socket_t *sock, const char *err) -{ - h2o_socket_cb cb; - - if (sock->ssl != NULL) - clear_output_buffer(sock->ssl); - - cb = sock->_cb.write; - sock->_cb.write = NULL; - cb(sock, err); -} - -void h2o_socket_read_start(h2o_socket_t *sock, h2o_socket_cb cb) -{ - sock->_cb.read = cb; - do_read_start(sock); -} - -void h2o_socket_read_stop(h2o_socket_t *sock) -{ - sock->_cb.read = NULL; - do_read_stop(sock); -} - -void h2o_socket_setpeername(h2o_socket_t *sock, struct sockaddr *sa, socklen_t len) -{ - if (sock->_peername != NULL) - free(sock->_peername); - sock->_peername = h2o_mem_alloc(offsetof(struct st_h2o_socket_peername_t, addr) + len); - sock->_peername->len = len; - memcpy(&sock->_peername->addr, sa, len); -} - -socklen_t h2o_socket_getpeername(h2o_socket_t *sock, struct sockaddr *sa) -{ - /* return cached, if exists */ - if (sock->_peername != NULL) { - memcpy(sa, &sock->_peername->addr, sock->_peername->len); - return sock->_peername->len; - } - /* call, copy to cache, and return */ - socklen_t len = get_peername_uncached(sock, sa); - h2o_socket_setpeername(sock, sa, len); - return len; -} - -const char *h2o_socket_get_ssl_protocol_version(h2o_socket_t *sock) -{ - if (sock->ssl != NULL) { -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) - return "TLSv1.3"; -#endif - if (sock->ssl->ossl != NULL) - return SSL_get_version(sock->ssl->ossl); - } - return NULL; -} - -int h2o_socket_get_ssl_session_reused(h2o_socket_t *sock) -{ - if (sock->ssl != NULL) { -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) - return ptls_is_psk_handshake(sock->ssl->ptls); -#endif - if (sock->ssl->ossl != NULL) - return (int)SSL_session_reused(sock->ssl->ossl); - } - return -1; -} - -const char *h2o_socket_get_ssl_cipher(h2o_socket_t *sock) -{ - if (sock->ssl != NULL) { -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - ptls_cipher_suite_t *cipher = ptls_get_cipher(sock->ssl->ptls); - if (cipher != NULL) - return cipher->aead->name; - } else -#endif - if (sock->ssl->ossl != NULL) - return SSL_get_cipher_name(sock->ssl->ossl); - } - return NULL; -} - -int h2o_socket_get_ssl_cipher_bits(h2o_socket_t *sock) -{ - if (sock->ssl != NULL) { -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - ptls_cipher_suite_t *cipher = ptls_get_cipher(sock->ssl->ptls); - if (cipher == NULL) - return 0; - return (int)cipher->aead->key_size; - } else -#endif - if (sock->ssl->ossl != NULL) - return SSL_get_cipher_bits(sock->ssl->ossl, NULL); - } - return 0; -} - -h2o_iovec_t h2o_socket_get_ssl_session_id(h2o_socket_t *sock) -{ - if (sock->ssl != NULL) { -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - /* FIXME */ - } else -#endif - if (sock->ssl->ossl != NULL) { - SSL_SESSION *session; - if (sock->ssl->handshake.server.async_resumption.state == ASYNC_RESUMPTION_STATE_COMPLETE && - (session = SSL_get_session(sock->ssl->ossl)) != NULL) { - unsigned id_len; - const unsigned char *id = SSL_SESSION_get_id(session, &id_len); - return h2o_iovec_init(id, id_len); - } - } - } - - return h2o_iovec_init(NULL, 0); -} - -const char *h2o_socket_get_ssl_server_name(const h2o_socket_t *sock) -{ - if (sock->ssl != NULL) { -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - return ptls_get_server_name(sock->ssl->ptls); - } else -#endif - if (sock->ssl->ossl != NULL) { - return SSL_get_servername(sock->ssl->ossl, TLSEXT_NAMETYPE_host_name); - } - } - return NULL; -} - -h2o_iovec_t h2o_socket_log_ssl_session_id(h2o_socket_t *sock, h2o_mem_pool_t *pool) -{ - h2o_iovec_t base64id, rawid = h2o_socket_get_ssl_session_id(sock); - - if (rawid.base == NULL) - return h2o_iovec_init(NULL, 0); - - base64id.base = pool != NULL ? h2o_mem_alloc_pool(pool, h2o_base64_encode_capacity(rawid.len)) - : h2o_mem_alloc(h2o_base64_encode_capacity(rawid.len)); - base64id.len = h2o_base64_encode(base64id.base, rawid.base, rawid.len, 1); - return base64id; -} - -h2o_iovec_t h2o_socket_log_ssl_cipher_bits(h2o_socket_t *sock, h2o_mem_pool_t *pool) -{ - int bits = h2o_socket_get_ssl_cipher_bits(sock); - if (bits != 0) { - char *s = (char *)(pool != NULL ? h2o_mem_alloc_pool(pool, sizeof(H2O_INT16_LONGEST_STR)) - : h2o_mem_alloc(sizeof(H2O_INT16_LONGEST_STR))); - size_t len = sprintf(s, "%" PRId16, (int16_t)bits); - return h2o_iovec_init(s, len); - } else { - return h2o_iovec_init(NULL, 0); - } -} - -int h2o_socket_compare_address(struct sockaddr *x, struct sockaddr *y) -{ -#define CMP(a, b) \ - if (a != b) \ - return a < b ? -1 : 1 - - CMP(x->sa_family, y->sa_family); - - if (x->sa_family == AF_UNIX) { - struct sockaddr_un *xun = (void *)x, *yun = (void *)y; - int r = strcmp(xun->sun_path, yun->sun_path); - if (r != 0) - return r; - } else if (x->sa_family == AF_INET) { - struct sockaddr_in *xin = (void *)x, *yin = (void *)y; - CMP(ntohl(xin->sin_addr.s_addr), ntohl(yin->sin_addr.s_addr)); - CMP(ntohs(xin->sin_port), ntohs(yin->sin_port)); - } else if (x->sa_family == AF_INET6) { - struct sockaddr_in6 *xin6 = (void *)x, *yin6 = (void *)y; - int r = memcmp(xin6->sin6_addr.s6_addr, yin6->sin6_addr.s6_addr, sizeof(xin6->sin6_addr.s6_addr)); - if (r != 0) - return r; - CMP(ntohs(xin6->sin6_port), ntohs(yin6->sin6_port)); - CMP(xin6->sin6_flowinfo, yin6->sin6_flowinfo); - CMP(xin6->sin6_scope_id, yin6->sin6_scope_id); - } else { - assert(!"unknown sa_family"); - } - -#undef CMP - return 0; -} - -size_t h2o_socket_getnumerichost(struct sockaddr *sa, socklen_t salen, char *buf) -{ - if (sa->sa_family == AF_INET) { - /* fast path for IPv4 addresses */ - struct sockaddr_in *sin = (void *)sa; - uint32_t addr; - addr = htonl(sin->sin_addr.s_addr); - return sprintf(buf, "%d.%d.%d.%d", addr >> 24, (addr >> 16) & 255, (addr >> 8) & 255, addr & 255); - } - - if (getnameinfo(sa, salen, buf, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) != 0) - return SIZE_MAX; - return strlen(buf); -} - -int32_t h2o_socket_getport(struct sockaddr *sa) -{ - switch (sa->sa_family) { - case AF_INET: - return htons(((struct sockaddr_in *)sa)->sin_port); - case AF_INET6: - return htons(((struct sockaddr_in6 *)sa)->sin6_port); - default: - return -1; - } -} - -static void create_ossl(h2o_socket_t *sock) -{ - sock->ssl->ossl = SSL_new(sock->ssl->ssl_ctx); - setup_bio(sock); -} - -static SSL_SESSION *on_async_resumption_get(SSL *ssl, -#if OPENSSL_VERSION_NUMBER >= 0x1010000fL && !defined(LIBRESSL_VERSION_NUMBER) - const -#endif - unsigned char *data, - int len, int *copy) -{ - h2o_socket_t *sock = BIO_get_data(SSL_get_rbio(ssl)); - - switch (sock->ssl->handshake.server.async_resumption.state) { - case ASYNC_RESUMPTION_STATE_RECORD: - sock->ssl->handshake.server.async_resumption.state = ASYNC_RESUMPTION_STATE_REQUEST_SENT; - resumption_get_async(sock, h2o_iovec_init(data, len)); - return NULL; - case ASYNC_RESUMPTION_STATE_COMPLETE: - *copy = 1; - return sock->ssl->handshake.server.async_resumption.session_data; - default: - assert(!"FIXME"); - return NULL; - } -} - -static int on_async_resumption_new(SSL *ssl, SSL_SESSION *session) -{ - h2o_iovec_t data; - const unsigned char *id; - unsigned id_len; - unsigned char *p; - - /* build data */ - data.len = i2d_SSL_SESSION(session, NULL); - data.base = alloca(data.len); - p = (void *)data.base; - i2d_SSL_SESSION(session, &p); - - id = SSL_SESSION_get_id(session, &id_len); - resumption_new(h2o_iovec_init(id, id_len), data); - return 0; -} - -static void on_handshake_complete(h2o_socket_t *sock, const char *err) -{ - if (err == NULL) { -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - sock->ssl->record_overhead = ptls_get_record_overhead(sock->ssl->ptls); - } else -#endif - { - const SSL_CIPHER *cipher = SSL_get_current_cipher(sock->ssl->ossl); - switch (SSL_CIPHER_get_id(cipher)) { - case TLS1_CK_RSA_WITH_AES_128_GCM_SHA256: - case TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256: - case TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256: - case TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: - case TLS1_CK_RSA_WITH_AES_256_GCM_SHA384: - case TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384: - case TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384: - case TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: - sock->ssl->record_overhead = 5 /* header */ + 8 /* record_iv_length (RFC 5288 3) */ + 16 /* tag (RFC 5116 5.1) */; - break; -#if defined(TLS1_CK_DHE_RSA_CHACHA20_POLY1305) - case TLS1_CK_DHE_RSA_CHACHA20_POLY1305: - case TLS1_CK_ECDHE_RSA_CHACHA20_POLY1305: - case TLS1_CK_ECDHE_ECDSA_CHACHA20_POLY1305: - sock->ssl->record_overhead = 5 /* header */ + 16 /* tag */; - break; -#endif - default: - sock->ssl->record_overhead = 32; /* sufficiently large number that can hold most payloads */ - break; - } - } - } - - /* set ssl session into the cache */ - if (sock->ssl->ossl != NULL && !SSL_is_server(sock->ssl->ossl) && sock->ssl->handshake.client.session_cache != NULL) { - if (err == NULL || err == h2o_socket_error_ssl_cert_name_mismatch) { - SSL_SESSION *session = SSL_get1_session(sock->ssl->ossl); - h2o_cache_set(sock->ssl->handshake.client.session_cache, h2o_now(h2o_socket_get_loop(sock)), - sock->ssl->handshake.client.session_cache_key, sock->ssl->handshake.client.session_cache_key_hash, - h2o_iovec_init(session, 1)); - } - } - - h2o_socket_cb handshake_cb = sock->ssl->handshake.cb; - sock->_cb.write = NULL; - sock->ssl->handshake.cb = NULL; - if (err == NULL) - decode_ssl_input(sock); - handshake_cb(sock, err); -} - -static void proceed_handshake(h2o_socket_t *sock, const char *err) -{ - h2o_iovec_t first_input = {NULL}; - int ret = 0; - - sock->_cb.write = NULL; - - if (err != NULL) { - goto Complete; - } - - if (sock->ssl->ossl == NULL) { -#if H2O_USE_PICOTLS - /* prepare I/O */ - size_t consumed = sock->ssl->input.encrypted->size; - ptls_buffer_t wbuf; - ptls_buffer_init(&wbuf, "", 0); - - if (sock->ssl->ptls != NULL) { - /* picotls in action, proceed the handshake */ - ret = ptls_handshake(sock->ssl->ptls, &wbuf, sock->ssl->input.encrypted->bytes, &consumed, NULL); - } else { - /* start using picotls if the first packet contains TLS 1.3 CH */ - ptls_context_t *ptls_ctx = h2o_socket_ssl_get_picotls_context(sock->ssl->ssl_ctx); - if (ptls_ctx != NULL) { - ptls_t *ptls = ptls_new(ptls_ctx, 1); - if (ptls == NULL) - h2o_fatal("no memory"); - ret = ptls_handshake(ptls, &wbuf, sock->ssl->input.encrypted->bytes, &consumed, NULL); - if ((ret == 0 || ret == PTLS_ERROR_IN_PROGRESS) && wbuf.off != 0) { - sock->ssl->ptls = ptls; - sock->ssl->handshake.server.async_resumption.state = ASYNC_RESUMPTION_STATE_COMPLETE; - } else { - ptls_free(ptls); - } - } - } - - if (sock->ssl->ptls != NULL) { - /* complete I/O done by picotls */ - h2o_buffer_consume(&sock->ssl->input.encrypted, consumed); - switch (ret) { - case 0: - case PTLS_ERROR_IN_PROGRESS: - if (wbuf.off != 0) { - h2o_socket_read_stop(sock); - write_ssl_bytes(sock, wbuf.base, wbuf.off); - flush_pending_ssl(sock, ret == 0 ? on_handshake_complete : proceed_handshake); - } else { - h2o_socket_read_start(sock, proceed_handshake); - } - break; - default: - /* FIXME send alert in wbuf before calling the callback */ - on_handshake_complete(sock, "picotls handshake error"); - break; - } - ptls_buffer_dispose(&wbuf); - return; - } - ptls_buffer_dispose(&wbuf); -#endif - - /* fallback to openssl if the attempt failed */ - create_ossl(sock); - } - - if (sock->ssl->ossl != NULL && SSL_is_server(sock->ssl->ossl) && - 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: - ERR_clear_error(); - if (SSL_is_server(sock->ssl->ossl)) { - ret = SSL_accept(sock->ssl->ossl); - switch (sock->ssl->handshake.server.async_resumption.state) { - case ASYNC_RESUMPTION_STATE_COMPLETE: - break; - 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_free(sock->ssl->ossl); - create_ossl(sock); - 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: - h2o_fatal("unexpected async resumption state"); - break; - } - } else { - ret = SSL_connect(sock->ssl->ossl); - } - - if (ret == 0 || (ret < 0 && SSL_get_error(sock->ssl->ossl, ret) != SSL_ERROR_WANT_READ)) { - /* failed */ - long verify_result = SSL_get_verify_result(sock->ssl->ossl); - 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->ossl)) { - X509 *cert = SSL_get_peer_certificate(sock->ssl->ossl); - 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); -} - -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)); - - sock->ssl->ssl_ctx = ssl_ctx; - - /* 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); - - sock->ssl->handshake.cb = handshake_cb; - if (server_name == NULL) { - /* is server */ - if (SSL_CTX_sess_get_get_cb(sock->ssl->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 { - create_ossl(sock); - h2o_cache_t *session_cache = h2o_socket_ssl_get_session_cache(sock->ssl->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->ossl, (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->ossl, sock->ssl->handshake.client.server_name); - proceed_handshake(sock, 0); - } -} - -void h2o_socket_ssl_resume_server_handshake(h2o_socket_t *sock, h2o_iovec_t session_data) -{ - if (session_data.len != 0) { - const unsigned char *p = (void *)session_data.base; - sock->ssl->handshake.server.async_resumption.session_data = d2i_SSL_SESSION(NULL, &p, (long)session_data.len); - /* FIXME warn on failure */ - } - - sock->ssl->handshake.server.async_resumption.state = ASYNC_RESUMPTION_STATE_COMPLETE; - proceed_handshake(sock, 0); - - if (sock->ssl->handshake.server.async_resumption.session_data != NULL) { - SSL_SESSION_free(sock->ssl->handshake.server.async_resumption.session_data); - sock->ssl->handshake.server.async_resumption.session_data = NULL; - } -} - -void h2o_socket_ssl_async_resumption_init(h2o_socket_ssl_resumption_get_async_cb get_async_cb, - h2o_socket_ssl_resumption_new_cb new_cb) -{ - resumption_get_async = get_async_cb; - resumption_new = new_cb; -} - -void h2o_socket_ssl_async_resumption_setup_ctx(SSL_CTX *ctx) -{ - SSL_CTX_sess_set_get_cb(ctx, on_async_resumption_get); - SSL_CTX_sess_set_new_cb(ctx, on_async_resumption_new); - /* if necessary, it is the responsibility of the caller to disable the internal cache */ -} - -#if H2O_USE_PICOTLS - -static int get_ptls_index(void) -{ - static int index = -1; - - if (index == -1) { - static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; - pthread_mutex_lock(&mutex); - if (index == -1) { - index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL); - assert(index != -1); - } - pthread_mutex_unlock(&mutex); - } - - return index; -} - -ptls_context_t *h2o_socket_ssl_get_picotls_context(SSL_CTX *ossl) -{ - return SSL_CTX_get_ex_data(ossl, get_ptls_index()); -} - -void h2o_socket_ssl_set_picotls_context(SSL_CTX *ossl, ptls_context_t *ptls) -{ - SSL_CTX_set_ex_data(ossl, get_ptls_index(), ptls); -} - -#endif - -static void on_dispose_ssl_ctx_session_cache(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, long argl, void *argp) -{ - h2o_cache_t *ssl_session_cache = (h2o_cache_t *)ptr; - if (ssl_session_cache != NULL) - h2o_cache_destroy(ssl_session_cache); -} - -static int get_ssl_session_cache_index(void) -{ - static int index = -1; - static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; - pthread_mutex_lock(&mutex); - if (index == -1) { - index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, on_dispose_ssl_ctx_session_cache); - assert(index != -1); - } - pthread_mutex_unlock(&mutex); - return index; -} - -h2o_cache_t *h2o_socket_ssl_get_session_cache(SSL_CTX *ctx) -{ - return (h2o_cache_t *)SSL_CTX_get_ex_data(ctx, get_ssl_session_cache_index()); -} - -void h2o_socket_ssl_set_session_cache(SSL_CTX *ctx, h2o_cache_t *cache) -{ - SSL_CTX_set_ex_data(ctx, get_ssl_session_cache_index(), cache); -} - -void h2o_socket_ssl_destroy_session_cache_entry(h2o_iovec_t value) -{ - SSL_SESSION *session = (SSL_SESSION *)value.base; - SSL_SESSION_free(session); -} - -h2o_iovec_t h2o_socket_ssl_get_selected_protocol(h2o_socket_t *sock) -{ - const unsigned char *data = NULL; - unsigned len = 0; - - assert(sock->ssl != NULL); - -#if H2O_USE_PICOTLS - if (sock->ssl->ptls != NULL) { - const char *proto = ptls_get_negotiated_protocol(sock->ssl->ptls); - return proto != NULL ? h2o_iovec_init(proto, strlen(proto)) : h2o_iovec_init(NULL, 0); - } -#endif - -#if H2O_USE_ALPN - if (len == 0) - SSL_get0_alpn_selected(sock->ssl->ossl, &data, &len); -#endif -#if H2O_USE_NPN - if (len == 0) - SSL_get0_next_proto_negotiated(sock->ssl->ossl, &data, &len); -#endif - - return h2o_iovec_init(data, len); -} - -static int on_alpn_select(SSL *ssl, const unsigned char **out, unsigned char *outlen, const unsigned char *_in, unsigned int inlen, - void *_protocols) -{ - const h2o_iovec_t *protocols = _protocols; - size_t i; - - for (i = 0; protocols[i].len != 0; ++i) { - const unsigned char *in = _in, *in_end = in + inlen; - while (in != in_end) { - size_t cand_len = *in++; - if (in_end - in < cand_len) { - /* broken request */ - return SSL_TLSEXT_ERR_NOACK; - } - if (cand_len == protocols[i].len && memcmp(in, protocols[i].base, cand_len) == 0) { - goto Found; - } - in += cand_len; - } - } - /* not found */ - return SSL_TLSEXT_ERR_NOACK; - -Found: - *out = (const unsigned char *)protocols[i].base; - *outlen = (unsigned char)protocols[i].len; - return SSL_TLSEXT_ERR_OK; -} - -#if H2O_USE_ALPN - -void h2o_ssl_register_alpn_protocols(SSL_CTX *ctx, const h2o_iovec_t *protocols) -{ - SSL_CTX_set_alpn_select_cb(ctx, on_alpn_select, (void *)protocols); -} - -#endif - -#if H2O_USE_NPN - -static int on_npn_advertise(SSL *ssl, const unsigned char **out, unsigned *outlen, void *protocols) -{ - *out = protocols; - *outlen = (unsigned)strlen(protocols); - return SSL_TLSEXT_ERR_OK; -} - -void h2o_ssl_register_npn_protocols(SSL_CTX *ctx, const char *protocols) -{ - SSL_CTX_set_next_protos_advertised_cb(ctx, on_npn_advertise, (void *)protocols); -} - -#endif - -void h2o_sliding_counter_stop(h2o_sliding_counter_t *counter, uint64_t now) -{ - uint64_t elapsed; - - assert(counter->cur.start_at != 0); - - /* calculate the time used, and reset cur */ - if (now <= counter->cur.start_at) - elapsed = 0; - else - elapsed = now - counter->cur.start_at; - counter->cur.start_at = 0; - - /* adjust prev */ - counter->prev.sum += elapsed; - counter->prev.sum -= counter->prev.slots[counter->prev.index]; - counter->prev.slots[counter->prev.index] = elapsed; - if (++counter->prev.index >= sizeof(counter->prev.slots) / sizeof(counter->prev.slots[0])) - counter->prev.index = 0; - - /* recalc average */ - counter->average = counter->prev.sum / (sizeof(counter->prev.slots) / sizeof(counter->prev.slots[0])); -} |