diff options
Diffstat (limited to 'web/server/h2o/libh2o/lib/common')
20 files changed, 0 insertions, 7259 deletions
diff --git a/web/server/h2o/libh2o/lib/common/cache.c b/web/server/h2o/libh2o/lib/common/cache.c deleted file mode 100644 index cc8d8f007..000000000 --- a/web/server/h2o/libh2o/lib/common/cache.c +++ /dev/null @@ -1,273 +0,0 @@ -/* - * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku - * - * 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 <assert.h> -#include <pthread.h> -#include "khash.h" -#include "h2o/cache.h" -#include "h2o/linklist.h" -#include "h2o/memory.h" -#include "h2o/string_.h" - -static h2o_cache_hashcode_t get_keyhash(h2o_cache_ref_t *ref); -static int is_equal(h2o_cache_ref_t *x, h2o_cache_ref_t *y); - -KHASH_INIT(cache, h2o_cache_ref_t *, char, 0, get_keyhash, is_equal) - -struct st_h2o_cache_t { - int flags; - khash_t(cache) * table; - size_t size; - size_t capacity; - h2o_linklist_t lru; - h2o_linklist_t age; - uint64_t duration; - void (*destroy_cb)(h2o_iovec_t value); - pthread_mutex_t mutex; /* only used if (flags & H2O_CACHE_FLAG_MULTITHREADED) != 0 */ -}; - -static h2o_cache_hashcode_t get_keyhash(h2o_cache_ref_t *ref) -{ - return ref->keyhash; -} - -static int is_equal(h2o_cache_ref_t *x, h2o_cache_ref_t *y) -{ - return x->key.len == y->key.len && memcmp(x->key.base, y->key.base, x->key.len) == 0; -} - -static void lock_cache(h2o_cache_t *cache) -{ - if ((cache->flags & H2O_CACHE_FLAG_MULTITHREADED) != 0) - pthread_mutex_lock(&cache->mutex); -} - -static void unlock_cache(h2o_cache_t *cache) -{ - if ((cache->flags & H2O_CACHE_FLAG_MULTITHREADED) != 0) - pthread_mutex_unlock(&cache->mutex); -} - -static void erase_ref(h2o_cache_t *cache, khiter_t iter, int reuse) -{ - h2o_cache_ref_t *ref = kh_key(cache->table, iter); - - if (!reuse) - kh_del(cache, cache->table, iter); - h2o_linklist_unlink(&ref->_lru_link); - h2o_linklist_unlink(&ref->_age_link); - cache->size -= ref->value.len; - - h2o_cache_release(cache, ref); -} - -static int64_t get_timeleft(h2o_cache_t *cache, h2o_cache_ref_t *ref, uint64_t now) -{ - return (int64_t)(ref->at + cache->duration) - now; -} - -static void purge(h2o_cache_t *cache, uint64_t now) -{ - /* by cache size */ - while (cache->capacity < cache->size) { - h2o_cache_ref_t *last; - assert(!h2o_linklist_is_empty(&cache->lru)); - last = H2O_STRUCT_FROM_MEMBER(h2o_cache_ref_t, _lru_link, cache->lru.next); - erase_ref(cache, kh_get(cache, cache->table, last), 0); - } - /* by TTL */ - while (!h2o_linklist_is_empty(&cache->age)) { - h2o_cache_ref_t *oldest = H2O_STRUCT_FROM_MEMBER(h2o_cache_ref_t, _age_link, cache->age.next); - if (get_timeleft(cache, oldest, now) >= 0) - break; - erase_ref(cache, kh_get(cache, cache->table, oldest), 0); - } -} - -h2o_cache_hashcode_t h2o_cache_calchash(const char *s, size_t l) -{ - h2o_cache_hashcode_t h = 0; - for (; l != 0; --l) - h = (h << 5) - h + ((unsigned char *)s)[l - 1]; - return h; -} - -h2o_cache_t *h2o_cache_create(int flags, size_t capacity, uint64_t duration, void (*destroy_cb)(h2o_iovec_t value)) -{ - h2o_cache_t *cache = h2o_mem_alloc(sizeof(*cache)); - - cache->flags = flags; - cache->table = kh_init(cache); - cache->size = 0; - cache->capacity = capacity; - h2o_linklist_init_anchor(&cache->lru); - h2o_linklist_init_anchor(&cache->age); - cache->duration = duration; - cache->destroy_cb = destroy_cb; - if ((cache->flags & H2O_CACHE_FLAG_MULTITHREADED) != 0) - pthread_mutex_init(&cache->mutex, NULL); - - return cache; -} - -void h2o_cache_destroy(h2o_cache_t *cache) -{ - h2o_cache_clear(cache); - kh_destroy(cache, cache->table); - if ((cache->flags & H2O_CACHE_FLAG_MULTITHREADED) != 0) - pthread_mutex_destroy(&cache->mutex); - free(cache); -} - -void h2o_cache_clear(h2o_cache_t *cache) -{ - lock_cache(cache); - - while (!h2o_linklist_is_empty(&cache->lru)) { - h2o_cache_ref_t *ref = H2O_STRUCT_FROM_MEMBER(h2o_cache_ref_t, _lru_link, cache->lru.next); - erase_ref(cache, kh_get(cache, cache->table, ref), 0); - } - assert(h2o_linklist_is_linked(&cache->age)); - assert(kh_size(cache->table) == 0); - assert(cache->size == 0); - - unlock_cache(cache); -} - -h2o_cache_ref_t *h2o_cache_fetch(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash) -{ - h2o_cache_ref_t search_key, *ref; - khiter_t iter; - int64_t timeleft; - - if (keyhash == 0) - keyhash = h2o_cache_calchash(key.base, key.len); - search_key.key = key; - search_key.keyhash = keyhash; - - lock_cache(cache); - - purge(cache, now); - - if ((iter = kh_get(cache, cache->table, &search_key)) == kh_end(cache->table)) - goto NotFound; - - /* found */ - ref = kh_key(cache->table, iter); - timeleft = get_timeleft(cache, ref, now); - if (timeleft < 0) - goto NotFound; - if ((cache->flags & H2O_CACHE_FLAG_EARLY_UPDATE) != 0 && timeleft < 10 && !ref->_requested_early_update) { - ref->_requested_early_update = 1; - goto NotFound; - } - /* move the entry to the top of LRU */ - h2o_linklist_unlink(&ref->_lru_link); - h2o_linklist_insert(&cache->lru, &ref->_lru_link); - __sync_fetch_and_add(&ref->_refcnt, 1); - - /* unlock and return the found entry */ - unlock_cache(cache); - return ref; - -NotFound: - unlock_cache(cache); - return NULL; -} - -void h2o_cache_release(h2o_cache_t *cache, h2o_cache_ref_t *ref) -{ - if (__sync_fetch_and_sub(&ref->_refcnt, 1) == 1) { - assert(!h2o_linklist_is_linked(&ref->_lru_link)); - assert(!h2o_linklist_is_linked(&ref->_age_link)); - if (cache->destroy_cb != NULL) - cache->destroy_cb(ref->value); - free(ref->key.base); - free(ref); - } -} - -int h2o_cache_set(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash, h2o_iovec_t value) -{ - h2o_cache_ref_t *newref; - khiter_t iter; - int existed; - - if (keyhash == 0) - keyhash = h2o_cache_calchash(key.base, key.len); - - /* create newref */ - newref = h2o_mem_alloc(sizeof(*newref)); - *newref = (h2o_cache_ref_t){h2o_strdup(NULL, key.base, key.len), keyhash, now, value, 0, {NULL}, {NULL}, 1}; - - lock_cache(cache); - - /* set or replace the named value */ - iter = kh_get(cache, cache->table, newref); - if (iter != kh_end(cache->table)) { - erase_ref(cache, iter, 1); - kh_key(cache->table, iter) = newref; - existed = 1; - } else { - int unused; - kh_put(cache, cache->table, newref, &unused); - existed = 0; - } - h2o_linklist_insert(&cache->lru, &newref->_lru_link); - h2o_linklist_insert(&cache->age, &newref->_age_link); - cache->size += newref->value.len; - - purge(cache, now); - - unlock_cache(cache); - - return existed; -} - -void h2o_cache_delete(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash) -{ - h2o_cache_ref_t search_key; - khiter_t iter; - - if (keyhash == 0) - keyhash = h2o_cache_calchash(key.base, key.len); - search_key.key = key; - search_key.keyhash = keyhash; - - lock_cache(cache); - - purge(cache, now); - - if ((iter = kh_get(cache, cache->table, &search_key)) != kh_end(cache->table)) - erase_ref(cache, iter, 0); - - unlock_cache(cache); -} - -size_t h2o_cache_get_capacity(h2o_cache_t *cache) -{ - return cache->capacity; -} - -uint64_t h2o_cache_get_duration(h2o_cache_t *cache) -{ - return cache->duration; -} diff --git a/web/server/h2o/libh2o/lib/common/file.c b/web/server/h2o/libh2o/lib/common/file.c deleted file mode 100644 index 3cf5ac5d1..000000000 --- a/web/server/h2o/libh2o/lib/common/file.c +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) 2015 DeNA Co., Ltd., Kazuho Oku - * - * 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 <stdint.h> -#include <stdlib.h> -#include <sys/stat.h> -#include <sys/types.h> -#include <sys/uio.h> -#include <unistd.h> -#include "h2o/file.h" - -h2o_iovec_t h2o_file_read(const char *fn) -{ - int fd; - struct stat st; - h2o_iovec_t ret = {NULL}; - - /* open */ - if ((fd = open(fn, O_RDONLY | O_CLOEXEC)) == -1) - goto Error; - if (fstat(fd, &st)) - goto Error; - /* allocate memory */ - if (st.st_size > SIZE_MAX) { - errno = ENOMEM; - goto Error; - } - if ((ret.base = malloc((size_t)st.st_size)) == NULL) - goto Error; - /* read */ - while (ret.len != (size_t)st.st_size) { - ssize_t r; - while ((r = read(fd, ret.base + ret.len, (size_t)st.st_size - ret.len)) == -1 && errno == EINTR) - ; - if (r <= 0) - goto Error; - ret.len += r; - } - /* close */ - close(fd); - return ret; - -Error: - if (fd != -1) - close(fd); - free(ret.base); - return (h2o_iovec_t){NULL}; -} diff --git a/web/server/h2o/libh2o/lib/common/filecache.c b/web/server/h2o/libh2o/lib/common/filecache.c deleted file mode 100644 index 747a1ffa6..000000000 --- a/web/server/h2o/libh2o/lib/common/filecache.c +++ /dev/null @@ -1,170 +0,0 @@ -/* - * Copyright (c) 2015 DeNA Co., Ltd., Kazuho Oku - * - * 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 <assert.h> -#include <errno.h> -#include <fcntl.h> -#include <stddef.h> -#include <unistd.h> -#include "khash.h" -#include "h2o/memory.h" -#include "h2o/filecache.h" - -KHASH_SET_INIT_STR(opencache_set) - -struct st_h2o_filecache_t { - khash_t(opencache_set) * hash; - h2o_linklist_t lru; - size_t capacity; -}; - -static inline void release_from_cache(h2o_filecache_t *cache, khiter_t iter) -{ - const char *path = kh_key(cache->hash, iter); - h2o_filecache_ref_t *ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _path, path); - - /* detach from list */ - kh_del(opencache_set, cache->hash, iter); - h2o_linklist_unlink(&ref->_lru); - - /* and close */ - h2o_filecache_close_file(ref); -} - -h2o_filecache_t *h2o_filecache_create(size_t capacity) -{ - h2o_filecache_t *cache = h2o_mem_alloc(sizeof(*cache)); - - cache->hash = kh_init(opencache_set); - h2o_linklist_init_anchor(&cache->lru); - cache->capacity = capacity; - - return cache; -} - -void h2o_filecache_destroy(h2o_filecache_t *cache) -{ - h2o_filecache_clear(cache); - assert(kh_size(cache->hash) == 0); - assert(h2o_linklist_is_empty(&cache->lru)); - kh_destroy(opencache_set, cache->hash); - free(cache); -} - -void h2o_filecache_clear(h2o_filecache_t *cache) -{ - khiter_t iter; - for (iter = kh_begin(cache->hash); iter != kh_end(cache->hash); ++iter) { - if (!kh_exist(cache->hash, iter)) - continue; - release_from_cache(cache, iter); - } - assert(kh_size(cache->hash) == 0); -} - -h2o_filecache_ref_t *h2o_filecache_open_file(h2o_filecache_t *cache, const char *path, int oflag) -{ - khiter_t iter = kh_get(opencache_set, cache->hash, path); - h2o_filecache_ref_t *ref; - int dummy; - - /* lookup cache, and return the one if found */ - if (iter != kh_end(cache->hash)) { - ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _path, kh_key(cache->hash, iter)); - ++ref->_refcnt; - goto Exit; - } - - /* create a new cache entry */ - ref = h2o_mem_alloc(offsetof(h2o_filecache_ref_t, _path) + strlen(path) + 1); - ref->_refcnt = 1; - ref->_lru = (h2o_linklist_t){NULL}; - strcpy(ref->_path, path); - - /* if cache is used, then... */ - if (cache->capacity != 0) { - /* purge one entry from LRU if cache is full */ - if (kh_size(cache->hash) == cache->capacity) { - h2o_filecache_ref_t *purge_ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _lru, cache->lru.prev); - khiter_t purge_iter = kh_get(opencache_set, cache->hash, purge_ref->_path); - assert(purge_iter != kh_end(cache->hash)); - release_from_cache(cache, purge_iter); - } - /* assign the new entry */ - ++ref->_refcnt; - kh_put(opencache_set, cache->hash, ref->_path, &dummy); - h2o_linklist_insert(cache->lru.next, &ref->_lru); - } - - /* open the file, or memoize the error */ - if ((ref->fd = open(path, oflag)) != -1 && fstat(ref->fd, &ref->st) == 0) { - ref->_last_modified.str[0] = '\0'; - ref->_etag.len = 0; - } else { - ref->open_err = errno; - if (ref->fd != -1) { - close(ref->fd); - ref->fd = -1; - } - } - -Exit: - /* if the cache entry retains an error, return it instead of the reference */ - if (ref->fd == -1) { - errno = ref->open_err; - h2o_filecache_close_file(ref); - ref = NULL; - } - return ref; -} - -void h2o_filecache_close_file(h2o_filecache_ref_t *ref) -{ - if (--ref->_refcnt != 0) - return; - assert(!h2o_linklist_is_linked(&ref->_lru)); - if (ref->fd != -1) { - close(ref->fd); - ref->fd = -1; - } - free(ref); -} - -struct tm *h2o_filecache_get_last_modified(h2o_filecache_ref_t *ref, char *outbuf) -{ - assert(ref->fd != -1); - if (ref->_last_modified.str[0] == '\0') { - gmtime_r(&ref->st.st_mtime, &ref->_last_modified.gm); - h2o_time2str_rfc1123(ref->_last_modified.str, &ref->_last_modified.gm); - } - if (outbuf != NULL) - memcpy(outbuf, ref->_last_modified.str, H2O_TIMESTR_RFC1123_LEN + 1); - return &ref->_last_modified.gm; -} - -size_t h2o_filecache_get_etag(h2o_filecache_ref_t *ref, char *outbuf) -{ - assert(ref->fd != -1); - if (ref->_etag.len == 0) - ref->_etag.len = sprintf(ref->_etag.buf, "\"%08x-%zx\"", (unsigned)ref->st.st_mtime, (size_t)ref->st.st_size); - memcpy(outbuf, ref->_etag.buf, ref->_etag.len + 1); - return ref->_etag.len; -} diff --git a/web/server/h2o/libh2o/lib/common/hostinfo.c b/web/server/h2o/libh2o/lib/common/hostinfo.c deleted file mode 100644 index 7b481e296..000000000 --- a/web/server/h2o/libh2o/lib/common/hostinfo.c +++ /dev/null @@ -1,229 +0,0 @@ -/* - * Copyright (c) 2015 DeNA Co., Ltd., Kazuho Oku - * - * 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 "h2o/hostinfo.h" - -struct st_h2o_hostinfo_getaddr_req_t { - h2o_multithread_receiver_t *_receiver; - h2o_hostinfo_getaddr_cb _cb; - void *cbdata; - h2o_linklist_t _pending; - union { - struct { - char *name; - char *serv; - struct addrinfo hints; - } _in; - struct { - h2o_multithread_message_t message; - const char *errstr; - struct addrinfo *ai; - } _out; - }; -}; - -static struct { - pthread_mutex_t mutex; - pthread_cond_t cond; - h2o_linklist_t pending; /* anchor of h2o_hostinfo_getaddr_req_t::_pending */ - size_t num_threads; - size_t num_threads_idle; -} queue = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, {&queue.pending, &queue.pending}, 0, 0}; - -size_t h2o_hostinfo_max_threads = 1; - -static void lookup_and_respond(h2o_hostinfo_getaddr_req_t *req) -{ - struct addrinfo *res; - - int ret = getaddrinfo(req->_in.name, req->_in.serv, &req->_in.hints, &res); - req->_out.message = (h2o_multithread_message_t){{NULL}}; - if (ret != 0) { - req->_out.errstr = gai_strerror(ret); - req->_out.ai = NULL; - } else { - req->_out.errstr = NULL; - req->_out.ai = res; - } - - h2o_multithread_send_message(req->_receiver, &req->_out.message); -} - -static void *lookup_thread_main(void *_unused) -{ - pthread_mutex_lock(&queue.mutex); - - while (1) { - --queue.num_threads_idle; - while (!h2o_linklist_is_empty(&queue.pending)) { - h2o_hostinfo_getaddr_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_hostinfo_getaddr_req_t, _pending, queue.pending.next); - h2o_linklist_unlink(&req->_pending); - pthread_mutex_unlock(&queue.mutex); - lookup_and_respond(req); - pthread_mutex_lock(&queue.mutex); - } - ++queue.num_threads_idle; - pthread_cond_wait(&queue.cond, &queue.mutex); - } - - h2o_fatal("unreachable"); - return NULL; -} - -static void create_lookup_thread(void) -{ - pthread_t tid; - pthread_attr_t attr; - int ret; - - pthread_attr_init(&attr); - pthread_attr_setdetachstate(&attr, 1); - pthread_attr_setstacksize(&attr, 100 * 1024); - if ((ret = pthread_create(&tid, NULL, lookup_thread_main, NULL)) != 0) { - if (queue.num_threads == 0) { - fprintf(stderr, "failed to start first thread for getaddrinfo:%s\n", strerror(ret)); - abort(); - } else { - perror("pthread_create(for getaddrinfo)"); - } - return; - } - - ++queue.num_threads; - ++queue.num_threads_idle; -} - -h2o_hostinfo_getaddr_req_t *h2o_hostinfo_getaddr(h2o_multithread_receiver_t *receiver, h2o_iovec_t name, h2o_iovec_t serv, - int family, int socktype, int protocol, int flags, h2o_hostinfo_getaddr_cb cb, - void *cbdata) -{ - h2o_hostinfo_getaddr_req_t *req = h2o_mem_alloc(sizeof(*req) + name.len + 1 + serv.len + 1); - req->_receiver = receiver; - req->_cb = cb; - req->cbdata = cbdata; - req->_pending = (h2o_linklist_t){NULL}; - req->_in.name = (char *)req + sizeof(*req); - memcpy(req->_in.name, name.base, name.len); - req->_in.name[name.len] = '\0'; - req->_in.serv = req->_in.name + name.len + 1; - memcpy(req->_in.serv, serv.base, serv.len); - req->_in.serv[serv.len] = '\0'; - memset(&req->_in.hints, 0, sizeof(req->_in.hints)); - req->_in.hints.ai_family = family; - req->_in.hints.ai_socktype = socktype; - req->_in.hints.ai_protocol = protocol; - req->_in.hints.ai_flags = flags; - - h2o__hostinfo_getaddr_dispatch(req); - - return req; -} - -void h2o__hostinfo_getaddr_dispatch(h2o_hostinfo_getaddr_req_t *req) -{ - pthread_mutex_lock(&queue.mutex); - - h2o_linklist_insert(&queue.pending, &req->_pending); - - if (queue.num_threads_idle == 0 && queue.num_threads < h2o_hostinfo_max_threads) - create_lookup_thread(); - - pthread_cond_signal(&queue.cond); - pthread_mutex_unlock(&queue.mutex); -} - -void h2o_hostinfo_getaddr_cancel(h2o_hostinfo_getaddr_req_t *req) -{ - int should_free = 0; - - pthread_mutex_lock(&queue.mutex); - - if (h2o_linklist_is_linked(&req->_pending)) { - h2o_linklist_unlink(&req->_pending); - should_free = 1; - } else { - req->_cb = NULL; - } - - pthread_mutex_unlock(&queue.mutex); - - if (should_free) - free(req); -} - -void h2o_hostinfo_getaddr_receiver(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages) -{ - while (!h2o_linklist_is_empty(messages)) { - h2o_hostinfo_getaddr_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_hostinfo_getaddr_req_t, _out.message.link, messages->next); - h2o_linklist_unlink(&req->_out.message.link); - h2o_hostinfo_getaddr_cb cb = req->_cb; - if (cb != NULL) { - req->_cb = NULL; - cb(req, req->_out.errstr, req->_out.ai, req->cbdata); - } - if (req->_out.ai != NULL) - freeaddrinfo(req->_out.ai); - free(req); - } -} - -static const char *fetch_aton_digit(const char *p, const char *end, unsigned char *value) -{ - size_t ndigits = 0; - int v = 0; - - while (p != end && ('0' <= *p && *p <= '9')) { - v = v * 10 + *p++ - '0'; - ++ndigits; - } - if (!(1 <= ndigits && ndigits <= 3)) - return NULL; - if (v > 255) - return NULL; - *value = (unsigned char)v; - return p; -} - -int h2o_hostinfo_aton(h2o_iovec_t host, struct in_addr *addr) -{ - union { - int32_t n; - unsigned char c[4]; - } value; - const char *p = host.base, *end = p + host.len; - size_t ndots = 0; - - while (1) { - if ((p = fetch_aton_digit(p, end, value.c + ndots)) == NULL) - return -1; - if (ndots == 3) - break; - if (p == end || !(*p == '.')) - return -1; - ++p; - ++ndots; - } - if (p != end) - return -1; - - addr->s_addr = value.n; - return 0; -} diff --git a/web/server/h2o/libh2o/lib/common/http1client.c b/web/server/h2o/libh2o/lib/common/http1client.c deleted file mode 100644 index 8547ea817..000000000 --- a/web/server/h2o/libh2o/lib/common/http1client.c +++ /dev/null @@ -1,582 +0,0 @@ -/* - * Copyright (c) 2014 DeNA Co., Ltd. - * - * 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 <arpa/inet.h> -#include <netdb.h> -#include <netinet/in.h> -#include <sys/socket.h> -#include <sys/types.h> -#include <sys/un.h> -#include "picohttpparser.h" -#include "h2o.h" - -struct st_h2o_http1client_private_t { - h2o_http1client_t super; - union { - h2o_http1client_connect_cb on_connect; - h2o_http1client_head_cb on_head; - h2o_http1client_body_cb on_body; - } _cb; - h2o_timeout_entry_t _timeout; - int _method_is_head; - h2o_hostinfo_getaddr_req_t *_getaddr_req; - int _can_keepalive; - union { - struct { - size_t bytesleft; - } content_length; - struct { - struct phr_chunked_decoder decoder; - size_t bytes_decoded_in_buf; - } chunked; - } _body_decoder; -}; - -static void close_client(struct st_h2o_http1client_private_t *client) -{ - if (client->_getaddr_req != NULL) { - h2o_hostinfo_getaddr_cancel(client->_getaddr_req); - client->_getaddr_req = NULL; - } - if (client->super.ssl.server_name != NULL) - free(client->super.ssl.server_name); - if (client->super.sock != NULL) { - if (client->super.sockpool.pool != NULL && client->_can_keepalive) { - /* we do not send pipelined requests, and thus can trash all the received input at the end of the request */ - h2o_buffer_consume(&client->super.sock->input, client->super.sock->input->size); - h2o_socketpool_return(client->super.sockpool.pool, client->super.sock); - } else { - h2o_socket_close(client->super.sock); - } - } else { - if (client->super.sockpool.connect_req != NULL) { - h2o_socketpool_cancel_connect(client->super.sockpool.connect_req); - client->super.sockpool.connect_req = NULL; - } - } - if (h2o_timeout_is_linked(&client->_timeout)) - h2o_timeout_unlink(&client->_timeout); - free(client); -} - -static void on_body_error(struct st_h2o_http1client_private_t *client, const char *errstr) -{ - client->_can_keepalive = 0; - client->_cb.on_body(&client->super, errstr); - close_client(client); -} - -static void on_body_timeout(h2o_timeout_entry_t *entry) -{ - struct st_h2o_http1client_private_t *client = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1client_private_t, _timeout, entry); - on_body_error(client, "I/O timeout"); -} - -static void on_body_until_close(h2o_socket_t *sock, const char *err) -{ - struct st_h2o_http1client_private_t *client = sock->data; - - h2o_timeout_unlink(&client->_timeout); - - if (err != NULL) { - client->_cb.on_body(&client->super, h2o_http1client_error_is_eos); - close_client(client); - return; - } - - if (sock->bytes_read != 0) { - if (client->_cb.on_body(&client->super, NULL) != 0) { - close_client(client); - return; - } - } - - h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout); -} - -static void on_body_content_length(h2o_socket_t *sock, const char *err) -{ - struct st_h2o_http1client_private_t *client = sock->data; - - h2o_timeout_unlink(&client->_timeout); - - if (err != NULL) { - on_body_error(client, "I/O error (body; content-length)"); - return; - } - - if (sock->bytes_read != 0 || client->_body_decoder.content_length.bytesleft == 0) { - const char *errstr; - int ret; - if (client->_body_decoder.content_length.bytesleft <= sock->bytes_read) { - if (client->_body_decoder.content_length.bytesleft < sock->bytes_read) { - /* remove the trailing garbage from buf, and disable keepalive */ - client->super.sock->input->size -= sock->bytes_read - client->_body_decoder.content_length.bytesleft; - client->_can_keepalive = 0; - } - client->_body_decoder.content_length.bytesleft = 0; - errstr = h2o_http1client_error_is_eos; - } else { - client->_body_decoder.content_length.bytesleft -= sock->bytes_read; - errstr = NULL; - } - ret = client->_cb.on_body(&client->super, errstr); - if (errstr == h2o_http1client_error_is_eos) { - close_client(client); - return; - } else if (ret != 0) { - client->_can_keepalive = 0; - close_client(client); - return; - } - } - - h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout); -} - -static void on_body_chunked(h2o_socket_t *sock, const char *err) -{ - struct st_h2o_http1client_private_t *client = sock->data; - h2o_buffer_t *inbuf; - - h2o_timeout_unlink(&client->_timeout); - - if (err != NULL) { - if (err == h2o_socket_error_closed && !phr_decode_chunked_is_in_data(&client->_body_decoder.chunked.decoder)) { - /* - * if the peer closed after a full chunk, treat this - * as if the transfer had complete, browsers appear to ignore - * a missing 0\r\n chunk - */ - client->_can_keepalive = 0; - client->_cb.on_body(&client->super, h2o_http1client_error_is_eos); - close_client(client); - } else { - on_body_error(client, "I/O error (body; chunked)"); - } - return; - } - - inbuf = client->super.sock->input; - if (sock->bytes_read != 0) { - const char *errstr; - int cb_ret; - size_t newsz = sock->bytes_read; - switch (phr_decode_chunked(&client->_body_decoder.chunked.decoder, inbuf->bytes + inbuf->size - newsz, &newsz)) { - case -1: /* error */ - newsz = sock->bytes_read; - client->_can_keepalive = 0; - errstr = "failed to parse the response (chunked)"; - break; - case -2: /* incomplete */ - errstr = NULL; - break; - default: /* complete, with garbage on tail; should disable keepalive */ - client->_can_keepalive = 0; - /* fallthru */ - case 0: /* complete */ - errstr = h2o_http1client_error_is_eos; - break; - } - inbuf->size -= sock->bytes_read - newsz; - cb_ret = client->_cb.on_body(&client->super, errstr); - if (errstr != NULL) { - close_client(client); - return; - } else if (cb_ret != 0) { - client->_can_keepalive = 0; - close_client(client); - return; - } - } - - h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout); -} - -static void on_error_before_head(struct st_h2o_http1client_private_t *client, const char *errstr) -{ - assert(!client->_can_keepalive); - client->_cb.on_head(&client->super, errstr, 0, 0, h2o_iovec_init(NULL, 0), NULL, 0, 0); - close_client(client); -} - -static void on_head(h2o_socket_t *sock, const char *err) -{ - struct st_h2o_http1client_private_t *client = sock->data; - int minor_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_mem_pool_t pool; - - h2o_timeout_unlink(&client->_timeout); - - if (err != NULL) { - on_error_before_head(client, "I/O error (head)"); - return; - } - - h2o_mem_init_pool(&pool); - - headers = h2o_mem_alloc_pool(&pool, sizeof(*headers) * MAX_HEADERS); - header_names = h2o_mem_alloc_pool(&pool, sizeof(*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"); - goto Exit; - case -2: /* incomplete */ - h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout); - goto Exit; - } - /* fill-in the headers */ - for (i = 0; i != num_headers; ++i) { - const h2o_token_t *token; - char *orig_name = h2o_strdup(&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; - } - - if (!(100 <= http_status && http_status <= 199 && http_status != 101)) - break; - - if (client->super.informational_cb != NULL && - client->super.informational_cb(&client->super, minor_version, http_status, h2o_iovec_init(msg, msg_len), headers, - num_headers) != 0) { - close_client(client); - goto Exit; - } - h2o_buffer_consume(&client->super.sock->input, rlen); - if (client->super.sock->input->size == 0) { - h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout); - goto Exit; - } - } - - /* parse the headers */ - reader = on_body_until_close; - client->_can_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->_can_keepalive = 1; - } else { - client->_can_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_body_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"); - goto Exit; - } - } 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"); - goto Exit; - } - if (reader != on_body_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; - } 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->_can_keepalive = 0; - } - - /* call the callback. sock may be stealed and stealed sock need rlen.*/ - client->_cb.on_body = client->_cb.on_head(&client->super, is_eos ? h2o_http1client_error_is_eos : NULL, minor_version, - http_status, h2o_iovec_init(msg, msg_len), headers, num_headers, rlen); - - if (is_eos) { - close_client(client); - goto Exit; - } else if (client->_cb.on_body == NULL) { - client->_can_keepalive = 0; - close_client(client); - goto Exit; - } - - h2o_buffer_consume(&client->super.sock->input, rlen); - client->super.sock->bytes_read = client->super.sock->input->size; - - client->_timeout.cb = on_body_timeout; - h2o_socket_read_start(sock, reader); - reader(client->super.sock, 0); - -Exit: - h2o_mem_clear_pool(&pool); -#undef MAX_HEADERS -} - -static void on_head_timeout(h2o_timeout_entry_t *entry) -{ - struct st_h2o_http1client_private_t *client = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1client_private_t, _timeout, entry); - on_error_before_head(client, "I/O timeout"); -} - -static void on_send_request(h2o_socket_t *sock, const char *err) -{ - struct st_h2o_http1client_private_t *client = sock->data; - - h2o_timeout_unlink(&client->_timeout); - - if (err != NULL) { - on_error_before_head(client, "I/O error (send request)"); - return; - } - - h2o_socket_read_start(client->super.sock, on_head); - client->_timeout.cb = on_head_timeout; - h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout); -} - -static void on_send_timeout(h2o_timeout_entry_t *entry) -{ - struct st_h2o_http1client_private_t *client = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1client_private_t, _timeout, entry); - on_error_before_head(client, "I/O timeout"); -} - -static void on_connect_error(struct st_h2o_http1client_private_t *client, const char *errstr) -{ - assert(errstr != NULL); - client->_cb.on_connect(&client->super, errstr, NULL, NULL, NULL); - close_client(client); -} - -static void on_connection_ready(struct st_h2o_http1client_private_t *client) -{ - h2o_iovec_t *reqbufs; - size_t reqbufcnt; - - if ((client->_cb.on_head = client->_cb.on_connect(&client->super, NULL, &reqbufs, &reqbufcnt, &client->_method_is_head)) == - NULL) { - close_client(client); - return; - } - h2o_socket_write(client->super.sock, reqbufs, reqbufcnt, on_send_request); - /* TODO no need to set the timeout if all data has been written into TCP sendbuf */ - client->_timeout.cb = on_send_timeout; - h2o_timeout_link(client->super.ctx->loop, client->super.ctx->io_timeout, &client->_timeout); -} - -static void on_handshake_complete(h2o_socket_t *sock, const char *err) -{ - struct st_h2o_http1client_private_t *client = sock->data; - - h2o_timeout_unlink(&client->_timeout); - - if (err == NULL) { - /* success */ - } else if (err == h2o_socket_error_ssl_cert_name_mismatch && - (SSL_CTX_get_verify_mode(client->super.ctx->ssl_ctx) & SSL_VERIFY_PEER) == 0) { - /* peer verification skipped */ - } else { - on_connect_error(client, err); - return; - } - - on_connection_ready(client); -} - -static void on_connect(h2o_socket_t *sock, const char *err) -{ - struct st_h2o_http1client_private_t *client = sock->data; - - if (err != NULL) { - h2o_timeout_unlink(&client->_timeout); - on_connect_error(client, err); - return; - } - if (client->super.ssl.server_name != NULL && client->super.sock->ssl == NULL) { - h2o_socket_ssl_handshake(client->super.sock, client->super.ctx->ssl_ctx, client->super.ssl.server_name, - on_handshake_complete); - return; - } - - h2o_timeout_unlink(&client->_timeout); - - on_connection_ready(client); -} - -static void on_pool_connect(h2o_socket_t *sock, const char *errstr, void *data) -{ - struct st_h2o_http1client_private_t *client = data; - - client->super.sockpool.connect_req = NULL; - - if (sock == NULL) { - assert(errstr != NULL); - on_connect_error(client, errstr); - return; - } - - client->super.sock = sock; - sock->data = client; - on_connect(sock, NULL); -} - -static void on_connect_timeout(h2o_timeout_entry_t *entry) -{ - struct st_h2o_http1client_private_t *client = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1client_private_t, _timeout, entry); - on_connect_error(client, "connection timeout"); -} - -static void start_connect(struct st_h2o_http1client_private_t *client, struct sockaddr *addr, socklen_t addrlen) -{ - if ((client->super.sock = h2o_socket_connect(client->super.ctx->loop, addr, addrlen, on_connect)) == NULL) { - on_connect_error(client, "socket create error"); - return; - } - client->super.sock->data = client; -} - -static void on_getaddr(h2o_hostinfo_getaddr_req_t *getaddr_req, const char *errstr, struct addrinfo *res, void *_client) -{ - struct st_h2o_http1client_private_t *client = _client; - - assert(getaddr_req == client->_getaddr_req); - client->_getaddr_req = NULL; - - if (errstr != NULL) { - on_connect_error(client, errstr); - return; - } - - /* start connecting */ - struct addrinfo *selected = h2o_hostinfo_select_one(res); - start_connect(client, selected->ai_addr, selected->ai_addrlen); -} - -static struct st_h2o_http1client_private_t *create_client(h2o_http1client_t **_client, void *data, h2o_http1client_ctx_t *ctx, - h2o_iovec_t ssl_server_name, h2o_http1client_connect_cb cb) -{ - struct st_h2o_http1client_private_t *client = h2o_mem_alloc(sizeof(*client)); - - *client = (struct st_h2o_http1client_private_t){{ctx}}; - if (ssl_server_name.base != NULL) - client->super.ssl.server_name = h2o_strdup(NULL, ssl_server_name.base, ssl_server_name.len).base; - client->super.data = data; - client->_cb.on_connect = cb; - /* caller needs to setup _cb, timeout.cb, sock, and sock->data */ - - if (_client != NULL) - *_client = &client->super; - return client; -} - -const char *const h2o_http1client_error_is_eos = "end of stream"; - -void h2o_http1client_connect(h2o_http1client_t **_client, void *data, h2o_http1client_ctx_t *ctx, h2o_iovec_t host, uint16_t port, - int is_ssl, h2o_http1client_connect_cb cb) -{ - struct st_h2o_http1client_private_t *client; - char serv[sizeof("65536")]; - - /* setup */ - client = create_client(_client, data, ctx, is_ssl ? host : h2o_iovec_init(NULL, 0), cb); - client->_timeout.cb = on_connect_timeout; - h2o_timeout_link(ctx->loop, ctx->io_timeout, &client->_timeout); - - { /* directly call connect(2) if `host` is an IP address */ - struct sockaddr_in sin; - memset(&sin, 0, sizeof(sin)); - if (h2o_hostinfo_aton(host, &sin.sin_addr) == 0) { - sin.sin_family = AF_INET; - sin.sin_port = htons(port); - start_connect(client, (void *)&sin, sizeof(sin)); - return; - } - } - { /* directly call connect(2) if `host` refers to an UNIX-domain socket */ - struct sockaddr_un sa; - const char *to_sa_err; - if ((to_sa_err = h2o_url_host_to_sun(host, &sa)) != h2o_url_host_to_sun_err_is_not_unix_socket) { - if (to_sa_err != NULL) { - on_connect_error(client, to_sa_err); - return; - } - start_connect(client, (void *)&sa, sizeof(sa)); - return; - } - } - /* resolve destination and then connect */ - client->_getaddr_req = - h2o_hostinfo_getaddr(ctx->getaddr_receiver, host, h2o_iovec_init(serv, sprintf(serv, "%u", (unsigned)port)), AF_UNSPEC, - SOCK_STREAM, IPPROTO_TCP, AI_ADDRCONFIG | AI_NUMERICSERV, on_getaddr, client); -} - -void h2o_http1client_connect_with_pool(h2o_http1client_t **_client, void *data, h2o_http1client_ctx_t *ctx, - h2o_socketpool_t *sockpool, h2o_http1client_connect_cb cb) -{ - struct st_h2o_http1client_private_t *client = - create_client(_client, data, ctx, sockpool->is_ssl ? sockpool->peer.host : h2o_iovec_init(NULL, 0), cb); - client->super.sockpool.pool = sockpool; - client->_timeout.cb = on_connect_timeout; - h2o_timeout_link(ctx->loop, ctx->io_timeout, &client->_timeout); - h2o_socketpool_connect(&client->super.sockpool.connect_req, sockpool, ctx->loop, ctx->getaddr_receiver, on_pool_connect, - client); -} - -void h2o_http1client_cancel(h2o_http1client_t *_client) -{ - struct st_h2o_http1client_private_t *client = (void *)_client; - client->_can_keepalive = 0; - close_client(client); -} - -h2o_socket_t *h2o_http1client_steal_socket(h2o_http1client_t *_client) -{ - struct st_h2o_http1client_private_t *client = (void *)_client; - h2o_socket_t *sock = client->super.sock; - h2o_socket_read_stop(sock); - client->super.sock = NULL; - return sock; -} diff --git a/web/server/h2o/libh2o/lib/common/memcached.c b/web/server/h2o/libh2o/lib/common/memcached.c deleted file mode 100644 index 752ea2fcb..000000000 --- a/web/server/h2o/libh2o/lib/common/memcached.c +++ /dev/null @@ -1,429 +0,0 @@ -/* - * Copyright (c) 2015 DeNA Co., Ltd., Kazuho Oku - * - * 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 <inttypes.h> -#include <unistd.h> -#include "yrmcds.h" -#include "h2o/linklist.h" -#include "h2o/memcached.h" -#include "h2o/rand.h" -#include "h2o/string_.h" - -struct st_h2o_memcached_context_t { - pthread_mutex_t mutex; - pthread_cond_t cond; - h2o_linklist_t pending; - size_t num_threads_connected; - char *host; - uint16_t port; - int text_protocol; - h2o_iovec_t prefix; -}; - -struct st_h2o_memcached_conn_t { - h2o_memcached_context_t *ctx; - yrmcds yrmcds; - pthread_mutex_t mutex; - h2o_linklist_t inflight; - int writer_exit_requested; -}; - -enum en_h2o_memcached_req_type_t { REQ_TYPE_GET, REQ_TYPE_SET, REQ_TYPE_DELETE }; - -struct st_h2o_memcached_req_t { - enum en_h2o_memcached_req_type_t type; - h2o_linklist_t pending; - h2o_linklist_t inflight; - union { - struct { - h2o_multithread_receiver_t *receiver; - h2o_multithread_message_t message; - h2o_memcached_get_cb cb; - void *cb_data; - int value_is_encoded; - h2o_iovec_t value; - uint32_t serial; - } get; - struct { - h2o_iovec_t value; - uint32_t expiration; - } set; - } data; - struct { - size_t len; - char base[1]; - } key; -}; - -static h2o_memcached_req_t *create_req(h2o_memcached_context_t *ctx, enum en_h2o_memcached_req_type_t type, h2o_iovec_t key, - int encode_key) -{ - h2o_memcached_req_t *req = h2o_mem_alloc(offsetof(h2o_memcached_req_t, key.base) + ctx->prefix.len + - (encode_key ? (key.len + 2) / 3 * 4 + 1 : key.len)); - req->type = type; - req->pending = (h2o_linklist_t){NULL}; - req->inflight = (h2o_linklist_t){NULL}; - memset(&req->data, 0, sizeof(req->data)); - if (ctx->prefix.len != 0) - memcpy(req->key.base, ctx->prefix.base, ctx->prefix.len); - req->key.len = ctx->prefix.len; - if (encode_key) { - req->key.len += h2o_base64_encode(req->key.base + req->key.len, key.base, key.len, 1); - } else { - memcpy(req->key.base + req->key.len, key.base, key.len); - req->key.len += key.len; - } - return req; -} - -static void free_req(h2o_memcached_req_t *req) -{ - assert(!h2o_linklist_is_linked(&req->pending)); - switch (req->type) { - case REQ_TYPE_GET: - assert(!h2o_linklist_is_linked(&req->data.get.message.link)); - h2o_mem_set_secure(req->data.get.value.base, 0, req->data.get.value.len); - free(req->data.get.value.base); - break; - case REQ_TYPE_SET: - h2o_mem_set_secure(req->data.set.value.base, 0, req->data.set.value.len); - free(req->data.set.value.base); - break; - case REQ_TYPE_DELETE: - break; - default: - assert(!"FIXME"); - break; - } - free(req); -} - -static void discard_req(h2o_memcached_req_t *req) -{ - switch (req->type) { - case REQ_TYPE_GET: - h2o_multithread_send_message(req->data.get.receiver, &req->data.get.message); - break; - default: - free_req(req); - break; - } -} - -static h2o_memcached_req_t *pop_inflight(struct st_h2o_memcached_conn_t *conn, uint32_t serial) -{ - h2o_memcached_req_t *req; - - pthread_mutex_lock(&conn->mutex); - - if (conn->yrmcds.text_mode) { - /* in text mode, responses are returned in order (and we may receive responses for commands other than GET) */ - if (!h2o_linklist_is_empty(&conn->inflight)) { - req = H2O_STRUCT_FROM_MEMBER(h2o_memcached_req_t, inflight, conn->inflight.next); - assert(req->type == REQ_TYPE_GET); - if (req->data.get.serial == serial) - goto Found; - } - } else { - /* in binary mode, responses are received out-of-order (and we would only recieve responses for GET) */ - h2o_linklist_t *node; - for (node = conn->inflight.next; node != &conn->inflight; node = node->next) { - req = H2O_STRUCT_FROM_MEMBER(h2o_memcached_req_t, inflight, node); - assert(req->type == REQ_TYPE_GET); - if (req->data.get.serial == serial) - goto Found; - } - } - - /* not found */ - pthread_mutex_unlock(&conn->mutex); - return NULL; - -Found: - h2o_linklist_unlink(&req->inflight); - pthread_mutex_unlock(&conn->mutex); - return req; -} - -static void *writer_main(void *_conn) -{ - struct st_h2o_memcached_conn_t *conn = _conn; - yrmcds_error err; - - pthread_mutex_lock(&conn->ctx->mutex); - - while (!__sync_add_and_fetch(&conn->writer_exit_requested, 0)) { - while (!h2o_linklist_is_empty(&conn->ctx->pending)) { - h2o_memcached_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_memcached_req_t, pending, conn->ctx->pending.next); - h2o_linklist_unlink(&req->pending); - pthread_mutex_unlock(&conn->ctx->mutex); - - switch (req->type) { - case REQ_TYPE_GET: - pthread_mutex_lock(&conn->mutex); - h2o_linklist_insert(&conn->inflight, &req->inflight); - pthread_mutex_unlock(&conn->mutex); - if ((err = yrmcds_get(&conn->yrmcds, req->key.base, req->key.len, 0, &req->data.get.serial)) != YRMCDS_OK) - goto Error; - break; - case REQ_TYPE_SET: - err = yrmcds_set(&conn->yrmcds, req->key.base, req->key.len, req->data.set.value.base, req->data.set.value.len, 0, - req->data.set.expiration, 0, !conn->yrmcds.text_mode, NULL); - discard_req(req); - if (err != YRMCDS_OK) - goto Error; - break; - case REQ_TYPE_DELETE: - err = yrmcds_remove(&conn->yrmcds, req->key.base, req->key.len, !conn->yrmcds.text_mode, NULL); - discard_req(req); - if (err != YRMCDS_OK) - goto Error; - break; - default: - fprintf(stderr, "[lib/common/memcached.c] unknown type:%d\n", (int)req->type); - err = YRMCDS_NOT_IMPLEMENTED; - goto Error; - } - - pthread_mutex_lock(&conn->ctx->mutex); - } - pthread_cond_wait(&conn->ctx->cond, &conn->ctx->mutex); - } - - pthread_mutex_unlock(&conn->ctx->mutex); - return NULL; - -Error: - fprintf(stderr, "[lib/common/memcached.c] failed to send request; %s\n", yrmcds_strerror(err)); - /* doc says the call can be used to interrupt yrmcds_recv */ - yrmcds_shutdown(&conn->yrmcds); - - return NULL; -} - -static void connect_to_server(h2o_memcached_context_t *ctx, yrmcds *yrmcds) -{ - size_t failcnt; - yrmcds_error err; - - for (failcnt = 0; (err = yrmcds_connect(yrmcds, ctx->host, ctx->port)) != YRMCDS_OK; ++failcnt) { - if (failcnt == 0) { - fprintf(stderr, "[lib/common/memcached.c] failed to connect to memcached at %s:%" PRIu16 ", %s\n", ctx->host, ctx->port, - yrmcds_strerror(err)); - } - ++failcnt; - usleep(2000000 + h2o_rand() % 3000000); /* sleep 2 to 5 seconds */ - } - /* connected */ - if (ctx->text_protocol) - yrmcds_text_mode(yrmcds); - fprintf(stderr, "[lib/common/memcached.c] connected to memcached at %s:%" PRIu16 "\n", ctx->host, ctx->port); -} - -static void reader_main(h2o_memcached_context_t *ctx) -{ - struct st_h2o_memcached_conn_t conn = {ctx, {0}, PTHREAD_MUTEX_INITIALIZER, {&conn.inflight, &conn.inflight}, 0}; - pthread_t writer_thread; - yrmcds_response resp; - yrmcds_error err; - - /* connect to server and start the writer thread */ - connect_to_server(conn.ctx, &conn.yrmcds); - if (pthread_create(&writer_thread, NULL, writer_main, &conn) != 0) { - perror("pthread_create"); - abort(); - } - - pthread_mutex_lock(&conn.ctx->mutex); - ++conn.ctx->num_threads_connected; - pthread_mutex_unlock(&conn.ctx->mutex); - - /* receive data until an error occurs */ - while (1) { - if ((err = yrmcds_recv(&conn.yrmcds, &resp)) != YRMCDS_OK) { - fprintf(stderr, "[lib/common/memcached.c] yrmcds_recv:%s\n", yrmcds_strerror(err)); - break; - } - h2o_memcached_req_t *req = pop_inflight(&conn, resp.serial); - if (req == NULL) { - if (conn.yrmcds.text_mode) - continue; - fprintf(stderr, "[lib/common/memcached.c] received unexpected serial\n"); - break; - } - if (resp.status == YRMCDS_STATUS_OK) { - req->data.get.value = h2o_iovec_init(h2o_mem_alloc(resp.data_len), resp.data_len); - memcpy(req->data.get.value.base, resp.data, resp.data_len); - h2o_mem_set_secure((void *)resp.data, 0, resp.data_len); - } - h2o_multithread_send_message(req->data.get.receiver, &req->data.get.message); - } - - /* send error to all the reqs in-flight */ - pthread_mutex_lock(&conn.mutex); - while (!h2o_linklist_is_empty(&conn.inflight)) { - h2o_memcached_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_memcached_req_t, inflight, conn.inflight.next); - h2o_linklist_unlink(&req->inflight); - assert(req->type == REQ_TYPE_GET); - h2o_multithread_send_message(req->data.get.receiver, &req->data.get.message); - } - pthread_mutex_unlock(&conn.mutex); - - /* stop the writer thread */ - __sync_add_and_fetch(&conn.writer_exit_requested, 1); - pthread_mutex_lock(&conn.ctx->mutex); - pthread_cond_broadcast(&conn.ctx->cond); - pthread_mutex_unlock(&conn.ctx->mutex); - pthread_join(writer_thread, NULL); - - /* decrement num_threads_connected, and discard all the pending requests if no connections are alive */ - pthread_mutex_lock(&conn.ctx->mutex); - if (--conn.ctx->num_threads_connected == 0) { - while (!h2o_linklist_is_empty(&conn.ctx->pending)) { - h2o_memcached_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_memcached_req_t, pending, conn.ctx->pending.next); - h2o_linklist_unlink(&req->pending); - discard_req(req); - } - } - pthread_mutex_unlock(&conn.ctx->mutex); - - /* close the connection */ - yrmcds_close(&conn.yrmcds); -} - -static void *thread_main(void *_ctx) -{ - h2o_memcached_context_t *ctx = _ctx; - - while (1) - reader_main(ctx); - return NULL; -} - -static void dispatch(h2o_memcached_context_t *ctx, h2o_memcached_req_t *req) -{ - pthread_mutex_lock(&ctx->mutex); - - if (ctx->num_threads_connected != 0) { - h2o_linklist_insert(&ctx->pending, &req->pending); - pthread_cond_signal(&ctx->cond); - } else { - discard_req(req); - } - - pthread_mutex_unlock(&ctx->mutex); -} - -void h2o_memcached_receiver(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages) -{ - while (!h2o_linklist_is_empty(messages)) { - h2o_memcached_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_memcached_req_t, data.get.message.link, messages->next); - h2o_linklist_unlink(&req->data.get.message.link); - assert(req->type == REQ_TYPE_GET); - if (req->data.get.cb != NULL) { - if (req->data.get.value_is_encoded && req->data.get.value.len != 0) { - h2o_iovec_t decoded = h2o_decode_base64url(NULL, req->data.get.value.base, req->data.get.value.len); - h2o_mem_set_secure(req->data.get.value.base, 0, req->data.get.value.len); - free(req->data.get.value.base); - req->data.get.value = decoded; - } - req->data.get.cb(req->data.get.value, req->data.get.cb_data); - } - free_req(req); - } -} - -h2o_memcached_req_t *h2o_memcached_get(h2o_memcached_context_t *ctx, h2o_multithread_receiver_t *receiver, h2o_iovec_t key, - h2o_memcached_get_cb cb, void *cb_data, int flags) -{ - h2o_memcached_req_t *req = create_req(ctx, REQ_TYPE_GET, key, (flags & H2O_MEMCACHED_ENCODE_KEY) != 0); - req->data.get.receiver = receiver; - req->data.get.cb = cb; - req->data.get.cb_data = cb_data; - req->data.get.value_is_encoded = (flags & H2O_MEMCACHED_ENCODE_VALUE) != 0; - dispatch(ctx, req); - return req; -} - -void h2o_memcached_cancel_get(h2o_memcached_context_t *ctx, h2o_memcached_req_t *req) -{ - int do_free = 0; - - pthread_mutex_lock(&ctx->mutex); - req->data.get.cb = NULL; - if (h2o_linklist_is_linked(&req->pending)) { - h2o_linklist_unlink(&req->pending); - do_free = 1; - } - pthread_mutex_unlock(&ctx->mutex); - - if (do_free) - free_req(req); -} - -void h2o_memcached_set(h2o_memcached_context_t *ctx, h2o_iovec_t key, h2o_iovec_t value, uint32_t expiration, int flags) -{ - h2o_memcached_req_t *req = create_req(ctx, REQ_TYPE_SET, key, (flags & H2O_MEMCACHED_ENCODE_KEY) != 0); - if ((flags & H2O_MEMCACHED_ENCODE_VALUE) != 0) { - req->data.set.value.base = h2o_mem_alloc((value.len + 2) / 3 * 4 + 1); - req->data.set.value.len = h2o_base64_encode(req->data.set.value.base, value.base, value.len, 1); - } else { - req->data.set.value = h2o_iovec_init(h2o_mem_alloc(value.len), value.len); - memcpy(req->data.set.value.base, value.base, value.len); - } - req->data.set.expiration = expiration; - dispatch(ctx, req); -} - -void h2o_memcached_delete(h2o_memcached_context_t *ctx, h2o_iovec_t key, int flags) -{ - h2o_memcached_req_t *req = create_req(ctx, REQ_TYPE_DELETE, key, (flags & H2O_MEMCACHED_ENCODE_KEY) != 0); - dispatch(ctx, req); -} - -h2o_memcached_context_t *h2o_memcached_create_context(const char *host, uint16_t port, int text_protocol, size_t num_threads, - const char *prefix) -{ - h2o_memcached_context_t *ctx = h2o_mem_alloc(sizeof(*ctx)); - - pthread_mutex_init(&ctx->mutex, NULL); - pthread_cond_init(&ctx->cond, NULL); - h2o_linklist_init_anchor(&ctx->pending); - ctx->num_threads_connected = 0; - ctx->host = h2o_strdup(NULL, host, SIZE_MAX).base; - ctx->port = port; - ctx->text_protocol = text_protocol; - ctx->prefix = h2o_strdup(NULL, prefix, SIZE_MAX); - - { /* start the threads */ - pthread_t tid; - pthread_attr_t attr; - size_t i; - pthread_attr_init(&attr); - pthread_attr_setdetachstate(&attr, 1); - for (i = 0; i != num_threads; ++i) - h2o_multithread_create_thread(&tid, &attr, thread_main, ctx); - pthread_attr_destroy(&attr); - } - - return ctx; -} diff --git a/web/server/h2o/libh2o/lib/common/memory.c b/web/server/h2o/libh2o/lib/common/memory.c deleted file mode 100644 index ba9f2dba2..000000000 --- a/web/server/h2o/libh2o/lib/common/memory.c +++ /dev/null @@ -1,400 +0,0 @@ -/* - * Copyright (c) 2014 DeNA Co., Ltd. - * - * 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 <assert.h> -#include <errno.h> -#include <fcntl.h> -#include <stddef.h> -#include <stdio.h> -#include <stdint.h> -#include <stdlib.h> -#include <string.h> -#include <sys/mman.h> -#include <unistd.h> -#include "h2o/memory.h" - -#if defined(__linux__) -#define USE_POSIX_FALLOCATE 1 -#elif __FreeBSD__ >= 9 -#define USE_POSIX_FALLOCATE 1 -#elif __NetBSD__ >= 7 -#define USE_POSIX_FALLOCATE 1 -#else -#define USE_POSIX_FALLOCATE 0 -#endif - -struct st_h2o_mem_recycle_chunk_t { - struct st_h2o_mem_recycle_chunk_t *next; -}; - -struct st_h2o_mem_pool_chunk_t { - struct st_h2o_mem_pool_chunk_t *next; - size_t _dummy; /* align to 2*sizeof(void*) */ - char bytes[4096 - sizeof(void *) * 2]; -}; - -struct st_h2o_mem_pool_direct_t { - struct st_h2o_mem_pool_direct_t *next; - size_t _dummy; /* align to 2*sizeof(void*) */ - char bytes[1]; -}; - -struct st_h2o_mem_pool_shared_ref_t { - struct st_h2o_mem_pool_shared_ref_t *next; - struct st_h2o_mem_pool_shared_entry_t *entry; -}; - -void *(*h2o_mem__set_secure)(void *, int, size_t) = memset; - -static __thread h2o_mem_recycle_t mempool_allocator = {16}; - -void h2o__fatal(const char *msg) -{ - fprintf(stderr, "fatal:%s\n", msg); - abort(); -} - -void *h2o_mem_alloc_recycle(h2o_mem_recycle_t *allocator, size_t sz) -{ - struct st_h2o_mem_recycle_chunk_t *chunk; - if (allocator->cnt == 0) - return h2o_mem_alloc(sz); - /* detach and return the pooled pointer */ - chunk = allocator->_link; - assert(chunk != NULL); - allocator->_link = chunk->next; - --allocator->cnt; - return chunk; -} - -void h2o_mem_free_recycle(h2o_mem_recycle_t *allocator, void *p) -{ - struct st_h2o_mem_recycle_chunk_t *chunk; - if (allocator->cnt == allocator->max) { - free(p); - return; - } - /* register the pointer to the pool */ - chunk = p; - chunk->next = allocator->_link; - allocator->_link = chunk; - ++allocator->cnt; -} - -void h2o_mem_init_pool(h2o_mem_pool_t *pool) -{ - pool->chunks = NULL; - pool->chunk_offset = sizeof(pool->chunks->bytes); - pool->directs = NULL; - pool->shared_refs = NULL; -} - -void h2o_mem_clear_pool(h2o_mem_pool_t *pool) -{ - /* release the refcounted chunks */ - if (pool->shared_refs != NULL) { - struct st_h2o_mem_pool_shared_ref_t *ref = pool->shared_refs; - do { - h2o_mem_release_shared(ref->entry->bytes); - } while ((ref = ref->next) != NULL); - pool->shared_refs = NULL; - } - /* release the direct chunks */ - if (pool->directs != NULL) { - struct st_h2o_mem_pool_direct_t *direct = pool->directs, *next; - do { - next = direct->next; - free(direct); - } while ((direct = next) != NULL); - pool->directs = NULL; - } - /* free chunks, and reset the first chunk */ - while (pool->chunks != NULL) { - struct st_h2o_mem_pool_chunk_t *next = pool->chunks->next; - h2o_mem_free_recycle(&mempool_allocator, pool->chunks); - pool->chunks = next; - } - pool->chunk_offset = sizeof(pool->chunks->bytes); -} - -void *h2o_mem_alloc_pool(h2o_mem_pool_t *pool, size_t sz) -{ - void *ret; - - if (sz >= sizeof(pool->chunks->bytes) / 4) { - /* allocate large requests directly */ - struct st_h2o_mem_pool_direct_t *newp = h2o_mem_alloc(offsetof(struct st_h2o_mem_pool_direct_t, bytes) + sz); - newp->next = pool->directs; - pool->directs = newp; - return newp->bytes; - } - - /* return a valid pointer even for 0 sized allocs */ - if (sz == 0) - sz = 1; - - /* 16-bytes rounding */ - sz = (sz + 15) & ~15; - if (sizeof(pool->chunks->bytes) - pool->chunk_offset < sz) { - /* allocate new chunk */ - struct st_h2o_mem_pool_chunk_t *newp = h2o_mem_alloc_recycle(&mempool_allocator, sizeof(*newp)); - newp->next = pool->chunks; - pool->chunks = newp; - pool->chunk_offset = 0; - } - - ret = pool->chunks->bytes + pool->chunk_offset; - pool->chunk_offset += sz; - return ret; -} - -static void link_shared(h2o_mem_pool_t *pool, struct st_h2o_mem_pool_shared_entry_t *entry) -{ - struct st_h2o_mem_pool_shared_ref_t *ref = h2o_mem_alloc_pool(pool, sizeof(struct st_h2o_mem_pool_shared_ref_t)); - ref->entry = entry; - ref->next = pool->shared_refs; - pool->shared_refs = ref; -} - -void *h2o_mem_alloc_shared(h2o_mem_pool_t *pool, size_t sz, void (*dispose)(void *)) -{ - struct st_h2o_mem_pool_shared_entry_t *entry = h2o_mem_alloc(offsetof(struct st_h2o_mem_pool_shared_entry_t, bytes) + sz); - entry->refcnt = 1; - entry->dispose = dispose; - if (pool != NULL) - link_shared(pool, entry); - return entry->bytes; -} - -void h2o_mem_link_shared(h2o_mem_pool_t *pool, void *p) -{ - h2o_mem_addref_shared(p); - link_shared(pool, H2O_STRUCT_FROM_MEMBER(struct st_h2o_mem_pool_shared_entry_t, bytes, p)); -} - -static size_t topagesize(size_t capacity) -{ - size_t pagesize = getpagesize(); - return (offsetof(h2o_buffer_t, _buf) + capacity + pagesize - 1) / pagesize * pagesize; -} - -void h2o_buffer__do_free(h2o_buffer_t *buffer) -{ - /* caller should assert that the buffer is not part of the prototype */ - if (buffer->capacity == buffer->_prototype->_initial_buf.capacity) { - h2o_mem_free_recycle(&buffer->_prototype->allocator, buffer); - } else if (buffer->_fd != -1) { - close(buffer->_fd); - munmap((void *)buffer, topagesize(buffer->capacity)); - } else { - free(buffer); - } -} - -h2o_iovec_t h2o_buffer_reserve(h2o_buffer_t **_inbuf, size_t min_guarantee) -{ - h2o_buffer_t *inbuf = *_inbuf; - h2o_iovec_t ret; - - if (inbuf->bytes == NULL) { - h2o_buffer_prototype_t *prototype = H2O_STRUCT_FROM_MEMBER(h2o_buffer_prototype_t, _initial_buf, inbuf); - if (min_guarantee <= prototype->_initial_buf.capacity) { - min_guarantee = prototype->_initial_buf.capacity; - inbuf = h2o_mem_alloc_recycle(&prototype->allocator, offsetof(h2o_buffer_t, _buf) + min_guarantee); - } else { - inbuf = h2o_mem_alloc(offsetof(h2o_buffer_t, _buf) + min_guarantee); - } - *_inbuf = inbuf; - inbuf->size = 0; - inbuf->bytes = inbuf->_buf; - inbuf->capacity = min_guarantee; - inbuf->_prototype = prototype; - inbuf->_fd = -1; - } else { - if (min_guarantee <= inbuf->capacity - inbuf->size - (inbuf->bytes - inbuf->_buf)) { - /* ok */ - } else if ((inbuf->size + min_guarantee) * 2 <= inbuf->capacity) { - /* the capacity should be less than or equal to 2 times of: size + guarantee */ - memmove(inbuf->_buf, inbuf->bytes, inbuf->size); - inbuf->bytes = inbuf->_buf; - } else { - size_t new_capacity = inbuf->capacity; - do { - new_capacity *= 2; - } while (new_capacity - inbuf->size < min_guarantee); - if (inbuf->_prototype->mmap_settings != NULL && inbuf->_prototype->mmap_settings->threshold <= new_capacity) { - size_t new_allocsize = topagesize(new_capacity); - int fd; - h2o_buffer_t *newp; - if (inbuf->_fd == -1) { - char *tmpfn = alloca(strlen(inbuf->_prototype->mmap_settings->fn_template) + 1); - strcpy(tmpfn, inbuf->_prototype->mmap_settings->fn_template); - if ((fd = mkstemp(tmpfn)) == -1) { - fprintf(stderr, "failed to create temporary file:%s:%s\n", tmpfn, strerror(errno)); - goto MapError; - } - unlink(tmpfn); - } else { - fd = inbuf->_fd; - } - int fallocate_ret; -#if USE_POSIX_FALLOCATE - fallocate_ret = posix_fallocate(fd, 0, new_allocsize); -#else - fallocate_ret = ftruncate(fd, new_allocsize); -#endif - if (fallocate_ret != 0) { - perror("failed to resize temporary file"); - goto MapError; - } - if ((newp = (void *)mmap(NULL, new_allocsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) { - perror("mmap failed"); - goto MapError; - } - if (inbuf->_fd == -1) { - /* copy data (moving from malloc to mmap) */ - newp->size = inbuf->size; - newp->bytes = newp->_buf; - newp->capacity = new_capacity; - newp->_prototype = inbuf->_prototype; - newp->_fd = fd; - memcpy(newp->_buf, inbuf->bytes, inbuf->size); - h2o_buffer__do_free(inbuf); - *_inbuf = inbuf = newp; - } else { - /* munmap */ - size_t offset = inbuf->bytes - inbuf->_buf; - munmap((void *)inbuf, topagesize(inbuf->capacity)); - *_inbuf = inbuf = newp; - inbuf->capacity = new_capacity; - inbuf->bytes = newp->_buf + offset; - } - } else { - h2o_buffer_t *newp = h2o_mem_alloc(offsetof(h2o_buffer_t, _buf) + new_capacity); - newp->size = inbuf->size; - newp->bytes = newp->_buf; - newp->capacity = new_capacity; - newp->_prototype = inbuf->_prototype; - newp->_fd = -1; - memcpy(newp->_buf, inbuf->bytes, inbuf->size); - h2o_buffer__do_free(inbuf); - *_inbuf = inbuf = newp; - } - } - } - - ret.base = inbuf->bytes + inbuf->size; - ret.len = inbuf->_buf + inbuf->capacity - ret.base; - - return ret; - -MapError: - ret.base = NULL; - ret.len = 0; - return ret; -} - -void h2o_buffer_consume(h2o_buffer_t **_inbuf, size_t delta) -{ - h2o_buffer_t *inbuf = *_inbuf; - - if (delta != 0) { - assert(inbuf->bytes != NULL); - if (inbuf->size == delta) { - *_inbuf = &inbuf->_prototype->_initial_buf; - h2o_buffer__do_free(inbuf); - } else { - inbuf->size -= delta; - inbuf->bytes += delta; - } - } -} - -void h2o_buffer__dispose_linked(void *p) -{ - h2o_buffer_t **buf = p; - h2o_buffer_dispose(buf); -} - -void h2o_vector__expand(h2o_mem_pool_t *pool, h2o_vector_t *vector, size_t element_size, size_t new_capacity) -{ - void *new_entries; - assert(vector->capacity < new_capacity); - if (vector->capacity == 0) - vector->capacity = 4; - while (vector->capacity < new_capacity) - vector->capacity *= 2; - if (pool != NULL) { - new_entries = h2o_mem_alloc_pool(pool, element_size * vector->capacity); - h2o_memcpy(new_entries, vector->entries, element_size * vector->size); - } else { - new_entries = h2o_mem_realloc(vector->entries, element_size * vector->capacity); - } - vector->entries = new_entries; -} - -void h2o_mem_swap(void *_x, void *_y, size_t len) -{ - char *x = _x, *y = _y; - char buf[256]; - - while (len != 0) { - size_t blocksz = len < sizeof(buf) ? len : sizeof(buf); - memcpy(buf, x, blocksz); - memcpy(x, y, blocksz); - memcpy(y, buf, blocksz); - len -= blocksz; - x += blocksz; - y += blocksz; - } -} - -void h2o_dump_memory(FILE *fp, const char *buf, size_t len) -{ - size_t i, j; - - for (i = 0; i < len; i += 16) { - fprintf(fp, "%08zx", i); - for (j = 0; j != 16; ++j) { - if (i + j < len) - fprintf(fp, " %02x", (int)(unsigned char)buf[i + j]); - else - fprintf(fp, " "); - } - fprintf(fp, " "); - for (j = 0; j != 16 && i + j < len; ++j) { - int ch = buf[i + j]; - fputc(' ' <= ch && ch < 0x7f ? ch : '.', fp); - } - fprintf(fp, "\n"); - } -} - -void h2o_append_to_null_terminated_list(void ***list, void *element) -{ - size_t cnt; - - for (cnt = 0; (*list)[cnt] != NULL; ++cnt) - ; - *list = h2o_mem_realloc(*list, (cnt + 2) * sizeof(void *)); - (*list)[cnt++] = element; - (*list)[cnt] = NULL; -} diff --git a/web/server/h2o/libh2o/lib/common/multithread.c b/web/server/h2o/libh2o/lib/common/multithread.c deleted file mode 100644 index b4e8ba836..000000000 --- a/web/server/h2o/libh2o/lib/common/multithread.c +++ /dev/null @@ -1,274 +0,0 @@ -/* - * Copyright (c) 2015-2016 DeNA Co., Ltd., Kazuho Oku, Tatsuhiko Kubo, - * Chul-Woong Yang - * - * 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 <assert.h> -#include <pthread.h> -#include "cloexec.h" -#include "h2o/multithread.h" - -struct st_h2o_multithread_queue_t { -#if H2O_USE_LIBUV - uv_async_t async; -#else - struct { - int write; - h2o_socket_t *read; - } async; -#endif - pthread_mutex_t mutex; - struct { - h2o_linklist_t active; - h2o_linklist_t inactive; - } receivers; -}; - -static void queue_cb(h2o_multithread_queue_t *queue) -{ - pthread_mutex_lock(&queue->mutex); - - while (!h2o_linklist_is_empty(&queue->receivers.active)) { - h2o_multithread_receiver_t *receiver = - H2O_STRUCT_FROM_MEMBER(h2o_multithread_receiver_t, _link, queue->receivers.active.next); - /* detach all the messages from the receiver */ - h2o_linklist_t messages; - h2o_linklist_init_anchor(&messages); - h2o_linklist_insert_list(&messages, &receiver->_messages); - /* relink the receiver to the inactive list */ - h2o_linklist_unlink(&receiver->_link); - h2o_linklist_insert(&queue->receivers.inactive, &receiver->_link); - - /* dispatch the messages */ - pthread_mutex_unlock(&queue->mutex); - receiver->cb(receiver, &messages); - assert(h2o_linklist_is_empty(&messages)); - pthread_mutex_lock(&queue->mutex); - } - - pthread_mutex_unlock(&queue->mutex); -} - -#ifdef H2O_NO_64BIT_ATOMICS -pthread_mutex_t h2o_conn_id_mutex = PTHREAD_MUTEX_INITIALIZER; -#endif - -#if H2O_USE_LIBUV -#else - -#include <errno.h> -#include <fcntl.h> -#include <unistd.h> - -static void on_read(h2o_socket_t *sock, const char *err) -{ - if (err != NULL) { - fprintf(stderr, "pipe error\n"); - abort(); - } - - h2o_buffer_consume(&sock->input, sock->input->size); - queue_cb(sock->data); -} - -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); -} - -#endif - -h2o_multithread_queue_t *h2o_multithread_create_queue(h2o_loop_t *loop) -{ - h2o_multithread_queue_t *queue = h2o_mem_alloc(sizeof(*queue)); - memset(queue, 0, sizeof(*queue)); - -#if H2O_USE_LIBUV - uv_async_init(loop, &queue->async, (uv_async_cb)queue_cb); -#else - init_async(queue, loop); -#endif - pthread_mutex_init(&queue->mutex, NULL); - h2o_linklist_init_anchor(&queue->receivers.active); - h2o_linklist_init_anchor(&queue->receivers.inactive); - - return queue; -} - -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, (uv_close_cb)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); -} - -void h2o_multithread_register_receiver(h2o_multithread_queue_t *queue, h2o_multithread_receiver_t *receiver, - h2o_multithread_receiver_cb cb) -{ - receiver->queue = queue; - receiver->_link = (h2o_linklist_t){NULL}; - h2o_linklist_init_anchor(&receiver->_messages); - receiver->cb = cb; - - pthread_mutex_lock(&queue->mutex); - h2o_linklist_insert(&queue->receivers.inactive, &receiver->_link); - pthread_mutex_unlock(&queue->mutex); -} - -void h2o_multithread_unregister_receiver(h2o_multithread_queue_t *queue, h2o_multithread_receiver_t *receiver) -{ - assert(queue == receiver->queue); - assert(h2o_linklist_is_empty(&receiver->_messages)); - pthread_mutex_lock(&queue->mutex); - h2o_linklist_unlink(&receiver->_link); - pthread_mutex_unlock(&queue->mutex); -} - -void h2o_multithread_send_message(h2o_multithread_receiver_t *receiver, h2o_multithread_message_t *message) -{ - int do_send = 0; - - pthread_mutex_lock(&receiver->queue->mutex); - if (message != NULL) { - assert(!h2o_linklist_is_linked(&message->link)); - if (h2o_linklist_is_empty(&receiver->_messages)) { - h2o_linklist_unlink(&receiver->_link); - h2o_linklist_insert(&receiver->queue->receivers.active, &receiver->_link); - do_send = 1; - } - h2o_linklist_insert(&receiver->_messages, &message->link); - } else { - if (h2o_linklist_is_empty(&receiver->_messages)) - do_send = 1; - } - pthread_mutex_unlock(&receiver->queue->mutex); - - if (do_send) { -#if H2O_USE_LIBUV - uv_async_send(&receiver->queue->async); -#else - while (write(receiver->queue->async.write, "", 1) == -1 && errno == EINTR) - ; -#endif - } -} - -void h2o_multithread_create_thread(pthread_t *tid, const pthread_attr_t *attr, void *(*func)(void *), void *arg) -{ - if (pthread_create(tid, attr, func, arg) != 0) { - perror("pthread_create"); - abort(); - } -} - -void h2o_sem_init(h2o_sem_t *sem, ssize_t capacity) -{ - pthread_mutex_init(&sem->_mutex, NULL); - pthread_cond_init(&sem->_cond, NULL); - sem->_cur = capacity; - sem->_capacity = capacity; -} - -void h2o_sem_destroy(h2o_sem_t *sem) -{ - assert(sem->_cur == sem->_capacity); - pthread_cond_destroy(&sem->_cond); - pthread_mutex_destroy(&sem->_mutex); -} - -void h2o_sem_wait(h2o_sem_t *sem) -{ - pthread_mutex_lock(&sem->_mutex); - while (sem->_cur <= 0) - pthread_cond_wait(&sem->_cond, &sem->_mutex); - --sem->_cur; - pthread_mutex_unlock(&sem->_mutex); -} - -void h2o_sem_post(h2o_sem_t *sem) -{ - pthread_mutex_lock(&sem->_mutex); - ++sem->_cur; - pthread_cond_signal(&sem->_cond); - pthread_mutex_unlock(&sem->_mutex); -} - -void h2o_sem_set_capacity(h2o_sem_t *sem, ssize_t new_capacity) -{ - pthread_mutex_lock(&sem->_mutex); - sem->_cur += new_capacity - sem->_capacity; - sem->_capacity = new_capacity; - pthread_cond_broadcast(&sem->_cond); - pthread_mutex_unlock(&sem->_mutex); -} - -/* barrier */ - -void h2o_barrier_init(h2o_barrier_t *barrier, size_t count) -{ - pthread_mutex_init(&barrier->_mutex, NULL); - pthread_cond_init(&barrier->_cond, NULL); - barrier->_count = count; -} - -int h2o_barrier_wait(h2o_barrier_t *barrier) -{ - int ret; - pthread_mutex_lock(&barrier->_mutex); - barrier->_count--; - if (barrier->_count == 0) { - pthread_cond_broadcast(&barrier->_cond); - ret = 1; - } else { - while (barrier->_count) - pthread_cond_wait(&barrier->_cond, &barrier->_mutex); - ret = 0; - } - pthread_mutex_unlock(&barrier->_mutex); - return ret; -} - -int h2o_barrier_done(h2o_barrier_t *barrier) -{ - return __sync_add_and_fetch(&barrier->_count, 0) == 0; -} - -void h2o_barrier_destroy(h2o_barrier_t *barrier) -{ - pthread_mutex_destroy(&barrier->_mutex); - pthread_cond_destroy(&barrier->_cond); -} diff --git a/web/server/h2o/libh2o/lib/common/serverutil.c b/web/server/h2o/libh2o/lib/common/serverutil.c deleted file mode 100644 index 8226f6efc..000000000 --- a/web/server/h2o/libh2o/lib/common/serverutil.c +++ /dev/null @@ -1,317 +0,0 @@ -/* - * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Nick Desaulniers - * - * 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 <grp.h> -#include <pthread.h> -#include <pwd.h> -#include <signal.h> -#include <spawn.h> -#include <stdint.h> -#include <stdlib.h> -#include <string.h> -#include <sys/types.h> -#include <sys/wait.h> -#include <unistd.h> -#if !defined(_SC_NPROCESSORS_ONLN) -#include <sys/sysctl.h> -#endif -#include "cloexec.h" -#include "h2o/memory.h" -#include "h2o/serverutil.h" -#include "h2o/socket.h" -#include "h2o/string_.h" - -void h2o_set_signal_handler(int signo, void (*cb)(int signo)) -{ - struct sigaction action; - - memset(&action, 0, sizeof(action)); - sigemptyset(&action.sa_mask); - action.sa_handler = cb; - sigaction(signo, &action, NULL); -} - -int h2o_setuidgid(const char *user) -{ - struct passwd pwbuf, *pw; - char buf[65536]; /* should be large enough */ - - errno = 0; - if (getpwnam_r(user, &pwbuf, buf, sizeof(buf), &pw) != 0) { - perror("getpwnam_r"); - return -1; - } - if (pw == NULL) { - fprintf(stderr, "unknown user:%s\n", user); - return -1; - } - if (setgid(pw->pw_gid) != 0) { - fprintf(stderr, "setgid(%d) failed:%s\n", (int)pw->pw_gid, strerror(errno)); - return -1; - } - if (initgroups(pw->pw_name, pw->pw_gid) != 0) { - fprintf(stderr, "initgroups(%s, %d) failed:%s\n", pw->pw_name, (int)pw->pw_gid, strerror(errno)); - return -1; - } - if (setuid(pw->pw_uid) != 0) { - fprintf(stderr, "setuid(%d) failed:%s\n", (int)pw->pw_uid, strerror(errno)); - return -1; - } - - return 0; -} - -size_t h2o_server_starter_get_fds(int **_fds) -{ - const char *ports_env, *start, *end, *eq; - size_t t; - H2O_VECTOR(int) fds = {NULL}; - - if ((ports_env = getenv("SERVER_STARTER_PORT")) == NULL) - return 0; - if (ports_env[0] == '\0') { - fprintf(stderr, "$SERVER_STARTER_PORT is empty\n"); - return SIZE_MAX; - } - - /* ports_env example: 127.0.0.1:80=3;/tmp/sock=4 */ - for (start = ports_env; *start != '\0'; start = *end == ';' ? end + 1 : end) { - if ((end = strchr(start, ';')) == NULL) - end = start + strlen(start); - if ((eq = memchr(start, '=', end - start)) == NULL) { - fprintf(stderr, "invalid $SERVER_STARTER_PORT, an element without `=` in: %s\n", ports_env); - goto Error; - } - if ((t = h2o_strtosize(eq + 1, end - eq - 1)) == SIZE_MAX) { - fprintf(stderr, "invalid file descriptor number in $SERVER_STARTER_PORT: %s\n", ports_env); - goto Error; - } - h2o_vector_reserve(NULL, &fds, fds.size + 1); - fds.entries[fds.size++] = (int)t; - } - - *_fds = fds.entries; - return fds.size; -Error: - free(fds.entries); - return SIZE_MAX; -} - -static char **build_spawn_env(void) -{ - extern char **environ; - size_t num; - - /* calculate number of envvars, as well as looking for H2O_ROOT= */ - for (num = 0; environ[num] != NULL; ++num) - if (strncmp(environ[num], "H2O_ROOT=", sizeof("H2O_ROOT=") - 1) == 0) - return NULL; - - /* not found */ - char **newenv = h2o_mem_alloc(sizeof(*newenv) * (num + 2) + sizeof("H2O_ROOT=" H2O_TO_STR(H2O_ROOT))); - memcpy(newenv, environ, sizeof(*newenv) * num); - newenv[num] = (char *)(newenv + num + 2); - newenv[num + 1] = NULL; - strcpy(newenv[num], "H2O_ROOT=" H2O_TO_STR(H2O_ROOT)); - - return newenv; -} - -pid_t h2o_spawnp(const char *cmd, char *const *argv, const int *mapped_fds, int cloexec_mutex_is_locked) -{ -#if defined(__linux__) - - /* posix_spawnp of Linux does not return error if the executable does not exist, see - * https://gist.github.com/kazuho/0c233e6f86d27d6e4f09 - */ - extern char **environ; - int pipefds[2] = {-1, -1}, errnum; - pid_t pid; - - /* create pipe, used for sending error codes */ - if (pipe2(pipefds, O_CLOEXEC) != 0) - goto Error; - - /* fork */ - if (!cloexec_mutex_is_locked) - pthread_mutex_lock(&cloexec_mutex); - if ((pid = fork()) == 0) { - /* in child process, map the file descriptors and execute; return the errnum through pipe if exec failed */ - if (mapped_fds != NULL) { - for (; *mapped_fds != -1; mapped_fds += 2) { - if (mapped_fds[0] != mapped_fds[1]) { - if (mapped_fds[1] != -1) - dup2(mapped_fds[0], mapped_fds[1]); - close(mapped_fds[0]); - } - } - } - char **env = build_spawn_env(); - if (env != NULL) - environ = env; - execvp(cmd, argv); - errnum = errno; - write(pipefds[1], &errnum, sizeof(errnum)); - _exit(EX_SOFTWARE); - } - if (!cloexec_mutex_is_locked) - pthread_mutex_unlock(&cloexec_mutex); - if (pid == -1) - goto Error; - - /* parent process */ - close(pipefds[1]); - pipefds[1] = -1; - ssize_t rret; - errnum = 0; - while ((rret = read(pipefds[0], &errnum, sizeof(errnum))) == -1 && errno == EINTR) - ; - if (rret != 0) { - /* spawn failed */ - while (waitpid(pid, NULL, 0) != pid) - ; - pid = -1; - errno = errnum; - goto Error; - } - - /* spawn succeeded */ - close(pipefds[0]); - return pid; - -Error: - errnum = errno; - if (pipefds[0] != -1) - close(pipefds[0]); - if (pipefds[1] != -1) - close(pipefds[1]); - errno = errnum; - return -1; - -#else - - posix_spawn_file_actions_t file_actions; - pid_t pid; - extern char **environ; - char **env = build_spawn_env(); - posix_spawn_file_actions_init(&file_actions); - if (mapped_fds != NULL) { - for (; *mapped_fds != -1; mapped_fds += 2) { - if (mapped_fds[1] != -1) - posix_spawn_file_actions_adddup2(&file_actions, mapped_fds[0], mapped_fds[1]); - posix_spawn_file_actions_addclose(&file_actions, mapped_fds[0]); - } - } - if (!cloexec_mutex_is_locked) - pthread_mutex_lock(&cloexec_mutex); - errno = posix_spawnp(&pid, cmd, &file_actions, NULL, argv, env != NULL ? env : environ); - if (!cloexec_mutex_is_locked) - pthread_mutex_unlock(&cloexec_mutex); - free(env); - if (errno != 0) - return -1; - - return pid; - -#endif -} - -int h2o_read_command(const char *cmd, char **argv, h2o_buffer_t **resp, int *child_status) -{ - int respfds[2] = {-1, -1}; - pid_t pid = -1; - int mutex_locked = 0, ret = -1; - - h2o_buffer_init(resp, &h2o_socket_buffer_prototype); - - pthread_mutex_lock(&cloexec_mutex); - mutex_locked = 1; - - /* create pipe for reading the result */ - if (pipe(respfds) != 0) - goto Exit; - if (fcntl(respfds[0], F_SETFD, O_CLOEXEC) < 0) - goto Exit; - - /* spawn */ - int mapped_fds[] = {respfds[1], 1, /* stdout of the child process is read from the pipe */ - -1}; - if ((pid = h2o_spawnp(cmd, argv, mapped_fds, 1)) == -1) - goto Exit; - close(respfds[1]); - respfds[1] = -1; - - pthread_mutex_unlock(&cloexec_mutex); - mutex_locked = 0; - - /* read the response from pipe */ - while (1) { - h2o_iovec_t buf = h2o_buffer_reserve(resp, 8192); - ssize_t r; - while ((r = read(respfds[0], buf.base, buf.len)) == -1 && errno == EINTR) - ; - if (r <= 0) - break; - (*resp)->size += r; - } - -Exit: - if (mutex_locked) - pthread_mutex_unlock(&cloexec_mutex); - if (pid != -1) { - /* wait for the child to complete */ - pid_t r; - while ((r = waitpid(pid, child_status, 0)) == -1 && errno == EINTR) - ; - if (r == pid) { - /* success */ - ret = 0; - } - } - if (respfds[0] != -1) - close(respfds[0]); - if (respfds[1] != -1) - close(respfds[1]); - if (ret != 0) - h2o_buffer_dispose(resp); - - return ret; -} - -size_t h2o_numproc(void) -{ -#if defined(_SC_NPROCESSORS_ONLN) - return (size_t)sysconf(_SC_NPROCESSORS_ONLN); -#elif defined(CTL_HW) && defined(HW_AVAILCPU) - int name[] = {CTL_HW, HW_AVAILCPU}; - int ncpu; - size_t ncpu_sz = sizeof(ncpu); - if (sysctl(name, sizeof(name) / sizeof(name[0]), &ncpu, &ncpu_sz, NULL, 0) != 0 || sizeof(ncpu) != ncpu_sz) { - fprintf(stderr, "[ERROR] failed to obtain number of CPU cores, assuming as one\n"); - ncpu = 1; - } - return ncpu; -#else - return 1; -#endif -} diff --git a/web/server/h2o/libh2o/lib/common/socket.c b/web/server/h2o/libh2o/lib/common/socket.c deleted file mode 100644 index 5b1c37e04..000000000 --- a/web/server/h2o/libh2o/lib/common/socket.c +++ /dev/null @@ -1,1433 +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); -} - -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])); -} diff --git a/web/server/h2o/libh2o/lib/common/socket/evloop.c.h b/web/server/h2o/libh2o/lib/common/socket/evloop.c.h deleted file mode 100644 index 754ed23b9..000000000 --- a/web/server/h2o/libh2o/lib/common/socket/evloop.c.h +++ /dev/null @@ -1,624 +0,0 @@ -/* - * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, 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 <netinet/in.h> -#include <netinet/tcp.h> -#include <stdlib.h> -#include <sys/socket.h> -#include <sys/time.h> -#include <sys/uio.h> -#include <unistd.h> -#include "cloexec.h" -#include "h2o/linklist.h" - -#if !defined(H2O_USE_ACCEPT4) -#ifdef __linux__ -#define H2O_USE_ACCEPT4 1 -#elif __FreeBSD__ >= 10 -#define H2O_USE_ACCEPT4 1 -#else -#define H2O_USE_ACCEPT4 0 -#endif -#endif - -struct st_h2o_evloop_socket_t { - h2o_socket_t super; - int fd; - int _flags; - h2o_evloop_t *loop; - struct { - size_t cnt; - h2o_iovec_t *bufs; - union { - h2o_iovec_t *alloced_ptr; - h2o_iovec_t smallbufs[4]; - }; - } _wreq; - struct st_h2o_evloop_socket_t *_next_pending; - struct st_h2o_evloop_socket_t *_next_statechanged; -}; - -static void link_to_pending(struct st_h2o_evloop_socket_t *sock); -static void write_pending(struct st_h2o_evloop_socket_t *sock); -static h2o_evloop_t *create_evloop(size_t sz); -static void update_now(h2o_evloop_t *loop); -static int32_t adjust_max_wait(h2o_evloop_t *loop, int32_t max_wait); - -/* functions to be defined in the backends */ -static int evloop_do_proceed(h2o_evloop_t *loop, int32_t max_wait); -static void evloop_do_on_socket_create(struct st_h2o_evloop_socket_t *sock); -static void evloop_do_on_socket_close(struct st_h2o_evloop_socket_t *sock); -static void evloop_do_on_socket_export(struct st_h2o_evloop_socket_t *sock); - -#if H2O_USE_POLL || H2O_USE_EPOLL || H2O_USE_KQUEUE -/* explicitly specified */ -#else -#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) -#define H2O_USE_KQUEUE 1 -#elif defined(__linux) -#define H2O_USE_EPOLL 1 -#else -#define H2O_USE_POLL 1 -#endif -#endif - -#if H2O_USE_POLL -#include "evloop/poll.c.h" -#elif H2O_USE_EPOLL -#include "evloop/epoll.c.h" -#elif H2O_USE_KQUEUE -#include "evloop/kqueue.c.h" -#else -#error "poller not specified" -#endif - -void link_to_pending(struct st_h2o_evloop_socket_t *sock) -{ - if (sock->_next_pending == sock) { - struct st_h2o_evloop_socket_t **slot = (sock->_flags & H2O_SOCKET_FLAG_IS_ACCEPTED_CONNECTION) != 0 - ? &sock->loop->_pending_as_server - : &sock->loop->_pending_as_client; - sock->_next_pending = *slot; - *slot = sock; - } -} - -static void link_to_statechanged(struct st_h2o_evloop_socket_t *sock) -{ - if (sock->_next_statechanged == sock) { - sock->_next_statechanged = NULL; - *sock->loop->_statechanged.tail_ref = sock; - sock->loop->_statechanged.tail_ref = &sock->_next_statechanged; - } -} - -static const char *on_read_core(int fd, h2o_buffer_t **input) -{ - int read_any = 0; - - while (1) { - ssize_t rret; - h2o_iovec_t buf = h2o_buffer_reserve(input, 4096); - if (buf.base == NULL) { - /* memory allocation failed */ - return h2o_socket_error_out_of_memory; - } - while ((rret = read(fd, buf.base, buf.len <= INT_MAX / 2 ? buf.len : INT_MAX / 2 + 1)) == -1 && errno == EINTR) - ; - if (rret == -1) { - if (errno == EAGAIN) - break; - else - return h2o_socket_error_io; - } else if (rret == 0) { - if (!read_any) - return h2o_socket_error_closed; /* TODO notify close */ - break; - } - (*input)->size += rret; - if (buf.len != rret) - break; - read_any = 1; - } - return NULL; -} - -static void wreq_free_buffer_if_allocated(struct st_h2o_evloop_socket_t *sock) -{ - if (sock->_wreq.smallbufs <= sock->_wreq.bufs && - sock->_wreq.bufs <= sock->_wreq.smallbufs + sizeof(sock->_wreq.smallbufs) / sizeof(sock->_wreq.smallbufs[0])) { - /* no need to free */ - } else { - free(sock->_wreq.alloced_ptr); - sock->_wreq.bufs = sock->_wreq.smallbufs; - } -} - -static int write_core(int fd, h2o_iovec_t **bufs, size_t *bufcnt) -{ - int iovcnt; - ssize_t wret; - - if (*bufcnt != 0) { - do { - /* write */ - iovcnt = IOV_MAX; - if (*bufcnt < iovcnt) - iovcnt = (int)*bufcnt; - while ((wret = writev(fd, (struct iovec *)*bufs, iovcnt)) == -1 && errno == EINTR) - ; - if (wret == -1) { - if (errno != EAGAIN) - return -1; - break; - } - /* adjust the buffer */ - while ((*bufs)->len < wret) { - wret -= (*bufs)->len; - ++*bufs; - --*bufcnt; - assert(*bufcnt != 0); - } - if (((*bufs)->len -= wret) == 0) { - ++*bufs; - --*bufcnt; - } else { - (*bufs)->base += wret; - } - } while (*bufcnt != 0 && iovcnt == IOV_MAX); - } - - return 0; -} - -void write_pending(struct st_h2o_evloop_socket_t *sock) -{ - assert(sock->super._cb.write != NULL); - - /* DONT_WRITE poll */ - if (sock->_wreq.cnt == 0) - goto Complete; - - /* write */ - if (write_core(sock->fd, &sock->_wreq.bufs, &sock->_wreq.cnt) == 0 && sock->_wreq.cnt != 0) { - /* partial write */ - return; - } - - /* either completed or failed */ - wreq_free_buffer_if_allocated(sock); - -Complete: - sock->_flags |= H2O_SOCKET_FLAG_IS_WRITE_NOTIFY; - link_to_pending(sock); - link_to_statechanged(sock); /* might need to disable the write polling */ -} - -static void read_on_ready(struct st_h2o_evloop_socket_t *sock) -{ - const char *err = 0; - size_t prev_bytes_read = sock->super.input->size; - - if ((sock->_flags & H2O_SOCKET_FLAG_DONT_READ) != 0) - goto Notify; - - if ((err = on_read_core(sock->fd, sock->super.ssl == NULL ? &sock->super.input : &sock->super.ssl->input.encrypted)) != NULL) - goto Notify; - - if (sock->super.ssl != NULL && sock->super.ssl->handshake.cb == NULL) - err = decode_ssl_input(&sock->super); - -Notify: - /* the application may get notified even if no new data is avaiable. The - * behavior is intentional; it is designed as such so that the applications - * can update their timeout counters when a partial SSL record arrives. - */ - sock->super.bytes_read = sock->super.input->size - prev_bytes_read; - sock->super._cb.read(&sock->super, err); -} - -void do_dispose_socket(h2o_socket_t *_sock) -{ - struct st_h2o_evloop_socket_t *sock = (struct st_h2o_evloop_socket_t *)_sock; - - evloop_do_on_socket_close(sock); - wreq_free_buffer_if_allocated(sock); - if (sock->fd != -1) { - close(sock->fd); - sock->fd = -1; - } - sock->_flags = H2O_SOCKET_FLAG_IS_DISPOSED; - link_to_statechanged(sock); -} - -void do_write(h2o_socket_t *_sock, h2o_iovec_t *_bufs, size_t bufcnt, h2o_socket_cb cb) -{ - struct st_h2o_evloop_socket_t *sock = (struct st_h2o_evloop_socket_t *)_sock; - h2o_iovec_t *bufs; - h2o_iovec_t *tofree = NULL; - - assert(sock->super._cb.write == NULL); - assert(sock->_wreq.cnt == 0); - sock->super._cb.write = cb; - - /* cap the number of buffers, since we're using alloca */ - if (bufcnt > 10000) - bufs = tofree = h2o_mem_alloc(sizeof(*bufs) * bufcnt); - else - bufs = alloca(sizeof(*bufs) * bufcnt); - - memcpy(bufs, _bufs, sizeof(*bufs) * bufcnt); - - /* try to write now */ - if (write_core(sock->fd, &bufs, &bufcnt) != 0) { - /* fill in _wreq.bufs with fake data to indicate error */ - sock->_wreq.bufs = sock->_wreq.smallbufs; - sock->_wreq.cnt = 1; - *sock->_wreq.bufs = h2o_iovec_init(H2O_STRLIT("deadbeef")); - sock->_flags |= H2O_SOCKET_FLAG_IS_WRITE_NOTIFY; - link_to_pending(sock); - goto Out; - } - if (bufcnt == 0) { - /* write complete, schedule the callback */ - sock->_flags |= H2O_SOCKET_FLAG_IS_WRITE_NOTIFY; - link_to_pending(sock); - goto Out; - } - - - /* setup the buffer to send pending data */ - if (bufcnt <= sizeof(sock->_wreq.smallbufs) / sizeof(sock->_wreq.smallbufs[0])) { - sock->_wreq.bufs = sock->_wreq.smallbufs; - } else { - sock->_wreq.bufs = h2o_mem_alloc(sizeof(h2o_iovec_t) * bufcnt); - sock->_wreq.alloced_ptr = sock->_wreq.bufs; - } - memcpy(sock->_wreq.bufs, bufs, sizeof(h2o_iovec_t) * bufcnt); - sock->_wreq.cnt = bufcnt; - - /* schedule the write */ - link_to_statechanged(sock); -Out: - free(tofree); -} - -int h2o_socket_get_fd(h2o_socket_t *_sock) -{ - struct st_h2o_evloop_socket_t *sock = (struct st_h2o_evloop_socket_t *)_sock; - return sock->fd; -} - -void do_read_start(h2o_socket_t *_sock) -{ - struct st_h2o_evloop_socket_t *sock = (struct st_h2o_evloop_socket_t *)_sock; - - link_to_statechanged(sock); -} - -void do_read_stop(h2o_socket_t *_sock) -{ - struct st_h2o_evloop_socket_t *sock = (struct st_h2o_evloop_socket_t *)_sock; - - sock->_flags &= ~H2O_SOCKET_FLAG_IS_READ_READY; - link_to_statechanged(sock); -} - -void h2o_socket_dont_read(h2o_socket_t *_sock, int dont_read) -{ - struct st_h2o_evloop_socket_t *sock = (struct st_h2o_evloop_socket_t *)_sock; - - if (dont_read) { - sock->_flags |= H2O_SOCKET_FLAG_DONT_READ; - } else { - sock->_flags &= ~H2O_SOCKET_FLAG_DONT_READ; - } -} - -int do_export(h2o_socket_t *_sock, h2o_socket_export_t *info) -{ - struct st_h2o_evloop_socket_t *sock = (void *)_sock; - - assert((sock->_flags & H2O_SOCKET_FLAG_IS_DISPOSED) == 0); - evloop_do_on_socket_export(sock); - sock->_flags = H2O_SOCKET_FLAG_IS_DISPOSED; - - info->fd = sock->fd; - sock->fd = -1; - - return 0; -} - -h2o_socket_t *do_import(h2o_loop_t *loop, h2o_socket_export_t *info) -{ - return h2o_evloop_socket_create(loop, info->fd, 0); -} - -h2o_loop_t *h2o_socket_get_loop(h2o_socket_t *_sock) -{ - struct st_h2o_evloop_socket_t *sock = (void *)_sock; - return sock->loop; -} - -socklen_t h2o_socket_getsockname(h2o_socket_t *_sock, struct sockaddr *sa) -{ - struct st_h2o_evloop_socket_t *sock = (void *)_sock; - socklen_t len = sizeof(struct sockaddr_storage); - if (getsockname(sock->fd, sa, &len) != 0) - return 0; - return len; -} - -socklen_t get_peername_uncached(h2o_socket_t *_sock, struct sockaddr *sa) -{ - struct st_h2o_evloop_socket_t *sock = (void *)_sock; - socklen_t len = sizeof(struct sockaddr_storage); - if (getpeername(sock->fd, sa, &len) != 0) - return 0; - return len; -} - -static struct st_h2o_evloop_socket_t *create_socket(h2o_evloop_t *loop, int fd, int flags) -{ - struct st_h2o_evloop_socket_t *sock; - - fcntl(fd, F_SETFL, O_NONBLOCK); - - sock = h2o_mem_alloc(sizeof(*sock)); - memset(sock, 0, sizeof(*sock)); - h2o_buffer_init(&sock->super.input, &h2o_socket_buffer_prototype); - sock->loop = loop; - sock->fd = fd; - sock->_flags = flags; - sock->_wreq.bufs = sock->_wreq.smallbufs; - sock->_next_pending = sock; - sock->_next_statechanged = sock; - - evloop_do_on_socket_create(sock); - - return sock; -} - -static struct st_h2o_evloop_socket_t *create_socket_set_nodelay(h2o_evloop_t *loop, int fd, int flags) -{ - int on = 1; - setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)); - return create_socket(loop, fd, flags); -} - -h2o_socket_t *h2o_evloop_socket_create(h2o_evloop_t *loop, int fd, int flags) -{ - fcntl(fd, F_SETFL, O_NONBLOCK); - return &create_socket(loop, fd, flags)->super; -} - -h2o_socket_t *h2o_evloop_socket_accept(h2o_socket_t *_listener) -{ - struct st_h2o_evloop_socket_t *listener = (struct st_h2o_evloop_socket_t *)_listener; - int fd; - -#if H2O_USE_ACCEPT4 - if ((fd = accept4(listener->fd, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC)) == -1) - return NULL; -#else - if ((fd = cloexec_accept(listener->fd, NULL, NULL)) == -1) - return NULL; - fcntl(fd, F_SETFL, O_NONBLOCK); -#endif - - return &create_socket_set_nodelay(listener->loop, fd, H2O_SOCKET_FLAG_IS_ACCEPTED_CONNECTION)->super; -} - -h2o_socket_t *h2o_socket_connect(h2o_loop_t *loop, struct sockaddr *addr, socklen_t addrlen, h2o_socket_cb cb) -{ - int fd; - struct st_h2o_evloop_socket_t *sock; - - if ((fd = cloexec_socket(addr->sa_family, SOCK_STREAM, 0)) == -1) - return NULL; - fcntl(fd, F_SETFL, O_NONBLOCK); - if (!(connect(fd, addr, addrlen) == 0 || errno == EINPROGRESS)) { - close(fd); - return NULL; - } - - sock = create_socket_set_nodelay(loop, fd, H2O_SOCKET_FLAG_IS_CONNECTING); - h2o_socket_notify_write(&sock->super, cb); - return &sock->super; -} - -h2o_evloop_t *create_evloop(size_t sz) -{ - h2o_evloop_t *loop = h2o_mem_alloc(sz); - - memset(loop, 0, sz); - loop->_statechanged.tail_ref = &loop->_statechanged.head; - h2o_linklist_init_anchor(&loop->_timeouts); - - update_now(loop); - - return loop; -} - -void update_now(h2o_evloop_t *loop) -{ - struct timeval tv; - gettimeofday(&tv, NULL); - loop->_now = (uint64_t)tv.tv_sec * 1000 + tv.tv_usec / 1000; -} - -int32_t adjust_max_wait(h2o_evloop_t *loop, int32_t max_wait) -{ - uint64_t wake_at = h2o_timeout_get_wake_at(&loop->_timeouts); - - update_now(loop); - - if (wake_at <= loop->_now) { - max_wait = 0; - } else { - uint64_t delta = wake_at - loop->_now; - if (delta < max_wait) - max_wait = (int32_t)delta; - } - - return max_wait; -} - -void h2o_socket_notify_write(h2o_socket_t *_sock, h2o_socket_cb cb) -{ - struct st_h2o_evloop_socket_t *sock = (struct st_h2o_evloop_socket_t *)_sock; - assert(sock->super._cb.write == NULL); - assert(sock->_wreq.cnt == 0); - - sock->super._cb.write = cb; - link_to_statechanged(sock); -} - -static void run_socket(struct st_h2o_evloop_socket_t *sock) -{ - if ((sock->_flags & H2O_SOCKET_FLAG_IS_DISPOSED) != 0) { - /* is freed in updatestates phase */ - return; - } - - if ((sock->_flags & H2O_SOCKET_FLAG_IS_READ_READY) != 0) { - sock->_flags &= ~H2O_SOCKET_FLAG_IS_READ_READY; - read_on_ready(sock); - } - - if ((sock->_flags & H2O_SOCKET_FLAG_IS_WRITE_NOTIFY) != 0) { - const char *err = NULL; - assert(sock->super._cb.write != NULL); - sock->_flags &= ~H2O_SOCKET_FLAG_IS_WRITE_NOTIFY; - if (sock->_wreq.cnt != 0) { - /* error */ - err = h2o_socket_error_io; - sock->_wreq.cnt = 0; - } else if ((sock->_flags & H2O_SOCKET_FLAG_IS_CONNECTING) != 0) { - sock->_flags &= ~H2O_SOCKET_FLAG_IS_CONNECTING; - int so_err = 0; - socklen_t l = sizeof(so_err); - so_err = 0; - if (getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &so_err, &l) != 0 || so_err != 0) { - /* FIXME lookup the error table */ - err = h2o_socket_error_conn_fail; - } - } - on_write_complete(&sock->super, err); - } -} - -static void run_pending(h2o_evloop_t *loop) -{ - struct st_h2o_evloop_socket_t *sock; - - while (loop->_pending_as_server != NULL || loop->_pending_as_client != NULL) { - while ((sock = loop->_pending_as_client) != NULL) { - loop->_pending_as_client = sock->_next_pending; - sock->_next_pending = sock; - run_socket(sock); - } - if ((sock = loop->_pending_as_server) != NULL) { - loop->_pending_as_server = sock->_next_pending; - sock->_next_pending = sock; - run_socket(sock); - } - } -} - -void h2o_evloop_destroy(h2o_evloop_t *loop) -{ - struct st_h2o_evloop_socket_t *sock; - - /* timeouts are governed by the application and MUST be destroyed prior to destroying the loop */ - assert(h2o_linklist_is_empty(&loop->_timeouts)); - - /* dispose all socket */ - while ((sock = loop->_pending_as_client) != NULL) { - loop->_pending_as_client = sock->_next_pending; - sock->_next_pending = sock; - h2o_socket_close((h2o_socket_t *)sock); - } - while ((sock = loop->_pending_as_server) != NULL) { - loop->_pending_as_server = sock->_next_pending; - sock->_next_pending = sock; - h2o_socket_close((h2o_socket_t *)sock); - } - - /* now all socket are disposedand and placed in linked list statechanged - * we can freeing memory in cycle by next_statechanged, - */ - while ((sock = loop->_statechanged.head) != NULL) { - loop->_statechanged.head = sock->_next_statechanged; - free(sock); - } - - /* lastly we need to free loop memory */ - free(loop); -} - -int h2o_evloop_run(h2o_evloop_t *loop, int32_t max_wait) -{ - h2o_linklist_t *node; - - /* update socket states, poll, set readable flags, perform pending writes */ - if (evloop_do_proceed(loop, max_wait) != 0) - return -1; - - /* run the pending callbacks */ - run_pending(loop); - - /* run the timeouts */ - for (node = loop->_timeouts.next; node != &loop->_timeouts; node = node->next) { - h2o_timeout_t *timeout = H2O_STRUCT_FROM_MEMBER(h2o_timeout_t, _link, node); - h2o_timeout_run(loop, timeout, loop->_now); - } - /* assert h2o_timeout_run has called run_pending */ - assert(loop->_pending_as_client == NULL); - assert(loop->_pending_as_server == NULL); - - if (h2o_sliding_counter_is_running(&loop->exec_time_counter)) { - update_now(loop); - h2o_sliding_counter_stop(&loop->exec_time_counter, loop->_now); - } - - return 0; -} - -void h2o_timeout__do_init(h2o_evloop_t *loop, h2o_timeout_t *timeout) -{ - h2o_linklist_insert(&loop->_timeouts, &timeout->_link); -} - -void h2o_timeout__do_dispose(h2o_evloop_t *loop, h2o_timeout_t *timeout) -{ - h2o_linklist_unlink(&timeout->_link); -} - -void h2o_timeout__do_link(h2o_evloop_t *loop, h2o_timeout_t *timeout, h2o_timeout_entry_t *entry) -{ - /* nothing to do */ -} - -void h2o_timeout__do_post_callback(h2o_evloop_t *loop) -{ - run_pending(loop); -} diff --git a/web/server/h2o/libh2o/lib/common/socket/evloop/epoll.c.h b/web/server/h2o/libh2o/lib/common/socket/evloop/epoll.c.h deleted file mode 100644 index 247dac893..000000000 --- a/web/server/h2o/libh2o/lib/common/socket/evloop/epoll.c.h +++ /dev/null @@ -1,203 +0,0 @@ -/* - * Copyright (c) 2014 DeNA Co., Ltd. - * - * 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 <assert.h> -#include <limits.h> -#include <stdio.h> -#include <sys/epoll.h> - -#if 0 -#define DEBUG_LOG(...) fprintf(stderr, __VA_ARGS__) -#else -#define DEBUG_LOG(...) -#endif - -struct st_h2o_evloop_epoll_t { - h2o_evloop_t super; - int ep; -}; - -static int update_status(struct st_h2o_evloop_epoll_t *loop) -{ - while (loop->super._statechanged.head != NULL) { - /* detach the top */ - struct st_h2o_evloop_socket_t *sock = loop->super._statechanged.head; - loop->super._statechanged.head = sock->_next_statechanged; - sock->_next_statechanged = sock; - /* update the state */ - if ((sock->_flags & H2O_SOCKET_FLAG_IS_DISPOSED) != 0) { - free(sock); - } else { - int changed = 0, op, ret; - struct epoll_event ev; - ev.events = 0; - if (h2o_socket_is_reading(&sock->super)) { - ev.events |= EPOLLIN; - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_READ) == 0) { - sock->_flags |= H2O_SOCKET_FLAG_IS_POLLED_FOR_READ; - changed = 1; - } - } else { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_READ) != 0) { - sock->_flags &= ~H2O_SOCKET_FLAG_IS_POLLED_FOR_READ; - changed = 1; - } - } - if (h2o_socket_is_writing(&sock->super)) { - ev.events |= EPOLLOUT; - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE) == 0) { - sock->_flags |= H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE; - changed = 1; - } - } else { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE) != 0) { - sock->_flags &= ~H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE; - changed = 1; - } - } - if (changed) { - if ((sock->_flags & H2O_SOCKET_FLAG__EPOLL_IS_REGISTERED) != 0) { - if (ev.events != 0) - op = EPOLL_CTL_MOD; - else - op = EPOLL_CTL_DEL; - } else { - assert(ev.events != 0); - op = EPOLL_CTL_ADD; - } - ev.data.ptr = sock; - while ((ret = epoll_ctl(loop->ep, op, sock->fd, &ev)) != 0 && errno == EINTR) - ; - if (ret != 0) - return -1; - if (op == EPOLL_CTL_DEL) - sock->_flags &= ~H2O_SOCKET_FLAG__EPOLL_IS_REGISTERED; - else - sock->_flags |= H2O_SOCKET_FLAG__EPOLL_IS_REGISTERED; - } - } - } - loop->super._statechanged.tail_ref = &loop->super._statechanged.head; - - return 0; -} - -int evloop_do_proceed(h2o_evloop_t *_loop, int32_t max_wait) -{ - struct st_h2o_evloop_epoll_t *loop = (struct st_h2o_evloop_epoll_t *)_loop; - struct epoll_event events[256]; - int nevents, i; - - /* collect (and update) status */ - if (update_status(loop) != 0) - return -1; - - /* poll */ - max_wait = adjust_max_wait(&loop->super, max_wait); - nevents = epoll_wait(loop->ep, events, sizeof(events) / sizeof(events[0]), max_wait); - update_now(&loop->super); - if (nevents == -1) - return -1; - - if (nevents != 0) - h2o_sliding_counter_start(&loop->super.exec_time_counter, loop->super._now); - - /* update readable flags, perform writes */ - for (i = 0; i != nevents; ++i) { - struct st_h2o_evloop_socket_t *sock = events[i].data.ptr; - int notified = 0; - if ((events[i].events & (EPOLLIN | EPOLLHUP | EPOLLERR)) != 0) { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_READ) != 0) { - sock->_flags |= H2O_SOCKET_FLAG_IS_READ_READY; - link_to_pending(sock); - notified = 1; - } - } - if ((events[i].events & (EPOLLOUT | EPOLLHUP | EPOLLERR)) != 0) { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE) != 0) { - write_pending(sock); - notified = 1; - } - } - if (!notified) { - static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; - static time_t last_reported = 0; - time_t now = time(NULL); - pthread_mutex_lock(&lock); - if (last_reported + 60 < now) { - last_reported = now; - fprintf(stderr, "ignoring epoll event (fd:%d,event:%x)\n", sock->fd, (int)events[i].events); - } - pthread_mutex_unlock(&lock); - } - } - - return 0; -} - -static void evloop_do_on_socket_create(struct st_h2o_evloop_socket_t *sock) -{ -} - -static void evloop_do_on_socket_close(struct st_h2o_evloop_socket_t *sock) -{ - struct st_h2o_evloop_epoll_t *loop = (void *)sock->loop; - int ret; - - if (sock->fd == -1) - return; - if ((sock->_flags & H2O_SOCKET_FLAG__EPOLL_IS_REGISTERED) == 0) - return; - while ((ret = epoll_ctl(loop->ep, EPOLL_CTL_DEL, sock->fd, NULL)) != 0 && errno == EINTR) - ; - if (ret != 0) - fprintf(stderr, "socket_close: epoll(DEL) returned error %d (fd=%d)\n", errno, sock->fd); -} - -static void evloop_do_on_socket_export(struct st_h2o_evloop_socket_t *sock) -{ - struct st_h2o_evloop_epoll_t *loop = (void *)sock->loop; - int ret; - - if ((sock->_flags & H2O_SOCKET_FLAG__EPOLL_IS_REGISTERED) == 0) - return; - while ((ret = epoll_ctl(loop->ep, EPOLL_CTL_DEL, sock->fd, NULL)) != 0 && errno == EINTR) - ; - if (ret != 0) - fprintf(stderr, "socket_export: epoll(DEL) returned error %d (fd=%d)\n", errno, sock->fd); -} - -h2o_evloop_t *h2o_evloop_create(void) -{ - struct st_h2o_evloop_epoll_t *loop = (struct st_h2o_evloop_epoll_t *)create_evloop(sizeof(*loop)); - - pthread_mutex_lock(&cloexec_mutex); - loop->ep = epoll_create(10); - while (fcntl(loop->ep, F_SETFD, FD_CLOEXEC) == -1) { - if (errno != EAGAIN) { - fprintf(stderr, "h2o_evloop_create: failed to set FD_CLOEXEC to the epoll fd (errno=%d)\n", errno); - abort(); - } - } - pthread_mutex_unlock(&cloexec_mutex); - - return &loop->super; -} diff --git a/web/server/h2o/libh2o/lib/common/socket/evloop/kqueue.c.h b/web/server/h2o/libh2o/lib/common/socket/evloop/kqueue.c.h deleted file mode 100644 index 21288ed7c..000000000 --- a/web/server/h2o/libh2o/lib/common/socket/evloop/kqueue.c.h +++ /dev/null @@ -1,186 +0,0 @@ -/* - * Copyright (c) 2014 DeNA Co., Ltd. - * - * 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 <assert.h> -#include <stdio.h> -#include <sys/types.h> -#include <sys/event.h> -#include <sys/time.h> - -#if 0 -#define DEBUG_LOG(...) fprintf(stderr, __VA_ARGS__) -#else -#define DEBUG_LOG(...) -#endif - -struct st_h2o_socket_loop_kqueue_t { - h2o_evloop_t super; - int kq; -}; - -static void ev_set(struct kevent *ev, int fd, int filter, int flags, struct st_h2o_evloop_socket_t *sock) -{ -#ifdef __NetBSD__ - EV_SET(ev, fd, filter, flags, 0, 0, (intptr_t)sock); -#else - EV_SET(ev, fd, filter, flags, 0, 0, sock); -#endif -} - -static int collect_status(struct st_h2o_socket_loop_kqueue_t *loop, struct kevent *changelist, int changelist_capacity) -{ - int change_index = 0; - -#define SET_AND_UPDATE(filter, flags) \ - do { \ - ev_set(changelist + change_index++, sock->fd, filter, flags, sock); \ - if (change_index == changelist_capacity) { \ - int ret; \ - while ((ret = kevent(loop->kq, changelist, change_index, NULL, 0, NULL)) != 0 && errno == EINTR) \ - ; \ - if (ret == -1) \ - return -1; \ - change_index = 0; \ - } \ - } while (0) - - while (loop->super._statechanged.head != NULL) { - /* detach the top */ - struct st_h2o_evloop_socket_t *sock = loop->super._statechanged.head; - loop->super._statechanged.head = sock->_next_statechanged; - sock->_next_statechanged = sock; - /* update the state */ - if ((sock->_flags & H2O_SOCKET_FLAG_IS_DISPOSED) != 0) { - free(sock); - } else { - if (h2o_socket_is_reading(&sock->super)) { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_READ) == 0) { - sock->_flags |= H2O_SOCKET_FLAG_IS_POLLED_FOR_READ; - SET_AND_UPDATE(EVFILT_READ, EV_ADD); - } - } else { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_READ) != 0) { - sock->_flags &= ~H2O_SOCKET_FLAG_IS_POLLED_FOR_READ; - SET_AND_UPDATE(EVFILT_READ, EV_DELETE); - } - } - if (h2o_socket_is_writing(&sock->super)) { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE) == 0) { - sock->_flags |= H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE; - SET_AND_UPDATE(EVFILT_WRITE, EV_ADD); - } - } else { - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE) != 0) { - sock->_flags &= ~H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE; - SET_AND_UPDATE(EVFILT_WRITE, EV_DELETE); - } - } - } - } - loop->super._statechanged.tail_ref = &loop->super._statechanged.head; - - return change_index; - -#undef SET_AND_UPDATE -} - -int evloop_do_proceed(h2o_evloop_t *_loop, int32_t max_wait) -{ - struct st_h2o_socket_loop_kqueue_t *loop = (struct st_h2o_socket_loop_kqueue_t *)_loop; - struct kevent changelist[64], events[128]; - int nchanges, nevents, i; - struct timespec ts; - - /* collect (and update) status */ - if ((nchanges = collect_status(loop, changelist, sizeof(changelist) / sizeof(changelist[0]))) == -1) - return -1; - - /* poll */ - max_wait = adjust_max_wait(&loop->super, max_wait); - ts.tv_sec = max_wait / 1000; - ts.tv_nsec = max_wait % 1000 * 1000 * 1000; - nevents = kevent(loop->kq, changelist, nchanges, events, sizeof(events) / sizeof(events[0]), &ts); - - update_now(&loop->super); - if (nevents == -1) - return -1; - - if (nevents != 0) - h2o_sliding_counter_start(&loop->super.exec_time_counter, loop->super._now); - - /* update readable flags, perform writes */ - for (i = 0; i != nevents; ++i) { - struct st_h2o_evloop_socket_t *sock = (void *)events[i].udata; - assert(sock->fd == events[i].ident); - switch (events[i].filter) { - case EVFILT_READ: - if (sock->_flags != H2O_SOCKET_FLAG_IS_DISPOSED) { - sock->_flags |= H2O_SOCKET_FLAG_IS_READ_READY; - link_to_pending(sock); - } - break; - case EVFILT_WRITE: - if (sock->_flags != H2O_SOCKET_FLAG_IS_DISPOSED) { - write_pending(sock); - } - break; - default: - break; /* ??? */ - } - } - - return 0; -} - -static void evloop_do_on_socket_create(struct st_h2o_evloop_socket_t *sock) -{ -} - -static void evloop_do_on_socket_close(struct st_h2o_evloop_socket_t *sock) -{ -} - -static void evloop_do_on_socket_export(struct st_h2o_evloop_socket_t *sock) -{ - struct st_h2o_socket_loop_kqueue_t *loop = (void *)sock->loop; - struct kevent changelist[2]; - int change_index = 0, ret; - - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_READ) != 0) - ev_set(changelist + change_index++, sock->fd, EVFILT_READ, EV_DELETE, 0); - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE) != 0) - ev_set(changelist + change_index++, sock->fd, EVFILT_WRITE, EV_DELETE, 0); - if (change_index == 0) - return; - while ((ret = kevent(loop->kq, changelist, change_index, NULL, 0, NULL)) != 0 && errno == EINTR) - ; - if (ret == -1) - fprintf(stderr, "kevent returned error %d (fd=%d)", errno, sock->fd); -} - -h2o_evloop_t *h2o_evloop_create(void) -{ - struct st_h2o_socket_loop_kqueue_t *loop = (struct st_h2o_socket_loop_kqueue_t *)create_evloop(sizeof(*loop)); - - loop->kq = kqueue(); - - return &loop->super; -} diff --git a/web/server/h2o/libh2o/lib/common/socket/evloop/poll.c.h b/web/server/h2o/libh2o/lib/common/socket/evloop/poll.c.h deleted file mode 100644 index 8b3f3d149..000000000 --- a/web/server/h2o/libh2o/lib/common/socket/evloop/poll.c.h +++ /dev/null @@ -1,178 +0,0 @@ -/* - * Copyright (c) 2014,2015 DeNA Co., Ltd., Kazuho Oku - * - * 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 <stdio.h> -#include <poll.h> - -#if 0 -#define DEBUG_LOG(...) fprintf(stderr, __VA_ARGS__) -#else -#define DEBUG_LOG(...) -#endif - -struct st_h2o_evloop_poll_t { - h2o_evloop_t super; - H2O_VECTOR(struct st_h2o_evloop_socket_t *) socks; -}; - -static void update_socks(struct st_h2o_evloop_poll_t *loop) -{ - /* update loop->socks */ - while (loop->super._statechanged.head != NULL) { - /* detach the top */ - struct st_h2o_evloop_socket_t *sock = loop->super._statechanged.head; - loop->super._statechanged.head = sock->_next_statechanged; - sock->_next_statechanged = sock; - /* update the state */ - if ((sock->_flags & H2O_SOCKET_FLAG_IS_DISPOSED) != 0) { - assert(sock->fd == -1); - free(sock); - } else { - assert(sock->fd < loop->socks.size); - if (loop->socks.entries[sock->fd] == NULL) { - loop->socks.entries[sock->fd] = sock; - } else { - assert(loop->socks.entries[sock->fd] == sock); - } - if (h2o_socket_is_reading(&sock->super)) { - DEBUG_LOG("setting READ for fd: %d\n", sock->fd); - sock->_flags |= H2O_SOCKET_FLAG_IS_POLLED_FOR_READ; - } else { - DEBUG_LOG("clearing READ for fd: %d\n", sock->fd); - sock->_flags &= ~H2O_SOCKET_FLAG_IS_POLLED_FOR_READ; - } - if (h2o_socket_is_writing(&sock->super)) { - DEBUG_LOG("setting WRITE for fd: %d\n", sock->fd); - sock->_flags |= H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE; - } else { - DEBUG_LOG("clearing WRITE for fd: %d\n", sock->fd); - sock->_flags &= ~H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE; - } - } - } - loop->super._statechanged.tail_ref = &loop->super._statechanged.head; -} - -int evloop_do_proceed(h2o_evloop_t *_loop, int32_t max_wait) -{ - struct st_h2o_evloop_poll_t *loop = (struct st_h2o_evloop_poll_t *)_loop; - H2O_VECTOR(struct pollfd) pollfds = {NULL}; - int fd, ret; - - /* update status */ - update_socks(loop); - - /* build list of fds to be polled */ - for (fd = 0; fd != loop->socks.size; ++fd) { - struct st_h2o_evloop_socket_t *sock = loop->socks.entries[fd]; - if (sock == NULL) - continue; - assert(fd == sock->fd); - if ((sock->_flags & (H2O_SOCKET_FLAG_IS_POLLED_FOR_READ | H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE)) != 0) { - h2o_vector_reserve(NULL, &pollfds, pollfds.size + 1); - struct pollfd *slot = pollfds.entries + pollfds.size++; - slot->fd = fd; - slot->events = 0; - slot->revents = 0; - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_READ) != 0) - slot->events |= POLLIN; - if ((sock->_flags & H2O_SOCKET_FLAG_IS_POLLED_FOR_WRITE) != 0) - slot->events |= POLLOUT; - } - } - - /* call */ - max_wait = adjust_max_wait(&loop->super, max_wait); - ret = poll(pollfds.entries, (nfds_t)pollfds.size, max_wait); - update_now(&loop->super); - if (ret == -1) - goto Exit; - DEBUG_LOG("poll returned: %d\n", ret); - - /* update readable flags, perform writes */ - if (ret > 0) { - size_t i; - h2o_sliding_counter_start(&loop->super.exec_time_counter, loop->super._now); - for (i = 0; i != pollfds.size; ++i) { - /* set read_ready flag before calling the write cb, since app. code invoked by the latter may close the socket, clearing - * the former flag */ - if ((pollfds.entries[i].revents & POLLIN) != 0) { - struct st_h2o_evloop_socket_t *sock = loop->socks.entries[pollfds.entries[i].fd]; - assert(sock != NULL); - assert(sock->fd == pollfds.entries[i].fd); - if (sock->_flags != H2O_SOCKET_FLAG_IS_DISPOSED) { - sock->_flags |= H2O_SOCKET_FLAG_IS_READ_READY; - link_to_pending(sock); - DEBUG_LOG("added fd %d as read_ready\n", sock->fd); - } - } - if ((pollfds.entries[i].revents & POLLOUT) != 0) { - struct st_h2o_evloop_socket_t *sock = loop->socks.entries[pollfds.entries[i].fd]; - assert(sock != NULL); - assert(sock->fd == pollfds.entries[i].fd); - if (sock->_flags != H2O_SOCKET_FLAG_IS_DISPOSED) { - DEBUG_LOG("handling pending writes on fd %d\n", fd); - write_pending(sock); - } - } - } - ret = 0; - } - -Exit: - free(pollfds.entries); - return ret; -} - -static void evloop_do_on_socket_create(struct st_h2o_evloop_socket_t *sock) -{ - struct st_h2o_evloop_poll_t *loop = (struct st_h2o_evloop_poll_t *)sock->loop; - - if (sock->fd >= loop->socks.size) { - h2o_vector_reserve(NULL, &loop->socks, sock->fd + 1); - memset(loop->socks.entries + loop->socks.size, 0, (sock->fd + 1 - loop->socks.size) * sizeof(loop->socks.entries[0])); - loop->socks.size = sock->fd + 1; - } - - if (loop->socks.entries[sock->fd] != NULL) - assert(loop->socks.entries[sock->fd]->_flags == H2O_SOCKET_FLAG_IS_DISPOSED); -} - -static void evloop_do_on_socket_close(struct st_h2o_evloop_socket_t *sock) -{ - struct st_h2o_evloop_poll_t *loop = (struct st_h2o_evloop_poll_t *)sock->loop; - - if (sock->fd != -1) - loop->socks.entries[sock->fd] = NULL; -} - -static void evloop_do_on_socket_export(struct st_h2o_evloop_socket_t *sock) -{ - struct st_h2o_evloop_poll_t *loop = (struct st_h2o_evloop_poll_t *)sock->loop; - evloop_do_on_socket_close(sock); - loop->socks.entries[sock->fd] = NULL; -} - -h2o_evloop_t *h2o_evloop_create(void) -{ - struct st_h2o_evloop_poll_t *loop = (struct st_h2o_evloop_poll_t *)create_evloop(sizeof(*loop)); - return &loop->super; -} diff --git a/web/server/h2o/libh2o/lib/common/socket/uv-binding.c.h b/web/server/h2o/libh2o/lib/common/socket/uv-binding.c.h deleted file mode 100644 index 44c71c166..000000000 --- a/web/server/h2o/libh2o/lib/common/socket/uv-binding.c.h +++ /dev/null @@ -1,283 +0,0 @@ -/* - * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, 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. - */ - -struct st_h2o_uv_socket_t { - h2o_socket_t super; - struct { - uv_stream_t *stream; - uv_close_cb close_cb; - } uv; - union { - uv_connect_t _creq; - uv_write_t _wreq; - }; -}; - -static void schedule_timer(h2o_timeout_t *timeout); - -static void alloc_inbuf_tcp(uv_handle_t *handle, size_t suggested_size, uv_buf_t *_buf) -{ - struct st_h2o_uv_socket_t *sock = handle->data; - - h2o_iovec_t buf = h2o_buffer_reserve(&sock->super.input, 4096); - memcpy(_buf, &buf, sizeof(buf)); -} - -static void alloc_inbuf_ssl(uv_handle_t *handle, size_t suggested_size, uv_buf_t *_buf) -{ - struct st_h2o_uv_socket_t *sock = handle->data; - - h2o_iovec_t buf = h2o_buffer_reserve(&sock->super.ssl->input.encrypted, 4096); - memcpy(_buf, &buf, sizeof(buf)); -} - -static void on_read_tcp(uv_stream_t *stream, ssize_t nread, const uv_buf_t *_unused) -{ - struct st_h2o_uv_socket_t *sock = stream->data; - - if (nread < 0) { - sock->super.bytes_read = 0; - sock->super._cb.read(&sock->super, h2o_socket_error_closed); - return; - } - - sock->super.input->size += nread; - sock->super.bytes_read = nread; - sock->super._cb.read(&sock->super, NULL); -} - -static void on_read_ssl(uv_stream_t *stream, ssize_t nread, const uv_buf_t *_unused) -{ - struct st_h2o_uv_socket_t *sock = stream->data; - size_t prev_bytes_read = sock->super.input->size; - const char *err = h2o_socket_error_io; - - if (nread > 0) { - sock->super.ssl->input.encrypted->size += nread; - if (sock->super.ssl->handshake.cb == NULL) - err = decode_ssl_input(&sock->super); - else - err = NULL; - } - sock->super.bytes_read = sock->super.input->size - prev_bytes_read; - sock->super._cb.read(&sock->super, err); -} - -static void on_do_write_complete(uv_write_t *wreq, int status) -{ - struct st_h2o_uv_socket_t *sock = H2O_STRUCT_FROM_MEMBER(struct st_h2o_uv_socket_t, _wreq, wreq); - if (sock->super._cb.write != NULL) - on_write_complete(&sock->super, status == 0 ? NULL : h2o_socket_error_io); -} - -static void free_sock(uv_handle_t *handle) -{ - struct st_h2o_uv_socket_t *sock = handle->data; - uv_close_cb cb = sock->uv.close_cb; - free(sock); - cb(handle); -} - -void do_dispose_socket(h2o_socket_t *_sock) -{ - struct st_h2o_uv_socket_t *sock = (struct st_h2o_uv_socket_t *)_sock; - sock->super._cb.write = NULL; /* avoid the write callback getting called when closing the socket (#1249) */ - uv_close((uv_handle_t *)sock->uv.stream, free_sock); -} - -int h2o_socket_get_fd(h2o_socket_t *_sock) -{ - int fd, ret; - struct st_h2o_uv_socket_t *sock = (struct st_h2o_uv_socket_t *)_sock; - - ret = uv_fileno((uv_handle_t *)sock->uv.stream, (uv_os_fd_t *)&fd); - if (ret) - return -1; - - return fd; -} - -void do_read_start(h2o_socket_t *_sock) -{ - struct st_h2o_uv_socket_t *sock = (struct st_h2o_uv_socket_t *)_sock; - - if (sock->super.ssl == NULL) - uv_read_start(sock->uv.stream, alloc_inbuf_tcp, on_read_tcp); - else - uv_read_start(sock->uv.stream, alloc_inbuf_ssl, on_read_ssl); -} - -void do_read_stop(h2o_socket_t *_sock) -{ - struct st_h2o_uv_socket_t *sock = (struct st_h2o_uv_socket_t *)_sock; - uv_read_stop(sock->uv.stream); -} - -void do_write(h2o_socket_t *_sock, h2o_iovec_t *bufs, size_t bufcnt, h2o_socket_cb cb) -{ - struct st_h2o_uv_socket_t *sock = (struct st_h2o_uv_socket_t *)_sock; - - assert(sock->super._cb.write == NULL); - sock->super._cb.write = cb; - - uv_write(&sock->_wreq, sock->uv.stream, (uv_buf_t *)bufs, (int)bufcnt, on_do_write_complete); -} - -static struct st_h2o_uv_socket_t *create_socket(h2o_loop_t *loop) -{ - uv_tcp_t *tcp = h2o_mem_alloc(sizeof(*tcp)); - - if (uv_tcp_init(loop, tcp) != 0) { - free(tcp); - return NULL; - } - return (void *)h2o_uv_socket_create((void *)tcp, (uv_close_cb)free); -} - -int do_export(h2o_socket_t *_sock, h2o_socket_export_t *info) -{ - struct st_h2o_uv_socket_t *sock = (void *)_sock; - uv_os_fd_t fd; - - if (uv_fileno((uv_handle_t *)sock->uv.stream, &fd) != 0) - return -1; - /* FIXME: consider how to overcome the epoll(2) problem; man says, - * "even after a file descriptor that is part of an epoll set has been closed, - * events may be reported for that file descriptor if other file descriptors - * referring to the same underlying file description remain open" - */ - if ((info->fd = dup(fd)) == -1) - return -1; - return 0; -} - -h2o_socket_t *do_import(h2o_loop_t *loop, h2o_socket_export_t *info) -{ - struct st_h2o_uv_socket_t *sock = create_socket(loop); - - if (sock == NULL) - return NULL; - if (uv_tcp_open((uv_tcp_t *)sock->uv.stream, info->fd) != 0) { - h2o_socket_close(&sock->super); - return NULL; - } - - return &sock->super; -} - -h2o_socket_t *h2o_uv_socket_create(uv_stream_t *stream, uv_close_cb close_cb) -{ - struct st_h2o_uv_socket_t *sock = h2o_mem_alloc(sizeof(*sock)); - - memset(sock, 0, sizeof(*sock)); - h2o_buffer_init(&sock->super.input, &h2o_socket_buffer_prototype); - sock->uv.stream = stream; - sock->uv.close_cb = close_cb; - stream->data = sock; - return &sock->super; -} - -static void on_connect(uv_connect_t *conn, int status) -{ - if (status == UV_ECANCELED) - return; - struct st_h2o_uv_socket_t *sock = H2O_STRUCT_FROM_MEMBER(struct st_h2o_uv_socket_t, _creq, conn); - h2o_socket_cb cb = sock->super._cb.write; - sock->super._cb.write = NULL; - cb(&sock->super, status == 0 ? NULL : h2o_socket_error_conn_fail); -} - -h2o_loop_t *h2o_socket_get_loop(h2o_socket_t *_sock) -{ - struct st_h2o_uv_socket_t *sock = (void *)_sock; - return sock->uv.stream->loop; -} - -h2o_socket_t *h2o_socket_connect(h2o_loop_t *loop, struct sockaddr *addr, socklen_t addrlen, h2o_socket_cb cb) -{ - struct st_h2o_uv_socket_t *sock = create_socket(loop); - - if (sock == NULL) - return NULL; - if (uv_tcp_connect(&sock->_creq, (void *)sock->uv.stream, addr, on_connect) != 0) { - h2o_socket_close(&sock->super); - return NULL; - } - sock->super._cb.write = cb; - return &sock->super; -} - -socklen_t h2o_socket_getsockname(h2o_socket_t *_sock, struct sockaddr *sa) -{ - struct st_h2o_uv_socket_t *sock = (void *)_sock; - int len = sizeof(struct sockaddr_storage); - if (uv_tcp_getsockname((void *)sock->uv.stream, sa, &len) != 0) - return 0; - return (socklen_t)len; -} - -socklen_t get_peername_uncached(h2o_socket_t *_sock, struct sockaddr *sa) -{ - struct st_h2o_uv_socket_t *sock = (void *)_sock; - int len = sizeof(struct sockaddr_storage); - if (uv_tcp_getpeername((void *)sock->uv.stream, sa, &len) != 0) - return 0; - return (socklen_t)len; -} - -static void on_timeout(uv_timer_t *timer) -{ - h2o_timeout_t *timeout = H2O_STRUCT_FROM_MEMBER(h2o_timeout_t, _backend.timer, timer); - - h2o_timeout_run(timer->loop, timeout, h2o_now(timer->loop)); - if (!h2o_linklist_is_empty(&timeout->_entries)) - schedule_timer(timeout); -} - -void schedule_timer(h2o_timeout_t *timeout) -{ - h2o_timeout_entry_t *entry = H2O_STRUCT_FROM_MEMBER(h2o_timeout_entry_t, _link, timeout->_entries.next); - uv_timer_start(&timeout->_backend.timer, on_timeout, - entry->registered_at + timeout->timeout - h2o_now(timeout->_backend.timer.loop), 0); -} - -void h2o_timeout__do_init(h2o_loop_t *loop, h2o_timeout_t *timeout) -{ - uv_timer_init(loop, &timeout->_backend.timer); -} - -void h2o_timeout__do_dispose(h2o_loop_t *loop, h2o_timeout_t *timeout) -{ - uv_close((uv_handle_t *)&timeout->_backend.timer, NULL); -} - -void h2o_timeout__do_link(h2o_loop_t *loop, h2o_timeout_t *timeout, h2o_timeout_entry_t *entry) -{ - /* register the timer if the entry just being added is the only entry */ - if (timeout->_entries.next == &entry->_link) - schedule_timer(timeout); -} - -void h2o_timeout__do_post_callback(h2o_loop_t *loop) -{ - /* nothing to do */ -} diff --git a/web/server/h2o/libh2o/lib/common/socketpool.c b/web/server/h2o/libh2o/lib/common/socketpool.c deleted file mode 100644 index da69933f7..000000000 --- a/web/server/h2o/libh2o/lib/common/socketpool.c +++ /dev/null @@ -1,342 +0,0 @@ -/* - * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku - * - * 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 <assert.h> -#include <errno.h> -#include <netdb.h> -#include <stdlib.h> -#include <sys/socket.h> -#include <sys/types.h> -#include <sys/un.h> -#include <netinet/in.h> -#include "h2o/hostinfo.h" -#include "h2o/linklist.h" -#include "h2o/socketpool.h" -#include "h2o/string_.h" -#include "h2o/timeout.h" - -struct pool_entry_t { - h2o_socket_export_t sockinfo; - h2o_linklist_t link; - uint64_t added_at; -}; - -struct st_h2o_socketpool_connect_request_t { - void *data; - h2o_socketpool_connect_cb cb; - h2o_socketpool_t *pool; - h2o_loop_t *loop; - h2o_hostinfo_getaddr_req_t *getaddr_req; - h2o_socket_t *sock; -}; - -static void destroy_detached(struct pool_entry_t *entry) -{ - h2o_socket_dispose_export(&entry->sockinfo); - free(entry); -} - -static void destroy_attached(struct pool_entry_t *entry) -{ - h2o_linklist_unlink(&entry->link); - destroy_detached(entry); -} - -static void destroy_expired(h2o_socketpool_t *pool) -{ - /* caller should lock the mutex */ - uint64_t expire_before = h2o_now(pool->_interval_cb.loop) - pool->timeout; - while (!h2o_linklist_is_empty(&pool->_shared.sockets)) { - struct pool_entry_t *entry = H2O_STRUCT_FROM_MEMBER(struct pool_entry_t, link, pool->_shared.sockets.next); - if (entry->added_at > expire_before) - break; - destroy_attached(entry); - __sync_sub_and_fetch(&pool->_shared.count, 1); - } -} - -static void on_timeout(h2o_timeout_entry_t *timeout_entry) -{ - /* FIXME decrease the frequency of this function being called; the expiration - * check can be (should be) performed in the `connect` fuction as well - */ - h2o_socketpool_t *pool = H2O_STRUCT_FROM_MEMBER(h2o_socketpool_t, _interval_cb.entry, timeout_entry); - - if (pthread_mutex_trylock(&pool->_shared.mutex) == 0) { - destroy_expired(pool); - pthread_mutex_unlock(&pool->_shared.mutex); - } - - h2o_timeout_link(pool->_interval_cb.loop, &pool->_interval_cb.timeout, &pool->_interval_cb.entry); -} - -static void common_init(h2o_socketpool_t *pool, h2o_socketpool_type_t type, h2o_iovec_t host, int is_ssl, size_t capacity) -{ - memset(pool, 0, sizeof(*pool)); - - pool->type = type; - pool->peer.host = h2o_strdup(NULL, host.base, host.len); - pool->is_ssl = is_ssl; - pool->capacity = capacity; - pool->timeout = UINT64_MAX; - - pthread_mutex_init(&pool->_shared.mutex, NULL); - h2o_linklist_init_anchor(&pool->_shared.sockets); -} - -void h2o_socketpool_init_by_address(h2o_socketpool_t *pool, struct sockaddr *sa, socklen_t salen, int is_ssl, size_t capacity) -{ - char host[NI_MAXHOST]; - size_t host_len; - - assert(salen <= sizeof(pool->peer.sockaddr.bytes)); - - if ((host_len = h2o_socket_getnumerichost(sa, salen, host)) == SIZE_MAX) { - if (sa->sa_family != AF_UNIX) - h2o_fatal("failed to convert a non-unix socket address to a numerical representation"); - /* use the sockaddr_un::sun_path as the SNI indicator (is that the right thing to do?) */ - strcpy(host, ((struct sockaddr_un *)sa)->sun_path); - host_len = strlen(host); - } - - common_init(pool, H2O_SOCKETPOOL_TYPE_SOCKADDR, h2o_iovec_init(host, host_len), is_ssl, capacity); - memcpy(&pool->peer.sockaddr.bytes, sa, salen); - pool->peer.sockaddr.len = salen; -} - -void h2o_socketpool_init_by_hostport(h2o_socketpool_t *pool, h2o_iovec_t host, uint16_t port, int is_ssl, size_t capacity) -{ - struct sockaddr_in sin; - memset(&sin, 0, sizeof(sin)); - - if (h2o_hostinfo_aton(host, &sin.sin_addr) == 0) { - sin.sin_family = AF_INET; - sin.sin_port = htons(port); - h2o_socketpool_init_by_address(pool, (void *)&sin, sizeof(sin), is_ssl, capacity); - return; - } - - common_init(pool, H2O_SOCKETPOOL_TYPE_NAMED, host, is_ssl, capacity); - pool->peer.named_serv.base = h2o_mem_alloc(sizeof(H2O_UINT16_LONGEST_STR)); - pool->peer.named_serv.len = sprintf(pool->peer.named_serv.base, "%u", (unsigned)port); -} - -void h2o_socketpool_dispose(h2o_socketpool_t *pool) -{ - pthread_mutex_lock(&pool->_shared.mutex); - while (!h2o_linklist_is_empty(&pool->_shared.sockets)) { - struct pool_entry_t *entry = H2O_STRUCT_FROM_MEMBER(struct pool_entry_t, link, pool->_shared.sockets.next); - destroy_attached(entry); - __sync_sub_and_fetch(&pool->_shared.count, 1); - } - pthread_mutex_unlock(&pool->_shared.mutex); - pthread_mutex_destroy(&pool->_shared.mutex); - - if (pool->_interval_cb.loop != NULL) { - h2o_timeout_unlink(&pool->_interval_cb.entry); - h2o_timeout_dispose(pool->_interval_cb.loop, &pool->_interval_cb.timeout); - } - free(pool->peer.host.base); - switch (pool->type) { - case H2O_SOCKETPOOL_TYPE_NAMED: - free(pool->peer.named_serv.base); - break; - case H2O_SOCKETPOOL_TYPE_SOCKADDR: - break; - } -} - -void h2o_socketpool_set_timeout(h2o_socketpool_t *pool, h2o_loop_t *loop, uint64_t msec) -{ - pool->timeout = msec; - - pool->_interval_cb.loop = loop; - h2o_timeout_init(loop, &pool->_interval_cb.timeout, 1000); - pool->_interval_cb.entry.cb = on_timeout; - - h2o_timeout_link(loop, &pool->_interval_cb.timeout, &pool->_interval_cb.entry); -} - -static void call_connect_cb(h2o_socketpool_connect_request_t *req, const char *errstr) -{ - h2o_socketpool_connect_cb cb = req->cb; - h2o_socket_t *sock = req->sock; - void *data = req->data; - - free(req); - cb(sock, errstr, data); -} - -static void on_connect(h2o_socket_t *sock, const char *err) -{ - h2o_socketpool_connect_request_t *req = sock->data; - const char *errstr = NULL; - - assert(req->sock == sock); - - if (err != NULL) { - h2o_socket_close(sock); - req->sock = NULL; - errstr = "connection failed"; - } - call_connect_cb(req, errstr); -} - -static void on_close(void *data) -{ - h2o_socketpool_t *pool = data; - __sync_sub_and_fetch(&pool->_shared.count, 1); -} - -static void start_connect(h2o_socketpool_connect_request_t *req, struct sockaddr *addr, socklen_t addrlen) -{ - req->sock = h2o_socket_connect(req->loop, addr, addrlen, on_connect); - if (req->sock == NULL) { - __sync_sub_and_fetch(&req->pool->_shared.count, 1); - call_connect_cb(req, "failed to connect to host"); - return; - } - req->sock->data = req; - req->sock->on_close.cb = on_close; - req->sock->on_close.data = req->pool; -} - -static void on_getaddr(h2o_hostinfo_getaddr_req_t *getaddr_req, const char *errstr, struct addrinfo *res, void *_req) -{ - h2o_socketpool_connect_request_t *req = _req; - - assert(getaddr_req == req->getaddr_req); - req->getaddr_req = NULL; - - if (errstr != NULL) { - __sync_sub_and_fetch(&req->pool->_shared.count, 1); - call_connect_cb(req, errstr); - return; - } - - struct addrinfo *selected = h2o_hostinfo_select_one(res); - start_connect(req, selected->ai_addr, selected->ai_addrlen); -} - -void h2o_socketpool_connect(h2o_socketpool_connect_request_t **_req, h2o_socketpool_t *pool, h2o_loop_t *loop, - h2o_multithread_receiver_t *getaddr_receiver, h2o_socketpool_connect_cb cb, void *data) -{ - struct pool_entry_t *entry = NULL; - - if (_req != NULL) - *_req = NULL; - - /* fetch an entry and return it */ - pthread_mutex_lock(&pool->_shared.mutex); - destroy_expired(pool); - while (1) { - if (h2o_linklist_is_empty(&pool->_shared.sockets)) - break; - entry = H2O_STRUCT_FROM_MEMBER(struct pool_entry_t, link, pool->_shared.sockets.next); - h2o_linklist_unlink(&entry->link); - pthread_mutex_unlock(&pool->_shared.mutex); - - /* test if the connection is still alive */ - char buf[1]; - ssize_t rret = recv(entry->sockinfo.fd, buf, 1, MSG_PEEK); - if (rret == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) { - /* yes! return it */ - h2o_socket_t *sock = h2o_socket_import(loop, &entry->sockinfo); - free(entry); - sock->on_close.cb = on_close; - sock->on_close.data = pool; - cb(sock, NULL, data); - return; - } - - /* connection is dead, report, close, and retry */ - if (rret <= 0) { - static long counter = 0; - if (__sync_fetch_and_add(&counter, 1) == 0) - fprintf(stderr, "[WARN] detected close by upstream before the expected timeout (see issue #679)\n"); - } else { - static long counter = 0; - if (__sync_fetch_and_add(&counter, 1) == 0) - fprintf(stderr, "[WARN] unexpectedly received data to a pooled socket (see issue #679)\n"); - } - destroy_detached(entry); - pthread_mutex_lock(&pool->_shared.mutex); - } - pthread_mutex_unlock(&pool->_shared.mutex); - - /* FIXME repsect `capacity` */ - __sync_add_and_fetch(&pool->_shared.count, 1); - - /* prepare request object */ - h2o_socketpool_connect_request_t *req = h2o_mem_alloc(sizeof(*req)); - *req = (h2o_socketpool_connect_request_t){data, cb, pool, loop}; - if (_req != NULL) - *_req = req; - - switch (pool->type) { - case H2O_SOCKETPOOL_TYPE_NAMED: - /* resolve the name, and connect */ - req->getaddr_req = h2o_hostinfo_getaddr(getaddr_receiver, pool->peer.host, pool->peer.named_serv, AF_UNSPEC, SOCK_STREAM, - IPPROTO_TCP, AI_ADDRCONFIG | AI_NUMERICSERV, on_getaddr, req); - break; - case H2O_SOCKETPOOL_TYPE_SOCKADDR: - /* connect (using sockaddr_in) */ - start_connect(req, (void *)&pool->peer.sockaddr.bytes, pool->peer.sockaddr.len); - break; - } -} - -void h2o_socketpool_cancel_connect(h2o_socketpool_connect_request_t *req) -{ - if (req->getaddr_req != NULL) { - h2o_hostinfo_getaddr_cancel(req->getaddr_req); - req->getaddr_req = NULL; - } - if (req->sock != NULL) - h2o_socket_close(req->sock); - free(req); -} - -int h2o_socketpool_return(h2o_socketpool_t *pool, h2o_socket_t *sock) -{ - struct pool_entry_t *entry; - - /* reset the on_close callback */ - assert(sock->on_close.data == pool); - sock->on_close.cb = NULL; - sock->on_close.data = NULL; - - entry = h2o_mem_alloc(sizeof(*entry)); - if (h2o_socket_export(sock, &entry->sockinfo) != 0) { - free(entry); - __sync_sub_and_fetch(&pool->_shared.count, 1); - return -1; - } - memset(&entry->link, 0, sizeof(entry->link)); - entry->added_at = h2o_now(h2o_socket_get_loop(sock)); - - pthread_mutex_lock(&pool->_shared.mutex); - destroy_expired(pool); - h2o_linklist_insert(&pool->_shared.sockets, &entry->link); - pthread_mutex_unlock(&pool->_shared.mutex); - - return 0; -} diff --git a/web/server/h2o/libh2o/lib/common/string.c b/web/server/h2o/libh2o/lib/common/string.c deleted file mode 100644 index 3c068f3ad..000000000 --- a/web/server/h2o/libh2o/lib/common/string.c +++ /dev/null @@ -1,594 +0,0 @@ -/* - * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Justin Zhu, 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 <stdint.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <time.h> -#include "h2o/string_.h" - -h2o_iovec_t h2o_strdup(h2o_mem_pool_t *pool, const char *s, size_t slen) -{ - h2o_iovec_t ret; - - if (slen == SIZE_MAX) - slen = strlen(s); - - if (pool != NULL) { - ret.base = h2o_mem_alloc_pool(pool, slen + 1); - } else { - ret.base = h2o_mem_alloc(slen + 1); - } - h2o_memcpy(ret.base, s, slen); - ret.base[slen] = '\0'; - ret.len = slen; - return ret; -} - -h2o_iovec_t h2o_strdup_shared(h2o_mem_pool_t *pool, const char *s, size_t slen) -{ - h2o_iovec_t ret; - - if (slen == SIZE_MAX) - slen = strlen(s); - - ret.base = h2o_mem_alloc_shared(pool, slen + 1, NULL); - memcpy(ret.base, s, slen); - ret.base[slen] = '\0'; - ret.len = slen; - return ret; -} - -h2o_iovec_t h2o_strdup_slashed(h2o_mem_pool_t *pool, const char *src, size_t len) -{ - h2o_iovec_t ret; - - ret.len = len != SIZE_MAX ? len : strlen(src); - ret.base = pool != NULL ? h2o_mem_alloc_pool(pool, ret.len + 2) : h2o_mem_alloc(ret.len + 2); - memcpy(ret.base, src, ret.len); - if (ret.len != 0 && ret.base[ret.len - 1] != '/') - ret.base[ret.len++] = '/'; - ret.base[ret.len] = '\0'; - - return ret; -} - -int h2o__lcstris_core(const char *target, const char *test, size_t test_len) -{ - for (; test_len != 0; --test_len) - if (h2o_tolower(*target++) != *test++) - return 0; - return 1; -} - -size_t h2o_strtosize(const char *s, size_t len) -{ - uint64_t v = 0, m = 1; - const char *p = s + len; - - if (len == 0) - goto Error; - - while (1) { - int ch = *--p; - if (!('0' <= ch && ch <= '9')) - goto Error; - v += (ch - '0') * m; - if (p == s) - break; - m *= 10; - /* do not even try to overflow */ - if (m == 10000000000000000000ULL) - goto Error; - } - - if (v >= SIZE_MAX) - goto Error; - return v; - -Error: - return SIZE_MAX; -} - -size_t h2o_strtosizefwd(char **s, size_t len) -{ - uint64_t v, c; - char *p = *s, *p_end = *s + len; - - if (len == 0) - goto Error; - - int ch = *p++; - if (!('0' <= ch && ch <= '9')) - goto Error; - v = ch - '0'; - c = 1; - - while (1) { - ch = *p; - if (!('0' <= ch && ch <= '9')) - break; - v *= 10; - v += ch - '0'; - p++; - c++; - if (p == p_end) - break; - /* similar as above, do not even try to overflow */ - if (c == 20) - goto Error; - } - - if (v >= SIZE_MAX) - goto Error; - *s = p; - return v; - -Error: - return SIZE_MAX; -} - -static uint32_t decode_base64url_quad(const char *src) -{ - const char *src_end = src + 4; - uint32_t decoded = 0; - - while (1) { - if ('A' <= *src && *src <= 'Z') { - decoded |= *src - 'A'; - } else if ('a' <= *src && *src <= 'z') { - decoded |= *src - 'a' + 26; - } else if ('0' <= *src && *src <= '9') { - decoded |= *src - '0' + 52; - } else if (*src == '-') { - decoded |= 62; - } else if (*src == '_') { - decoded |= 63; -#if 1 /* curl uses normal base64 */ - } else if (*src == '+') { - decoded |= 62; - } else if (*src == '/') { - decoded |= 63; -#endif - } else { - return UINT32_MAX; - } - if (++src == src_end) - break; - decoded <<= 6; - } - - return decoded; -} - -h2o_iovec_t h2o_decode_base64url(h2o_mem_pool_t *pool, const char *src, size_t len) -{ - h2o_iovec_t decoded; - uint32_t t; - uint8_t *dst; - char remaining_input[4]; - - decoded.len = len * 3 / 4; - decoded.base = pool != NULL ? h2o_mem_alloc_pool(pool, decoded.len + 1) : h2o_mem_alloc(decoded.len + 1); - dst = (uint8_t *)decoded.base; - - while (len >= 4) { - if ((t = decode_base64url_quad(src)) == UINT32_MAX) - goto Error; - *dst++ = t >> 16; - *dst++ = t >> 8; - *dst++ = t; - src += 4; - len -= 4; - } - switch (len) { - case 0: - break; - case 1: - goto Error; - case 2: - remaining_input[0] = *src++; - remaining_input[1] = *src++; - remaining_input[2] = 'A'; - remaining_input[3] = 'A'; - if ((t = decode_base64url_quad(remaining_input)) == UINT32_MAX) - goto Error; - *dst++ = t >> 16; - break; - case 3: - remaining_input[0] = *src++; - remaining_input[1] = *src++; - remaining_input[2] = *src++; - remaining_input[3] = 'A'; - if ((t = decode_base64url_quad(remaining_input)) == UINT32_MAX) - goto Error; - *dst++ = t >> 16; - *dst++ = t >> 8; - break; - } - - assert((char *)dst - decoded.base == decoded.len); - decoded.base[decoded.len] = '\0'; - - return decoded; - -Error: - if (pool == NULL) - free(decoded.base); - return h2o_iovec_init(NULL, 0); -} - -size_t h2o_base64_encode(char *_dst, const void *_src, size_t len, int url_encoded) -{ - static const char *MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - "abcdefghijklmnopqrstuvwxyz" - "0123456789+/"; - static const char *MAP_URL_ENCODED = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - "abcdefghijklmnopqrstuvwxyz" - "0123456789-_"; - - char *dst = _dst; - const uint8_t *src = _src; - const char *map = url_encoded ? MAP_URL_ENCODED : MAP; - uint32_t quad; - - for (; len >= 3; src += 3, len -= 3) { - quad = ((uint32_t)src[0] << 16) | ((uint32_t)src[1] << 8) | src[2]; - *dst++ = map[quad >> 18]; - *dst++ = map[(quad >> 12) & 63]; - *dst++ = map[(quad >> 6) & 63]; - *dst++ = map[quad & 63]; - } - if (len != 0) { - quad = (uint32_t)src[0] << 16; - *dst++ = map[quad >> 18]; - if (len == 2) { - quad |= (uint32_t)src[1] << 8; - *dst++ = map[(quad >> 12) & 63]; - *dst++ = map[(quad >> 6) & 63]; - if (!url_encoded) - *dst++ = '='; - } else { - *dst++ = map[(quad >> 12) & 63]; - if (!url_encoded) { - *dst++ = '='; - *dst++ = '='; - } - } - } - - *dst = '\0'; - return dst - _dst; -} - -static int decode_hex(int ch) -{ - if ('0' <= ch && ch <= '9') - return ch - '0'; - if ('A' <= ch && ch <= 'F') - return ch - 'A' + 0xa; - if ('a' <= ch && ch <= 'f') - return ch - 'a' + 0xa; - return -1; -} - -int h2o_hex_decode(void *_dst, const char *src, size_t src_len) -{ - unsigned char *dst = _dst; - - if (src_len % 2 != 0) - return -1; - for (; src_len != 0; src_len -= 2) { - int hi, lo; - if ((hi = decode_hex(*src++)) == -1 || (lo = decode_hex(*src++)) == -1) - return -1; - *dst++ = (hi << 4) | lo; - } - return 0; -} - -void h2o_hex_encode(char *dst, const void *_src, size_t src_len) -{ - const unsigned char *src = _src, *src_end = src + src_len; - for (; src != src_end; ++src) { - *dst++ = "0123456789abcdef"[*src >> 4]; - *dst++ = "0123456789abcdef"[*src & 0xf]; - } - *dst = '\0'; -} - -h2o_iovec_t h2o_uri_escape(h2o_mem_pool_t *pool, const char *s, size_t l, const char *preserve_chars) -{ - h2o_iovec_t encoded; - size_t i, capacity = l * 3 + 1; - - encoded.base = pool != NULL ? h2o_mem_alloc_pool(pool, capacity) : h2o_mem_alloc(capacity); - encoded.len = 0; - - /* RFC 3986: - path-noscheme = segment-nz-nc *( "/" segment ) - segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" ) - unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" - sub-delims = "!" / "$" / "&" / "'" / "(" / ")" - / "*" / "+" / "," / ";" / "=" - */ - for (i = 0; i != l; ++i) { - int ch = s[i]; - if (('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ('0' <= ch && ch <= '9') || ch == '-' || ch == '.' || - ch == '_' || ch == '~' || ch == '!' || ch == '$' || ch == '&' || ch == '\'' || ch == '(' || ch == ')' || ch == '*' || - ch == '+' || ch == ',' || ch == ';' || ch == '=' || - (ch != '\0' && preserve_chars != NULL && strchr(preserve_chars, ch) != NULL)) { - encoded.base[encoded.len++] = ch; - } else { - encoded.base[encoded.len++] = '%'; - encoded.base[encoded.len++] = "0123456789ABCDEF"[(ch >> 4) & 0xf]; - encoded.base[encoded.len++] = "0123456789ABCDEF"[ch & 0xf]; - } - } - encoded.base[encoded.len] = '\0'; - - return encoded; -} - -h2o_iovec_t h2o_get_filext(const char *path, size_t len) -{ - const char *end = path + len, *p = end; - - while (--p != path) { - if (*p == '.') { - return h2o_iovec_init(p + 1, end - (p + 1)); - } else if (*p == '/') { - break; - } - } - return h2o_iovec_init(NULL, 0); -} - -static int is_ws(int ch) -{ - return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n'; -} - -h2o_iovec_t h2o_str_stripws(const char *s, size_t len) -{ - const char *end = s + len; - - while (s != end) { - if (!is_ws(*s)) - break; - ++s; - } - while (s != end) { - if (!is_ws(end[-1])) - break; - --end; - } - return h2o_iovec_init(s, end - s); -} - -size_t h2o_strstr(const char *haysack, size_t haysack_len, const char *needle, size_t needle_len) -{ - /* TODO optimize */ - if (haysack_len >= needle_len) { - size_t off, max = haysack_len - needle_len + 1; - if (needle_len == 0) - return 0; - for (off = 0; off != max; ++off) - if (haysack[off] == needle[0] && memcmp(haysack + off + 1, needle + 1, needle_len - 1) == 0) - return off; - } - return SIZE_MAX; -} - -/* note: returns a zero-width match as well */ -const char *h2o_next_token(h2o_iovec_t *iter, int separator, size_t *element_len, h2o_iovec_t *value) -{ - const char *cur = iter->base, *end = iter->base + iter->len, *token_start, *token_end; - - /* find start */ - for (;; ++cur) { - if (cur == end) - return NULL; - if (!(*cur == ' ' || *cur == '\t')) - break; - } - token_start = cur; - token_end = cur; - - /* find last */ - for (;; ++cur) { - if (cur == end) - break; - if (*cur == separator) { - ++cur; - break; - } - if (*cur == ',') { - if (token_start == cur) { - ++cur; - token_end = cur; - } - break; - } - if (value != NULL && *cur == '=') { - ++cur; - goto FindValue; - } - if (!(*cur == ' ' || *cur == '\t')) - token_end = cur + 1; - } - - /* found */ - *iter = h2o_iovec_init(cur, end - cur); - *element_len = token_end - token_start; - if (value != NULL) - *value = (h2o_iovec_t){NULL}; - return token_start; - -FindValue: - *iter = h2o_iovec_init(cur, end - cur); - *element_len = token_end - token_start; - if ((value->base = (char *)h2o_next_token(iter, separator, &value->len, NULL)) == NULL) { - *value = (h2o_iovec_t){"", 0}; - } else if (h2o_memis(value->base, value->len, H2O_STRLIT(","))) { - *value = (h2o_iovec_t){"", 0}; - iter->base -= 1; - iter->len += 1; - } - return token_start; -} - -int h2o_contains_token(const char *haysack, size_t haysack_len, const char *needle, size_t needle_len, int separator) -{ - h2o_iovec_t iter = h2o_iovec_init(haysack, haysack_len); - const char *token = NULL; - size_t token_len = 0; - - while ((token = h2o_next_token(&iter, separator, &token_len, NULL)) != NULL) { - if (h2o_lcstris(token, token_len, needle, needle_len)) { - return 1; - } - } - return 0; -} - -h2o_iovec_t h2o_htmlescape(h2o_mem_pool_t *pool, const char *src, size_t len) -{ - const char *s, *end = src + len; - size_t add_size = 0; - -#define ENTITY_MAP() \ - ENTITY('"', """); \ - ENTITY('&', "&"); \ - ENTITY('\'', "'"); \ - ENTITY('<', "<"); \ - ENTITY('>', ">"); - - for (s = src; s != end; ++s) { - if ((unsigned)(unsigned char)*s - '"' <= '>' - '"') { - switch (*s) { -#define ENTITY(code, quoted) \ - case code: \ - add_size += sizeof(quoted) - 2; \ - break - ENTITY_MAP() -#undef ENTITY - } - } - } - - /* escape and return the result if necessary */ - if (add_size != 0) { - /* allocate buffer and fill in the chars that are known not to require escaping */ - h2o_iovec_t escaped = {h2o_mem_alloc_pool(pool, len + add_size + 1), 0}; - /* fill-in the rest */ - for (s = src; s != end; ++s) { - switch (*s) { -#define ENTITY(code, quoted) \ - case code: \ - memcpy(escaped.base + escaped.len, quoted, sizeof(quoted) - 1); \ - escaped.len += sizeof(quoted) - 1; \ - break - ENTITY_MAP() -#undef ENTITY - default: - escaped.base[escaped.len++] = *s; - break; - } - } - assert(escaped.len == len + add_size); - escaped.base[escaped.len] = '\0'; - - return escaped; - } - -#undef ENTITY_MAP - - /* no need not escape; return the original */ - return h2o_iovec_init(src, len); -} - -h2o_iovec_t h2o_concat_list(h2o_mem_pool_t *pool, h2o_iovec_t *list, size_t count) -{ - h2o_iovec_t ret = {NULL, 0}; - size_t i; - - /* calc the length */ - for (i = 0; i != count; ++i) { - ret.len += list[i].len; - } - - /* allocate memory */ - if (pool != NULL) - ret.base = h2o_mem_alloc_pool(pool, ret.len + 1); - else - ret.base = h2o_mem_alloc(ret.len + 1); - - /* concatenate */ - ret.len = 0; - for (i = 0; i != count; ++i) { - h2o_memcpy(ret.base + ret.len, list[i].base, list[i].len); - ret.len += list[i].len; - } - ret.base[ret.len] = '\0'; - - return ret; -} - -int h2o_str_at_position(char *buf, const char *src, size_t src_len, int lineno, int column) -{ - const char *src_end = src + src_len; - int i; - - /* find the line */ - if (lineno <= 0 || column <= 0) - return -1; - for (--lineno; lineno != 0; --lineno) { - do { - if (src == src_end) - return -1; - } while (*src++ != '\n'); - } - - /* adjust the starting column */ - while (column > 40) { - if (src != src_end) - ++src; - --column; - } - - /* emit */ - for (i = 1; i <= 76; ++i) { - if (src == src_end || *src == '\n') - break; - *buf++ = *src++; - } - if (i < column) - column = i; - *buf++ = '\n'; - for (i = 1; i < column; ++i) - *buf++ = ' '; - *buf++ = '^'; - *buf++ = '\n'; - *buf = '\0'; - return 0; -} diff --git a/web/server/h2o/libh2o/lib/common/time.c b/web/server/h2o/libh2o/lib/common/time.c deleted file mode 100644 index 368143e78..000000000 --- a/web/server/h2o/libh2o/lib/common/time.c +++ /dev/null @@ -1,175 +0,0 @@ -/* - * Copyright (c) 2015 DeNA Co., Ltd. - * - * 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 <assert.h> -#include <stdio.h> -#include <string.h> -#include "h2o/time_.h" - -static char *emit_wday(char *dst, int wday) -{ - memcpy(dst, ("SunMonTueWedThuFriSat") + wday * 3, 3); - return dst + 3; -} - -static char *emit_mon(char *dst, int mon) -{ - memcpy(dst, ("JanFebMarAprMayJunJulAugSepOctNovDec") + mon * 3, 3); - return dst + 3; -} - -static char *emit_digits(char *dst, int n, size_t cnt) -{ - char *p = dst + cnt; - - /* emit digits from back */ - do { - *--p = '0' + n % 10; - n /= 10; - } while (p != dst); - - return dst + cnt; -} - -void h2o_time2str_rfc1123(char *buf, struct tm *gmt) -{ - char *p = buf; - - /* format: Fri, 19 Sep 2014 05:24:04 GMT */ - p = emit_wday(p, gmt->tm_wday); - *p++ = ','; - *p++ = ' '; - p = emit_digits(p, gmt->tm_mday, 2); - *p++ = ' '; - p = emit_mon(p, gmt->tm_mon); - *p++ = ' '; - p = emit_digits(p, gmt->tm_year + 1900, 4); - *p++ = ' '; - p = emit_digits(p, gmt->tm_hour, 2); - *p++ = ':'; - p = emit_digits(p, gmt->tm_min, 2); - *p++ = ':'; - p = emit_digits(p, gmt->tm_sec, 2); - memcpy(p, " GMT", 4); - p += 4; - *p = '\0'; - - assert(p - buf == H2O_TIMESTR_RFC1123_LEN); -} - -static int fetch_digits(const char *s, size_t n) -{ - int value = 0; - for (; n != 0; ++s, --n) { - if (!('0' <= *s && *s <= '9')) - return -1; - value = value * 10 + *s - '0'; - } - return value; -} - -int h2o_time_parse_rfc1123(const char *s, size_t len, struct tm *tm) -{ - if (len != H2O_TIMESTR_RFC1123_LEN) - return -1; - -/* 1 2 - * 01234567890123456789012345678 - * Fri, 19 Sep 2014 05:24:04 GMT - */ - -#define FETCH(dst, pos, n) \ - if ((dst = fetch_digits(s + pos, n)) == -1) \ - return -1; - FETCH(tm->tm_year, 12, 4); - tm->tm_year -= 1900; - /* month is parsed afterwards */ - FETCH(tm->tm_mday, 5, 2); - FETCH(tm->tm_hour, 17, 2); - FETCH(tm->tm_min, 20, 2); - FETCH(tm->tm_sec, 23, 2); -#undef FETCH - -#define PACK3(a, b, c) (((a)&0xff) << 16 | ((b)&0xff) << 8 | ((c)&0xff)) -#define MAP(c1, c2, c3, value) \ - case PACK3(c1, c2, c3): \ - tm->tm_mon = value; \ - break - switch (PACK3(s[8], s[9], s[10])) { - MAP('J', 'a', 'n', 0); - MAP('F', 'e', 'b', 1); - MAP('M', 'a', 'r', 2); - MAP('A', 'p', 'r', 3); - MAP('M', 'a', 'y', 4); - MAP('J', 'u', 'n', 5); - MAP('J', 'u', 'l', 6); - MAP('A', 'u', 'g', 7); - MAP('S', 'e', 'p', 8); - MAP('O', 'c', 't', 9); - MAP('N', 'o', 'v', 10); - MAP('D', 'e', 'c', 11); - default: - return -1; - } -#undef MAP -#undef PACK3 - - return 0; -} - -static int calc_gmt_offset(time_t t, struct tm *local) -{ - struct tm gmt; - int delta; - - gmtime_r(&t, &gmt); - delta = (local->tm_hour - gmt.tm_hour) * 60 + (local->tm_min - gmt.tm_min); - - if (local->tm_yday != gmt.tm_yday) { - int day_offset; - if (local->tm_year == gmt.tm_year) - day_offset = local->tm_yday - gmt.tm_yday; - else - day_offset = local->tm_year - gmt.tm_year; - delta += day_offset * 24 * 60; - } - return delta; -} - -void h2o_time2str_log(char *buf, time_t time) -{ - struct tm localt; - localtime_r(&time, &localt); - int gmt_off = calc_gmt_offset(time, &localt); - int gmt_sign; - - if (gmt_off >= 0) { - gmt_sign = '+'; - } else { - gmt_off = -gmt_off; - gmt_sign = '-'; - } - - int len = sprintf(buf, "%02d/%s/%d:%02d:%02d:%02d %c%02d%02d", localt.tm_mday, - ("Jan\0Feb\0Mar\0Apr\0May\0Jun\0Jul\0Aug\0Sep\0Oct\0Nov\0Dec\0") + localt.tm_mon * 4, localt.tm_year + 1900, - localt.tm_hour, localt.tm_min, localt.tm_sec, gmt_sign, gmt_off / 60, gmt_off % 60); - assert(len == H2O_TIMESTR_LOG_LEN); -} diff --git a/web/server/h2o/libh2o/lib/common/timeout.c b/web/server/h2o/libh2o/lib/common/timeout.c deleted file mode 100644 index c50be0a3f..000000000 --- a/web/server/h2o/libh2o/lib/common/timeout.c +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (c) 2014 DeNA Co., Ltd. - * - * 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 "h2o/timeout.h" - -void h2o_timeout_run(h2o_loop_t *loop, h2o_timeout_t *timeout, uint64_t now) -{ - uint64_t max_registered_at = now - timeout->timeout; - - while (!h2o_linklist_is_empty(&timeout->_entries)) { - h2o_timeout_entry_t *entry = H2O_STRUCT_FROM_MEMBER(h2o_timeout_entry_t, _link, timeout->_entries.next); - if (entry->registered_at > max_registered_at) { - break; - } - h2o_linklist_unlink(&entry->_link); - entry->registered_at = 0; - entry->cb(entry); - h2o_timeout__do_post_callback(loop); - } -} - -uint64_t h2o_timeout_get_wake_at(h2o_linklist_t *timeouts) -{ - h2o_linklist_t *node; - uint64_t wake_at = UINT64_MAX; - - /* change wake_at to the minimum value of the timeouts */ - for (node = timeouts->next; node != timeouts; node = node->next) { - h2o_timeout_t *timeout = H2O_STRUCT_FROM_MEMBER(h2o_timeout_t, _link, node); - if (!h2o_linklist_is_empty(&timeout->_entries)) { - h2o_timeout_entry_t *entry = H2O_STRUCT_FROM_MEMBER(h2o_timeout_entry_t, _link, timeout->_entries.next); - uint64_t entry_wake_at = entry->registered_at + timeout->timeout; - if (entry_wake_at < wake_at) - wake_at = entry_wake_at; - } - } - - return wake_at; -} - -void h2o_timeout_init(h2o_loop_t *loop, h2o_timeout_t *timeout, uint64_t millis) -{ - memset(timeout, 0, sizeof(*timeout)); - timeout->timeout = millis; - h2o_linklist_init_anchor(&timeout->_entries); - - h2o_timeout__do_init(loop, timeout); -} - -void h2o_timeout_dispose(h2o_loop_t *loop, h2o_timeout_t *timeout) -{ - assert(h2o_linklist_is_empty(&timeout->_entries)); - h2o_timeout__do_dispose(loop, timeout); -} - -void h2o_timeout_link(h2o_loop_t *loop, h2o_timeout_t *timeout, h2o_timeout_entry_t *entry) -{ - /* insert at tail, so that the entries are sorted in ascending order */ - h2o_linklist_insert(&timeout->_entries, &entry->_link); - /* set data */ - entry->registered_at = h2o_now(loop); - - h2o_timeout__do_link(loop, timeout, entry); -} - -void h2o_timeout_unlink(h2o_timeout_entry_t *entry) -{ - if (h2o_linklist_is_linked(&entry->_link)) { - h2o_linklist_unlink(&entry->_link); - entry->registered_at = 0; - } -} diff --git a/web/server/h2o/libh2o/lib/common/url.c b/web/server/h2o/libh2o/lib/common/url.c deleted file mode 100644 index d65d18fb5..000000000 --- a/web/server/h2o/libh2o/lib/common/url.c +++ /dev/null @@ -1,409 +0,0 @@ -/* - * Copyright (c) 2014,2015 DeNA Co., Ltd. - * - * 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 <sys/socket.h> -#include <sys/types.h> -#include <sys/un.h> -#include "h2o/memory.h" -#include "h2o/string_.h" -#include "h2o/url.h" - -const h2o_url_scheme_t H2O_URL_SCHEME_HTTP = {{H2O_STRLIT("http")}, 80}; -const h2o_url_scheme_t H2O_URL_SCHEME_HTTPS = {{H2O_STRLIT("https")}, 443}; - -static int decode_hex(int ch) -{ - if ('0' <= ch && ch <= '9') - return ch - '0'; - if ('A' <= ch && ch <= 'F') - return ch - 'A' + 0xa; - if ('a' <= ch && ch <= 'f') - return ch - 'a' + 0xa; - return -1; -} - -static size_t handle_special_paths(const char *path, size_t off, size_t last_slash) -{ - size_t orig_off = off, part_size = off - last_slash; - - if (part_size == 2 && path[off - 1] == '.') { - --off; - } else if (part_size == 3 && path[off - 2] == '.' && path[off - 1] == '.') { - off -= 2; - if (off > 1) { - for (--off; path[off - 1] != '/'; --off) - ; - } - } - return orig_off - off; -} - -/* Perform path normalization and URL decoding in one pass. - * See h2o_req_t for the purpose of @norm_indexes. */ -static h2o_iovec_t rebuild_path(h2o_mem_pool_t *pool, const char *src, size_t src_len, size_t *query_at, size_t **norm_indexes) -{ - char *dst; - size_t src_off = 0, dst_off = 0, last_slash, rewind; - - { /* locate '?', and set len to the end of input path */ - const char *q = memchr(src, '?', src_len); - if (q != NULL) { - src_len = *query_at = q - src; - } else { - *query_at = SIZE_MAX; - } - } - - /* dst can be 1 byte more than src if src is missing the prefixing '/' */ - dst = h2o_mem_alloc_pool(pool, src_len + 1); - *norm_indexes = h2o_mem_alloc_pool(pool, (src_len + 1) * sizeof(*norm_indexes[0])); - - if (src[0] == '/') - src_off++; - last_slash = dst_off; - dst[dst_off] = '/'; - (*norm_indexes)[dst_off] = src_off; - dst_off++; - - /* decode %xx */ - while (src_off < src_len) { - int hi, lo; - char decoded; - - if (src[src_off] == '%' && (src_off + 2 < src_len) && (hi = decode_hex(src[src_off + 1])) != -1 && - (lo = decode_hex(src[src_off + 2])) != -1) { - decoded = (hi << 4) | lo; - src_off += 3; - } else { - decoded = src[src_off++]; - } - if (decoded == '/') { - rewind = handle_special_paths(dst, dst_off, last_slash); - if (rewind > 0) { - dst_off -= rewind; - last_slash = dst_off - 1; - continue; - } - last_slash = dst_off; - } - dst[dst_off] = decoded; - (*norm_indexes)[dst_off] = src_off; - dst_off++; - } - rewind = handle_special_paths(dst, dst_off, last_slash); - dst_off -= rewind; - - return h2o_iovec_init(dst, dst_off); -} - -h2o_iovec_t h2o_url_normalize_path(h2o_mem_pool_t *pool, const char *path, size_t len, size_t *query_at, size_t **norm_indexes) -{ - const char *p = path, *end = path + len; - h2o_iovec_t ret; - - *query_at = SIZE_MAX; - *norm_indexes = NULL; - - if (len == 0) { - ret = h2o_iovec_init("/", 1); - return ret; - } - - if (path[0] != '/') - goto Rewrite; - - for (; p + 1 < end; ++p) { - if ((p[0] == '/' && p[1] == '.') || p[0] == '%') { - /* detect false positives as well */ - goto Rewrite; - } else if (p[0] == '?') { - *query_at = p - path; - goto Return; - } - } - for (; p < end; ++p) { - if (p[0] == '?') { - *query_at = p - path; - goto Return; - } - } - -Return: - ret.base = (char *)path; - ret.len = p - path; - return ret; - -Rewrite: - ret = rebuild_path(pool, path, len, query_at, norm_indexes); - if (ret.len == 0) - goto RewriteError; - if (ret.base[0] != '/') - goto RewriteError; - if (h2o_strstr(ret.base, ret.len, H2O_STRLIT("/../")) != SIZE_MAX) - goto RewriteError; - if (ret.len >= 3 && memcmp(ret.base + ret.len - 3, "/..", 3) == 0) - goto RewriteError; - return ret; -RewriteError: - fprintf(stderr, "failed to normalize path: `%.*s` => `%.*s`\n", (int)len, path, (int)ret.len, ret.base); - ret = h2o_iovec_init("/", 1); - return ret; -} - -static const char *parse_scheme(const char *s, const char *end, const h2o_url_scheme_t **scheme) -{ - if (end - s >= 5 && memcmp(s, "http:", 5) == 0) { - *scheme = &H2O_URL_SCHEME_HTTP; - return s + 5; - } else if (end - s >= 6 && memcmp(s, "https:", 6) == 0) { - *scheme = &H2O_URL_SCHEME_HTTPS; - return s + 6; - } - return NULL; -} - -const char *h2o_url_parse_hostport(const char *s, size_t len, h2o_iovec_t *host, uint16_t *port) -{ - const char *token_start = s, *token_end, *end = s + len; - - *port = 65535; - - if (token_start == end) - return NULL; - - if (*token_start == '[') { - /* is IPv6 address */ - ++token_start; - if ((token_end = memchr(token_start, ']', end - token_start)) == NULL) - return NULL; - *host = h2o_iovec_init(token_start, token_end - token_start); - token_start = token_end + 1; - } else { - for (token_end = token_start; !(token_end == end || *token_end == '/' || *token_end == ':'); ++token_end) - ; - *host = h2o_iovec_init(token_start, token_end - token_start); - token_start = token_end; - } - - /* disallow zero-length host */ - if (host->len == 0) - return NULL; - - /* parse port */ - if (token_start != end && *token_start == ':') { - size_t p; - ++token_start; - if ((token_end = memchr(token_start, '/', end - token_start)) == NULL) - token_end = end; - if ((p = h2o_strtosize(token_start, token_end - token_start)) >= 65535) - return NULL; - *port = (uint16_t)p; - token_start = token_end; - } - - return token_start; -} - -static int parse_authority_and_path(const char *src, const char *url_end, h2o_url_t *parsed) -{ - const char *p = h2o_url_parse_hostport(src, url_end - src, &parsed->host, &parsed->_port); - if (p == NULL) - return -1; - parsed->authority = h2o_iovec_init(src, p - src); - if (p == url_end) { - parsed->path = h2o_iovec_init(H2O_STRLIT("/")); - } else { - if (*p != '/') - return -1; - parsed->path = h2o_iovec_init(p, url_end - p); - } - return 0; -} - -int h2o_url_parse(const char *url, size_t url_len, h2o_url_t *parsed) -{ - const char *url_end, *p; - - if (url_len == SIZE_MAX) - url_len = strlen(url); - url_end = url + url_len; - - /* check and skip scheme */ - if ((p = parse_scheme(url, url_end, &parsed->scheme)) == NULL) - return -1; - - /* skip "//" */ - if (!(url_end - p >= 2 && p[0] == '/' && p[1] == '/')) - return -1; - p += 2; - - return parse_authority_and_path(p, url_end, parsed); -} - -int h2o_url_parse_relative(const char *url, size_t url_len, h2o_url_t *parsed) -{ - const char *url_end, *p; - - if (url_len == SIZE_MAX) - url_len = strlen(url); - url_end = url + url_len; - - /* obtain scheme and port number */ - if ((p = parse_scheme(url, url_end, &parsed->scheme)) == NULL) { - parsed->scheme = NULL; - p = url; - } - - /* handle "//" */ - if (url_end - p >= 2 && p[0] == '/' && p[1] == '/') - return parse_authority_and_path(p + 2, url_end, parsed); - - /* reset authority, host, port, and set path */ - parsed->authority = (h2o_iovec_t){NULL}; - parsed->host = (h2o_iovec_t){NULL}; - parsed->_port = 65535; - parsed->path = h2o_iovec_init(p, url_end - p); - - return 0; -} - -h2o_iovec_t h2o_url_resolve(h2o_mem_pool_t *pool, const h2o_url_t *base, const h2o_url_t *relative, h2o_url_t *dest) -{ - h2o_iovec_t base_path, relative_path, ret; - - assert(base->path.len != 0); - assert(base->path.base[0] == '/'); - - if (relative == NULL) { - /* build URL using base copied to dest */ - *dest = *base; - base_path = base->path; - relative_path = h2o_iovec_init(NULL, 0); - goto Build; - } - - /* scheme */ - dest->scheme = relative->scheme != NULL ? relative->scheme : base->scheme; - - /* authority (and host:port) */ - if (relative->authority.base != NULL) { - assert(relative->host.base != NULL); - dest->authority = relative->authority; - dest->host = relative->host; - dest->_port = relative->_port; - } else { - assert(relative->host.base == NULL); - assert(relative->_port == 65535); - dest->authority = base->authority; - dest->host = base->host; - dest->_port = base->_port; - } - - /* path */ - base_path = base->path; - if (relative->path.base != NULL) { - relative_path = relative->path; - h2o_url_resolve_path(&base_path, &relative_path); - } else { - assert(relative->path.len == 0); - relative_path = (h2o_iovec_t){NULL}; - } - -Build: - /* build the output */ - ret = h2o_concat(pool, dest->scheme->name, h2o_iovec_init(H2O_STRLIT("://")), dest->authority, base_path, relative_path); - /* adjust dest */ - dest->authority.base = ret.base + dest->scheme->name.len + 3; - dest->host.base = dest->authority.base; - if (dest->authority.len != 0 && dest->authority.base[0] == '[') - ++dest->host.base; - dest->path.base = dest->authority.base + dest->authority.len; - dest->path.len = ret.base + ret.len - dest->path.base; - - return ret; -} - -void h2o_url_resolve_path(h2o_iovec_t *base, h2o_iovec_t *relative) -{ - size_t base_path_len = base->len, rel_path_offset = 0; - - if (relative->len != 0 && relative->base[0] == '/') { - base_path_len = 0; - } else { - /* relative path */ - while (base->base[--base_path_len] != '/') - ; - while (rel_path_offset != relative->len) { - if (relative->base[rel_path_offset] == '.') { - if (relative->len - rel_path_offset >= 2 && relative->base[rel_path_offset + 1] == '.' && - (relative->len - rel_path_offset == 2 || relative->base[rel_path_offset + 2] == '/')) { - if (base_path_len != 0) { - while (base->base[--base_path_len] != '/') - ; - } - rel_path_offset += relative->len - rel_path_offset == 2 ? 2 : 3; - continue; - } - if (relative->len - rel_path_offset == 1) { - rel_path_offset += 1; - continue; - } else if (relative->base[rel_path_offset + 1] == '/') { - rel_path_offset += 2; - continue; - } - } - break; - } - base_path_len += 1; - } - - base->len = base_path_len; - *relative = h2o_iovec_init(relative->base + rel_path_offset, relative->len - rel_path_offset); -} - -void h2o_url_copy(h2o_mem_pool_t *pool, h2o_url_t *dest, const h2o_url_t *src) -{ - dest->scheme = src->scheme; - dest->authority = h2o_strdup(pool, src->authority.base, src->authority.len); - dest->host = h2o_strdup(pool, src->host.base, src->host.len); - dest->path = h2o_strdup(pool, src->path.base, src->path.len); - dest->_port = src->_port; -} - -const char *h2o_url_host_to_sun(h2o_iovec_t host, struct sockaddr_un *sa) -{ -#define PREFIX "unix:" - - if (host.len < sizeof(PREFIX) - 1 || memcmp(host.base, PREFIX, sizeof(PREFIX) - 1) != 0) - return h2o_url_host_to_sun_err_is_not_unix_socket; - - if (host.len - sizeof(PREFIX) - 1 >= sizeof(sa->sun_path)) - return "unix-domain socket path is too long"; - - memset(sa, 0, sizeof(*sa)); - sa->sun_family = AF_UNIX; - memcpy(sa->sun_path, host.base + sizeof(PREFIX) - 1, host.len - (sizeof(PREFIX) - 1)); - return NULL; - -#undef PREFIX -} - -const char *h2o_url_host_to_sun_err_is_not_unix_socket = "supplied name does not look like an unix-domain socket"; |