diff options
Diffstat (limited to '')
91 files changed, 31855 insertions, 0 deletions
diff --git a/web/server/h2o/libh2o/lib/common/cache.c b/web/server/h2o/libh2o/lib/common/cache.c new file mode 100644 index 000000000..cc8d8f007 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/cache.c @@ -0,0 +1,273 @@ +/* + * 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 new file mode 100644 index 000000000..3cf5ac5d1 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/file.c @@ -0,0 +1,68 @@ +/* + * 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 new file mode 100644 index 000000000..747a1ffa6 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/filecache.c @@ -0,0 +1,170 @@ +/* + * 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 new file mode 100644 index 000000000..7b481e296 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/hostinfo.c @@ -0,0 +1,229 @@ +/* + * 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 new file mode 100644 index 000000000..8547ea817 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/http1client.c @@ -0,0 +1,582 @@ +/* + * 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 new file mode 100644 index 000000000..752ea2fcb --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/memcached.c @@ -0,0 +1,429 @@ +/* + * 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 new file mode 100644 index 000000000..ba9f2dba2 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/memory.c @@ -0,0 +1,400 @@ +/* + * 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 new file mode 100644 index 000000000..b4e8ba836 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/multithread.c @@ -0,0 +1,274 @@ +/* + * 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 new file mode 100644 index 000000000..8226f6efc --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/serverutil.c @@ -0,0 +1,317 @@ +/* + * 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 new file mode 100644 index 000000000..5b1c37e04 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/socket.c @@ -0,0 +1,1433 @@ +/* + * 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 new file mode 100644 index 000000000..754ed23b9 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/socket/evloop.c.h @@ -0,0 +1,624 @@ +/* + * 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 new file mode 100644 index 000000000..247dac893 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/socket/evloop/epoll.c.h @@ -0,0 +1,203 @@ +/* + * 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 new file mode 100644 index 000000000..21288ed7c --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/socket/evloop/kqueue.c.h @@ -0,0 +1,186 @@ +/* + * 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 new file mode 100644 index 000000000..8b3f3d149 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/socket/evloop/poll.c.h @@ -0,0 +1,178 @@ +/* + * 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 new file mode 100644 index 000000000..44c71c166 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/socket/uv-binding.c.h @@ -0,0 +1,283 @@ +/* + * 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 new file mode 100644 index 000000000..da69933f7 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/socketpool.c @@ -0,0 +1,342 @@ +/* + * 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 new file mode 100644 index 000000000..3c068f3ad --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/string.c @@ -0,0 +1,594 @@ +/* + * 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 new file mode 100644 index 000000000..368143e78 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/time.c @@ -0,0 +1,175 @@ +/* + * 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 new file mode 100644 index 000000000..c50be0a3f --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/timeout.c @@ -0,0 +1,90 @@ +/* + * 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 new file mode 100644 index 000000000..d65d18fb5 --- /dev/null +++ b/web/server/h2o/libh2o/lib/common/url.c @@ -0,0 +1,409 @@ +/* + * 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"; diff --git a/web/server/h2o/libh2o/lib/core/config.c b/web/server/h2o/libh2o/lib/core/config.c new file mode 100644 index 000000000..ce1d32018 --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/config.c @@ -0,0 +1,325 @@ +/* + * Copyright (c) 2014-2016 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 <inttypes.h> +#include <limits.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "h2o.h" +#include "h2o/configurator.h" +#include "h2o/http1.h" +#include "h2o/http2.h" + +static h2o_hostconf_t *create_hostconf(h2o_globalconf_t *globalconf) +{ + h2o_hostconf_t *hostconf = h2o_mem_alloc(sizeof(*hostconf)); + *hostconf = (h2o_hostconf_t){globalconf}; + hostconf->http2.push_preload = 1; /* enabled by default */ + h2o_config_init_pathconf(&hostconf->fallback_path, globalconf, NULL, globalconf->mimemap); + hostconf->mimemap = globalconf->mimemap; + h2o_mem_addref_shared(hostconf->mimemap); + return hostconf; +} + +static void destroy_hostconf(h2o_hostconf_t *hostconf) +{ + size_t i; + + if (hostconf->authority.hostport.base != hostconf->authority.host.base) + free(hostconf->authority.hostport.base); + free(hostconf->authority.host.base); + for (i = 0; i != hostconf->paths.size; ++i) { + h2o_pathconf_t *pathconf = hostconf->paths.entries + i; + h2o_config_dispose_pathconf(pathconf); + } + free(hostconf->paths.entries); + h2o_config_dispose_pathconf(&hostconf->fallback_path); + h2o_mem_release_shared(hostconf->mimemap); + + free(hostconf); +} + +static void on_dispose_envconf(void *_envconf) +{ + h2o_envconf_t *envconf = _envconf; + size_t i; + + if (envconf->parent != NULL) + h2o_mem_release_shared(envconf->parent); + + for (i = 0; i != envconf->unsets.size; ++i) + h2o_mem_release_shared(envconf->unsets.entries[i].base); + free(envconf->unsets.entries); + for (i = 0; i != envconf->sets.size; ++i) + h2o_mem_release_shared(envconf->sets.entries[i].base); + free(envconf->sets.entries); +} + +h2o_envconf_t *h2o_config_create_envconf(h2o_envconf_t *parent) +{ + h2o_envconf_t *envconf = h2o_mem_alloc_shared(NULL, sizeof(*envconf), on_dispose_envconf); + *envconf = (h2o_envconf_t){NULL}; + + if (parent != NULL) { + envconf->parent = parent; + h2o_mem_addref_shared(parent); + } + return envconf; +} + +void h2o_config_setenv(h2o_envconf_t *envconf, const char *name, const char *value) +{ + size_t name_len = strlen(name), i; + h2o_iovec_t *value_slot; + + /* remove from the list of unsets */ + for (i = 0; i != envconf->unsets.size; ++i) { + if (h2o_memis(envconf->unsets.entries[i].base, envconf->unsets.entries[i].len, name, name_len)) { + h2o_mem_release_shared(envconf->unsets.entries[i].base); + h2o_vector_erase(&envconf->unsets, i); + break; + } + } + /* find the slot */ + for (i = 0; i != envconf->sets.size; i += 2) { + if (h2o_memis(envconf->sets.entries[i].base, envconf->sets.entries[i].len, name, name_len)) { + value_slot = envconf->sets.entries + i + 1; + h2o_mem_release_shared(value_slot->base); + goto SetValue; + } + } + /* name not found in existing sets */ + h2o_vector_reserve(NULL, &envconf->sets, envconf->sets.size + 2); + envconf->sets.entries[envconf->sets.size++] = h2o_strdup_shared(NULL, name, name_len); + value_slot = envconf->sets.entries + envconf->sets.size++; +SetValue: + *value_slot = h2o_strdup_shared(NULL, value, SIZE_MAX); +} + +void h2o_config_unsetenv(h2o_envconf_t *envconf, const char *name) +{ + size_t i, name_len = strlen(name); + + /* do nothing if already set */ + for (i = 0; i != envconf->unsets.size; ++i) + if (h2o_memis(envconf->unsets.entries[i].base, envconf->unsets.entries[i].len, name, name_len)) + return; + /* register */ + h2o_vector_reserve(NULL, &envconf->unsets, envconf->unsets.size + 1); + envconf->unsets.entries[envconf->unsets.size++] = h2o_strdup_shared(NULL, name, name_len); +} + +void h2o_config_init_pathconf(h2o_pathconf_t *pathconf, h2o_globalconf_t *globalconf, const char *path, h2o_mimemap_t *mimemap) +{ + memset(pathconf, 0, sizeof(*pathconf)); + pathconf->global = globalconf; + h2o_chunked_register(pathconf); + if (path != NULL) + pathconf->path = h2o_strdup(NULL, path, SIZE_MAX); + h2o_mem_addref_shared(mimemap); + pathconf->mimemap = mimemap; + pathconf->error_log.emit_request_errors = 1; +} + +void h2o_config_dispose_pathconf(h2o_pathconf_t *pathconf) +{ +#define DESTROY_LIST(type, list) \ + do { \ + size_t i; \ + for (i = 0; i != list.size; ++i) { \ + type *e = list.entries[i]; \ + if (e->dispose != NULL) \ + e->dispose(e); \ + free(e); \ + } \ + free(list.entries); \ + } while (0) + DESTROY_LIST(h2o_handler_t, pathconf->handlers); + DESTROY_LIST(h2o_filter_t, pathconf->filters); + DESTROY_LIST(h2o_logger_t, pathconf->loggers); +#undef DESTROY_LIST + + free(pathconf->path.base); + if (pathconf->mimemap != NULL) + h2o_mem_release_shared(pathconf->mimemap); + if (pathconf->env != NULL) + h2o_mem_release_shared(pathconf->env); +} + +void h2o_config_init(h2o_globalconf_t *config) +{ + memset(config, 0, sizeof(*config)); + config->hosts = h2o_mem_alloc(sizeof(config->hosts[0])); + config->hosts[0] = NULL; + h2o_linklist_init_anchor(&config->configurators); + config->server_name = h2o_iovec_init(H2O_STRLIT("h2o/" H2O_VERSION)); + config->max_request_entity_size = H2O_DEFAULT_MAX_REQUEST_ENTITY_SIZE; + config->max_delegations = H2O_DEFAULT_MAX_DELEGATIONS; + config->handshake_timeout = H2O_DEFAULT_HANDSHAKE_TIMEOUT; + config->http1.req_timeout = H2O_DEFAULT_HTTP1_REQ_TIMEOUT; + config->http1.upgrade_to_http2 = H2O_DEFAULT_HTTP1_UPGRADE_TO_HTTP2; + config->http1.callbacks = H2O_HTTP1_CALLBACKS; + config->http2.idle_timeout = H2O_DEFAULT_HTTP2_IDLE_TIMEOUT; + config->http2.graceful_shutdown_timeout = H2O_DEFAULT_HTTP2_GRACEFUL_SHUTDOWN_TIMEOUT; + config->proxy.io_timeout = H2O_DEFAULT_PROXY_IO_TIMEOUT; + config->proxy.emit_x_forwarded_headers = 1; + config->proxy.emit_via_header = 1; + config->http2.max_concurrent_requests_per_connection = H2O_HTTP2_SETTINGS_HOST.max_concurrent_streams; + config->http2.max_streams_for_priority = 16; + config->http2.latency_optimization.min_rtt = 50; // milliseconds + config->http2.latency_optimization.max_additional_delay = 10; + config->http2.latency_optimization.max_cwnd = 65535; + config->http2.callbacks = H2O_HTTP2_CALLBACKS; + config->mimemap = h2o_mimemap_create(); + + h2o_configurator__init_core(config); +} + +h2o_pathconf_t *h2o_config_register_path(h2o_hostconf_t *hostconf, const char *path, int flags) +{ + h2o_pathconf_t *pathconf; + + h2o_vector_reserve(NULL, &hostconf->paths, hostconf->paths.size + 1); + pathconf = hostconf->paths.entries + hostconf->paths.size++; + + h2o_config_init_pathconf(pathconf, hostconf->global, path, hostconf->mimemap); + + return pathconf; +} + +void h2o_config_register_status_handler(h2o_globalconf_t *config, h2o_status_handler_t status_handler) +{ + h2o_vector_reserve(NULL, &config->statuses, config->statuses.size + 1); + config->statuses.entries[config->statuses.size++] = status_handler; +} + +void h2o_config_register_simple_status_handler(h2o_globalconf_t *config, h2o_iovec_t name, final_status_handler_cb status_handler) +{ + h2o_status_handler_t *sh; + + h2o_vector_reserve(NULL, &config->statuses, config->statuses.size + 1); + sh = &config->statuses.entries[config->statuses.size++]; + memset(sh, 0, sizeof(*sh)); + sh->name = h2o_strdup(NULL, name.base, name.len); + sh->final = status_handler; +} + +h2o_hostconf_t *h2o_config_register_host(h2o_globalconf_t *config, h2o_iovec_t host, uint16_t port) +{ + h2o_hostconf_t *hostconf = NULL; + h2o_iovec_t host_lc; + + assert(host.len != 0); + + /* convert hostname to lowercase */ + host_lc = h2o_strdup(NULL, host.base, host.len); + h2o_strtolower(host_lc.base, host_lc.len); + + { /* return NULL if given authority is already registered */ + h2o_hostconf_t **p; + for (p = config->hosts; *p != NULL; ++p) + if (h2o_memis((*p)->authority.host.base, (*p)->authority.host.len, host_lc.base, host_lc.len) && + (*p)->authority.port == port) + goto Exit; + } + + /* create hostconf */ + hostconf = create_hostconf(config); + hostconf->authority.host = host_lc; + host_lc = (h2o_iovec_t){NULL}; + hostconf->authority.port = port; + if (hostconf->authority.port == 65535) { + hostconf->authority.hostport = hostconf->authority.host; + } else { + hostconf->authority.hostport.base = h2o_mem_alloc(hostconf->authority.host.len + sizeof("[]:" H2O_UINT16_LONGEST_STR)); + if (strchr(hostconf->authority.host.base, ':') != NULL) { + hostconf->authority.hostport.len = + sprintf(hostconf->authority.hostport.base, "[%s]:%" PRIu16, hostconf->authority.host.base, port); + } else { + hostconf->authority.hostport.len = + sprintf(hostconf->authority.hostport.base, "%s:%" PRIu16, hostconf->authority.host.base, port); + } + } + + /* append to the list */ + h2o_append_to_null_terminated_list((void *)&config->hosts, hostconf); + +Exit: + free(host_lc.base); + return hostconf; +} + +void h2o_config_dispose(h2o_globalconf_t *config) +{ + size_t i; + + for (i = 0; config->hosts[i] != NULL; ++i) { + h2o_hostconf_t *hostconf = config->hosts[i]; + destroy_hostconf(hostconf); + } + free(config->hosts); + + h2o_mem_release_shared(config->mimemap); + h2o_configurator__dispose_configurators(config); +} + +h2o_handler_t *h2o_create_handler(h2o_pathconf_t *conf, size_t sz) +{ + h2o_handler_t *handler = h2o_mem_alloc(sz); + + memset(handler, 0, sz); + handler->_config_slot = conf->global->_num_config_slots++; + + h2o_vector_reserve(NULL, &conf->handlers, conf->handlers.size + 1); + conf->handlers.entries[conf->handlers.size++] = handler; + + return handler; +} + +h2o_filter_t *h2o_create_filter(h2o_pathconf_t *conf, size_t sz) +{ + h2o_filter_t *filter = h2o_mem_alloc(sz); + + memset(filter, 0, sz); + filter->_config_slot = conf->global->_num_config_slots++; + + h2o_vector_reserve(NULL, &conf->filters, conf->filters.size + 1); + memmove(conf->filters.entries + 1, conf->filters.entries, conf->filters.size * sizeof(conf->filters.entries[0])); + conf->filters.entries[0] = filter; + ++conf->filters.size; + + return filter; +} + +h2o_logger_t *h2o_create_logger(h2o_pathconf_t *conf, size_t sz) +{ + h2o_logger_t *logger = h2o_mem_alloc(sz); + + memset(logger, 0, sz); + logger->_config_slot = conf->global->_num_config_slots++; + + h2o_vector_reserve(NULL, &conf->loggers, conf->loggers.size + 1); + conf->loggers.entries[conf->loggers.size++] = logger; + + return logger; +} diff --git a/web/server/h2o/libh2o/lib/core/configurator.c b/web/server/h2o/libh2o/lib/core/configurator.c new file mode 100644 index 000000000..891770cc2 --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/configurator.c @@ -0,0 +1,1102 @@ +/* + * 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 <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <inttypes.h> +#include "h2o.h" +#include "h2o/configurator.h" + +struct st_core_config_vars_t { + struct { + unsigned reprioritize_blocking_assets : 1; + unsigned push_preload : 1; + h2o_casper_conf_t casper; + } http2; + struct { + unsigned emit_request_errors : 1; + } error_log; +}; + +struct st_core_configurator_t { + h2o_configurator_t super; + struct st_core_config_vars_t *vars, _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static h2o_configurator_context_t *create_context(h2o_configurator_context_t *parent, int is_custom_handler) +{ + h2o_configurator_context_t *ctx = h2o_mem_alloc(sizeof(*ctx)); + if (parent == NULL) { + *ctx = (h2o_configurator_context_t){NULL}; + return ctx; + } + *ctx = *parent; + if (ctx->env != NULL) + h2o_mem_addref_shared(ctx->env); + ctx->parent = parent; + return ctx; +} + +static void destroy_context(h2o_configurator_context_t *ctx) +{ + if (ctx->env != NULL) { + if (ctx->pathconf != NULL) + ctx->pathconf->env = ctx->env; + else + h2o_mem_release_shared(ctx->env); + } + free(ctx); +} + +static int on_core_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_core_configurator_t *self = (void *)_self; + + ++self->vars; + self->vars[0] = self->vars[-1]; + return 0; +} + +static int on_core_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_core_configurator_t *self = (void *)_self; + + if (ctx->hostconf != NULL && ctx->pathconf == NULL) { + /* exitting from host-level configuration */ + ctx->hostconf->http2.reprioritize_blocking_assets = self->vars->http2.reprioritize_blocking_assets; + ctx->hostconf->http2.push_preload = self->vars->http2.push_preload; + ctx->hostconf->http2.casper = self->vars->http2.casper; + } else if (ctx->pathconf != NULL) { + /* exitting from path or extension-level configuration */ + ctx->pathconf->error_log.emit_request_errors = self->vars->error_log.emit_request_errors; + } + + --self->vars; + return 0; +} + +static void destroy_configurator(h2o_configurator_t *configurator) +{ + if (configurator->dispose != NULL) + configurator->dispose(configurator); + free(configurator->commands.entries); + free(configurator); +} + +static int setup_configurators(h2o_configurator_context_t *ctx, int is_enter, yoml_t *node) +{ + h2o_linklist_t *n; + + for (n = ctx->globalconf->configurators.next; n != &ctx->globalconf->configurators; n = n->next) { + h2o_configurator_t *c = H2O_STRUCT_FROM_MEMBER(h2o_configurator_t, _link, n); + if (is_enter) { + if (c->enter != NULL && c->enter(c, ctx, node) != 0) + return -1; + } else { + if (c->exit != NULL && c->exit(c, ctx, node) != 0) + return -1; + } + } + + return 0; +} + +static int config_timeout(h2o_configurator_command_t *cmd, yoml_t *node, uint64_t *slot) +{ + uint64_t timeout_in_secs; + + if (h2o_configurator_scanf(cmd, node, "%" SCNu64, &timeout_in_secs) != 0) + return -1; + + *slot = timeout_in_secs * 1000; + return 0; +} + +int h2o_configurator_apply_commands(h2o_configurator_context_t *ctx, yoml_t *node, int flags_mask, const char **ignore_commands) +{ + struct st_cmd_value_t { + h2o_configurator_command_t *cmd; + yoml_t *value; + }; + H2O_VECTOR(struct st_cmd_value_t) deferred = {NULL}, semi_deferred = {NULL}; + int ret = -1; + + if (node != NULL && node->type != YOML_TYPE_MAPPING) { + h2o_configurator_errprintf(NULL, node, "node must be a MAPPING"); + goto Exit; + } + + /* call on_enter of every configurator */ + if (setup_configurators(ctx, 1, node) != 0) + goto Exit; + + /* handle the configuration commands */ + if (node != NULL) { + size_t i; + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key, *value = node->data.mapping.elements[i].value; + h2o_configurator_command_t *cmd; + /* obtain the target command */ + if (key->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(NULL, key, "command must be a string"); + goto Exit; + } + if (ignore_commands != NULL) { + size_t i; + for (i = 0; ignore_commands[i] != NULL; ++i) + if (strcmp(ignore_commands[i], key->data.scalar) == 0) + goto SkipCommand; + } + if ((cmd = h2o_configurator_get_command(ctx->globalconf, key->data.scalar)) == NULL) { + h2o_configurator_errprintf(NULL, key, "unknown command: %s", key->data.scalar); + goto Exit; + } + if ((cmd->flags & flags_mask) == 0) { + h2o_configurator_errprintf(cmd, key, "the command cannot be used at this level"); + goto Exit; + } + /* check value type */ + if ((cmd->flags & (H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR | H2O_CONFIGURATOR_FLAG_EXPECT_SEQUENCE | + H2O_CONFIGURATOR_FLAG_EXPECT_MAPPING)) != 0) { + switch (value->type) { + case YOML_TYPE_SCALAR: + if ((cmd->flags & H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR) == 0) { + h2o_configurator_errprintf(cmd, value, "argument cannot be a scalar"); + goto Exit; + } + break; + case YOML_TYPE_SEQUENCE: + if ((cmd->flags & H2O_CONFIGURATOR_FLAG_EXPECT_SEQUENCE) == 0) { + h2o_configurator_errprintf(cmd, value, "argument cannot be a sequence"); + goto Exit; + } + break; + case YOML_TYPE_MAPPING: + if ((cmd->flags & H2O_CONFIGURATOR_FLAG_EXPECT_MAPPING) == 0) { + h2o_configurator_errprintf(cmd, value, "argument cannot be a mapping"); + goto Exit; + } + break; + default: + assert(!"unreachable"); + break; + } + } + /* handle the command (or keep it for later execution) */ + if ((cmd->flags & H2O_CONFIGURATOR_FLAG_SEMI_DEFERRED) != 0) { + h2o_vector_reserve(NULL, &semi_deferred, semi_deferred.size + 1); + semi_deferred.entries[semi_deferred.size++] = (struct st_cmd_value_t){cmd, value}; + } else if ((cmd->flags & H2O_CONFIGURATOR_FLAG_DEFERRED) != 0) { + h2o_vector_reserve(NULL, &deferred, deferred.size + 1); + deferred.entries[deferred.size++] = (struct st_cmd_value_t){cmd, value}; + } else { + if (cmd->cb(cmd, ctx, value) != 0) + goto Exit; + } + SkipCommand:; + } + for (i = 0; i != semi_deferred.size; ++i) { + struct st_cmd_value_t *pair = semi_deferred.entries + i; + if (pair->cmd->cb(pair->cmd, ctx, pair->value) != 0) + goto Exit; + } + for (i = 0; i != deferred.size; ++i) { + struct st_cmd_value_t *pair = deferred.entries + i; + if (pair->cmd->cb(pair->cmd, ctx, pair->value) != 0) + goto Exit; + } + } + + /* call on_exit of every configurator */ + if (setup_configurators(ctx, 0, node) != 0) + goto Exit; + + ret = 0; +Exit: + free(deferred.entries); + free(semi_deferred.entries); + return ret; +} + +static int sort_from_longer_paths(const yoml_mapping_element_t *x, const yoml_mapping_element_t *y) +{ + size_t xlen = strlen(x->key->data.scalar), ylen = strlen(y->key->data.scalar); + if (xlen < ylen) + return 1; + else if (xlen > ylen) + return -1; + /* apply strcmp for stable sort */ + return strcmp(x->key->data.scalar, y->key->data.scalar); +} + +static yoml_t *convert_path_config_node(h2o_configurator_command_t *cmd, yoml_t *node) +{ + size_t i, j; + + switch (node->type) { + case YOML_TYPE_MAPPING: + break; + case YOML_TYPE_SEQUENCE: { + /* convert to mapping */ + yoml_t *map = h2o_mem_alloc(sizeof(yoml_t)); + *map = (yoml_t){YOML_TYPE_MAPPING}; + if (node->filename != NULL) + map->filename = h2o_strdup(NULL, node->filename, SIZE_MAX).base; + map->line = node->line; + map->column = node->column; + if (node->anchor != NULL) + map->anchor = h2o_strdup(NULL, node->anchor, SIZE_MAX).base; + map->_refcnt = 1; + + for (i = 0; i != node->data.sequence.size; ++i) { + yoml_t *elem = node->data.sequence.elements[i]; + if (elem->type != YOML_TYPE_MAPPING) { + yoml_free(map, NULL); + goto Error; + } + for (j = 0; j != elem->data.mapping.size; ++j) { + yoml_t *elemkey = elem->data.mapping.elements[j].key; + yoml_t *elemvalue = elem->data.mapping.elements[j].value; + map = h2o_mem_realloc(map, offsetof(yoml_t, data.mapping.elements) + + sizeof(yoml_mapping_element_t) * (map->data.mapping.size + 1)); + map->data.mapping.elements[map->data.mapping.size].key = elemkey; + map->data.mapping.elements[map->data.mapping.size].value = elemvalue; + ++map->data.mapping.size; + ++elemkey->_refcnt; + ++elemvalue->_refcnt; + } + } + return map; + } break; + default: + Error: + h2o_configurator_errprintf(cmd, node, "value must be a mapping or sequence of mapping"); + return NULL; + } + + ++node->_refcnt; + return node; +} + +static int config_path(h2o_configurator_context_t *parent_ctx, h2o_pathconf_t *pathconf, yoml_t *node) +{ + h2o_configurator_context_t *path_ctx = create_context(parent_ctx, 0); + path_ctx->pathconf = pathconf; + path_ctx->mimemap = &pathconf->mimemap; + + int ret = h2o_configurator_apply_commands(path_ctx, node, H2O_CONFIGURATOR_FLAG_PATH, NULL); + + destroy_context(path_ctx); + return ret; +} + +static int on_config_paths(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + size_t i; + + /* sort by the length of the path (descending) */ + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key; + if (key->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, key, "key (representing the virtual path) must be a string"); + return -1; + } + } + qsort(node->data.mapping.elements, node->data.mapping.size, sizeof(node->data.mapping.elements[0]), + (int (*)(const void *, const void *))sort_from_longer_paths); + + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key, *value; + if ((value = convert_path_config_node(cmd, node->data.mapping.elements[i].value)) == NULL) + return -1; + h2o_pathconf_t *pathconf = h2o_config_register_path(ctx->hostconf, key->data.scalar, 0); + int cmd_ret = config_path(ctx, pathconf, value); + yoml_free(value, NULL); + if (cmd_ret != 0) + return cmd_ret; + } + + /* configure fallback path along with ordinary paths */ + return config_path(ctx, &ctx->hostconf->fallback_path, NULL); +} + +static int on_config_hosts(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + size_t i; + + if (node->data.mapping.size == 0) { + h2o_configurator_errprintf(cmd, node, "the mapping cannot be empty"); + return -1; + } + + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key; + yoml_t *value = node->data.mapping.elements[i].value; + h2o_iovec_t hostname; + uint16_t port; + if (key->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, key, "key (representing the hostname) must be a string"); + return -1; + } + if (h2o_url_parse_hostport(key->data.scalar, strlen(key->data.scalar), &hostname, &port) == NULL) { + h2o_configurator_errprintf(cmd, key, "invalid key (must be either `host` or `host:port`)"); + return -1; + } + assert(hostname.len != 0); + if ((hostname.base[0] == '*' && !(hostname.len == 1 || hostname.base[1] == '.')) || + memchr(hostname.base + 1, '*', hostname.len - 1) != NULL) { + h2o_configurator_errprintf(cmd, key, "wildcard (*) can only be used at the start of the hostname"); + return -1; + } + h2o_configurator_context_t *host_ctx = create_context(ctx, 0); + if ((host_ctx->hostconf = h2o_config_register_host(host_ctx->globalconf, hostname, port)) == NULL) { + h2o_configurator_errprintf(cmd, key, "duplicate host entry"); + destroy_context(host_ctx); + return -1; + } + host_ctx->mimemap = &host_ctx->hostconf->mimemap; + int cmd_ret = h2o_configurator_apply_commands(host_ctx, value, H2O_CONFIGURATOR_FLAG_HOST, NULL); + destroy_context(host_ctx); + if (cmd_ret != 0) + return -1; + if (yoml_get(value, "paths") == NULL) { + h2o_configurator_errprintf(NULL, value, "mandatory configuration directive `paths` is missing"); + return -1; + } + } + + return 0; +} + +static int on_config_limit_request_body(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + return h2o_configurator_scanf(cmd, node, "%zu", &ctx->globalconf->max_request_entity_size); +} + +static int on_config_max_delegations(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + return h2o_configurator_scanf(cmd, node, "%u", &ctx->globalconf->max_delegations); +} + +static int on_config_handshake_timeout(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + return config_timeout(cmd, node, &ctx->globalconf->handshake_timeout); +} + +static int on_config_http1_request_timeout(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + return config_timeout(cmd, node, &ctx->globalconf->http1.req_timeout); +} + +static int on_config_http1_upgrade_to_http2(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + ctx->globalconf->http1.upgrade_to_http2 = (int)ret; + return 0; +} + +static int on_config_http2_idle_timeout(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + return config_timeout(cmd, node, &ctx->globalconf->http2.idle_timeout); +} + +static int on_config_http2_graceful_shutdown_timeout(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + return config_timeout(cmd, node, &ctx->globalconf->http2.graceful_shutdown_timeout); +} + +static int on_config_http2_max_concurrent_requests_per_connection(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, + yoml_t *node) +{ + return h2o_configurator_scanf(cmd, node, "%zu", &ctx->globalconf->http2.max_concurrent_requests_per_connection); +} + +static int on_config_http2_latency_optimization_min_rtt(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, + yoml_t *node) +{ + return h2o_configurator_scanf(cmd, node, "%u", &ctx->globalconf->http2.latency_optimization.min_rtt); +} + +static int on_config_http2_latency_optimization_max_additional_delay(h2o_configurator_command_t *cmd, + h2o_configurator_context_t *ctx, yoml_t *node) +{ + double ratio; + if (h2o_configurator_scanf(cmd, node, "%lf", &ratio) != 0) + return -1; + if (!(0.0 < ratio)) { + h2o_configurator_errprintf(cmd, node, "ratio must be a positive number"); + return -1; + } + ctx->globalconf->http2.latency_optimization.max_additional_delay = 100 * ratio; + return 0; +} + +static int on_config_http2_latency_optimization_max_cwnd(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, + yoml_t *node) +{ + return h2o_configurator_scanf(cmd, node, "%u", &ctx->globalconf->http2.latency_optimization.max_cwnd); +} + +static int on_config_http2_reprioritize_blocking_assets(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, + yoml_t *node) +{ + struct st_core_configurator_t *self = (void *)cmd->configurator; + ssize_t on; + + if ((on = h2o_configurator_get_one_of(cmd, node, "OFF,ON")) == -1) + return -1; + self->vars->http2.reprioritize_blocking_assets = (int)on; + + return 0; +} + +static int on_config_http2_push_preload(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_core_configurator_t *self = (void *)cmd->configurator; + ssize_t on; + + if ((on = h2o_configurator_get_one_of(cmd, node, "OFF,ON")) == -1) + return -1; + self->vars->http2.push_preload = (int)on; + + return 0; +} + +static int on_config_http2_casper(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + static const h2o_casper_conf_t defaults = { + 13, /* casper_bits: default (2^13 ~= 100 assets * 1/0.01 collision probability) */ + 0 /* track blocking assets only */ + }; + + struct st_core_configurator_t *self = (void *)cmd->configurator; + + switch (node->type) { + case YOML_TYPE_SCALAR: + if (strcasecmp(node->data.scalar, "OFF") == 0) { + self->vars->http2.casper = (h2o_casper_conf_t){0}; + } else if (strcasecmp(node->data.scalar, "ON") == 0) { + self->vars->http2.casper = defaults; + } + break; + case YOML_TYPE_MAPPING: { + /* set to default */ + self->vars->http2.casper = defaults; + /* override the attributes defined */ + yoml_t *t; + if ((t = yoml_get(node, "capacity-bits")) != NULL) { + if (!(t->type == YOML_TYPE_SCALAR && sscanf(t->data.scalar, "%u", &self->vars->http2.casper.capacity_bits) == 1 && + self->vars->http2.casper.capacity_bits < 16)) { + h2o_configurator_errprintf(cmd, t, "value of `capacity-bits` must be an integer between 0 to 15"); + return -1; + } + } + if ((t = yoml_get(node, "tracking-types")) != NULL) { + if (t->type == YOML_TYPE_SCALAR && strcasecmp(t->data.scalar, "blocking-assets") == 0) { + self->vars->http2.casper.track_all_types = 0; + } else if (t->type == YOML_TYPE_SCALAR && strcasecmp(t->data.scalar, "all") == 0) { + self->vars->http2.casper.track_all_types = 1; + } else { + h2o_configurator_errprintf(cmd, t, "value of `tracking-types` must be either of: `blocking-assets` or `all`"); + return -1; + } + } + } break; + default: + h2o_configurator_errprintf(cmd, node, "value must be `OFF`,`ON` or a mapping containing the necessary attributes"); + return -1; + } + + return 0; +} + +static int assert_is_mimetype(h2o_configurator_command_t *cmd, yoml_t *node) +{ + if (node->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, node, "expected a scalar (mime-type)"); + return -1; + } + if (strchr(node->data.scalar, '/') == NULL) { + h2o_configurator_errprintf(cmd, node, "the string \"%s\" does not look like a mime-type", node->data.scalar); + return -1; + } + return 0; +} + +static int assert_is_extension(h2o_configurator_command_t *cmd, yoml_t *node) +{ + if (node->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, node, "expected a scalar (extension)"); + return -1; + } + if (node->data.scalar[0] != '.') { + h2o_configurator_errprintf(cmd, node, "given extension \"%s\" does not start with a \".\"", node->data.scalar); + return -1; + } + return 0; +} + +static int set_mimetypes(h2o_configurator_command_t *cmd, h2o_mimemap_t *mimemap, yoml_t *node) +{ + size_t i, j; + + assert(node->type == YOML_TYPE_MAPPING); + + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key; + yoml_t *value = node->data.mapping.elements[i].value; + if (assert_is_mimetype(cmd, key) != 0) + return -1; + switch (value->type) { + case YOML_TYPE_SCALAR: + if (assert_is_extension(cmd, value) != 0) + return -1; + h2o_mimemap_define_mimetype(mimemap, value->data.scalar + 1, key->data.scalar, NULL); + break; + case YOML_TYPE_SEQUENCE: + for (j = 0; j != value->data.sequence.size; ++j) { + yoml_t *ext_node = value->data.sequence.elements[j]; + if (assert_is_extension(cmd, ext_node) != 0) + return -1; + h2o_mimemap_define_mimetype(mimemap, ext_node->data.scalar + 1, key->data.scalar, NULL); + } + break; + case YOML_TYPE_MAPPING: { + yoml_t *t; + h2o_mime_attributes_t attr; + h2o_mimemap_get_default_attributes(key->data.scalar, &attr); + if ((t = yoml_get(value, "is_compressible")) != NULL) { + if (t->type == YOML_TYPE_SCALAR && strcasecmp(t->data.scalar, "YES") == 0) { + attr.is_compressible = 1; + } else if (t->type == YOML_TYPE_SCALAR && strcasecmp(t->data.scalar, "NO") == 0) { + attr.is_compressible = 0; + } else { + h2o_configurator_errprintf(cmd, t, "`is_compressible` attribute must be either of: `YES` or `NO`"); + return -1; + } + } + if ((t = yoml_get(value, "priority")) != NULL) { + if (t->type == YOML_TYPE_SCALAR && strcasecmp(t->data.scalar, "normal") == 0) { + attr.priority = H2O_MIME_ATTRIBUTE_PRIORITY_NORMAL; + } else if (t->type == YOML_TYPE_SCALAR && strcasecmp(t->data.scalar, "highest") == 0) { + attr.priority = H2O_MIME_ATTRIBUTE_PRIORITY_HIGHEST; + } else { + h2o_configurator_errprintf(cmd, t, "`priority` attribute must be either of: `normal` or `highest`"); + return -1; + } + } + if ((t = yoml_get(value, "extensions")) == NULL) { + h2o_configurator_errprintf(cmd, value, "cannot find mandatory attribute `extensions`"); + return -1; + } + if (t->type != YOML_TYPE_SEQUENCE) { + h2o_configurator_errprintf(cmd, t, "`extensions` attribute must be a sequence of scalars"); + return -1; + } + for (j = 0; j != t->data.sequence.size; ++j) { + yoml_t *ext_node = t->data.sequence.elements[j]; + if (assert_is_extension(cmd, ext_node) != 0) + return -1; + h2o_mimemap_define_mimetype(mimemap, ext_node->data.scalar + 1, key->data.scalar, &attr); + } + } break; + default: + fprintf(stderr, "logic flaw at %s:%d\n", __FILE__, __LINE__); + abort(); + } + } + + return 0; +} + +static int on_config_mime_settypes(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + h2o_mimemap_t *newmap = h2o_mimemap_create(); + h2o_mimemap_clear_types(newmap); + h2o_mimemap_set_default_type(newmap, h2o_mimemap_get_default_type(*ctx->mimemap)->data.mimetype.base, NULL); + if (set_mimetypes(cmd, newmap, node) != 0) { + h2o_mem_release_shared(newmap); + return -1; + } + + h2o_mem_release_shared(*ctx->mimemap); + *ctx->mimemap = newmap; + return 0; +} + +static void clone_mimemap_if_clean(h2o_configurator_context_t *ctx) +{ + if (ctx->parent == NULL) + return; + if (*ctx->mimemap != *ctx->parent->mimemap) + return; + h2o_mem_release_shared(*ctx->mimemap); + /* even after release, ctx->mimemap is still retained by the parent and therefore we can use it as the argument to clone */ + *ctx->mimemap = h2o_mimemap_clone(*ctx->mimemap); +} + +static int on_config_mime_addtypes(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + clone_mimemap_if_clean(ctx); + return set_mimetypes(cmd, *ctx->mimemap, node); +} + +static int on_config_mime_removetypes(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + size_t i; + + clone_mimemap_if_clean(ctx); + for (i = 0; i != node->data.sequence.size; ++i) { + yoml_t *ext_node = node->data.sequence.elements[i]; + if (assert_is_extension(cmd, ext_node) != 0) + return -1; + h2o_mimemap_remove_type(*ctx->mimemap, ext_node->data.scalar + 1); + } + + return 0; +} + +static int on_config_mime_setdefaulttype(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + if (assert_is_mimetype(cmd, node) != 0) + return -1; + + clone_mimemap_if_clean(ctx); + h2o_mimemap_set_default_type(*ctx->mimemap, node->data.scalar, NULL); + + return 0; +} + +static int on_config_custom_handler(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + static const char *ignore_commands[] = {"extension", NULL}; + yoml_t *ext_node; + const char **exts; + h2o_mimemap_type_t *type = NULL; + + if (node->type != YOML_TYPE_MAPPING) { + h2o_configurator_errprintf(cmd, node, "argument must be a MAPPING"); + return -1; + } + if ((ext_node = yoml_get(node, "extension")) == NULL) { + h2o_configurator_errprintf(cmd, node, "mandatory key `extension` is missing"); + return -1; + } + + /* create dynamic type */ + switch (ext_node->type) { + case YOML_TYPE_SCALAR: + if (assert_is_extension(cmd, ext_node) != 0) + return -1; + exts = alloca(2 * sizeof(*exts)); + exts[0] = ext_node->data.scalar + 1; + exts[1] = NULL; + break; + case YOML_TYPE_SEQUENCE: { + exts = alloca((ext_node->data.sequence.size + 1) * sizeof(*exts)); + size_t i; + for (i = 0; i != ext_node->data.sequence.size; ++i) { + yoml_t *n = ext_node->data.sequence.elements[i]; + if (assert_is_extension(cmd, n) != 0) + return -1; + exts[i] = n->data.scalar + 1; + } + exts[i] = NULL; + } break; + default: + h2o_configurator_errprintf(cmd, ext_node, "`extensions` must be a scalar or sequence of scalar"); + return -1; + } + clone_mimemap_if_clean(ctx); + type = h2o_mimemap_define_dynamic(*ctx->mimemap, exts, ctx->globalconf); + + /* apply the configuration commands */ + h2o_configurator_context_t *ext_ctx = create_context(ctx, 1); + ext_ctx->pathconf = &type->data.dynamic.pathconf; + ext_ctx->mimemap = NULL; + int cmd_ret = h2o_configurator_apply_commands(ext_ctx, node, H2O_CONFIGURATOR_FLAG_EXTENSION, ignore_commands); + destroy_context(ext_ctx); + if (cmd_ret != 0) + return cmd_ret; + switch (type->data.dynamic.pathconf.handlers.size) { + case 1: + break; + case 0: + h2o_configurator_errprintf(cmd, node, "no handler declared for given extension"); + return -1; + default: + h2o_configurator_errprintf(cmd, node, "cannot assign more than one handler for given extension"); + return -1; + } + + return 0; +} + +static void inherit_env_if_necessary(h2o_configurator_context_t *ctx) +{ + if (ctx->env == (ctx->parent != NULL ? ctx->parent->env : NULL)) + ctx->env = h2o_config_create_envconf(ctx->env); +} + +static int on_config_setenv(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + size_t i; + + inherit_env_if_necessary(ctx); + + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key, *value = node->data.mapping.elements[i].value; + if (key->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, key, "key must be a scalar"); + return -1; + } + if (value->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, value, "value must be a scalar"); + return -1; + } + h2o_config_setenv(ctx->env, key->data.scalar, value->data.scalar); + } + + return 0; +} + +static int on_config_unsetenv(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + inherit_env_if_necessary(ctx); + + switch (node->type) { + case YOML_TYPE_SCALAR: + h2o_config_unsetenv(ctx->env, node->data.scalar); + break; + case YOML_TYPE_SEQUENCE: { + size_t i; + for (i = 0; i != node->data.sequence.size; ++i) { + yoml_t *element = node->data.sequence.elements[i]; + if (element->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, element, "element of a sequence passed to unsetenv must be a scalar"); + return -1; + } + h2o_config_unsetenv(ctx->env, element->data.scalar); + } + } break; + default: + h2o_configurator_errprintf(cmd, node, "argument to unsetenv must be either a scalar or a sequence"); + return -1; + } + + return 0; +} + +static int on_config_server_name(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + ctx->globalconf->server_name = h2o_strdup(NULL, node->data.scalar, SIZE_MAX); + return 0; +} + +static int on_config_send_server_name(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + switch(h2o_configurator_get_one_of(cmd, node, "OFF,ON,preserve")) { + case 0: /* off */ + ctx->globalconf->server_name = h2o_iovec_init(H2O_STRLIT("")); + break; + case 1: /* on */ + break; + case 2: /* preserve */ + ctx->globalconf->server_name = h2o_iovec_init(H2O_STRLIT("")); + ctx->globalconf->proxy.preserve_server_header = 1; + break; + default: + return -1; + } + return 0; +} + +static int on_config_error_log_emit_request_errors(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_core_configurator_t *self = (void *)cmd->configurator; + ssize_t on; + + if ((on = h2o_configurator_get_one_of(cmd, node, "OFF,ON")) == -1) + return -1; + + self->vars->error_log.emit_request_errors = (int)on; + return 0; +} + +void h2o_configurator__init_core(h2o_globalconf_t *conf) +{ + /* check if already initialized */ + if (h2o_configurator_get_command(conf, "files") != NULL) + return; + + { /* `hosts` and `paths` */ + h2o_configurator_t *c = h2o_configurator_create(conf, sizeof(*c)); + h2o_configurator_define_command(c, "hosts", H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_MAPPING | + H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_hosts); + h2o_configurator_define_command(c, "paths", H2O_CONFIGURATOR_FLAG_HOST | H2O_CONFIGURATOR_FLAG_EXPECT_MAPPING | + H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_paths); + }; + + { /* setup global configurators */ + struct st_core_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + c->super.enter = on_core_enter; + c->super.exit = on_core_exit; + c->vars = c->_vars_stack; + c->vars->http2.reprioritize_blocking_assets = 1; /* defaults to ON */ + c->vars->http2.push_preload = 1; /* defaults to ON */ + c->vars->error_log.emit_request_errors = 1; /* defaults to ON */ + h2o_configurator_define_command(&c->super, "limit-request-body", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_limit_request_body); + h2o_configurator_define_command(&c->super, "max-delegations", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_max_delegations); + h2o_configurator_define_command(&c->super, "handshake-timeout", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_handshake_timeout); + h2o_configurator_define_command(&c->super, "http1-request-timeout", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http1_request_timeout); + h2o_configurator_define_command(&c->super, "http1-upgrade-to-http2", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http1_upgrade_to_http2); + h2o_configurator_define_command(&c->super, "http2-idle-timeout", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_idle_timeout); + h2o_configurator_define_command(&c->super, "http2-graceful-shutdown-timeout", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_graceful_shutdown_timeout); + h2o_configurator_define_command(&c->super, "http2-max-concurrent-requests-per-connection", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_max_concurrent_requests_per_connection); + h2o_configurator_define_command(&c->super, "http2-latency-optimization-min-rtt", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_latency_optimization_min_rtt); + h2o_configurator_define_command(&c->super, "http2-latency-optimization-max-additional-delay", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_latency_optimization_max_additional_delay); + h2o_configurator_define_command(&c->super, "http2-latency-optimization-max-cwnd", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_latency_optimization_max_cwnd); + h2o_configurator_define_command(&c->super, "http2-reprioritize-blocking-assets", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_HOST | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_reprioritize_blocking_assets); + h2o_configurator_define_command(&c->super, "http2-push-preload", H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_HOST | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_http2_push_preload); + h2o_configurator_define_command(&c->super, "http2-casper", H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_HOST, + on_config_http2_casper); + h2o_configurator_define_command(&c->super, "file.mime.settypes", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_MAPPING, + on_config_mime_settypes); + h2o_configurator_define_command(&c->super, "file.mime.addtypes", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_MAPPING, + on_config_mime_addtypes); + h2o_configurator_define_command(&c->super, "file.mime.removetypes", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_SEQUENCE, + on_config_mime_removetypes); + h2o_configurator_define_command(&c->super, "file.mime.setdefaulttype", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_mime_setdefaulttype); + h2o_configurator_define_command(&c->super, "file.custom-handler", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_SEMI_DEFERRED, + on_config_custom_handler); + h2o_configurator_define_command(&c->super, "setenv", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_MAPPING, on_config_setenv); + h2o_configurator_define_command(&c->super, "unsetenv", H2O_CONFIGURATOR_FLAG_ALL_LEVELS, on_config_unsetenv); + h2o_configurator_define_command(&c->super, "server-name", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, on_config_server_name); + h2o_configurator_define_command(&c->super, "send-server-name", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR | + H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_send_server_name); + h2o_configurator_define_command(&c->super, "error-log.emit-request-errors", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_error_log_emit_request_errors); + } +} + +void h2o_configurator__dispose_configurators(h2o_globalconf_t *conf) +{ + while (!h2o_linklist_is_empty(&conf->configurators)) { + h2o_configurator_t *c = H2O_STRUCT_FROM_MEMBER(h2o_configurator_t, _link, conf->configurators.next); + h2o_linklist_unlink(&c->_link); + if (c->dispose != NULL) + c->dispose(c); + destroy_configurator(c); + } +} + +h2o_configurator_t *h2o_configurator_create(h2o_globalconf_t *conf, size_t sz) +{ + h2o_configurator_t *c; + + assert(sz >= sizeof(*c)); + + c = h2o_mem_alloc(sz); + memset(c, 0, sz); + h2o_linklist_insert(&conf->configurators, &c->_link); + + return c; +} + +void h2o_configurator_define_command(h2o_configurator_t *configurator, const char *name, int flags, h2o_configurator_command_cb cb) +{ + h2o_configurator_command_t *cmd; + + h2o_vector_reserve(NULL, &configurator->commands, configurator->commands.size + 1); + cmd = configurator->commands.entries + configurator->commands.size++; + cmd->configurator = configurator; + cmd->flags = flags; + cmd->name = name; + cmd->cb = cb; +} + +h2o_configurator_command_t *h2o_configurator_get_command(h2o_globalconf_t *conf, const char *name) +{ + h2o_linklist_t *node; + size_t i; + + for (node = conf->configurators.next; node != &conf->configurators; node = node->next) { + h2o_configurator_t *configurator = H2O_STRUCT_FROM_MEMBER(h2o_configurator_t, _link, node); + for (i = 0; i != configurator->commands.size; ++i) { + h2o_configurator_command_t *cmd = configurator->commands.entries + i; + if (strcmp(cmd->name, name) == 0) { + return cmd; + } + } + } + + return NULL; +} + +int h2o_configurator_apply(h2o_globalconf_t *config, yoml_t *node, int dry_run) +{ + h2o_configurator_context_t *ctx = create_context(NULL, 0); + ctx->globalconf = config; + ctx->mimemap = &ctx->globalconf->mimemap; + ctx->dry_run = dry_run; + int cmd_ret = h2o_configurator_apply_commands(ctx, node, H2O_CONFIGURATOR_FLAG_GLOBAL, NULL); + destroy_context(ctx); + + if (cmd_ret != 0) + return cmd_ret; + if (config->hosts[0] == NULL) { + h2o_configurator_errprintf(NULL, node, "mandatory configuration directive `hosts` is missing"); + return -1; + } + return 0; +} + +void h2o_configurator_errprintf(h2o_configurator_command_t *cmd, yoml_t *node, const char *reason, ...) +{ + va_list args; + + fprintf(stderr, "[%s:%zu] ", node->filename ? node->filename : "-", node->line + 1); + if (cmd != NULL) + fprintf(stderr, "in command %s, ", cmd->name); + va_start(args, reason); + vfprintf(stderr, reason, args); + va_end(args); + fputc('\n', stderr); +} + +int h2o_configurator_scanf(h2o_configurator_command_t *cmd, yoml_t *node, const char *fmt, ...) +{ + va_list args; + int sscan_ret; + + if (node->type != YOML_TYPE_SCALAR) + goto Error; + va_start(args, fmt); + sscan_ret = vsscanf(node->data.scalar, fmt, args); + va_end(args); + if (sscan_ret != 1) + goto Error; + + return 0; +Error: + h2o_configurator_errprintf(cmd, node, "argument must match the format: %s", fmt); + return -1; +} + +ssize_t h2o_configurator_get_one_of(h2o_configurator_command_t *cmd, yoml_t *node, const char *candidates) +{ + const char *config_str, *cand_str; + ssize_t config_str_len, cand_index; + + if (node->type != YOML_TYPE_SCALAR) + goto Error; + + config_str = node->data.scalar; + config_str_len = strlen(config_str); + + cand_str = candidates; + for (cand_index = 0;; ++cand_index) { + if (strncasecmp(cand_str, config_str, config_str_len) == 0 && + (cand_str[config_str_len] == '\0' || cand_str[config_str_len] == ',')) { + /* found */ + return cand_index; + } + cand_str = strchr(cand_str, ','); + if (cand_str == NULL) + goto Error; + cand_str += 1; /* skip ',' */ + } +/* not reached */ + +Error: + h2o_configurator_errprintf(cmd, node, "argument must be one of: %s", candidates); + return -1; +} + +char *h2o_configurator_get_cmd_path(const char *cmd) +{ + char *root, *cmd_fullpath; + + /* just return the cmd (being strdup'ed) in case we do not need to prefix the value */ + if (cmd[0] == '/' || strchr(cmd, '/') == NULL) + goto ReturnOrig; + + /* obtain root */ + if ((root = getenv("H2O_ROOT")) == NULL) { + root = H2O_TO_STR(H2O_ROOT); + } + + /* build full-path and return */ + cmd_fullpath = h2o_mem_alloc(strlen(root) + strlen(cmd) + 2); + sprintf(cmd_fullpath, "%s/%s", root, cmd); + return cmd_fullpath; + +ReturnOrig: + return h2o_strdup(NULL, cmd, SIZE_MAX).base; +} diff --git a/web/server/h2o/libh2o/lib/core/context.c b/web/server/h2o/libh2o/lib/core/context.c new file mode 100644 index 000000000..8d1101381 --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/context.c @@ -0,0 +1,201 @@ +/* + * 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 <stddef.h> +#include <stdlib.h> +#include <sys/time.h> +#include "h2o.h" +#include "h2o/memcached.h" + +void h2o_context_init_pathconf_context(h2o_context_t *ctx, h2o_pathconf_t *pathconf) +{ + /* add pathconf to the inited list (or return if already inited) */ + size_t i; + for (i = 0; i != ctx->_pathconfs_inited.size; ++i) + if (ctx->_pathconfs_inited.entries[i] == pathconf) + return; + h2o_vector_reserve(NULL, &ctx->_pathconfs_inited, ctx->_pathconfs_inited.size + 1); + ctx->_pathconfs_inited.entries[ctx->_pathconfs_inited.size++] = pathconf; + +#define DOIT(type, list) \ + do { \ + size_t i; \ + for (i = 0; i != pathconf->list.size; ++i) { \ + type *o = pathconf->list.entries[i]; \ + if (o->on_context_init != NULL) \ + o->on_context_init(o, ctx); \ + } \ + } while (0) + + DOIT(h2o_handler_t, handlers); + DOIT(h2o_filter_t, filters); + DOIT(h2o_logger_t, loggers); + +#undef DOIT +} + +void h2o_context_dispose_pathconf_context(h2o_context_t *ctx, h2o_pathconf_t *pathconf) +{ + /* nullify pathconf in the inited list (or return if already disposed) */ + size_t i; + for (i = 0; i != ctx->_pathconfs_inited.size; ++i) + if (ctx->_pathconfs_inited.entries[i] == pathconf) + break; + if (i == ctx->_pathconfs_inited.size) + return; + ctx->_pathconfs_inited.entries[i] = NULL; + +#define DOIT(type, list) \ + do { \ + size_t i; \ + for (i = 0; i != pathconf->list.size; ++i) { \ + type *o = pathconf->list.entries[i]; \ + if (o->on_context_dispose != NULL) \ + o->on_context_dispose(o, ctx); \ + } \ + } while (0) + + DOIT(h2o_handler_t, handlers); + DOIT(h2o_filter_t, filters); + DOIT(h2o_logger_t, loggers); + +#undef DOIT +} + +void h2o_context_init(h2o_context_t *ctx, h2o_loop_t *loop, h2o_globalconf_t *config) +{ + size_t i, j; + + assert(config->hosts[0] != NULL); + + memset(ctx, 0, sizeof(*ctx)); + ctx->loop = loop; + ctx->globalconf = config; + h2o_timeout_init(ctx->loop, &ctx->zero_timeout, 0); + h2o_timeout_init(ctx->loop, &ctx->one_sec_timeout, 1000); + h2o_timeout_init(ctx->loop, &ctx->hundred_ms_timeout, 100); + ctx->queue = h2o_multithread_create_queue(loop); + h2o_multithread_register_receiver(ctx->queue, &ctx->receivers.hostinfo_getaddr, h2o_hostinfo_getaddr_receiver); + ctx->filecache = h2o_filecache_create(config->filecache.capacity); + + h2o_timeout_init(ctx->loop, &ctx->handshake_timeout, config->handshake_timeout); + h2o_timeout_init(ctx->loop, &ctx->http1.req_timeout, config->http1.req_timeout); + h2o_linklist_init_anchor(&ctx->http1._conns); + h2o_timeout_init(ctx->loop, &ctx->http2.idle_timeout, config->http2.idle_timeout); + h2o_timeout_init(ctx->loop, &ctx->http2.graceful_shutdown_timeout, config->http2.graceful_shutdown_timeout); + h2o_linklist_init_anchor(&ctx->http2._conns); + ctx->proxy.client_ctx.loop = loop; + h2o_timeout_init(ctx->loop, &ctx->proxy.io_timeout, config->proxy.io_timeout); + ctx->proxy.client_ctx.getaddr_receiver = &ctx->receivers.hostinfo_getaddr; + ctx->proxy.client_ctx.io_timeout = &ctx->proxy.io_timeout; + ctx->proxy.client_ctx.ssl_ctx = config->proxy.ssl_ctx; + + ctx->_module_configs = h2o_mem_alloc(sizeof(*ctx->_module_configs) * config->_num_config_slots); + memset(ctx->_module_configs, 0, sizeof(*ctx->_module_configs) * config->_num_config_slots); + + static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; + pthread_mutex_lock(&mutex); + for (i = 0; config->hosts[i] != NULL; ++i) { + h2o_hostconf_t *hostconf = config->hosts[i]; + for (j = 0; j != hostconf->paths.size; ++j) { + h2o_pathconf_t *pathconf = hostconf->paths.entries + j; + h2o_context_init_pathconf_context(ctx, pathconf); + } + h2o_context_init_pathconf_context(ctx, &hostconf->fallback_path); + } + pthread_mutex_unlock(&mutex); +} + +void h2o_context_dispose(h2o_context_t *ctx) +{ + h2o_globalconf_t *config = ctx->globalconf; + size_t i, j; + + for (i = 0; config->hosts[i] != NULL; ++i) { + h2o_hostconf_t *hostconf = config->hosts[i]; + for (j = 0; j != hostconf->paths.size; ++j) { + h2o_pathconf_t *pathconf = hostconf->paths.entries + j; + h2o_context_dispose_pathconf_context(ctx, pathconf); + } + h2o_context_dispose_pathconf_context(ctx, &hostconf->fallback_path); + } + free(ctx->_pathconfs_inited.entries); + free(ctx->_module_configs); + h2o_timeout_dispose(ctx->loop, &ctx->zero_timeout); + h2o_timeout_dispose(ctx->loop, &ctx->one_sec_timeout); + h2o_timeout_dispose(ctx->loop, &ctx->hundred_ms_timeout); + h2o_timeout_dispose(ctx->loop, &ctx->handshake_timeout); + h2o_timeout_dispose(ctx->loop, &ctx->http1.req_timeout); + h2o_timeout_dispose(ctx->loop, &ctx->http2.idle_timeout); + h2o_timeout_dispose(ctx->loop, &ctx->http2.graceful_shutdown_timeout); + h2o_timeout_dispose(ctx->loop, &ctx->proxy.io_timeout); + /* what should we do here? assert(!h2o_linklist_is_empty(&ctx->http2._conns); */ + + h2o_filecache_destroy(ctx->filecache); + ctx->filecache = NULL; + + /* clear storage */ + for (i = 0; i != ctx->storage.size; ++i) { + h2o_context_storage_item_t *item = ctx->storage.entries + i; + if (item->dispose != NULL) { + item->dispose(item->data); + } + } + free(ctx->storage.entries); + + /* TODO assert that the all the getaddrinfo threads are idle */ + h2o_multithread_unregister_receiver(ctx->queue, &ctx->receivers.hostinfo_getaddr); + h2o_multithread_destroy_queue(ctx->queue); + + if (ctx->_timestamp_cache.value != NULL) + h2o_mem_release_shared(ctx->_timestamp_cache.value); + +#if H2O_USE_LIBUV + /* make sure the handles released by h2o_timeout_dispose get freed */ + uv_run(ctx->loop, UV_RUN_NOWAIT); +#endif +} + +void h2o_context_request_shutdown(h2o_context_t *ctx) +{ + ctx->shutdown_requested = 1; + if (ctx->globalconf->http1.callbacks.request_shutdown != NULL) + ctx->globalconf->http1.callbacks.request_shutdown(ctx); + if (ctx->globalconf->http2.callbacks.request_shutdown != NULL) + ctx->globalconf->http2.callbacks.request_shutdown(ctx); +} + +void h2o_context_update_timestamp_cache(h2o_context_t *ctx) +{ + time_t prev_sec = ctx->_timestamp_cache.tv_at.tv_sec; + ctx->_timestamp_cache.uv_now_at = h2o_now(ctx->loop); + gettimeofday(&ctx->_timestamp_cache.tv_at, NULL); + if (ctx->_timestamp_cache.tv_at.tv_sec != prev_sec) { + struct tm gmt; + /* update the string cache */ + if (ctx->_timestamp_cache.value != NULL) + h2o_mem_release_shared(ctx->_timestamp_cache.value); + ctx->_timestamp_cache.value = h2o_mem_alloc_shared(NULL, sizeof(h2o_timestamp_string_t), NULL); + gmtime_r(&ctx->_timestamp_cache.tv_at.tv_sec, &gmt); + h2o_time2str_rfc1123(ctx->_timestamp_cache.value->rfc1123, &gmt); + h2o_time2str_log(ctx->_timestamp_cache.value->log, ctx->_timestamp_cache.tv_at.tv_sec); + } +} diff --git a/web/server/h2o/libh2o/lib/core/headers.c b/web/server/h2o/libh2o/lib/core/headers.c new file mode 100644 index 000000000..d31183623 --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/headers.c @@ -0,0 +1,155 @@ +/* + * 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 <stddef.h> +#include <stdio.h> +#include "h2o.h" + +static void add_header(h2o_mem_pool_t *pool, h2o_headers_t *headers, h2o_iovec_t *name, const char *orig_name, const char *value, + size_t value_len) +{ + h2o_header_t *slot; + + h2o_vector_reserve(pool, headers, headers->size + 1); + slot = headers->entries + headers->size++; + + slot->name = name; + slot->value.base = (char *)value; + slot->value.len = value_len; + slot->orig_name = orig_name ? h2o_strdup(pool, orig_name, name->len).base : NULL; +} + +ssize_t h2o_find_header(const h2o_headers_t *headers, const h2o_token_t *token, ssize_t cursor) +{ + for (++cursor; cursor < headers->size; ++cursor) { + if (headers->entries[cursor].name == &token->buf) { + return cursor; + } + } + return -1; +} + +ssize_t h2o_find_header_by_str(const h2o_headers_t *headers, const char *name, size_t name_len, ssize_t cursor) +{ + for (++cursor; cursor < headers->size; ++cursor) { + h2o_header_t *t = headers->entries + cursor; + if (h2o_memis(t->name->base, t->name->len, name, name_len)) { + return cursor; + } + } + return -1; +} + +void h2o_add_header(h2o_mem_pool_t *pool, h2o_headers_t *headers, const h2o_token_t *token, const char *orig_name, + const char *value, size_t value_len) +{ + add_header(pool, headers, (h2o_iovec_t *)&token->buf, orig_name, value, value_len); +} + +void h2o_add_header_by_str(h2o_mem_pool_t *pool, h2o_headers_t *headers, const char *name, size_t name_len, int maybe_token, + const char *orig_name, const char *value, size_t value_len) +{ + h2o_iovec_t *name_buf; + + if (maybe_token) { + const h2o_token_t *token = h2o_lookup_token(name, name_len); + if (token != NULL) { + add_header(pool, headers, (h2o_iovec_t *)token, orig_name, value, value_len); + return; + } + } + name_buf = h2o_mem_alloc_pool(pool, sizeof(h2o_iovec_t)); + name_buf->base = (char *)name; + name_buf->len = name_len; + add_header(pool, headers, name_buf, orig_name, value, value_len); +} + +void h2o_set_header(h2o_mem_pool_t *pool, h2o_headers_t *headers, const h2o_token_t *token, const char *value, size_t value_len, + int overwrite_if_exists) +{ + ssize_t cursor = h2o_find_header(headers, token, -1); + if (cursor != -1) { + if (overwrite_if_exists) { + h2o_iovec_t *slot = &headers->entries[cursor].value; + slot->base = (char *)value; + slot->len = value_len; + } + } else { + h2o_add_header(pool, headers, token, NULL, value, value_len); + } +} + +void h2o_set_header_by_str(h2o_mem_pool_t *pool, h2o_headers_t *headers, const char *name, size_t name_len, int maybe_token, + const char *value, size_t value_len, int overwrite_if_exists) +{ + ssize_t cursor; + + if (maybe_token) { + const h2o_token_t *token = h2o_lookup_token(name, name_len); + if (token != NULL) { + h2o_set_header(pool, headers, token, value, value_len, overwrite_if_exists); + return; + } + } + + cursor = h2o_find_header_by_str(headers, name, name_len, -1); + if (cursor != -1) { + if (overwrite_if_exists) { + h2o_iovec_t *slot = &headers->entries[cursor].value; + slot->base = (char *)value; + slot->len = value_len; + } + } else { + h2o_iovec_t *name_buf = h2o_mem_alloc_pool(pool, sizeof(h2o_iovec_t)); + name_buf->base = (char *)name; + name_buf->len = name_len; + add_header(pool, headers, name_buf, NULL, value, value_len); + } +} + +void h2o_set_header_token(h2o_mem_pool_t *pool, h2o_headers_t *headers, const h2o_token_t *token, const char *value, + size_t value_len) +{ + h2o_header_t *dest = NULL; + size_t i; + for (i = 0; i != headers->size; ++i) { + if (headers->entries[i].name == &token->buf) { + if (h2o_contains_token(headers->entries[i].value.base, headers->entries[i].value.len, value, value_len, ',')) + return; + dest = headers->entries + i; + } + } + if (dest != NULL) { + dest->value = h2o_concat(pool, dest->value, h2o_iovec_init(H2O_STRLIT(", ")), h2o_iovec_init(value, value_len)); + } else { + h2o_add_header(pool, headers, token, NULL, value, value_len); + } +} + +ssize_t h2o_delete_header(h2o_headers_t *headers, ssize_t cursor) +{ + assert(cursor != -1); + + --headers->size; + memmove(headers->entries + cursor, headers->entries + cursor + 1, sizeof(h2o_header_t) * (headers->size - cursor)); + + return cursor; +} diff --git a/web/server/h2o/libh2o/lib/core/logconf.c b/web/server/h2o/libh2o/lib/core/logconf.c new file mode 100644 index 000000000..4d79736cc --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/logconf.c @@ -0,0 +1,793 @@ +/* + * 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 <inttypes.h> +#include <stdio.h> +#include <stdlib.h> +#include "h2o.h" + +enum { + ELEMENT_TYPE_EMPTY, /* empty element (with suffix only) */ + ELEMENT_TYPE_LOCAL_ADDR, /* %A */ + ELEMENT_TYPE_BYTES_SENT, /* %b */ + ELEMENT_TYPE_PROTOCOL, /* %H */ + ELEMENT_TYPE_REMOTE_ADDR, /* %h */ + ELEMENT_TYPE_LOGNAME, /* %l */ + ELEMENT_TYPE_METHOD, /* %m */ + ELEMENT_TYPE_LOCAL_PORT, /* %p, %{local}p */ + ELEMENT_TYPE_REMOTE_PORT, /* %{remote}p */ + ELEMENT_TYPE_ENV_VAR, /* %{..}e */ + ELEMENT_TYPE_QUERY, /* %q */ + ELEMENT_TYPE_REQUEST_LINE, /* %r */ + ELEMENT_TYPE_STATUS, /* %s */ + ELEMENT_TYPE_TIMESTAMP, /* %t */ + ELEMENT_TYPE_TIMESTAMP_STRFTIME, /* %{...}t */ + ELEMENT_TYPE_TIMESTAMP_SEC_SINCE_EPOCH, /* %{sec}t */ + ELEMENT_TYPE_TIMESTAMP_MSEC_SINCE_EPOCH, /* %{msec}t */ + ELEMENT_TYPE_TIMESTAMP_USEC_SINCE_EPOCH, /* %{usec}t */ + ELEMENT_TYPE_TIMESTAMP_MSEC_FRAC, /* %{msec_frac}t */ + ELEMENT_TYPE_TIMESTAMP_USEC_FRAC, /* %{usec_frac}t */ + ELEMENT_TYPE_URL_PATH, /* %U */ + ELEMENT_TYPE_REMOTE_USER, /* %u */ + ELEMENT_TYPE_AUTHORITY, /* %V */ + ELEMENT_TYPE_HOSTCONF, /* %v */ + ELEMENT_TYPE_IN_HEADER_TOKEN, /* %{data.header_token}i */ + ELEMENT_TYPE_IN_HEADER_STRING, /* %{data.name}i */ + ELEMENT_TYPE_OUT_HEADER_TOKEN, /* %{data.header_token}o */ + ELEMENT_TYPE_OUT_HEADER_STRING, /* %{data.name}o */ + ELEMENT_TYPE_OUT_HEADER_TOKEN_CONCATENATED, /* %{data.header_token}o */ + ELEMENT_TYPE_EXTENDED_VAR, /* %{data.name}x */ + ELEMENT_TYPE_CONNECTION_ID, /* %{connection-id}x */ + ELEMENT_TYPE_CONNECT_TIME, /* %{connect-time}x */ + ELEMENT_TYPE_REQUEST_HEADER_TIME, /* %{request-header-time}x */ + ELEMENT_TYPE_REQUEST_BODY_TIME, /* %{request-body-time}x */ + ELEMENT_TYPE_REQUEST_TOTAL_TIME, /* %{request-total-time}x */ + ELEMENT_TYPE_PROCESS_TIME, /* %{process-time}x */ + ELEMENT_TYPE_RESPONSE_TIME, /* %{response-total-time}x */ + ELEMENT_TYPE_DURATION, /* %{duration}x */ + ELEMENT_TYPE_ERROR, /* %{error}x */ + ELEMENT_TYPE_PROTOCOL_SPECIFIC, /* %{protocol-specific...}x */ + NUM_ELEMENT_TYPES +}; + +struct log_element_t { + unsigned type; + h2o_iovec_t suffix; + union { + const h2o_token_t *header_token; + h2o_iovec_t name; + size_t protocol_specific_callback_index; + } data; + unsigned magically_quoted_json : 1; /* whether to omit surrounding doublequotes when the output is null */ + unsigned original_response : 1; +}; + +struct st_h2o_logconf_t { + H2O_VECTOR(struct log_element_t) elements; + int escape; +}; + +static h2o_iovec_t strdup_lowercased(const char *s, size_t len) +{ + h2o_iovec_t v = h2o_strdup(NULL, s, len); + h2o_strtolower(v.base, v.len); + return v; +} + +static int determine_magicquote_nodes(h2o_logconf_t *logconf, char *errbuf) +{ + size_t element_index; + int quote_char = '\0'; /* the quote char being used if the state machine is within a string literal */ + int just_in = 0; /* if we just went into the string literal */ + + for (element_index = 0; element_index < logconf->elements.size; ++element_index) { + h2o_iovec_t suffix = logconf->elements.entries[element_index].suffix; + logconf->elements.entries[element_index].magically_quoted_json = just_in && suffix.len != 0 && suffix.base[0] == quote_char; + + just_in = 0; + + size_t i; + for (i = 0; i < suffix.len; ++i) { + just_in = 0; + if (quote_char != '\0') { + if (quote_char == suffix.base[i]) { + /* out of quote? */ + size_t j, num_bs = 0; + for (j = i; j != 0; ++num_bs) + if (suffix.base[--j] != '\\') + break; + if (num_bs % 2 == 0) + quote_char = '\0'; + } + } else { + if (suffix.base[i] == '"' || suffix.base[i] == '\'') { + quote_char = suffix.base[i]; + just_in = 1; + } + } + } + } + + return 1; +} + +h2o_logconf_t *h2o_logconf_compile(const char *fmt, int escape, char *errbuf) +{ + h2o_logconf_t *logconf = h2o_mem_alloc(sizeof(*logconf)); + const char *pt = fmt; + size_t fmt_len = strlen(fmt); + + *logconf = (h2o_logconf_t){{NULL}, escape}; + +#define LAST_ELEMENT() (logconf->elements.entries + logconf->elements.size - 1) +/* suffix buffer is always guaranteed to be larger than the fmt + (sizeof('\n') - 1) (so that they would be no buffer overruns) */ +#define NEW_ELEMENT(ty) \ + do { \ + h2o_vector_reserve(NULL, &logconf->elements, logconf->elements.size + 1); \ + logconf->elements.size++; \ + *LAST_ELEMENT() = (struct log_element_t){0}; \ + LAST_ELEMENT()->type = ty; \ + LAST_ELEMENT()->suffix.base = h2o_mem_alloc(fmt_len + 1); \ + } while (0) + + while (*pt != '\0') { + if (memcmp(pt, "%%", 2) == 0) { + ++pt; /* emit % */ + } else if (*pt == '%') { + ++pt; + /* handle < and > */ + int log_original = 0; + for (;; ++pt) { + if (*pt == '<') { + log_original = 1; + } else if (*pt == '>') { + log_original = 0; + } else { + break; + } + } + /* handle {...}n */ + if (*pt == '{') { + const h2o_token_t *token; + const char *quote_end = strchr(++pt, '}'); + if (quote_end == NULL) { + sprintf(errbuf, "failed to compile log format: unterminated header name starting at: \"%16s\"", pt); + goto Error; + } + const char modifier = quote_end[1]; + switch (modifier) { + case 'i': + case 'o': { + h2o_iovec_t name = strdup_lowercased(pt, quote_end - pt); + token = h2o_lookup_token(name.base, name.len); + if (token != NULL) { + free(name.base); + if (modifier == 'o' && token == H2O_TOKEN_SET_COOKIE) { + NEW_ELEMENT(ELEMENT_TYPE_OUT_HEADER_TOKEN_CONCATENATED); + LAST_ELEMENT()->data.header_token = token; + } else { + NEW_ELEMENT(modifier == 'i' ? ELEMENT_TYPE_IN_HEADER_TOKEN : ELEMENT_TYPE_OUT_HEADER_TOKEN); + LAST_ELEMENT()->data.header_token = token; + } + } else { + NEW_ELEMENT(modifier == 'i' ? ELEMENT_TYPE_IN_HEADER_STRING : ELEMENT_TYPE_OUT_HEADER_STRING); + LAST_ELEMENT()->data.name = name; + } + LAST_ELEMENT()->original_response = log_original; + } break; + case 'p': + if (h2o_memis(pt, quote_end - pt, H2O_STRLIT("local"))) { + NEW_ELEMENT(ELEMENT_TYPE_LOCAL_PORT); + } else if (h2o_memis(pt, quote_end - pt, H2O_STRLIT("remote"))) { + NEW_ELEMENT(ELEMENT_TYPE_REMOTE_PORT); + } else { + sprintf(errbuf, "failed to compile log format: unknown specifier for %%{...}p"); + goto Error; + } + break; + case 'e': + { + h2o_iovec_t name = h2o_strdup(NULL, pt, quote_end - pt); + NEW_ELEMENT(ELEMENT_TYPE_ENV_VAR); + LAST_ELEMENT()->data.name = name; + } + break; + case 't': + if (h2o_memis(pt, quote_end - pt, H2O_STRLIT("sec"))) { + NEW_ELEMENT(ELEMENT_TYPE_TIMESTAMP_SEC_SINCE_EPOCH); + } else if (h2o_memis(pt, quote_end - pt, H2O_STRLIT("msec"))) { + NEW_ELEMENT(ELEMENT_TYPE_TIMESTAMP_MSEC_SINCE_EPOCH); + } else if (h2o_memis(pt, quote_end - pt, H2O_STRLIT("usec"))) { + NEW_ELEMENT(ELEMENT_TYPE_TIMESTAMP_USEC_SINCE_EPOCH); + } else if (h2o_memis(pt, quote_end - pt, H2O_STRLIT("msec_frac"))) { + NEW_ELEMENT(ELEMENT_TYPE_TIMESTAMP_MSEC_FRAC); + } else if (h2o_memis(pt, quote_end - pt, H2O_STRLIT("usec_frac"))) { + NEW_ELEMENT(ELEMENT_TYPE_TIMESTAMP_USEC_FRAC); + } else { + h2o_iovec_t name = h2o_strdup(NULL, pt, quote_end - pt); + NEW_ELEMENT(ELEMENT_TYPE_TIMESTAMP_STRFTIME); + LAST_ELEMENT()->data.name = name; + } + break; + case 'x': +#define MAP_EXT_TO_TYPE(name, id) \ + if (h2o_lcstris(pt, quote_end - pt, H2O_STRLIT(name))) { \ + NEW_ELEMENT(id); \ + goto MAP_EXT_Found; \ + } +#define MAP_EXT_TO_PROTO(name, cb) \ + if (h2o_lcstris(pt, quote_end - pt, H2O_STRLIT(name))) { \ + h2o_conn_callbacks_t dummy_; \ + NEW_ELEMENT(ELEMENT_TYPE_PROTOCOL_SPECIFIC); \ + LAST_ELEMENT()->data.protocol_specific_callback_index = \ + &dummy_.log_.cb - dummy_.log_.callbacks; \ + goto MAP_EXT_Found; \ + } + MAP_EXT_TO_TYPE("connection-id", ELEMENT_TYPE_CONNECTION_ID); + MAP_EXT_TO_TYPE("connect-time", ELEMENT_TYPE_CONNECT_TIME); + MAP_EXT_TO_TYPE("request-total-time", ELEMENT_TYPE_REQUEST_TOTAL_TIME); + MAP_EXT_TO_TYPE("request-header-time", ELEMENT_TYPE_REQUEST_HEADER_TIME); + MAP_EXT_TO_TYPE("request-body-time", ELEMENT_TYPE_REQUEST_BODY_TIME); + MAP_EXT_TO_TYPE("process-time", ELEMENT_TYPE_PROCESS_TIME); + MAP_EXT_TO_TYPE("response-time", ELEMENT_TYPE_RESPONSE_TIME); + MAP_EXT_TO_TYPE("duration", ELEMENT_TYPE_DURATION); + MAP_EXT_TO_TYPE("error", ELEMENT_TYPE_ERROR); + MAP_EXT_TO_PROTO("http1.request-index", http1.request_index); + MAP_EXT_TO_PROTO("http2.stream-id", http2.stream_id); + MAP_EXT_TO_PROTO("http2.priority.received", http2.priority_received); + MAP_EXT_TO_PROTO("http2.priority.received.exclusive", http2.priority_received_exclusive); + MAP_EXT_TO_PROTO("http2.priority.received.parent", http2.priority_received_parent); + MAP_EXT_TO_PROTO("http2.priority.received.weight", http2.priority_received_weight); + MAP_EXT_TO_PROTO("http2.priority.actual", http2.priority_actual); + MAP_EXT_TO_PROTO("http2.priority.actual.parent", http2.priority_actual_parent); + MAP_EXT_TO_PROTO("http2.priority.actual.weight", http2.priority_actual_weight); + MAP_EXT_TO_PROTO("ssl.protocol-version", ssl.protocol_version); + MAP_EXT_TO_PROTO("ssl.session-reused", ssl.session_reused); + MAP_EXT_TO_PROTO("ssl.cipher", ssl.cipher); + MAP_EXT_TO_PROTO("ssl.cipher-bits", ssl.cipher_bits); + MAP_EXT_TO_PROTO("ssl.session-id", ssl.session_id); + { /* not found */ + h2o_iovec_t name = strdup_lowercased(pt, quote_end - pt); + NEW_ELEMENT(ELEMENT_TYPE_EXTENDED_VAR); + LAST_ELEMENT()->data.name = name; + } + MAP_EXT_Found: +#undef MAP_EXT_TO_TYPE +#undef MAP_EXT_TO_PROTO + break; + default: + sprintf(errbuf, "failed to compile log format: header name is not followed by either `i`, `o`, `x`, `e`"); + goto Error; + } + pt = quote_end + 2; + continue; + } else { + unsigned type = NUM_ELEMENT_TYPES; + switch (*pt++) { +#define TYPE_MAP(ch, ty) \ + case ch: \ + type = ty; \ + break + TYPE_MAP('A', ELEMENT_TYPE_LOCAL_ADDR); + TYPE_MAP('b', ELEMENT_TYPE_BYTES_SENT); + TYPE_MAP('H', ELEMENT_TYPE_PROTOCOL); + TYPE_MAP('h', ELEMENT_TYPE_REMOTE_ADDR); + TYPE_MAP('l', ELEMENT_TYPE_LOGNAME); + TYPE_MAP('m', ELEMENT_TYPE_METHOD); + TYPE_MAP('p', ELEMENT_TYPE_LOCAL_PORT); + TYPE_MAP('e', ELEMENT_TYPE_ENV_VAR); + TYPE_MAP('q', ELEMENT_TYPE_QUERY); + TYPE_MAP('r', ELEMENT_TYPE_REQUEST_LINE); + TYPE_MAP('s', ELEMENT_TYPE_STATUS); + TYPE_MAP('t', ELEMENT_TYPE_TIMESTAMP); + TYPE_MAP('U', ELEMENT_TYPE_URL_PATH); + TYPE_MAP('u', ELEMENT_TYPE_REMOTE_USER); + TYPE_MAP('V', ELEMENT_TYPE_AUTHORITY); + TYPE_MAP('v', ELEMENT_TYPE_HOSTCONF); +#undef TYPE_MAP + default: + sprintf(errbuf, "failed to compile log format: unknown escape sequence: %%%c", pt[-1]); + goto Error; + } + NEW_ELEMENT(type); + LAST_ELEMENT()->original_response = log_original; + continue; + } + } + /* emit current char */ + if (logconf->elements.size == 0) + NEW_ELEMENT(ELEMENT_TYPE_EMPTY); + LAST_ELEMENT()->suffix.base[LAST_ELEMENT()->suffix.len++] = *pt++; + } + + /* emit end-of-line */ + if (logconf->elements.size == 0) + NEW_ELEMENT(ELEMENT_TYPE_EMPTY); + LAST_ELEMENT()->suffix.base[LAST_ELEMENT()->suffix.len++] = '\n'; + +#undef NEW_ELEMENT +#undef LAST_ELEMENT + + if (escape == H2O_LOGCONF_ESCAPE_JSON) { + if (!determine_magicquote_nodes(logconf, errbuf)) + goto Error; + } + + return logconf; + +Error: + h2o_logconf_dispose(logconf); + return NULL; +} + +void h2o_logconf_dispose(h2o_logconf_t *logconf) +{ + size_t i; + + for (i = 0; i != logconf->elements.size; ++i) { + free(logconf->elements.entries[i].suffix.base); + switch (logconf->elements.entries[i].type) { + case ELEMENT_TYPE_EXTENDED_VAR: + case ELEMENT_TYPE_IN_HEADER_STRING: + case ELEMENT_TYPE_OUT_HEADER_STRING: + case ELEMENT_TYPE_TIMESTAMP_STRFTIME: + free(logconf->elements.entries[i].data.name.base); + break; + default: + break; + } + } + free(logconf->elements.entries); + free(logconf); +} + +static inline char *append_safe_string(char *pos, const char *src, size_t len) +{ + memcpy(pos, src, len); + return pos + len; +} + +static char *append_unsafe_string_apache(char *pos, const char *src, size_t len) +{ + const char *src_end = src + len; + + for (; src != src_end; ++src) { + if (' ' <= *src && *src < 0x7d && *src != '"') { + *pos++ = *src; + } else { + *pos++ = '\\'; + *pos++ = 'x'; + *pos++ = ("0123456789abcdef")[(*src >> 4) & 0xf]; + *pos++ = ("0123456789abcdef")[*src & 0xf]; + } + } + + return pos; +} + +static char *append_unsafe_string_json(char *pos, const char *src, size_t len) +{ + const char *src_end = src + len; + + for (; src != src_end; ++src) { + if (' ' <= *src && *src < 0x7e) { + if (*src == '"' || *src == '\\') + *pos++ = '\\'; + *pos++ = *src; + } else { + *pos++ = '\\'; + *pos++ = 'u'; + *pos++ = '0'; + *pos++ = '0'; + *pos++ = ("0123456789abcdef")[(*src >> 4) & 0xf]; + *pos++ = ("0123456789abcdef")[*src & 0xf]; + } + } + + return pos; +} + +static char *append_addr(char *pos, socklen_t (*cb)(h2o_conn_t *conn, struct sockaddr *sa), h2o_conn_t *conn, h2o_iovec_t nullexpr) +{ + struct sockaddr_storage ss; + socklen_t sslen; + + if ((sslen = cb(conn, (void *)&ss)) == 0) + goto Fail; + size_t l = h2o_socket_getnumerichost((void *)&ss, sslen, pos); + if (l == SIZE_MAX) + goto Fail; + pos += l; + return pos; + +Fail: + memcpy(pos, nullexpr.base, nullexpr.len); + pos += nullexpr.len; + return pos; +} + +static char *append_port(char *pos, socklen_t (*cb)(h2o_conn_t *conn, struct sockaddr *sa), h2o_conn_t *conn, h2o_iovec_t nullexpr) +{ + struct sockaddr_storage ss; + socklen_t sslen; + + if ((sslen = cb(conn, (void *)&ss)) == 0) + goto Fail; + int32_t port = h2o_socket_getport((void *)&ss); + if (port == -1) + goto Fail; + pos += sprintf(pos, "%" PRIu16, (uint16_t)port); + return pos; + +Fail: + memcpy(pos, nullexpr.base, nullexpr.len); + pos += nullexpr.len; + return pos; +} + +#define APPEND_DURATION(pos, name) \ + do { \ + int64_t delta_usec; \ + if (!h2o_time_compute_##name(req, &delta_usec)) \ + goto EmitNull; \ + int32_t delta_sec = (int32_t)(delta_usec / (1000 * 1000)); \ + delta_usec -= ((int64_t)delta_sec * (1000 * 1000)); \ + RESERVE(sizeof(H2O_INT32_LONGEST_STR ".999999") - 1); \ + pos += sprintf(pos, "%" PRId32, delta_sec); \ + if (delta_usec != 0) { \ + int i; \ + *pos++ = '.'; \ + for (i = 5; i >= 0; --i) { \ + pos[i] = '0' + delta_usec % 10; \ + delta_usec /= 10; \ + } \ + pos += 6; \ + } \ + } while (0); + +static char *expand_line_buf(char *line, size_t *cur_size, size_t required, int should_realloc) +{ + size_t new_size = *cur_size; + + /* determine the new size */ + do { + new_size *= 2; + } while (new_size < required); + + /* reallocate */ + if (!should_realloc) { + char *newpt = h2o_mem_alloc(new_size); + memcpy(newpt, line, *cur_size); + line = newpt; + } else { + line = h2o_mem_realloc(line, new_size); + } + *cur_size = new_size; + + return line; +} + +char *h2o_log_request(h2o_logconf_t *logconf, h2o_req_t *req, size_t *len, char *buf) +{ + char *line = buf, *pos = line, *line_end = line + *len; + h2o_iovec_t nullexpr; + char *(*append_unsafe_string)(char *pos, const char *src, size_t len); + size_t element_index, unsafe_factor; + struct tm localt = {0}; + int should_realloc_on_expand = 0; + + switch (logconf->escape) { + case H2O_LOGCONF_ESCAPE_APACHE: + nullexpr = h2o_iovec_init(H2O_STRLIT("-")); + append_unsafe_string = append_unsafe_string_apache; + unsafe_factor = 4; + break; + case H2O_LOGCONF_ESCAPE_JSON: + nullexpr = h2o_iovec_init(H2O_STRLIT("null")); + append_unsafe_string = append_unsafe_string_json; + unsafe_factor = 6; + break; + default: + h2o_fatal("unexpected escape mode"); + break; + } + + for (element_index = 0; element_index != logconf->elements.size; ++element_index) { + struct log_element_t *element = logconf->elements.entries + element_index; + +/* reserve capacity + suffix.len */ +#define RESERVE(capacity) \ + do { \ + if ((capacity) + element->suffix.len > line_end - pos) { \ + size_t off = pos - line; \ + size_t size = line_end - line; \ + line = expand_line_buf(line, &size, off + (capacity) + element->suffix.len, should_realloc_on_expand); \ + pos = line + off; \ + line_end = line + size; \ + should_realloc_on_expand = 1; \ + } \ + } while (0) + + switch (element->type) { + case ELEMENT_TYPE_EMPTY: + RESERVE(0); + break; + case ELEMENT_TYPE_LOCAL_ADDR: /* %A */ + RESERVE(NI_MAXHOST); + pos = append_addr(pos, req->conn->callbacks->get_sockname, req->conn, nullexpr); + break; + case ELEMENT_TYPE_BYTES_SENT: /* %b */ + RESERVE(sizeof(H2O_UINT64_LONGEST_STR) - 1); + pos += sprintf(pos, "%" PRIu64, (uint64_t)req->bytes_sent); + break; + case ELEMENT_TYPE_PROTOCOL: /* %H */ + RESERVE(sizeof("HTTP/1.1")); + pos += h2o_stringify_protocol_version(pos, req->version); + break; + case ELEMENT_TYPE_REMOTE_ADDR: /* %h */ + RESERVE(NI_MAXHOST); + pos = append_addr(pos, req->conn->callbacks->get_peername, req->conn, nullexpr); + break; + case ELEMENT_TYPE_METHOD: /* %m */ + RESERVE(req->input.method.len * unsafe_factor); + pos = append_unsafe_string(pos, req->input.method.base, req->input.method.len); + break; + case ELEMENT_TYPE_LOCAL_PORT: /* %p */ + RESERVE(sizeof(H2O_UINT16_LONGEST_STR) - 1); + pos = append_port(pos, req->conn->callbacks->get_sockname, req->conn, nullexpr); + break; + case ELEMENT_TYPE_REMOTE_PORT: /* %{remote}p */ + RESERVE(sizeof(H2O_UINT16_LONGEST_STR) - 1); + pos = append_port(pos, req->conn->callbacks->get_peername, req->conn, nullexpr); + break; + case ELEMENT_TYPE_ENV_VAR: /* %{..}e */ { + h2o_iovec_t *env_var = h2o_req_getenv(req, element->data.name.base, element->data.name.len, 0); + if (env_var == NULL) + goto EmitNull; + RESERVE(env_var->len * unsafe_factor); + pos = append_safe_string(pos, env_var->base, env_var->len); + } break; + case ELEMENT_TYPE_QUERY: /* %q */ + if (req->input.query_at != SIZE_MAX) { + size_t len = req->input.path.len - req->input.query_at; + RESERVE(len * unsafe_factor); + pos = append_unsafe_string(pos, req->input.path.base + req->input.query_at, len); + } + break; + case ELEMENT_TYPE_REQUEST_LINE: /* %r */ + RESERVE((req->input.method.len + req->input.path.len) * unsafe_factor + sizeof(" HTTP/1.1")); + pos = append_unsafe_string(pos, req->input.method.base, req->input.method.len); + *pos++ = ' '; + pos = append_unsafe_string(pos, req->input.path.base, req->input.path.len); + *pos++ = ' '; + pos += h2o_stringify_protocol_version(pos, req->version); + break; + case ELEMENT_TYPE_STATUS: /* %s */ + RESERVE(sizeof(H2O_INT32_LONGEST_STR) - 1); + pos += sprintf(pos, "%" PRId32, (int32_t)(element->original_response ? req->res.original.status : req->res.status)); + break; + case ELEMENT_TYPE_TIMESTAMP: /* %t */ + if (h2o_timeval_is_null(&req->processed_at.at)) + goto EmitNull; + RESERVE(H2O_TIMESTR_LOG_LEN + 2); + *pos++ = '['; + pos = append_safe_string(pos, req->processed_at.str->log, H2O_TIMESTR_LOG_LEN); + *pos++ = ']'; + break; + case ELEMENT_TYPE_TIMESTAMP_STRFTIME: /* %{...}t */ + if (h2o_timeval_is_null(&req->processed_at.at)) + goto EmitNull; + { + size_t bufsz, len; + if (localt.tm_year == 0) + localtime_r(&req->processed_at.at.tv_sec, &localt); + for (bufsz = 128;; bufsz *= 2) { + RESERVE(bufsz); + if ((len = strftime(pos, bufsz, element->data.name.base, &localt)) != 0) + break; + } + pos += len; + } + break; + case ELEMENT_TYPE_TIMESTAMP_SEC_SINCE_EPOCH: /* %{sec}t */ + if (h2o_timeval_is_null(&req->processed_at.at)) + goto EmitNull; + RESERVE(sizeof(H2O_UINT32_LONGEST_STR) - 1); + pos += sprintf(pos, "%" PRIu32, (uint32_t)req->processed_at.at.tv_sec); + break; + case ELEMENT_TYPE_TIMESTAMP_MSEC_SINCE_EPOCH: /* %{msec}t */ + if (h2o_timeval_is_null(&req->processed_at.at)) + goto EmitNull; + RESERVE(sizeof(H2O_UINT64_LONGEST_STR) - 1); + pos += sprintf(pos, "%" PRIu64, + (uint64_t)req->processed_at.at.tv_sec * 1000 + (uint64_t)req->processed_at.at.tv_usec / 1000); + break; + case ELEMENT_TYPE_TIMESTAMP_USEC_SINCE_EPOCH: /* %{usec}t */ + if (h2o_timeval_is_null(&req->processed_at.at)) + goto EmitNull; + RESERVE(sizeof(H2O_UINT64_LONGEST_STR) - 1); + pos += + sprintf(pos, "%" PRIu64, (uint64_t)req->processed_at.at.tv_sec * 1000000 + (uint64_t)req->processed_at.at.tv_usec); + break; + case ELEMENT_TYPE_TIMESTAMP_MSEC_FRAC: /* %{msec_frac}t */ + if (h2o_timeval_is_null(&req->processed_at.at)) + goto EmitNull; + RESERVE(3); + pos += sprintf(pos, "%03u", (unsigned)(req->processed_at.at.tv_usec / 1000)); + break; + case ELEMENT_TYPE_TIMESTAMP_USEC_FRAC: /* %{usec_frac}t */ + if (h2o_timeval_is_null(&req->processed_at.at)) + goto EmitNull; + RESERVE(6); + pos += sprintf(pos, "%06u", (unsigned)req->processed_at.at.tv_usec); + break; + case ELEMENT_TYPE_URL_PATH: /* %U */ { + size_t path_len = req->input.query_at == SIZE_MAX ? req->input.path.len : req->input.query_at; + RESERVE(path_len * unsafe_factor); + pos = append_unsafe_string(pos, req->input.path.base, path_len); + } break; + case ELEMENT_TYPE_REMOTE_USER: /* %u */ { + h2o_iovec_t *remote_user = h2o_req_getenv(req, H2O_STRLIT("REMOTE_USER"), 0); + if (remote_user == NULL) + goto EmitNull; + RESERVE(remote_user->len * unsafe_factor); + pos = append_unsafe_string(pos, remote_user->base, remote_user->len); + } break; + case ELEMENT_TYPE_AUTHORITY: /* %V */ + RESERVE(req->input.authority.len * unsafe_factor); + pos = append_unsafe_string(pos, req->input.authority.base, req->input.authority.len); + break; + case ELEMENT_TYPE_HOSTCONF: /* %v */ + RESERVE(req->hostconf->authority.hostport.len * unsafe_factor); + pos = append_unsafe_string(pos, req->hostconf->authority.hostport.base, req->hostconf->authority.hostport.len); + break; + +#define EMIT_HEADER(__headers, concat, findfunc, ...) \ + do { \ + h2o_headers_t *headers = (__headers); \ + ssize_t index = -1; \ + int found = 0; \ + while ((index = (findfunc)(headers, __VA_ARGS__, index)) != -1) { \ + if (found) { \ + RESERVE(2); \ + *pos++ = ','; \ + *pos++ = ' '; \ + } else { \ + found = 1; \ + } \ + const h2o_header_t *header = headers->entries + index; \ + RESERVE(header->value.len *unsafe_factor); \ + pos = append_unsafe_string(pos, header->value.base, header->value.len); \ + if (!concat) \ + break; \ + } \ + if (!found) \ + goto EmitNull; \ + } while (0) + + case ELEMENT_TYPE_IN_HEADER_TOKEN: + EMIT_HEADER(&req->headers, 0, h2o_find_header, element->data.header_token); + break; + case ELEMENT_TYPE_IN_HEADER_STRING: + EMIT_HEADER(&req->headers, 0, h2o_find_header_by_str, element->data.name.base, element->data.name.len); + break; + case ELEMENT_TYPE_OUT_HEADER_TOKEN: + EMIT_HEADER(element->original_response ? &req->res.original.headers : &req->res.headers, 0, h2o_find_header, + element->data.header_token); + break; + case ELEMENT_TYPE_OUT_HEADER_STRING: + EMIT_HEADER(element->original_response ? &req->res.original.headers : &req->res.headers, 0, h2o_find_header_by_str, + element->data.name.base, element->data.name.len); + break; + case ELEMENT_TYPE_OUT_HEADER_TOKEN_CONCATENATED: + EMIT_HEADER(element->original_response ? &req->res.original.headers : &req->res.headers, 1, h2o_find_header, + element->data.header_token); + break; + +#undef EMIT_HEADER + + case ELEMENT_TYPE_CONNECTION_ID: + RESERVE(sizeof(H2O_UINT64_LONGEST_STR) - 1); + pos += sprintf(pos, "%" PRIu64, req->conn->id); + break; + + case ELEMENT_TYPE_CONNECT_TIME: + APPEND_DURATION(pos, connect_time); + break; + + case ELEMENT_TYPE_REQUEST_HEADER_TIME: + APPEND_DURATION(pos, header_time); + break; + + case ELEMENT_TYPE_REQUEST_BODY_TIME: + APPEND_DURATION(pos, body_time); + break; + + case ELEMENT_TYPE_REQUEST_TOTAL_TIME: + APPEND_DURATION(pos, request_total_time); + break; + + case ELEMENT_TYPE_PROCESS_TIME: + APPEND_DURATION(pos, process_time); + break; + + case ELEMENT_TYPE_RESPONSE_TIME: + APPEND_DURATION(pos, response_time); + break; + + case ELEMENT_TYPE_DURATION: + APPEND_DURATION(pos, duration); + break; + + case ELEMENT_TYPE_ERROR: { + size_t i; + for (i = 0; i != req->error_logs.size; ++i) { + h2o_req_error_log_t *log = req->error_logs.entries + i; + size_t module_len = strlen(log->module); + RESERVE(sizeof("[] ") - 1 + module_len + log->msg.len * unsafe_factor); + *pos++ = '['; + pos = append_safe_string(pos, log->module, module_len); + *pos++ = ']'; + *pos++ = ' '; + pos = append_unsafe_string(pos, log->msg.base, log->msg.len); + } + } break; + + case ELEMENT_TYPE_PROTOCOL_SPECIFIC: { + h2o_iovec_t (*cb)(h2o_req_t *) = req->conn->callbacks->log_.callbacks[element->data.protocol_specific_callback_index]; + if (cb != NULL) { + h2o_iovec_t s = cb(req); + if (s.base == NULL) + goto EmitNull; + RESERVE(s.len); + pos = append_safe_string(pos, s.base, s.len); + } else { + goto EmitNull; + } + } break; + + case ELEMENT_TYPE_LOGNAME: /* %l */ + case ELEMENT_TYPE_EXTENDED_VAR: /* %{...}x */ + EmitNull: + RESERVE(nullexpr.len); + /* special case that trims surrounding quotes */ + if (element->magically_quoted_json) { + --pos; + pos = append_safe_string(pos, nullexpr.base, nullexpr.len); + pos = append_safe_string(pos, element->suffix.base + 1, element->suffix.len - 1); + continue; + } + pos = append_safe_string(pos, nullexpr.base, nullexpr.len); + break; + + default: + assert(!"unknown type"); + break; + } + +#undef RESERVE + + pos = append_safe_string(pos, element->suffix.base, element->suffix.len); + } + + *len = pos - line; + return line; +} diff --git a/web/server/h2o/libh2o/lib/core/proxy.c b/web/server/h2o/libh2o/lib/core/proxy.c new file mode 100644 index 000000000..edb4baf9d --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/proxy.c @@ -0,0 +1,610 @@ +/* + * Copyright (c) 2014,2015 DeNA Co., Ltd., Kazuho Oku, Masahiro Nagano + * + * 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 <netdb.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/socket.h> +#include "picohttpparser.h" +#include "h2o.h" +#include "h2o/http1.h" +#include "h2o/http1client.h" +#include "h2o/tunnel.h" + +struct rp_generator_t { + h2o_generator_t super; + h2o_req_t *src_req; + h2o_http1client_t *client; + struct { + h2o_iovec_t bufs[2]; /* first buf is the request line and headers, the second is the POST content */ + int is_head; + } up_req; + h2o_buffer_t *last_content_before_send; + h2o_doublebuffer_t sending; + int is_websocket_handshake; + int had_body_error; /* set if an error happened while fetching the body so that we can propagate the error */ +}; + +struct rp_ws_upgrade_info_t { + h2o_context_t *ctx; + h2o_timeout_t *timeout; + h2o_socket_t *upstream_sock; +}; + +static h2o_http1client_ctx_t *get_client_ctx(h2o_req_t *req) +{ + h2o_req_overrides_t *overrides = req->overrides; + if (overrides != NULL && overrides->client_ctx != NULL) + return overrides->client_ctx; + return &req->conn->ctx->proxy.client_ctx; +} + +static h2o_iovec_t rewrite_location(h2o_mem_pool_t *pool, const char *location, size_t location_len, h2o_url_t *match, + const h2o_url_scheme_t *req_scheme, h2o_iovec_t req_authority, h2o_iovec_t req_basepath) +{ + h2o_url_t loc_parsed; + + if (h2o_url_parse(location, location_len, &loc_parsed) != 0) + goto NoRewrite; + if (loc_parsed.scheme != &H2O_URL_SCHEME_HTTP) + goto NoRewrite; + if (!h2o_url_hosts_are_equal(&loc_parsed, match)) + goto NoRewrite; + if (h2o_url_get_port(&loc_parsed) != h2o_url_get_port(match)) + goto NoRewrite; + if (loc_parsed.path.len < match->path.len) + goto NoRewrite; + if (memcmp(loc_parsed.path.base, match->path.base, match->path.len) != 0) + goto NoRewrite; + + return h2o_concat(pool, req_scheme->name, h2o_iovec_init(H2O_STRLIT("://")), req_authority, req_basepath, + h2o_iovec_init(loc_parsed.path.base + match->path.len, loc_parsed.path.len - match->path.len)); + +NoRewrite: + return (h2o_iovec_t){NULL}; +} + +static h2o_iovec_t build_request_merge_headers(h2o_mem_pool_t *pool, h2o_iovec_t merged, h2o_iovec_t added, int seperator) +{ + if (added.len == 0) + return merged; + if (merged.len == 0) + return added; + + size_t newlen = merged.len + 2 + added.len; + char *buf = h2o_mem_alloc_pool(pool, newlen); + memcpy(buf, merged.base, merged.len); + buf[merged.len] = seperator; + buf[merged.len + 1] = ' '; + memcpy(buf + merged.len + 2, added.base, added.len); + merged.base = buf; + merged.len = newlen; + return merged; +} + +/* + * A request without neither Content-Length or Transfer-Encoding header implies a zero-length request body (see 6th rule of RFC 7230 + * 3.3.3). + * OTOH, section 3.3.3 states: + * + * A user agent SHOULD send a Content-Length in a request message when + * no Transfer-Encoding is sent and the request method defines a meaning + * for an enclosed payload body. For example, a Content-Length header + * field is normally sent in a POST request even when the value is 0 + * (indicating an empty payload body). A user agent SHOULD NOT send a + * Content-Length header field when the request message does not contain + * a payload body and the method semantics do not anticipate such a + * body. + * + * PUT and POST define a meaning for the payload body, let's emit a + * Content-Length header if it doesn't exist already, since the server + * might send a '411 Length Required' response. + * + * see also: ML thread starting at https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0580.html + */ +static int req_requires_content_length(h2o_req_t *req) +{ + int is_put_or_post = + (req->method.len >= 1 && req->method.base[0] == 'P' && (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("POST")) || + h2o_memis(req->method.base, req->method.len, H2O_STRLIT("PUT")))); + + return is_put_or_post && h2o_find_header(&req->res.headers, H2O_TOKEN_TRANSFER_ENCODING, -1) == -1; +} + +static h2o_iovec_t build_request(h2o_req_t *req, int keepalive, int is_websocket_handshake, int use_proxy_protocol) +{ + h2o_iovec_t buf; + size_t offset = 0, remote_addr_len = SIZE_MAX; + char remote_addr[NI_MAXHOST]; + struct sockaddr_storage ss; + socklen_t sslen; + h2o_iovec_t cookie_buf = {NULL}, xff_buf = {NULL}, via_buf = {NULL}; + int preserve_x_forwarded_proto = req->conn->ctx->globalconf->proxy.preserve_x_forwarded_proto; + int emit_x_forwarded_headers = req->conn->ctx->globalconf->proxy.emit_x_forwarded_headers; + int emit_via_header = req->conn->ctx->globalconf->proxy.emit_via_header; + + /* for x-f-f */ + if ((sslen = req->conn->callbacks->get_peername(req->conn, (void *)&ss)) != 0) + remote_addr_len = h2o_socket_getnumerichost((void *)&ss, sslen, remote_addr); + + /* build response */ + buf.len = req->method.len + req->path.len + req->authority.len + 512; + if (use_proxy_protocol) + buf.len += H2O_PROXY_HEADER_MAX_LENGTH; + buf.base = h2o_mem_alloc_pool(&req->pool, buf.len); + +#define RESERVE(sz) \ + do { \ + size_t required = offset + sz + 4 /* for "\r\n\r\n" */; \ + if (required > buf.len) { \ + do { \ + buf.len *= 2; \ + } while (required > buf.len); \ + char *newp = h2o_mem_alloc_pool(&req->pool, buf.len); \ + memcpy(newp, buf.base, offset); \ + buf.base = newp; \ + } \ + } while (0) +#define APPEND(s, l) \ + do { \ + memcpy(buf.base + offset, (s), (l)); \ + offset += (l); \ + } while (0) +#define APPEND_STRLIT(lit) APPEND((lit), sizeof(lit) - 1) +#define FLATTEN_PREFIXED_VALUE(prefix, value, add_size) \ + do { \ + RESERVE(sizeof(prefix) - 1 + value.len + 2 + add_size); \ + APPEND_STRLIT(prefix); \ + if (value.len != 0) { \ + APPEND(value.base, value.len); \ + if (add_size != 0) { \ + buf.base[offset++] = ','; \ + buf.base[offset++] = ' '; \ + } \ + } \ + } while (0) + + if (use_proxy_protocol) + offset += h2o_stringify_proxy_header(req->conn, buf.base + offset); + + APPEND(req->method.base, req->method.len); + buf.base[offset++] = ' '; + APPEND(req->path.base, req->path.len); + APPEND_STRLIT(" HTTP/1.1\r\nconnection: "); + if (is_websocket_handshake) { + APPEND_STRLIT("upgrade\r\nupgrade: websocket\r\nhost: "); + } else if (keepalive) { + APPEND_STRLIT("keep-alive\r\nhost: "); + } else { + APPEND_STRLIT("close\r\nhost: "); + } + APPEND(req->authority.base, req->authority.len); + buf.base[offset++] = '\r'; + buf.base[offset++] = '\n'; + assert(offset <= buf.len); + if (req->entity.base != NULL || req_requires_content_length(req)) { + RESERVE(sizeof("content-length: " H2O_UINT64_LONGEST_STR) - 1); + offset += sprintf(buf.base + offset, "content-length: %zu\r\n", req->entity.len); + } + + /* rewrite headers if necessary */ + h2o_headers_t req_headers = req->headers; + if (req->overrides != NULL && req->overrides->headers_cmds != NULL) { + req_headers.entries = NULL; + req_headers.size = 0; + req_headers.capacity = 0; + h2o_headers_command_t *cmd; + h2o_vector_reserve(&req->pool, &req_headers, req->headers.capacity); + memcpy(req_headers.entries, req->headers.entries, sizeof(req->headers.entries[0]) * req->headers.size); + req_headers.size = req->headers.size; + for (cmd = req->overrides->headers_cmds; cmd->cmd != H2O_HEADERS_CMD_NULL; ++cmd) + h2o_rewrite_headers(&req->pool, &req_headers, cmd); + } + + { + const h2o_header_t *h, *h_end; + for (h = req_headers.entries, h_end = h + req_headers.size; h != h_end; ++h) { + if (h2o_iovec_is_token(h->name)) { + const h2o_token_t *token = (void *)h->name; + if (token->proxy_should_drop_for_req) { + continue; + } else if (token == H2O_TOKEN_COOKIE) { + /* merge the cookie headers; see HTTP/2 8.1.2.5 and HTTP/1 (RFC6265 5.4) */ + /* FIXME current algorithm is O(n^2) against the number of cookie headers */ + cookie_buf = build_request_merge_headers(&req->pool, cookie_buf, h->value, ';'); + continue; + } else if (token == H2O_TOKEN_VIA) { + if (!emit_via_header) { + goto AddHeader; + } + via_buf = build_request_merge_headers(&req->pool, via_buf, h->value, ','); + continue; + } else if (token == H2O_TOKEN_X_FORWARDED_FOR) { + if (!emit_x_forwarded_headers) { + goto AddHeader; + } + xff_buf = build_request_merge_headers(&req->pool, xff_buf, h->value, ','); + continue; + } + } + if (!preserve_x_forwarded_proto && h2o_lcstris(h->name->base, h->name->len, H2O_STRLIT("x-forwarded-proto"))) + continue; + AddHeader: + RESERVE(h->name->len + h->value.len + 2); + APPEND(h->orig_name ? h->orig_name : h->name->base, h->name->len); + buf.base[offset++] = ':'; + buf.base[offset++] = ' '; + APPEND(h->value.base, h->value.len); + buf.base[offset++] = '\r'; + buf.base[offset++] = '\n'; + } + } + if (cookie_buf.len != 0) { + FLATTEN_PREFIXED_VALUE("cookie: ", cookie_buf, 0); + buf.base[offset++] = '\r'; + buf.base[offset++] = '\n'; + } + if (emit_x_forwarded_headers) { + if (!preserve_x_forwarded_proto) { + FLATTEN_PREFIXED_VALUE("x-forwarded-proto: ", req->input.scheme->name, 0); + buf.base[offset++] = '\r'; + buf.base[offset++] = '\n'; + } + if (remote_addr_len != SIZE_MAX) { + FLATTEN_PREFIXED_VALUE("x-forwarded-for: ", xff_buf, remote_addr_len); + APPEND(remote_addr, remote_addr_len); + } else { + FLATTEN_PREFIXED_VALUE("x-forwarded-for: ", xff_buf, 0); + } + buf.base[offset++] = '\r'; + buf.base[offset++] = '\n'; + } + if (emit_via_header) { + FLATTEN_PREFIXED_VALUE("via: ", via_buf, sizeof("1.1 ") - 1 + req->input.authority.len); + if (req->version < 0x200) { + buf.base[offset++] = '1'; + buf.base[offset++] = '.'; + buf.base[offset++] = '0' + (0x100 <= req->version && req->version <= 0x109 ? req->version - 0x100 : 0); + } else { + buf.base[offset++] = '2'; + } + buf.base[offset++] = ' '; + APPEND(req->input.authority.base, req->input.authority.len); + buf.base[offset++] = '\r'; + buf.base[offset++] = '\n'; + } + APPEND_STRLIT("\r\n"); + +#undef RESERVE +#undef APPEND +#undef APPEND_STRLIT +#undef FLATTEN_PREFIXED_VALUE + + /* set the length */ + assert(offset <= buf.len); + buf.len = offset; + + return buf; +} + +static void do_close(h2o_generator_t *generator, h2o_req_t *req) +{ + struct rp_generator_t *self = (void *)generator; + + if (self->client != NULL) { + h2o_http1client_cancel(self->client); + self->client = NULL; + } +} + +static void do_send(struct rp_generator_t *self) +{ + h2o_iovec_t vecs[1]; + size_t veccnt; + h2o_send_state_t ststate; + + assert(self->sending.bytes_inflight == 0); + + vecs[0] = h2o_doublebuffer_prepare(&self->sending, + self->client != NULL ? &self->client->sock->input : &self->last_content_before_send, + self->src_req->preferred_chunk_size); + + if (self->client == NULL && vecs[0].len == self->sending.buf->size && self->last_content_before_send->size == 0) { + veccnt = vecs[0].len != 0 ? 1 : 0; + ststate = H2O_SEND_STATE_FINAL; + } else { + if (vecs[0].len == 0) + return; + veccnt = 1; + ststate = H2O_SEND_STATE_IN_PROGRESS; + } + + if (self->had_body_error) + ststate = H2O_SEND_STATE_ERROR; + + h2o_send(self->src_req, vecs, veccnt, ststate); +} + +static void do_proceed(h2o_generator_t *generator, h2o_req_t *req) +{ + struct rp_generator_t *self = (void *)generator; + + h2o_doublebuffer_consume(&self->sending); + do_send(self); +} + +static void on_websocket_upgrade_complete(void *_info, h2o_socket_t *sock, size_t reqsize) +{ + struct rp_ws_upgrade_info_t *info = _info; + + if (sock != NULL) { + h2o_buffer_consume(&sock->input, reqsize);//It is detached from conn. Let's trash unused data. + h2o_tunnel_establish(info->ctx, sock, info->upstream_sock, info->timeout); + } else { + h2o_socket_close(info->upstream_sock); + } + free(info); +} + +static inline void on_websocket_upgrade(struct rp_generator_t *self, h2o_timeout_t *timeout, int rlen) +{ + h2o_req_t *req = self->src_req; + h2o_socket_t *sock = h2o_http1client_steal_socket(self->client); + h2o_buffer_consume(&sock->input, rlen);//trash data after stealing sock. + struct rp_ws_upgrade_info_t *info = h2o_mem_alloc(sizeof(*info)); + info->upstream_sock = sock; + info->timeout = timeout; + info->ctx = req->conn->ctx; + h2o_http1_upgrade(req, NULL, 0, on_websocket_upgrade_complete, info); +} + +static int on_body(h2o_http1client_t *client, const char *errstr) +{ + struct rp_generator_t *self = client->data; + + if (errstr != NULL) { + /* detach the content */ + self->last_content_before_send = self->client->sock->input; + h2o_buffer_init(&self->client->sock->input, &h2o_socket_buffer_prototype); + self->client = NULL; + if (errstr != h2o_http1client_error_is_eos) { + h2o_req_log_error(self->src_req, "lib/core/proxy.c", "%s", errstr); + self->had_body_error = 1; + } + } + if (self->sending.bytes_inflight == 0) + do_send(self); + + return 0; +} + +static char compress_hint_to_enum(const char *val, size_t len) +{ + if (h2o_lcstris(val, len, H2O_STRLIT("on"))) { + return H2O_COMPRESS_HINT_ENABLE; + } + if (h2o_lcstris(val, len, H2O_STRLIT("off"))) { + return H2O_COMPRESS_HINT_DISABLE; + } + return H2O_COMPRESS_HINT_AUTO; +} + +static h2o_http1client_body_cb on_head(h2o_http1client_t *client, const char *errstr, int minor_version, int status, + h2o_iovec_t msg, h2o_header_t *headers, size_t num_headers, int rlen) +{ + struct rp_generator_t *self = client->data; + h2o_req_t *req = self->src_req; + size_t i; + + if (errstr != NULL && errstr != h2o_http1client_error_is_eos) { + self->client = NULL; + h2o_req_log_error(req, "lib/core/proxy.c", "%s", errstr); + h2o_send_error_502(req, "Gateway Error", errstr, 0); + return NULL; + } + + /* copy the response (note: all the headers must be copied; http1client discards the input once we return from this callback) */ + req->res.status = status; + req->res.reason = h2o_strdup(&req->pool, msg.base, msg.len).base; + for (i = 0; i != num_headers; ++i) { + if (h2o_iovec_is_token(headers[i].name)) { + const h2o_token_t *token = H2O_STRUCT_FROM_MEMBER(h2o_token_t, buf, headers[i].name); + h2o_iovec_t value; + if (token->proxy_should_drop_for_res) { + goto Skip; + } + if (token == H2O_TOKEN_CONTENT_LENGTH) { + if (req->res.content_length != SIZE_MAX || + (req->res.content_length = h2o_strtosize(headers[i].value.base, headers[i].value.len)) == SIZE_MAX) { + self->client = NULL; + h2o_req_log_error(req, "lib/core/proxy.c", "%s", "invalid response from upstream (malformed content-length)"); + h2o_send_error_502(req, "Gateway Error", "invalid response from upstream", 0); + return NULL; + } + goto Skip; + } else if (token == H2O_TOKEN_LOCATION) { + if (req->res_is_delegated && (300 <= status && status <= 399) && status != 304) { + self->client = NULL; + h2o_iovec_t method = h2o_get_redirect_method(req->method, status); + h2o_send_redirect_internal(req, method, headers[i].value.base, headers[i].value.len, 1); + return NULL; + } + if (req->overrides != NULL && req->overrides->location_rewrite.match != NULL) { + value = rewrite_location(&req->pool, headers[i].value.base, headers[i].value.len, + req->overrides->location_rewrite.match, req->input.scheme, req->input.authority, + req->overrides->location_rewrite.path_prefix); + if (value.base != NULL) + goto AddHeader; + } + goto AddHeaderDuped; + } else if (token == H2O_TOKEN_LINK) { + h2o_iovec_t new_value; + new_value = h2o_push_path_in_link_header(req, headers[i].value.base, headers[i].value.len); + if (!new_value.len) + goto Skip; + headers[i].value.base = new_value.base; + headers[i].value.len = new_value.len; + } else if (token == H2O_TOKEN_SERVER) { + if (!req->conn->ctx->globalconf->proxy.preserve_server_header) + goto Skip; + } else if (token == H2O_TOKEN_X_COMPRESS_HINT) { + req->compress_hint = compress_hint_to_enum(headers[i].value.base, headers[i].value.len); + goto Skip; + } + /* default behaviour, transfer the header downstream */ + AddHeaderDuped: + value = h2o_strdup(&req->pool, headers[i].value.base, headers[i].value.len); + AddHeader: + h2o_add_header(&req->pool, &req->res.headers, token, headers[i].orig_name, value.base, value.len); + Skip:; + } else { + h2o_iovec_t name = h2o_strdup(&req->pool, headers[i].name->base, headers[i].name->len); + h2o_iovec_t value = h2o_strdup(&req->pool, headers[i].value.base, headers[i].value.len); + h2o_add_header_by_str(&req->pool, &req->res.headers, name.base, name.len, 0, headers[i].orig_name, value.base, + value.len); + } + } + + if (self->is_websocket_handshake && req->res.status == 101) { + h2o_http1client_ctx_t *client_ctx = get_client_ctx(req); + assert(client_ctx->websocket_timeout != NULL); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_UPGRADE, NULL, H2O_STRLIT("websocket")); + on_websocket_upgrade(self, client_ctx->websocket_timeout, rlen); + self->client = NULL; + return NULL; + } + /* declare the start of the response */ + h2o_start_response(req, &self->super); + + if (errstr == h2o_http1client_error_is_eos) { + self->client = NULL; + h2o_send(req, NULL, 0, H2O_SEND_STATE_FINAL); + return NULL; + } + + return on_body; +} + +static int on_1xx(h2o_http1client_t *client, int minor_version, int status, h2o_iovec_t msg, h2o_header_t *headers, + size_t num_headers) +{ + struct rp_generator_t *self = client->data; + size_t i; + + for (i = 0; i != num_headers; ++i) { + if (headers[i].name == &H2O_TOKEN_LINK->buf) + h2o_push_path_in_link_header(self->src_req, headers[i].value.base, headers[i].value.len); + } + + return 0; +} + +static h2o_http1client_head_cb on_connect(h2o_http1client_t *client, const char *errstr, h2o_iovec_t **reqbufs, size_t *reqbufcnt, + int *method_is_head) +{ + struct rp_generator_t *self = client->data; + + if (errstr != NULL) { + self->client = NULL; + h2o_req_log_error(self->src_req, "lib/core/proxy.c", "%s", errstr); + h2o_send_error_502(self->src_req, "Gateway Error", errstr, 0); + return NULL; + } + + *reqbufs = self->up_req.bufs; + *reqbufcnt = self->up_req.bufs[1].base != NULL ? 2 : 1; + *method_is_head = self->up_req.is_head; + self->client->informational_cb = on_1xx; + return on_head; +} + +static void on_generator_dispose(void *_self) +{ + struct rp_generator_t *self = _self; + + if (self->client != NULL) { + h2o_http1client_cancel(self->client); + self->client = NULL; + } + h2o_buffer_dispose(&self->last_content_before_send); + h2o_doublebuffer_dispose(&self->sending); +} + +static struct rp_generator_t *proxy_send_prepare(h2o_req_t *req, int keepalive, int use_proxy_protocol) +{ + struct rp_generator_t *self = h2o_mem_alloc_shared(&req->pool, sizeof(*self), on_generator_dispose); + h2o_http1client_ctx_t *client_ctx = get_client_ctx(req); + + self->super.proceed = do_proceed; + self->super.stop = do_close; + self->src_req = req; + if (client_ctx->websocket_timeout != NULL && h2o_lcstris(req->upgrade.base, req->upgrade.len, H2O_STRLIT("websocket"))) { + self->is_websocket_handshake = 1; + } else { + self->is_websocket_handshake = 0; + } + self->had_body_error = 0; + self->up_req.bufs[0] = build_request(req, keepalive, self->is_websocket_handshake, use_proxy_protocol); + self->up_req.bufs[1] = req->entity; + self->up_req.is_head = h2o_memis(req->method.base, req->method.len, H2O_STRLIT("HEAD")); + h2o_buffer_init(&self->last_content_before_send, &h2o_socket_buffer_prototype); + h2o_doublebuffer_init(&self->sending, &h2o_socket_buffer_prototype); + + return self; +} + +void h2o__proxy_process_request(h2o_req_t *req) +{ + h2o_req_overrides_t *overrides = req->overrides; + h2o_http1client_ctx_t *client_ctx = get_client_ctx(req); + struct rp_generator_t *self; + + if (overrides != NULL) { + if (overrides->socketpool != NULL) { + if (overrides->use_proxy_protocol) + assert(!"proxy protocol cannot be used for a persistent upstream connection"); + self = proxy_send_prepare(req, 1, 0); + h2o_http1client_connect_with_pool(&self->client, self, client_ctx, overrides->socketpool, on_connect); + return; + } else if (overrides->hostport.host.base != NULL) { + self = proxy_send_prepare(req, 0, overrides->use_proxy_protocol); + h2o_http1client_connect(&self->client, self, client_ctx, req->overrides->hostport.host, req->overrides->hostport.port, + 0, on_connect); + return; + } + } + { /* default logic */ + h2o_iovec_t host; + uint16_t port; + if (h2o_url_parse_hostport(req->authority.base, req->authority.len, &host, &port) == NULL) { + h2o_req_log_error(req, "lib/core/proxy.c", "invalid URL supplied for internal redirection:%s://%.*s%.*s", + req->scheme->name.base, (int)req->authority.len, req->authority.base, (int)req->path.len, + req->path.base); + h2o_send_error_502(req, "Gateway Error", "internal error", 0); + return; + } + if (port == 65535) + port = req->scheme->default_port; + self = proxy_send_prepare(req, 0, overrides != NULL && overrides->use_proxy_protocol); + h2o_http1client_connect(&self->client, self, client_ctx, host, port, req->scheme == &H2O_URL_SCHEME_HTTPS, on_connect); + return; + } +} diff --git a/web/server/h2o/libh2o/lib/core/request.c b/web/server/h2o/libh2o/lib/core/request.c new file mode 100644 index 000000000..96aabb22d --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/request.c @@ -0,0 +1,696 @@ +/* + * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Tatsuhiro Tsujikawa + * + * 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 <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/uio.h> +#include "h2o.h" + +#ifndef IOV_MAX +#define IOV_MAX UIO_MAXIOV +#endif + +#define INITIAL_INBUFSZ 8192 + +struct st_deferred_request_action_t { + h2o_timeout_entry_t timeout; + h2o_req_t *req; +}; + +struct st_delegate_request_deferred_t { + struct st_deferred_request_action_t super; + h2o_handler_t *current_handler; +}; + +struct st_reprocess_request_deferred_t { + struct st_deferred_request_action_t super; + h2o_iovec_t method; + const h2o_url_scheme_t *scheme; + h2o_iovec_t authority; + h2o_iovec_t path; + h2o_req_overrides_t *overrides; + int is_delegated; +}; + +struct st_send_error_deferred_t { + h2o_req_t *req; + int status; + const char *reason; + const char *body; + int flags; + h2o_timeout_entry_t _timeout; +}; + +static void on_deferred_action_dispose(void *_action) +{ + struct st_deferred_request_action_t *action = _action; + if (h2o_timeout_is_linked(&action->timeout)) + h2o_timeout_unlink(&action->timeout); +} + +static struct st_deferred_request_action_t *create_deferred_action(h2o_req_t *req, size_t sz, h2o_timeout_cb cb) +{ + struct st_deferred_request_action_t *action = h2o_mem_alloc_shared(&req->pool, sz, on_deferred_action_dispose); + *action = (struct st_deferred_request_action_t){{0, cb}, req}; + h2o_timeout_link(req->conn->ctx->loop, &req->conn->ctx->zero_timeout, &action->timeout); + return action; +} + +static h2o_hostconf_t *find_hostconf(h2o_hostconf_t **hostconfs, h2o_iovec_t authority, uint16_t default_port) +{ + h2o_iovec_t hostname; + uint16_t port; + char *hostname_lc; + + /* safe-guard for alloca */ + if (authority.len >= 65536) + return NULL; + + /* extract the specified hostname and port */ + if (h2o_url_parse_hostport(authority.base, authority.len, &hostname, &port) == NULL) + return NULL; + if (port == 65535) + port = default_port; + + /* convert supplied hostname to lower-case */ + hostname_lc = alloca(hostname.len); + memcpy(hostname_lc, hostname.base, hostname.len); + h2o_strtolower(hostname_lc, hostname.len); + + do { + h2o_hostconf_t *hostconf = *hostconfs; + if (hostconf->authority.port == port || (hostconf->authority.port == 65535 && port == default_port)) { + if (hostconf->authority.host.base[0] == '*') { + /* matching against "*.foo.bar" */ + size_t cmplen = hostconf->authority.host.len - 1; + if (cmplen < hostname.len && + memcmp(hostconf->authority.host.base + 1, hostname_lc + hostname.len - cmplen, cmplen) == 0) + return hostconf; + } else { + /* exact match */ + if (h2o_memis(hostconf->authority.host.base, hostconf->authority.host.len, hostname_lc, hostname.len)) + return hostconf; + } + } + } while (*++hostconfs != NULL); + + return NULL; +} + +static h2o_hostconf_t *setup_before_processing(h2o_req_t *req) +{ + h2o_context_t *ctx = req->conn->ctx; + h2o_hostconf_t *hostconf; + + h2o_get_timestamp(ctx, &req->pool, &req->processed_at); + + /* find the host context */ + if (req->input.authority.base != NULL) { + if (req->conn->hosts[1] == NULL || + (hostconf = find_hostconf(req->conn->hosts, req->input.authority, req->input.scheme->default_port)) == NULL) + hostconf = *req->conn->hosts; + } else { + /* set the authority name to the default one */ + hostconf = *req->conn->hosts; + req->input.authority = hostconf->authority.hostport; + } + + req->scheme = req->input.scheme; + req->method = req->input.method; + req->authority = req->input.authority; + req->path = req->input.path; + req->path_normalized = + h2o_url_normalize_path(&req->pool, req->input.path.base, req->input.path.len, &req->query_at, &req->norm_indexes); + req->input.query_at = req->query_at; /* we can do this since input.path == path */ + + return hostconf; +} + +static void call_handlers(h2o_req_t *req, h2o_handler_t **handler) +{ + h2o_handler_t **end = req->pathconf->handlers.entries + req->pathconf->handlers.size; + + for (; handler != end; ++handler) + if ((*handler)->on_req(*handler, req) == 0) + return; + + h2o_send_error_404(req, "File Not Found", "not found", 0); +} + +static void process_hosted_request(h2o_req_t *req, h2o_hostconf_t *hostconf) +{ + h2o_pathconf_t *selected_pathconf = &hostconf->fallback_path; + size_t i; + + /* setup pathconf, or redirect to "path/" */ + for (i = 0; i != hostconf->paths.size; ++i) { + h2o_pathconf_t *candidate = hostconf->paths.entries + i; + if (req->path_normalized.len >= candidate->path.len && + memcmp(req->path_normalized.base, candidate->path.base, candidate->path.len) == 0 && + (candidate->path.base[candidate->path.len - 1] == '/' || req->path_normalized.len == candidate->path.len || + req->path_normalized.base[candidate->path.len] == '/')) { + selected_pathconf = candidate; + break; + } + } + h2o_req_bind_conf(req, hostconf, selected_pathconf); + + call_handlers(req, req->pathconf->handlers.entries); +} + +static void deferred_proceed_cb(h2o_timeout_entry_t *entry) +{ + h2o_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_req_t, _timeout_entry, entry); + h2o_proceed_response(req); +} + +static void close_generator_and_filters(h2o_req_t *req) +{ + /* close the generator if it is still open */ + if (req->_generator != NULL) { + /* close generator */ + if (req->_generator->stop != NULL) + req->_generator->stop(req->_generator, req); + req->_generator = NULL; + } + /* close the ostreams still open */ + while (req->_ostr_top->next != NULL) { + if (req->_ostr_top->stop != NULL) + req->_ostr_top->stop(req->_ostr_top, req); + req->_ostr_top = req->_ostr_top->next; + } +} + +static void reset_response(h2o_req_t *req) +{ + req->res = (h2o_res_t){0, NULL, SIZE_MAX}; + req->res.reason = "OK"; + req->_next_filter_index = 0; + req->bytes_sent = 0; +} + +static void retain_original_response(h2o_req_t *req) +{ + if (req->res.original.status != 0) + return; + + req->res.original.status = req->res.status; + h2o_vector_reserve(&req->pool, &req->res.original.headers, req->res.headers.size); + h2o_memcpy(req->res.original.headers.entries, req->res.headers.entries, + sizeof(req->res.headers.entries[0]) * req->res.headers.size); + req->res.original.headers.size = req->res.headers.size; +} + +void h2o_init_request(h2o_req_t *req, h2o_conn_t *conn, h2o_req_t *src) +{ + /* clear all memory (expect memory pool, since it is large) */ + memset(req, 0, offsetof(h2o_req_t, pool)); + + /* init memory pool (before others, since it may be used) */ + h2o_mem_init_pool(&req->pool); + + /* init properties that should be initialized to non-zero */ + req->conn = conn; + req->_timeout_entry.cb = deferred_proceed_cb; + req->res.reason = "OK"; /* default to "OK" regardless of the status value, it's not important after all (never sent in HTTP2) */ + req->res.content_length = SIZE_MAX; + req->preferred_chunk_size = SIZE_MAX; + + if (src != NULL) { + size_t i; +#define COPY(buf) \ + do { \ + req->buf.base = h2o_mem_alloc_pool(&req->pool, src->buf.len); \ + memcpy(req->buf.base, src->buf.base, src->buf.len); \ + req->buf.len = src->buf.len; \ + } while (0) + COPY(input.authority); + COPY(input.method); + COPY(input.path); + req->input.scheme = src->input.scheme; + req->version = src->version; + req->entity = src->entity; + req->http1_is_persistent = src->http1_is_persistent; + req->timestamps = src->timestamps; + if (src->upgrade.base != NULL) { + COPY(upgrade); + } else { + req->upgrade.base = NULL; + req->upgrade.len = 0; + } +#undef COPY + h2o_vector_reserve(&req->pool, &req->headers, src->headers.size); + req->headers.size = src->headers.size; + for (i = 0; i != src->headers.size; ++i) { + h2o_header_t *dst_header = req->headers.entries + i, *src_header = src->headers.entries + i; + if (h2o_iovec_is_token(src_header->name)) { + dst_header->name = src_header->name; + } else { + dst_header->name = h2o_mem_alloc_pool(&req->pool, sizeof(*dst_header->name)); + *dst_header->name = h2o_strdup(&req->pool, src_header->name->base, src_header->name->len); + } + dst_header->value = h2o_strdup(&req->pool, src_header->value.base, src_header->value.len); + if (!src_header->orig_name) + dst_header->orig_name = NULL; + else + dst_header->orig_name = h2o_strdup(&req->pool, src_header->orig_name, src_header->name->len).base; + } + if (src->env.size != 0) { + h2o_vector_reserve(&req->pool, &req->env, src->env.size); + req->env.size = src->env.size; + for (i = 0; i != req->env.size; ++i) + req->env.entries[i] = h2o_strdup(&req->pool, src->env.entries[i].base, src->env.entries[i].len); + } + } +} + +void h2o_dispose_request(h2o_req_t *req) +{ + close_generator_and_filters(req); + + h2o_timeout_unlink(&req->_timeout_entry); + + if (req->version != 0 && req->pathconf != NULL) { + h2o_logger_t **logger = req->pathconf->loggers.entries, **end = logger + req->pathconf->loggers.size; + for (; logger != end; ++logger) { + (*logger)->log_access((*logger), req); + } + } + + h2o_mem_clear_pool(&req->pool); +} + +void h2o_process_request(h2o_req_t *req) +{ + h2o_hostconf_t *hostconf = setup_before_processing(req); + process_hosted_request(req, hostconf); +} + +void h2o_delegate_request(h2o_req_t *req, h2o_handler_t *current_handler) +{ + h2o_handler_t **handler = req->pathconf->handlers.entries, **end = handler + req->pathconf->handlers.size; + + for (; handler != end; ++handler) { + if (*handler == current_handler) { + ++handler; + break; + } + } + call_handlers(req, handler); +} + +static void on_delegate_request_cb(h2o_timeout_entry_t *entry) +{ + struct st_delegate_request_deferred_t *args = + H2O_STRUCT_FROM_MEMBER(struct st_delegate_request_deferred_t, super.timeout, entry); + h2o_delegate_request(args->super.req, args->current_handler); +} + +void h2o_delegate_request_deferred(h2o_req_t *req, h2o_handler_t *current_handler) +{ + struct st_delegate_request_deferred_t *args = + (struct st_delegate_request_deferred_t *)create_deferred_action(req, sizeof(*args), on_delegate_request_cb); + args->current_handler = current_handler; +} + +void h2o_reprocess_request(h2o_req_t *req, h2o_iovec_t method, const h2o_url_scheme_t *scheme, h2o_iovec_t authority, + h2o_iovec_t path, h2o_req_overrides_t *overrides, int is_delegated) +{ + h2o_hostconf_t *hostconf; + + retain_original_response(req); + + /* close generators and filters that are already running */ + close_generator_and_filters(req); + + /* setup the request/response parameters */ + req->method = method; + req->scheme = scheme; + req->authority = authority; + req->path = path; + req->path_normalized = h2o_url_normalize_path(&req->pool, req->path.base, req->path.len, &req->query_at, &req->norm_indexes); + req->overrides = overrides; + req->res_is_delegated |= is_delegated; + reset_response(req); + + /* check the delegation (or reprocess) counter */ + if (req->res_is_delegated) { + if (req->num_delegated == req->conn->ctx->globalconf->max_delegations) { + /* TODO log */ + h2o_send_error_502(req, "Gateway Error", "too many internal delegations", 0); + return; + } + ++req->num_delegated; + } else { + if (req->num_reprocessed >= 5) { + /* TODO log */ + h2o_send_error_502(req, "Gateway Error", "too many internal reprocesses", 0); + return; + } + ++req->num_reprocessed; + } + + /* handle the response using the handlers, if hostconf exists */ + h2o_hostconf_t **hosts = is_delegated ? req->conn->ctx->globalconf->hosts : req->conn->hosts; + if (req->overrides == NULL && (hostconf = find_hostconf(hosts, req->authority, req->scheme->default_port)) != NULL) { + req->pathconf = NULL; + process_hosted_request(req, hostconf); + return; + } + + /* uses the current pathconf, in other words, proxy uses the previous pathconf for building filters */ + h2o__proxy_process_request(req); +} + +static void on_reprocess_request_cb(h2o_timeout_entry_t *entry) +{ + struct st_reprocess_request_deferred_t *args = + H2O_STRUCT_FROM_MEMBER(struct st_reprocess_request_deferred_t, super.timeout, entry); + h2o_reprocess_request(args->super.req, args->method, args->scheme, args->authority, args->path, args->overrides, + args->is_delegated); +} + +void h2o_reprocess_request_deferred(h2o_req_t *req, h2o_iovec_t method, const h2o_url_scheme_t *scheme, h2o_iovec_t authority, + h2o_iovec_t path, h2o_req_overrides_t *overrides, int is_delegated) +{ + struct st_reprocess_request_deferred_t *args = + (struct st_reprocess_request_deferred_t *)create_deferred_action(req, sizeof(*args), on_reprocess_request_cb); + args->method = method; + args->scheme = scheme; + args->authority = authority; + args->path = path; + args->overrides = overrides; + args->is_delegated = is_delegated; +} + +void h2o_start_response(h2o_req_t *req, h2o_generator_t *generator) +{ + retain_original_response(req); + + /* set generator */ + assert(req->_generator == NULL); + req->_generator = generator; + + /* setup response filters */ + if (req->prefilters != NULL) { + req->prefilters->on_setup_ostream(req->prefilters, req, &req->_ostr_top); + } else { + h2o_setup_next_ostream(req, &req->_ostr_top); + } +} + +void h2o_send(h2o_req_t *req, h2o_iovec_t *bufs, size_t bufcnt, h2o_send_state_t state) +{ + assert(req->_generator != NULL); + + if (!h2o_send_state_is_in_progress(state)) + req->_generator = NULL; + + req->_ostr_top->do_send(req->_ostr_top, req, bufs, bufcnt, state); +} + +h2o_req_prefilter_t *h2o_add_prefilter(h2o_req_t *req, size_t sz) +{ + h2o_req_prefilter_t *prefilter = h2o_mem_alloc_pool(&req->pool, sz); + prefilter->next = req->prefilters; + req->prefilters = prefilter; + return prefilter; +} + +h2o_ostream_t *h2o_add_ostream(h2o_req_t *req, size_t sz, h2o_ostream_t **slot) +{ + h2o_ostream_t *ostr = h2o_mem_alloc_pool(&req->pool, sz); + ostr->next = *slot; + ostr->do_send = NULL; + ostr->stop = NULL; + ostr->start_pull = NULL; + + *slot = ostr; + + return ostr; +} + +static void apply_env(h2o_req_t *req, h2o_envconf_t *env) +{ + size_t i; + + if (env->parent != NULL) + apply_env(req, env->parent); + for (i = 0; i != env->unsets.size; ++i) + h2o_req_unsetenv(req, env->unsets.entries[i].base, env->unsets.entries[i].len); + for (i = 0; i != env->sets.size; i += 2) + *h2o_req_getenv(req, env->sets.entries[i].base, env->sets.entries[i].len, 1) = env->sets.entries[i + 1]; +} + +void h2o_req_bind_conf(h2o_req_t *req, h2o_hostconf_t *hostconf, h2o_pathconf_t *pathconf) +{ + req->hostconf = hostconf; + req->pathconf = pathconf; + if (pathconf->env != NULL) + apply_env(req, pathconf->env); +} + +void h2o_ostream_send_next(h2o_ostream_t *ostream, h2o_req_t *req, h2o_iovec_t *bufs, size_t bufcnt, h2o_send_state_t state) +{ + if (!h2o_send_state_is_in_progress(state)) { + assert(req->_ostr_top == ostream); + req->_ostr_top = ostream->next; + } else if (bufcnt == 0) { + h2o_timeout_link(req->conn->ctx->loop, &req->conn->ctx->zero_timeout, &req->_timeout_entry); + return; + } + ostream->next->do_send(ostream->next, req, bufs, bufcnt, state); +} + +void h2o_req_fill_mime_attributes(h2o_req_t *req) +{ + ssize_t content_type_index; + h2o_mimemap_type_t *mime; + + if (req->res.mime_attr != NULL) + return; + + if ((content_type_index = h2o_find_header(&req->res.headers, H2O_TOKEN_CONTENT_TYPE, -1)) != -1 && + (mime = h2o_mimemap_get_type_by_mimetype(req->pathconf->mimemap, req->res.headers.entries[content_type_index].value, 0)) != + NULL) + req->res.mime_attr = &mime->data.attr; + else + req->res.mime_attr = &h2o_mime_attributes_as_is; +} + +void h2o_send_inline(h2o_req_t *req, const char *body, size_t len) +{ + static h2o_generator_t generator = {NULL, NULL}; + + h2o_iovec_t buf = h2o_strdup(&req->pool, body, len); + /* the function intentionally does not set the content length, since it may be used for generating 304 response, etc. */ + /* req->res.content_length = buf.len; */ + + h2o_start_response(req, &generator); + + if (h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("HEAD"))) + h2o_send(req, NULL, 0, H2O_SEND_STATE_FINAL); + else + h2o_send(req, &buf, 1, H2O_SEND_STATE_FINAL); +} + +void h2o_send_error_generic(h2o_req_t *req, int status, const char *reason, const char *body, int flags) +{ + if (req->pathconf == NULL) { + h2o_hostconf_t *hostconf = setup_before_processing(req); + h2o_req_bind_conf(req, hostconf, &hostconf->fallback_path); + } + + if ((flags & H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION) != 0) + req->http1_is_persistent = 0; + + req->res.status = status; + req->res.reason = reason; + req->res.content_length = strlen(body); + + if ((flags & H2O_SEND_ERROR_KEEP_HEADERS) == 0) + memset(&req->res.headers, 0, sizeof(req->res.headers)); + + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, H2O_STRLIT("text/plain; charset=utf-8")); + + h2o_send_inline(req, body, SIZE_MAX); +} + +#define DECL_SEND_ERROR_DEFERRED(status_) \ + static void send_error_deferred_cb_##status_(h2o_timeout_entry_t *entry) \ + { \ + struct st_send_error_deferred_t *args = H2O_STRUCT_FROM_MEMBER(struct st_send_error_deferred_t, _timeout, entry); \ + reset_response(args->req); \ + args->req->conn->ctx->emitted_error_status[H2O_STATUS_ERROR_##status_]++; \ + h2o_send_error_generic(args->req, args->status, args->reason, args->body, args->flags); \ + } \ + \ + static void h2o_send_error_deferred_##status_(h2o_req_t *req, const char *reason, const char *body, int flags) \ + { \ + struct st_send_error_deferred_t *args = h2o_mem_alloc_pool(&req->pool, sizeof(*args)); \ + *args = (struct st_send_error_deferred_t){req, status_, reason, body, flags}; \ + args->_timeout.cb = send_error_deferred_cb_##status_; \ + h2o_timeout_link(req->conn->ctx->loop, &req->conn->ctx->zero_timeout, &args->_timeout); \ + } + +DECL_SEND_ERROR_DEFERRED(502) + +#undef DECL_SEND_ERROR_DEFERRED + +void h2o_req_log_error(h2o_req_t *req, const char *module, const char *fmt, ...) +{ +#define INITIAL_BUF_SIZE 256 + + char *errbuf = h2o_mem_alloc_pool(&req->pool, INITIAL_BUF_SIZE); + int errlen; + va_list args; + + va_start(args, fmt); + errlen = vsnprintf(errbuf, INITIAL_BUF_SIZE, fmt, args); + va_end(args); + + if (errlen >= INITIAL_BUF_SIZE) { + errbuf = h2o_mem_alloc_pool(&req->pool, errlen + 1); + va_start(args, fmt); + errlen = vsnprintf(errbuf, errlen + 1, fmt, args); + va_end(args); + } + +#undef INITIAL_BUF_SIZE + + /* save the log */ + h2o_vector_reserve(&req->pool, &req->error_logs, req->error_logs.size + 1); + req->error_logs.entries[req->error_logs.size++] = (h2o_req_error_log_t){module, h2o_iovec_init(errbuf, errlen)}; + + if (req->pathconf->error_log.emit_request_errors) { + /* build prefix */ + char *prefix = alloca(sizeof("[] in request::") + 32 + strlen(module)), *p = prefix; + p += sprintf(p, "[%s] in request:", module); + if (req->path.len < 32) { + memcpy(p, req->path.base, req->path.len); + p += req->path.len; + } else { + memcpy(p, req->path.base, 29); + p += 29; + memcpy(p, "...", 3); + p += 3; + } + *p++ = ':'; + /* use writev(2) to emit error atomically */ + struct iovec vecs[] = {{prefix, p - prefix}, {errbuf, errlen}, {"\n", 1}}; + H2O_BUILD_ASSERT(sizeof(vecs) / sizeof(vecs[0]) < IOV_MAX); + writev(2, vecs, sizeof(vecs) / sizeof(vecs[0])); + } +} + +void h2o_send_redirect(h2o_req_t *req, int status, const char *reason, const char *url, size_t url_len) +{ + if (req->res_is_delegated) { + h2o_iovec_t method = h2o_get_redirect_method(req->method, status); + h2o_send_redirect_internal(req, method, url, url_len, 0); + return; + } + + static h2o_generator_t generator = {NULL, NULL}; + static const h2o_iovec_t body_prefix = {H2O_STRLIT("<!DOCTYPE html><TITLE>Moved</TITLE><P>The document has moved <A HREF=\"")}; + static const h2o_iovec_t body_suffix = {H2O_STRLIT("\">here</A>")}; + + /* build and send response */ + h2o_iovec_t bufs[3]; + size_t bufcnt; + if (h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("HEAD"))) { + req->res.content_length = SIZE_MAX; + bufcnt = 0; + } else { + bufs[0] = body_prefix; + bufs[1] = h2o_htmlescape(&req->pool, url, url_len); + bufs[2] = body_suffix; + bufcnt = 3; + req->res.content_length = body_prefix.len + bufs[1].len + body_suffix.len; + } + req->res.status = status; + req->res.reason = reason; + req->res.headers = (h2o_headers_t){NULL}; + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_LOCATION, NULL, url, url_len); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, H2O_STRLIT("text/html; charset=utf-8")); + h2o_start_response(req, &generator); + h2o_send(req, bufs, bufcnt, H2O_SEND_STATE_FINAL); +} + +void h2o_send_redirect_internal(h2o_req_t *req, h2o_iovec_t method, const char *url_str, size_t url_len, int preserve_overrides) +{ + h2o_url_t url; + + /* parse the location URL */ + if (h2o_url_parse_relative(url_str, url_len, &url) != 0) { + /* TODO log fprintf(stderr, "[proxy] cannot handle location header: %.*s\n", (int)url_len, url); */ + h2o_send_error_deferred_502(req, "Gateway Error", "internal error", 0); + return; + } + /* convert the location to absolute (while creating copies of the values passed to the deferred call) */ + if (url.scheme == NULL) + url.scheme = req->scheme; + if (url.authority.base == NULL) { + if (req->hostconf != NULL) + url.authority = req->hostconf->authority.hostport; + else + url.authority = req->authority; + } else { + if (h2o_lcstris(url.authority.base, url.authority.len, req->authority.base, req->authority.len)) { + url.authority = req->authority; + } else { + url.authority = h2o_strdup(&req->pool, url.authority.base, url.authority.len); + preserve_overrides = 0; + } + } + h2o_iovec_t base_path = req->path; + h2o_url_resolve_path(&base_path, &url.path); + url.path = h2o_concat(&req->pool, base_path, url.path); + + h2o_reprocess_request_deferred(req, method, url.scheme, url.authority, url.path, preserve_overrides ? req->overrides : NULL, 1); +} + +h2o_iovec_t h2o_get_redirect_method(h2o_iovec_t method, int status) +{ + if (h2o_memis(method.base, method.len, H2O_STRLIT("POST")) && !(status == 307 || status == 308)) + method = h2o_iovec_init(H2O_STRLIT("GET")); + return method; +} + +h2o_iovec_t h2o_push_path_in_link_header(h2o_req_t *req, const char *value, size_t value_len) +{ + int i; + h2o_iovec_t ret = h2o_iovec_init(value, value_len); + if (req->conn->callbacks->push_path == NULL) + return ret; + + h2o_iovec_vector_t paths = h2o_extract_push_path_from_link_header( + &req->pool, value, value_len, req->path_normalized, req->input.scheme, req->input.authority, + req->res_is_delegated ? req->scheme : NULL, req->res_is_delegated ? &req->authority : NULL, &ret); + if (paths.size == 0) + return ret; + + for (i = 0; i < paths.size; i++) { + req->conn->callbacks->push_path(req, paths.entries[i].base, paths.entries[i].len); + } + return ret; +} diff --git a/web/server/h2o/libh2o/lib/core/token.c b/web/server/h2o/libh2o/lib/core/token.c new file mode 100644 index 000000000..e21ce2383 --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/token.c @@ -0,0 +1,28 @@ +/* + * 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.h" +#include "token_table.h" + +int h2o_iovec_is_token(const h2o_iovec_t *buf) +{ + return &h2o__tokens[0].buf <= buf && buf <= &h2o__tokens[H2O_MAX_TOKENS - 1].buf; +} diff --git a/web/server/h2o/libh2o/lib/core/token_table.h b/web/server/h2o/libh2o/lib/core/token_table.h new file mode 100644 index 000000000..ae26aa6c4 --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/token_table.h @@ -0,0 +1,408 @@ +/* + * 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. + */ + +/* DO NOT EDIT! generated by tokens.pl */ +h2o_token_t h2o__tokens[] = {{{H2O_STRLIT(":authority")}, 1, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT(":method")}, 2, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT(":path")}, 4, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT(":scheme")}, 6, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT(":status")}, 8, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("accept")}, 19, 0, 0, 0, 0, 1, 0}, + {{H2O_STRLIT("accept-charset")}, 15, 0, 0, 0, 0, 1, 0}, + {{H2O_STRLIT("accept-encoding")}, 16, 0, 0, 0, 0, 1, 0}, + {{H2O_STRLIT("accept-language")}, 17, 0, 0, 0, 0, 1, 0}, + {{H2O_STRLIT("accept-ranges")}, 18, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("access-control-allow-origin")}, 20, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("age")}, 21, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("allow")}, 22, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("authorization")}, 23, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("cache-control")}, 24, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("cache-digest")}, 0, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("connection")}, 0, 1, 1, 0, 1, 0, 0}, + {{H2O_STRLIT("content-disposition")}, 25, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("content-encoding")}, 26, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("content-language")}, 27, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("content-length")}, 28, 0, 0, 1, 0, 0, 0}, + {{H2O_STRLIT("content-location")}, 29, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("content-range")}, 30, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("content-type")}, 31, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("cookie")}, 32, 0, 0, 0, 0, 0, 1}, + {{H2O_STRLIT("date")}, 33, 0, 1, 0, 0, 0, 0}, + {{H2O_STRLIT("etag")}, 34, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("expect")}, 35, 0, 0, 1, 0, 0, 0}, + {{H2O_STRLIT("expires")}, 36, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("from")}, 37, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("host")}, 38, 0, 0, 1, 1, 0, 0}, + {{H2O_STRLIT("http2-settings")}, 0, 1, 0, 0, 1, 0, 0}, + {{H2O_STRLIT("if-match")}, 39, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("if-modified-since")}, 40, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("if-none-match")}, 41, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("if-range")}, 42, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("if-unmodified-since")}, 43, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("keep-alive")}, 0, 1, 1, 0, 0, 0, 0}, + {{H2O_STRLIT("last-modified")}, 44, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("link")}, 45, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("location")}, 46, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("max-forwards")}, 47, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("proxy-authenticate")}, 48, 1, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("proxy-authorization")}, 49, 1, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("range")}, 50, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("referer")}, 51, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("refresh")}, 52, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("retry-after")}, 53, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("server")}, 54, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("set-cookie")}, 55, 0, 0, 0, 0, 0, 1}, + {{H2O_STRLIT("strict-transport-security")}, 56, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("te")}, 0, 1, 0, 0, 1, 0, 0}, + {{H2O_STRLIT("transfer-encoding")}, 57, 1, 1, 1, 1, 0, 0}, + {{H2O_STRLIT("upgrade")}, 0, 1, 1, 1, 1, 0, 0}, + {{H2O_STRLIT("user-agent")}, 58, 0, 0, 0, 0, 1, 0}, + {{H2O_STRLIT("vary")}, 59, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("via")}, 60, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("www-authenticate")}, 61, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("x-compress-hint")}, 0, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("x-forwarded-for")}, 0, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("x-reproxy-url")}, 0, 0, 0, 0, 0, 0, 0}, + {{H2O_STRLIT("x-traffic")}, 0, 0, 0, 0, 0, 0, 0}}; +size_t h2o__num_tokens = 62; + +const h2o_token_t *h2o_lookup_token(const char *name, size_t len) +{ + switch (len) { + case 2: + switch (name[1]) { + case 'e': + if (memcmp(name, "t", 1) == 0) + return H2O_TOKEN_TE; + break; + } + break; + case 3: + switch (name[2]) { + case 'a': + if (memcmp(name, "vi", 2) == 0) + return H2O_TOKEN_VIA; + break; + case 'e': + if (memcmp(name, "ag", 2) == 0) + return H2O_TOKEN_AGE; + break; + } + break; + case 4: + switch (name[3]) { + case 'e': + if (memcmp(name, "dat", 3) == 0) + return H2O_TOKEN_DATE; + break; + case 'g': + if (memcmp(name, "eta", 3) == 0) + return H2O_TOKEN_ETAG; + break; + case 'k': + if (memcmp(name, "lin", 3) == 0) + return H2O_TOKEN_LINK; + break; + case 'm': + if (memcmp(name, "fro", 3) == 0) + return H2O_TOKEN_FROM; + break; + case 't': + if (memcmp(name, "hos", 3) == 0) + return H2O_TOKEN_HOST; + break; + case 'y': + if (memcmp(name, "var", 3) == 0) + return H2O_TOKEN_VARY; + break; + } + break; + case 5: + switch (name[4]) { + case 'e': + if (memcmp(name, "rang", 4) == 0) + return H2O_TOKEN_RANGE; + break; + case 'h': + if (memcmp(name, ":pat", 4) == 0) + return H2O_TOKEN_PATH; + break; + case 'w': + if (memcmp(name, "allo", 4) == 0) + return H2O_TOKEN_ALLOW; + break; + } + break; + case 6: + switch (name[5]) { + case 'e': + if (memcmp(name, "cooki", 5) == 0) + return H2O_TOKEN_COOKIE; + break; + case 'r': + if (memcmp(name, "serve", 5) == 0) + return H2O_TOKEN_SERVER; + break; + case 't': + if (memcmp(name, "accep", 5) == 0) + return H2O_TOKEN_ACCEPT; + if (memcmp(name, "expec", 5) == 0) + return H2O_TOKEN_EXPECT; + break; + } + break; + case 7: + switch (name[6]) { + case 'd': + if (memcmp(name, ":metho", 6) == 0) + return H2O_TOKEN_METHOD; + break; + case 'e': + if (memcmp(name, ":schem", 6) == 0) + return H2O_TOKEN_SCHEME; + if (memcmp(name, "upgrad", 6) == 0) + return H2O_TOKEN_UPGRADE; + break; + case 'h': + if (memcmp(name, "refres", 6) == 0) + return H2O_TOKEN_REFRESH; + break; + case 'r': + if (memcmp(name, "refere", 6) == 0) + return H2O_TOKEN_REFERER; + break; + case 's': + if (memcmp(name, ":statu", 6) == 0) + return H2O_TOKEN_STATUS; + if (memcmp(name, "expire", 6) == 0) + return H2O_TOKEN_EXPIRES; + break; + } + break; + case 8: + switch (name[7]) { + case 'e': + if (memcmp(name, "if-rang", 7) == 0) + return H2O_TOKEN_IF_RANGE; + break; + case 'h': + if (memcmp(name, "if-matc", 7) == 0) + return H2O_TOKEN_IF_MATCH; + break; + case 'n': + if (memcmp(name, "locatio", 7) == 0) + return H2O_TOKEN_LOCATION; + break; + } + break; + case 9: + switch (name[8]) { + case 'c': + if (memcmp(name, "x-traffi", 8) == 0) + return H2O_TOKEN_X_TRAFFIC; + break; + } + break; + case 10: + switch (name[9]) { + case 'e': + if (memcmp(name, "keep-aliv", 9) == 0) + return H2O_TOKEN_KEEP_ALIVE; + if (memcmp(name, "set-cooki", 9) == 0) + return H2O_TOKEN_SET_COOKIE; + break; + case 'n': + if (memcmp(name, "connectio", 9) == 0) + return H2O_TOKEN_CONNECTION; + break; + case 't': + if (memcmp(name, "user-agen", 9) == 0) + return H2O_TOKEN_USER_AGENT; + break; + case 'y': + if (memcmp(name, ":authorit", 9) == 0) + return H2O_TOKEN_AUTHORITY; + break; + } + break; + case 11: + switch (name[10]) { + case 'r': + if (memcmp(name, "retry-afte", 10) == 0) + return H2O_TOKEN_RETRY_AFTER; + break; + } + break; + case 12: + switch (name[11]) { + case 'e': + if (memcmp(name, "content-typ", 11) == 0) + return H2O_TOKEN_CONTENT_TYPE; + break; + case 's': + if (memcmp(name, "max-forward", 11) == 0) + return H2O_TOKEN_MAX_FORWARDS; + break; + case 't': + if (memcmp(name, "cache-diges", 11) == 0) + return H2O_TOKEN_CACHE_DIGEST; + break; + } + break; + case 13: + switch (name[12]) { + case 'd': + if (memcmp(name, "last-modifie", 12) == 0) + return H2O_TOKEN_LAST_MODIFIED; + break; + case 'e': + if (memcmp(name, "content-rang", 12) == 0) + return H2O_TOKEN_CONTENT_RANGE; + break; + case 'h': + if (memcmp(name, "if-none-matc", 12) == 0) + return H2O_TOKEN_IF_NONE_MATCH; + break; + case 'l': + if (memcmp(name, "cache-contro", 12) == 0) + return H2O_TOKEN_CACHE_CONTROL; + if (memcmp(name, "x-reproxy-ur", 12) == 0) + return H2O_TOKEN_X_REPROXY_URL; + break; + case 'n': + if (memcmp(name, "authorizatio", 12) == 0) + return H2O_TOKEN_AUTHORIZATION; + break; + case 's': + if (memcmp(name, "accept-range", 12) == 0) + return H2O_TOKEN_ACCEPT_RANGES; + break; + } + break; + case 14: + switch (name[13]) { + case 'h': + if (memcmp(name, "content-lengt", 13) == 0) + return H2O_TOKEN_CONTENT_LENGTH; + break; + case 's': + if (memcmp(name, "http2-setting", 13) == 0) + return H2O_TOKEN_HTTP2_SETTINGS; + break; + case 't': + if (memcmp(name, "accept-charse", 13) == 0) + return H2O_TOKEN_ACCEPT_CHARSET; + break; + } + break; + case 15: + switch (name[14]) { + case 'e': + if (memcmp(name, "accept-languag", 14) == 0) + return H2O_TOKEN_ACCEPT_LANGUAGE; + break; + case 'g': + if (memcmp(name, "accept-encodin", 14) == 0) + return H2O_TOKEN_ACCEPT_ENCODING; + break; + case 'r': + if (memcmp(name, "x-forwarded-fo", 14) == 0) + return H2O_TOKEN_X_FORWARDED_FOR; + break; + case 't': + if (memcmp(name, "x-compress-hin", 14) == 0) + return H2O_TOKEN_X_COMPRESS_HINT; + break; + } + break; + case 16: + switch (name[15]) { + case 'e': + if (memcmp(name, "content-languag", 15) == 0) + return H2O_TOKEN_CONTENT_LANGUAGE; + if (memcmp(name, "www-authenticat", 15) == 0) + return H2O_TOKEN_WWW_AUTHENTICATE; + break; + case 'g': + if (memcmp(name, "content-encodin", 15) == 0) + return H2O_TOKEN_CONTENT_ENCODING; + break; + case 'n': + if (memcmp(name, "content-locatio", 15) == 0) + return H2O_TOKEN_CONTENT_LOCATION; + break; + } + break; + case 17: + switch (name[16]) { + case 'e': + if (memcmp(name, "if-modified-sinc", 16) == 0) + return H2O_TOKEN_IF_MODIFIED_SINCE; + break; + case 'g': + if (memcmp(name, "transfer-encodin", 16) == 0) + return H2O_TOKEN_TRANSFER_ENCODING; + break; + } + break; + case 18: + switch (name[17]) { + case 'e': + if (memcmp(name, "proxy-authenticat", 17) == 0) + return H2O_TOKEN_PROXY_AUTHENTICATE; + break; + } + break; + case 19: + switch (name[18]) { + case 'e': + if (memcmp(name, "if-unmodified-sinc", 18) == 0) + return H2O_TOKEN_IF_UNMODIFIED_SINCE; + break; + case 'n': + if (memcmp(name, "content-dispositio", 18) == 0) + return H2O_TOKEN_CONTENT_DISPOSITION; + if (memcmp(name, "proxy-authorizatio", 18) == 0) + return H2O_TOKEN_PROXY_AUTHORIZATION; + break; + } + break; + case 25: + switch (name[24]) { + case 'y': + if (memcmp(name, "strict-transport-securit", 24) == 0) + return H2O_TOKEN_STRICT_TRANSPORT_SECURITY; + break; + } + break; + case 27: + switch (name[26]) { + case 'n': + if (memcmp(name, "access-control-allow-origi", 26) == 0) + return H2O_TOKEN_ACCESS_CONTROL_ALLOW_ORIGIN; + break; + } + break; + } + + return NULL; +} diff --git a/web/server/h2o/libh2o/lib/core/util.c b/web/server/h2o/libh2o/lib/core/util.c new file mode 100644 index 000000000..50d2b2493 --- /dev/null +++ b/web/server/h2o/libh2o/lib/core/util.c @@ -0,0 +1,562 @@ +/* + * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Satoh Hiroh + * + * 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 <inttypes.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include "h2o.h" +#include "h2o/http1.h" +#include "h2o/http2.h" + +struct st_h2o_accept_data_t { + h2o_accept_ctx_t *ctx; + h2o_socket_t *sock; + h2o_timeout_entry_t timeout; + h2o_memcached_req_t *async_resumption_get_req; + struct timeval connected_at; +}; + +static void on_accept_timeout(h2o_timeout_entry_t *entry); + +static struct st_h2o_accept_data_t *create_accept_data(h2o_accept_ctx_t *ctx, h2o_socket_t *sock, struct timeval connected_at) +{ + struct st_h2o_accept_data_t *data = h2o_mem_alloc(sizeof(*data)); + + data->ctx = ctx; + data->sock = sock; + data->timeout = (h2o_timeout_entry_t){0}; + data->timeout.cb = on_accept_timeout; + h2o_timeout_link(ctx->ctx->loop, &ctx->ctx->handshake_timeout, &data->timeout); + data->async_resumption_get_req = NULL; + data->connected_at = connected_at; + + sock->data = data; + return data; +} + +static void free_accept_data(struct st_h2o_accept_data_t *data) +{ + assert(data->async_resumption_get_req == NULL); + h2o_timeout_unlink(&data->timeout); + free(data); +} + +static struct { + h2o_memcached_context_t *memc; + unsigned expiration; +} async_resumption_context; + +static void async_resumption_on_get(h2o_iovec_t session_data, void *_accept_data) +{ + struct st_h2o_accept_data_t *accept_data = _accept_data; + accept_data->async_resumption_get_req = NULL; + h2o_socket_ssl_resume_server_handshake(accept_data->sock, session_data); +} + +static void async_resumption_get(h2o_socket_t *sock, h2o_iovec_t session_id) +{ + struct st_h2o_accept_data_t *data = sock->data; + + data->async_resumption_get_req = + h2o_memcached_get(async_resumption_context.memc, data->ctx->libmemcached_receiver, session_id, async_resumption_on_get, + data, H2O_MEMCACHED_ENCODE_KEY | H2O_MEMCACHED_ENCODE_VALUE); +} + +static void async_resumption_new(h2o_iovec_t session_id, h2o_iovec_t session_data) +{ + h2o_memcached_set(async_resumption_context.memc, session_id, session_data, + (uint32_t)time(NULL) + async_resumption_context.expiration, + H2O_MEMCACHED_ENCODE_KEY | H2O_MEMCACHED_ENCODE_VALUE); +} + +void h2o_accept_setup_async_ssl_resumption(h2o_memcached_context_t *memc, unsigned expiration) +{ + async_resumption_context.memc = memc; + async_resumption_context.expiration = expiration; + h2o_socket_ssl_async_resumption_init(async_resumption_get, async_resumption_new); +} + +void on_accept_timeout(h2o_timeout_entry_t *entry) +{ + /* TODO log */ + struct st_h2o_accept_data_t *data = H2O_STRUCT_FROM_MEMBER(struct st_h2o_accept_data_t, timeout, entry); + if (data->async_resumption_get_req != NULL) { + h2o_memcached_cancel_get(async_resumption_context.memc, data->async_resumption_get_req); + data->async_resumption_get_req = NULL; + } + h2o_socket_t *sock = data->sock; + free_accept_data(data); + h2o_socket_close(sock); +} + +static void on_ssl_handshake_complete(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_accept_data_t *data = sock->data; + sock->data = NULL; + + if (err != NULL) { + h2o_socket_close(sock); + goto Exit; + } + + h2o_iovec_t proto = h2o_socket_ssl_get_selected_protocol(sock); + const h2o_iovec_t *ident; + for (ident = h2o_http2_alpn_protocols; ident->len != 0; ++ident) { + if (proto.len == ident->len && memcmp(proto.base, ident->base, proto.len) == 0) { + /* connect as http2 */ + h2o_http2_accept(data->ctx, sock, data->connected_at); + goto Exit; + } + } + /* connect as http1 */ + h2o_http1_accept(data->ctx, sock, data->connected_at); + +Exit: + free_accept_data(data); +} + +static ssize_t parse_proxy_line(char *src, size_t len, struct sockaddr *sa, socklen_t *salen) +{ +#define CHECK_EOF() \ + if (p == end) \ + return -2 +#define EXPECT_CHAR(ch) \ + do { \ + CHECK_EOF(); \ + if (*p++ != ch) \ + return -1; \ + } while (0) +#define SKIP_TO_WS() \ + do { \ + do { \ + CHECK_EOF(); \ + } while (*p++ != ' '); \ + --p; \ + } while (0) + + char *p = src, *end = p + len; + void *addr; + in_port_t *port; + + /* "PROXY "*/ + EXPECT_CHAR('P'); + EXPECT_CHAR('R'); + EXPECT_CHAR('O'); + EXPECT_CHAR('X'); + EXPECT_CHAR('Y'); + EXPECT_CHAR(' '); + + /* "TCP[46] " */ + CHECK_EOF(); + if (*p++ != 'T') { + *salen = 0; /* indicate that no data has been obtained */ + goto SkipToEOL; + } + EXPECT_CHAR('C'); + EXPECT_CHAR('P'); + CHECK_EOF(); + switch (*p++) { + case '4': + *salen = sizeof(struct sockaddr_in); + memset(sa, 0, sizeof(struct sockaddr_in)); + sa->sa_family = AF_INET; + addr = &((struct sockaddr_in *)sa)->sin_addr; + port = &((struct sockaddr_in *)sa)->sin_port; + break; + case '6': + *salen = sizeof(struct sockaddr_in6); + memset(sa, 0, sizeof(struct sockaddr_in6)); + sa->sa_family = AF_INET6; + addr = &((struct sockaddr_in6 *)sa)->sin6_addr; + port = &((struct sockaddr_in6 *)sa)->sin6_port; + break; + default: + return -1; + } + EXPECT_CHAR(' '); + + /* parse peer address */ + char *addr_start = p; + SKIP_TO_WS(); + *p = '\0'; + if (inet_pton(sa->sa_family, addr_start, addr) != 1) + return -1; + *p++ = ' '; + + /* skip local address */ + SKIP_TO_WS(); + ++p; + + /* parse peer port */ + char *port_start = p; + SKIP_TO_WS(); + *p = '\0'; + unsigned short usval; + if (sscanf(port_start, "%hu", &usval) != 1) + return -1; + *port = htons(usval); + *p++ = ' '; + +SkipToEOL: + do { + CHECK_EOF(); + } while (*p++ != '\r'); + CHECK_EOF(); + if (*p++ != '\n') + return -2; + return p - src; + +#undef CHECK_EOF +#undef EXPECT_CHAR +#undef SKIP_TO_WS +} + +static void on_read_proxy_line(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_accept_data_t *data = sock->data; + + if (err != NULL) { + free_accept_data(data); + h2o_socket_close(sock); + return; + } + + struct sockaddr_storage addr; + socklen_t addrlen; + ssize_t r = parse_proxy_line(sock->input->bytes, sock->input->size, (void *)&addr, &addrlen); + switch (r) { + case -1: /* error, just pass the input to the next handler */ + break; + case -2: /* incomplete */ + return; + default: + h2o_buffer_consume(&sock->input, r); + if (addrlen != 0) + h2o_socket_setpeername(sock, (void *)&addr, addrlen); + break; + } + + if (data->ctx->ssl_ctx != NULL) { + h2o_socket_ssl_handshake(sock, data->ctx->ssl_ctx, NULL, on_ssl_handshake_complete); + } else { + struct st_h2o_accept_data_t *data = sock->data; + sock->data = NULL; + h2o_http1_accept(data->ctx, sock, data->connected_at); + free_accept_data(data); + } +} + +void h2o_accept(h2o_accept_ctx_t *ctx, h2o_socket_t *sock) +{ + struct timeval connected_at = *h2o_get_timestamp(ctx->ctx, NULL, NULL); + + if (ctx->expect_proxy_line || ctx->ssl_ctx != NULL) { + create_accept_data(ctx, sock, connected_at); + if (ctx->expect_proxy_line) { + h2o_socket_read_start(sock, on_read_proxy_line); + } else { + h2o_socket_ssl_handshake(sock, ctx->ssl_ctx, NULL, on_ssl_handshake_complete); + } + } else { + h2o_http1_accept(ctx, sock, connected_at); + } +} + +size_t h2o_stringify_protocol_version(char *dst, int version) +{ + char *p = dst; + + if (version < 0x200) { + assert(version <= 0x109); +#define PREFIX "HTTP/1." + memcpy(p, PREFIX, sizeof(PREFIX) - 1); + p += sizeof(PREFIX) - 1; +#undef PREFIX + *p++ = '0' + (version & 0xff); + } else { +#define PROTO "HTTP/2" + memcpy(p, PROTO, sizeof(PROTO) - 1); + p += sizeof(PROTO) - 1; +#undef PROTO + } + + *p = '\0'; + return p - dst; +} + +size_t h2o_stringify_proxy_header(h2o_conn_t *conn, char *buf) +{ + struct sockaddr_storage ss; + socklen_t sslen; + size_t strlen; + uint16_t peerport; + char *dst = buf; + + if ((sslen = conn->callbacks->get_peername(conn, (void *)&ss)) == 0) + goto Unknown; + switch (ss.ss_family) { + case AF_INET: + memcpy(dst, "PROXY TCP4 ", 11); + dst += 11; + break; + case AF_INET6: + memcpy(dst, "PROXY TCP6 ", 11); + dst += 11; + break; + default: + goto Unknown; + } + if ((strlen = h2o_socket_getnumerichost((void *)&ss, sslen, dst)) == SIZE_MAX) + goto Unknown; + dst += strlen; + *dst++ = ' '; + + peerport = h2o_socket_getport((void *)&ss); + + if ((sslen = conn->callbacks->get_sockname(conn, (void *)&ss)) == 0) + goto Unknown; + if ((strlen = h2o_socket_getnumerichost((void *)&ss, sslen, dst)) == SIZE_MAX) + goto Unknown; + dst += strlen; + *dst++ = ' '; + + dst += sprintf(dst, "%" PRIu16 " %" PRIu16 "\r\n", peerport, (uint16_t)h2o_socket_getport((void *)&ss)); + + return dst - buf; + +Unknown: + memcpy(buf, "PROXY UNKNOWN\r\n", 15); + return 15; +} + +static void push_one_path(h2o_mem_pool_t *pool, h2o_iovec_vector_t *paths_to_push, h2o_iovec_t url, h2o_iovec_t base_path, + const h2o_url_scheme_t *input_scheme, h2o_iovec_t input_authority, const h2o_url_scheme_t *base_scheme, + h2o_iovec_t *base_authority) +{ + h2o_url_t parsed, resolved; + + /* check the authority, and extract absolute path */ + if (h2o_url_parse_relative(url.base, url.len, &parsed) != 0) + return; + + /* fast-path for abspath form */ + if (base_scheme == NULL && parsed.scheme == NULL && parsed.authority.base == NULL && url.len != 0 && url.base[0] == '/') { + h2o_vector_reserve(pool, paths_to_push, paths_to_push->size + 1); + paths_to_push->entries[paths_to_push->size++] = h2o_strdup(pool, url.base, url.len); + return; + } + + /* check scheme and authority if given URL contains either of the two, or if base is specified */ + h2o_url_t base = {input_scheme, input_authority, {NULL}, base_path, 65535}; + if (base_scheme != NULL) { + base.scheme = base_scheme; + base.authority = *base_authority; + } + h2o_url_resolve(pool, &base, &parsed, &resolved); + if (input_scheme != resolved.scheme) + return; + if (!h2o_lcstris(input_authority.base, input_authority.len, resolved.authority.base, resolved.authority.len)) + return; + + h2o_vector_reserve(pool, paths_to_push, paths_to_push->size + 1); + paths_to_push->entries[paths_to_push->size++] = resolved.path; +} + +h2o_iovec_vector_t h2o_extract_push_path_from_link_header(h2o_mem_pool_t *pool, const char *value, size_t value_len, + h2o_iovec_t base_path, const h2o_url_scheme_t *input_scheme, + h2o_iovec_t input_authority, const h2o_url_scheme_t *base_scheme, + h2o_iovec_t *base_authority, h2o_iovec_t *filtered_value) +{ + h2o_iovec_vector_t paths_to_push = {NULL}; + h2o_iovec_t iter = h2o_iovec_init(value, value_len), token_value; + const char *token; + size_t token_len; + *filtered_value = h2o_iovec_init(NULL, 0); + +#define PUSH_FILTERED_VALUE(s, e) \ + do { \ + if (filtered_value->len != 0) { \ + memcpy(filtered_value->base + filtered_value->len, ", ", 2); \ + filtered_value->len += 2; \ + } \ + memcpy(filtered_value->base + filtered_value->len, (s), (e) - (s)); \ + filtered_value->len += (e) - (s); \ + } while (0) + + /* extract URL values from Link: </pushed.css>; rel=preload */ + do { + if ((token = h2o_next_token(&iter, ';', &token_len, NULL)) == NULL) + break; + /* first element should be <URL> */ + if (!(token_len >= 2 && token[0] == '<' && token[token_len - 1] == '>')) + break; + h2o_iovec_t url_with_brackets = h2o_iovec_init(token, token_len); + /* find rel=preload */ + int preload = 0, nopush = 0, push_only = 0; + while ((token = h2o_next_token(&iter, ';', &token_len, &token_value)) != NULL && + !h2o_memis(token, token_len, H2O_STRLIT(","))) { + if (h2o_lcstris(token, token_len, H2O_STRLIT("rel")) && + h2o_lcstris(token_value.base, token_value.len, H2O_STRLIT("preload"))) { + preload++; + } else if (h2o_lcstris(token, token_len, H2O_STRLIT("nopush"))) { + nopush++; + } else if (h2o_lcstris(token, token_len, H2O_STRLIT("x-http2-push-only"))) { + push_only++; + } + } + /* push the path */ + if (!nopush && preload) + push_one_path(pool, &paths_to_push, h2o_iovec_init(url_with_brackets.base + 1, url_with_brackets.len - 2), base_path, + input_scheme, input_authority, base_scheme, base_authority); + /* store the elements that needs to be preserved to filtered_value */ + if (push_only) { + if (filtered_value->base == NULL) { + /* the max. size of filtered_value would be x2 in the worst case, when "," is converted to ", " */ + filtered_value->base = h2o_mem_alloc_pool(pool, value_len * 2); + const char *prev_comma = h2o_memrchr(value, ',', url_with_brackets.base - value); + if (prev_comma != NULL) + PUSH_FILTERED_VALUE(value, prev_comma); + } + } else if (filtered_value->base != NULL) { + PUSH_FILTERED_VALUE(url_with_brackets.base, token != NULL ? token : value + value_len); + } + } while (token != NULL); + + if (filtered_value->base != NULL) { + if (token != NULL) + PUSH_FILTERED_VALUE(token, value + value_len); + } else { + *filtered_value = h2o_iovec_init(value, value_len); + } + + return paths_to_push; + +#undef PUSH_FILTERED_VALUE +} + +int h2o_get_compressible_types(const h2o_headers_t *headers) +{ + size_t header_index; + int compressible_types = 0; + + for (header_index = 0; header_index != headers->size; ++header_index) { + const h2o_header_t *header = headers->entries + header_index; + if (H2O_UNLIKELY(header->name == &H2O_TOKEN_ACCEPT_ENCODING->buf)) { + h2o_iovec_t iter = h2o_iovec_init(header->value.base, header->value.len); + const char *token = NULL; + size_t token_len = 0; + while ((token = h2o_next_token(&iter, ',', &token_len, NULL)) != NULL) { + if (h2o_lcstris(token, token_len, H2O_STRLIT("gzip"))) + compressible_types |= H2O_COMPRESSIBLE_GZIP; + else if (h2o_lcstris(token, token_len, H2O_STRLIT("br"))) + compressible_types |= H2O_COMPRESSIBLE_BROTLI; + } + } + } + + return compressible_types; +} + +h2o_iovec_t h2o_build_destination(h2o_req_t *req, const char *prefix, size_t prefix_len, int use_path_normalized) +{ + h2o_iovec_t parts[4]; + size_t num_parts = 0; + int conf_ends_with_slash = req->pathconf->path.base[req->pathconf->path.len - 1] == '/'; + int prefix_ends_with_slash = prefix[prefix_len - 1] == '/'; + + /* destination starts with given prefix */ + parts[num_parts++] = h2o_iovec_init(prefix, prefix_len); + + /* make adjustments depending on the trailing slashes */ + if (conf_ends_with_slash != prefix_ends_with_slash) { + if (conf_ends_with_slash) { + parts[num_parts++] = h2o_iovec_init(H2O_STRLIT("/")); + } else { + if (req->path_normalized.len != req->pathconf->path.len) + parts[num_parts - 1].len -= 1; + } + } + + /* append suffix path and query */ + + if (use_path_normalized) { + parts[num_parts++] = h2o_uri_escape(&req->pool, req->path_normalized.base + req->pathconf->path.len, + req->path_normalized.len - req->pathconf->path.len, "/@:"); + if (req->query_at != SIZE_MAX) { + parts[num_parts++] = h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at); + } + } else { + if (req->path.len > 1) { + /* + * When proxying, we want to modify the input URL as little + * as possible. We use norm_indexes to find the start of + * the path we want to forward. + */ + size_t next_unnormalized; + if (req->norm_indexes && req->pathconf->path.len > 1) { + next_unnormalized = req->norm_indexes[req->pathconf->path.len - 1]; + } else { + next_unnormalized = req->pathconf->path.len; + } + + /* + * Special case: the input path didn't have any '/' including the first, + * so the first character is actually found at '0' + */ + if (req->path.base[0] != '/' && next_unnormalized == 1) { + next_unnormalized = 0; + } + parts[num_parts++] = (h2o_iovec_t){req->path.base + next_unnormalized, req->path.len - next_unnormalized}; + } + } + + return h2o_concat_list(&req->pool, parts, num_parts); +} + +/* h2-14 and h2-16 are kept for backwards compatibility, as they are often used */ +#define ALPN_ENTRY(s) \ + { \ + H2O_STRLIT(s) \ + } +#define ALPN_PROTOCOLS_CORE ALPN_ENTRY("h2"), ALPN_ENTRY("h2-16"), ALPN_ENTRY("h2-14") +#define NPN_PROTOCOLS_CORE \ + "\x02" \ + "h2" \ + "\x05" \ + "h2-16" \ + "\x05" \ + "h2-14" + +static const h2o_iovec_t http2_alpn_protocols[] = {ALPN_PROTOCOLS_CORE, {NULL}}; +const h2o_iovec_t *h2o_http2_alpn_protocols = http2_alpn_protocols; + +static const h2o_iovec_t alpn_protocols[] = {ALPN_PROTOCOLS_CORE, {H2O_STRLIT("http/1.1")}, {NULL}}; +const h2o_iovec_t *h2o_alpn_protocols = alpn_protocols; + +const char *h2o_http2_npn_protocols = NPN_PROTOCOLS_CORE; +const char *h2o_npn_protocols = NPN_PROTOCOLS_CORE "\x08" + "http/1.1"; + +uint64_t h2o_connection_id = 0; diff --git a/web/server/h2o/libh2o/lib/handler/access_log.c b/web/server/h2o/libh2o/lib/handler/access_log.c new file mode 100644 index 000000000..4a7704174 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/access_log.c @@ -0,0 +1,153 @@ +/* + * 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 <errno.h> +#include <fcntl.h> +#include <inttypes.h> +#include <netdb.h> +#include <netinet/in.h> +#include <spawn.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/socket.h> +#include <sys/types.h> +#include "h2o.h" +#include "h2o/serverutil.h" + +struct st_h2o_access_log_filehandle_t { + h2o_logconf_t *logconf; + int fd; +}; + +struct st_h2o_access_logger_t { + h2o_logger_t super; + h2o_access_log_filehandle_t *fh; +}; + +static void log_access(h2o_logger_t *_self, h2o_req_t *req) +{ + struct st_h2o_access_logger_t *self = (struct st_h2o_access_logger_t *)_self; + h2o_access_log_filehandle_t *fh = self->fh; + char *logline, buf[4096]; + size_t len; + + /* stringify */ + len = sizeof(buf); + logline = h2o_log_request(fh->logconf, req, &len, buf); + + /* emit */ + write(fh->fd, logline, len); + + /* free memory */ + if (logline != buf) + free(logline); +} + +static void on_dispose_handle(void *_fh) +{ + h2o_access_log_filehandle_t *fh = _fh; + + h2o_logconf_dispose(fh->logconf); + close(fh->fd); +} + +int h2o_access_log_open_log(const char *path) +{ + int fd; + + if (path[0] == '|') { + int pipefds[2]; + pid_t pid; + char *argv[4] = {"/bin/sh", "-c", (char *)(path + 1), NULL}; + /* create pipe */ + if (pipe(pipefds) != 0) { + perror("pipe failed"); + return -1; + } + if (fcntl(pipefds[1], F_SETFD, FD_CLOEXEC) == -1) { + perror("failed to set FD_CLOEXEC on pipefds[1]"); + return -1; + } + /* spawn the logger */ + int mapped_fds[] = {pipefds[0], 0, /* map pipefds[0] to stdin */ + -1}; + if ((pid = h2o_spawnp(argv[0], argv, mapped_fds, 0)) == -1) { + fprintf(stderr, "failed to open logger: %s:%s\n", path + 1, strerror(errno)); + return -1; + } + /* close the read side of the pipefds and return the write side */ + close(pipefds[0]); + fd = pipefds[1]; + } else { + if ((fd = open(path, O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC, 0644)) == -1) { + fprintf(stderr, "failed to open log file:%s:%s\n", path, strerror(errno)); + return -1; + } + } + + return fd; +} + +h2o_access_log_filehandle_t *h2o_access_log_open_handle(const char *path, const char *fmt, int escape) +{ + h2o_logconf_t *logconf; + int fd; + h2o_access_log_filehandle_t *fh; + char errbuf[256]; + + /* default to combined log format */ + if (fmt == NULL) + fmt = "%h %l %u %t \"%r\" %s %b \"%{Referer}i\" \"%{User-agent}i\""; + if ((logconf = h2o_logconf_compile(fmt, escape, errbuf)) == NULL) { + fprintf(stderr, "%s\n", errbuf); + return NULL; + } + + /* open log file */ + if ((fd = h2o_access_log_open_log(path)) == -1) { + h2o_logconf_dispose(logconf); + return NULL; + } + + fh = h2o_mem_alloc_shared(NULL, sizeof(*fh), on_dispose_handle); + fh->logconf = logconf; + fh->fd = fd; + return fh; +} + +static void dispose(h2o_logger_t *_self) +{ + struct st_h2o_access_logger_t *self = (void *)_self; + + h2o_mem_release_shared(self->fh); +} + +h2o_logger_t *h2o_access_log_register(h2o_pathconf_t *pathconf, h2o_access_log_filehandle_t *fh) +{ + struct st_h2o_access_logger_t *self = (void *)h2o_create_logger(pathconf, sizeof(*self)); + + self->super.dispose = dispose; + self->super.log_access = log_access; + self->fh = fh; + h2o_mem_addref_shared(fh); + + return &self->super; +} diff --git a/web/server/h2o/libh2o/lib/handler/chunked.c b/web/server/h2o/libh2o/lib/handler/chunked.c new file mode 100644 index 000000000..b6ad4346b --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/chunked.c @@ -0,0 +1,113 @@ +/* + * 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 <stdlib.h> +#include "h2o.h" + +typedef struct st_chunked_encoder_t { + h2o_ostream_t super; + char buf[64]; +} chunked_encoder_t; + +static void send_chunk(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state) +{ + chunked_encoder_t *self = (void *)_self; + h2o_iovec_t *outbufs = alloca(sizeof(h2o_iovec_t) * (inbufcnt + 2)); + size_t chunk_size, outbufcnt = 0, i; + + /* calc chunk size */ + chunk_size = 0; + for (i = 0; i != inbufcnt; ++i) + chunk_size += inbufs[i].len; + req->bytes_sent += chunk_size; + + /* create chunk header and output data */ + if (chunk_size != 0) { + outbufs[outbufcnt].base = self->buf; + outbufs[outbufcnt].len = sprintf(self->buf, "%zx\r\n", chunk_size); + assert(outbufs[outbufcnt].len < sizeof(self->buf)); + outbufcnt++; + memcpy(outbufs + outbufcnt, inbufs, sizeof(h2o_iovec_t) * inbufcnt); + outbufcnt += inbufcnt; + if (state != H2O_SEND_STATE_ERROR) { + outbufs[outbufcnt].base = "\r\n0\r\n\r\n"; + outbufs[outbufcnt].len = state == H2O_SEND_STATE_FINAL ? 7 : 2; + outbufcnt++; + } + } else if (state == H2O_SEND_STATE_FINAL) { + outbufs[outbufcnt].base = "0\r\n\r\n"; + outbufs[outbufcnt].len = 5; + outbufcnt++; + } + + /* if state is error, send a broken chunk to pass the error down to the browser */ + if (state == H2O_SEND_STATE_ERROR) { + outbufs[outbufcnt].base = "\r\n1\r\n"; + outbufs[outbufcnt].len = 5; + outbufcnt++; + } + + h2o_ostream_send_next(&self->super, req, outbufs, outbufcnt, state); +} + +static void on_setup_ostream(h2o_filter_t *self, h2o_req_t *req, h2o_ostream_t **slot) +{ + chunked_encoder_t *encoder; + + /* do nothing if not HTTP/1.1 or content-length is known */ + if (req->res.content_length != SIZE_MAX || req->version != 0x101) + goto Next; + /* RFC 2616 4.4 states that the following status codes (and response to a HEAD method) should not include message body */ + if ((100 <= req->res.status && req->res.status <= 199) || req->res.status == 204 || req->res.status == 304) + goto Next; + else if (h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("HEAD"))) + goto Next; + /* we cannot handle certain responses (like 101 switching protocols) */ + if (req->res.status != 200) { + req->http1_is_persistent = 0; + goto Next; + } + /* skip if content-encoding header is being set */ + if (h2o_find_header(&req->res.headers, H2O_TOKEN_TRANSFER_ENCODING, -1) != -1) + goto Next; + + /* set content-encoding header */ + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_TRANSFER_ENCODING, NULL, H2O_STRLIT("chunked")); + + /* set the flag that tells finalostream that req->bytes_sent is already counted */ + req->bytes_counted_by_ostream = 1; + + /* setup filter */ + encoder = (void *)h2o_add_ostream(req, sizeof(chunked_encoder_t), slot); + encoder->super.do_send = send_chunk; + slot = &encoder->super.next; + +Next: + h2o_setup_next_ostream(req, slot); +} + +void h2o_chunked_register(h2o_pathconf_t *pathconf) +{ + h2o_filter_t *self = h2o_create_filter(pathconf, sizeof(*self)); + self->on_setup_ostream = on_setup_ostream; +} diff --git a/web/server/h2o/libh2o/lib/handler/compress.c b/web/server/h2o/libh2o/lib/handler/compress.c new file mode 100644 index 000000000..615977131 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/compress.c @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2015,2016 Justin Zhu, 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 <stdlib.h> +#include "h2o.h" + +#ifndef BUF_SIZE +#define BUF_SIZE 8192 +#endif + +struct st_compress_filter_t { + h2o_filter_t super; + h2o_compress_args_t args; +}; + +struct st_compress_encoder_t { + h2o_ostream_t super; + h2o_compress_context_t *compressor; +}; + +static void do_send(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state) +{ + struct st_compress_encoder_t *self = (void *)_self; + h2o_iovec_t *outbufs; + size_t outbufcnt; + + self->compressor->transform(self->compressor, inbufs, inbufcnt, state, &outbufs, &outbufcnt); + h2o_ostream_send_next(&self->super, req, outbufs, outbufcnt, state); +} + +static void on_setup_ostream(h2o_filter_t *_self, h2o_req_t *req, h2o_ostream_t **slot) +{ + struct st_compress_filter_t *self = (void *)_self; + struct st_compress_encoder_t *encoder; + int compressible_types; + h2o_compress_context_t *compressor; + ssize_t i; + + if (req->version < 0x101) + goto Next; + if (req->res.status != 200) + goto Next; + if (h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("HEAD"))) + goto Next; + + switch (req->compress_hint) { + case H2O_COMPRESS_HINT_DISABLE: + /* compression was explicitely disabled, skip */ + goto Next; + case H2O_COMPRESS_HINT_ENABLE: + /* compression was explicitely enabled */ + break; + case H2O_COMPRESS_HINT_AUTO: + default: + /* no hint from the producer, decide whether to compress based + on the configuration */ + if (req->res.mime_attr == NULL) + h2o_req_fill_mime_attributes(req); + if (!req->res.mime_attr->is_compressible) + goto Next; + if (req->res.content_length < self->args.min_size) + goto Next; + } + + /* skip if failed to gather the list of compressible types */ + if ((compressible_types = h2o_get_compressible_types(&req->headers)) == 0) + goto Next; + + /* skip if content-encoding header is being set (as well as obtain the location of accept-ranges) */ + size_t content_encoding_header_index = -1, accept_ranges_header_index = -1; + for (i = 0; i != req->res.headers.size; ++i) { + if (req->res.headers.entries[i].name == &H2O_TOKEN_CONTENT_ENCODING->buf) + content_encoding_header_index = i; + else if (req->res.headers.entries[i].name == &H2O_TOKEN_ACCEPT_RANGES->buf) + accept_ranges_header_index = i; + else + continue; + } + if (content_encoding_header_index != -1) + goto Next; + +/* open the compressor */ +#if H2O_USE_BROTLI + if (self->args.brotli.quality != -1 && (compressible_types & H2O_COMPRESSIBLE_BROTLI) != 0) { + compressor = h2o_compress_brotli_open(&req->pool, self->args.brotli.quality, req->res.content_length); + } else +#endif + if (self->args.gzip.quality != -1 && (compressible_types & H2O_COMPRESSIBLE_GZIP) != 0) { + compressor = h2o_compress_gzip_open(&req->pool, self->args.gzip.quality); + } else { + /* let proxies know that we looked at accept-encoding when deciding not to compress */ + h2o_set_header_token(&req->pool, &req->res.headers, H2O_TOKEN_VARY, H2O_STRLIT("accept-encoding")); + goto Next; + } + + /* adjust the response headers */ + req->res.content_length = SIZE_MAX; + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_ENCODING, NULL, compressor->name.base, compressor->name.len); + h2o_set_header_token(&req->pool, &req->res.headers, H2O_TOKEN_VARY, H2O_STRLIT("accept-encoding")); + if (accept_ranges_header_index != -1) { + req->res.headers.entries[accept_ranges_header_index].value = h2o_iovec_init(H2O_STRLIT("none")); + } else { + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_ACCEPT_RANGES, NULL, H2O_STRLIT("none")); + } + + /* setup filter */ + encoder = (void *)h2o_add_ostream(req, sizeof(*encoder), slot); + encoder->super.do_send = do_send; + slot = &encoder->super.next; + encoder->compressor = compressor; + + /* adjust preferred chunk size (compress by 8192 bytes) */ + if (req->preferred_chunk_size > BUF_SIZE) + req->preferred_chunk_size = BUF_SIZE; + +Next: + h2o_setup_next_ostream(req, slot); +} + +void h2o_compress_register(h2o_pathconf_t *pathconf, h2o_compress_args_t *args) +{ + struct st_compress_filter_t *self = (void *)h2o_create_filter(pathconf, sizeof(*self)); + self->super.on_setup_ostream = on_setup_ostream; + self->args = *args; +} diff --git a/web/server/h2o/libh2o/lib/handler/compress/brotli.cc b/web/server/h2o/libh2o/lib/handler/compress/brotli.cc new file mode 100644 index 000000000..d4d06e9c4 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/compress/brotli.cc @@ -0,0 +1,138 @@ +/* + * Copyright (c) 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 <cassert> +#include <cstdlib> +#include <vector> +#include <zlib.h> +#include "h2o.h" +#include "encode.h" + +namespace { + class brotli_context : public h2o_compress_context_t { + protected: + brotli::BrotliCompressor *brotli_; + brotli::BrotliParams params_; + std::vector<h2o_iovec_t> bufs_; // all bufs_[nnn].base must be free(3)ed + public: + brotli_context(int quality, size_t estimated_content_length) : brotli_(NULL) { + name = h2o_iovec_init(H2O_STRLIT("br")); + transform = _compress; + params_.quality = quality; + if (estimated_content_length != std::numeric_limits<size_t>::max()) + _update_lgwin(params_, estimated_content_length); + } + ~brotli_context() { + _clear_bufs(); + delete brotli_; + } + static void dispose(void *_self) { + brotli_context *self = static_cast<brotli_context *>(_self); + self->~brotli_context(); + } + private: + void _clear_bufs(); + void _emit(bool is_last, bool force_flush); + void _compress(h2o_iovec_t *inbufs, size_t inbufcnt, int is_final, h2o_iovec_t **outbufs, size_t *outbufcnt); + static void _compress(h2o_compress_context_t *self, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state, + h2o_iovec_t **outbufs, size_t *outbufcnt) { + static_cast<brotli_context*>(self)->_compress(inbufs, inbufcnt, !h2o_send_state_is_in_progress(state), outbufs, outbufcnt); + } + static void _update_lgwin(brotli::BrotliParams ¶ms, size_t estimated_content_length); + }; +} + +void brotli_context::_clear_bufs() +{ + for (std::vector<h2o_iovec_t>::iterator i = bufs_.begin(); i != bufs_.end(); ++i) + free(i->base); + bufs_.clear(); +} + +void brotli_context::_emit(bool is_last, bool force_flush) +{ + uint8_t *output; + size_t out_size; + bool ret = brotli_->WriteBrotliData(is_last, force_flush, &out_size, &output); + assert(ret); + (void)ret; + if (out_size != 0) + bufs_.push_back(h2o_strdup(NULL, reinterpret_cast<const char *>(output), out_size)); +} + +void brotli_context::_compress(h2o_iovec_t *inbufs, size_t inbufcnt, int is_final, h2o_iovec_t **outbufs, size_t *outbufcnt) +{ + if (brotli_ == NULL) { + if (is_final) { + uint64_t len = 0; + for (size_t i = 0; i != inbufcnt; ++i) + len += inbufs[i].len; + if (len < std::numeric_limits<size_t>::max()) + _update_lgwin(params_, len); + } + brotli_ = new brotli::BrotliCompressor(params_); + } + + _clear_bufs(); + + if (inbufcnt != 0) { + size_t inbufindex = 0, offset = 0, block_space = brotli_->input_block_size(); + while (inbufindex != inbufcnt) { + size_t copy_len = std::min(block_space, inbufs[inbufindex].len - offset); + brotli_->CopyInputToRingBuffer(copy_len, reinterpret_cast<const uint8_t *>(inbufs[inbufindex].base) + offset); + offset += copy_len; + if (inbufs[inbufindex].len == offset) { + if (++inbufindex == inbufcnt) + break; + offset = 0; + } + if (block_space == 0) { + _emit(false, false); + block_space = brotli_->input_block_size(); + } + } + _emit(is_final, !is_final); + } else { + if (is_final) + _emit(true, false); + } + + if (is_final) { + delete brotli_; + brotli_ = NULL; + } + + *outbufs = &bufs_.front(); + *outbufcnt = bufs_.size(); +} + +void brotli_context::_update_lgwin(brotli::BrotliParams ¶ms, size_t estimated_content_length) +{ + int bits = estimated_content_length > 1 ? sizeof(unsigned long long) * 8 - __builtin_clzll(estimated_content_length - 1) : 1; + if (bits < params.lgwin) + params.lgwin = std::max(bits, brotli::kMinWindowBits); +} + +h2o_compress_context_t *h2o_compress_brotli_open(h2o_mem_pool_t *pool, int quality, size_t estimated_content_length) +{ + brotli_context *ctx = static_cast<brotli_context *>(h2o_mem_alloc_shared(pool, sizeof(*ctx), brotli_context::dispose)); + return new (ctx) brotli_context(quality, estimated_content_length); +} diff --git a/web/server/h2o/libh2o/lib/handler/compress/gzip.c b/web/server/h2o/libh2o/lib/handler/compress/gzip.c new file mode 100644 index 000000000..c12260df3 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/compress/gzip.c @@ -0,0 +1,190 @@ +/* + * Copyright (c) 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 <stdlib.h> +#include <zlib.h> +#include "h2o.h" + +#define WINDOW_BITS 31 +#ifndef BUF_SIZE /* is altered by unit test */ +#define BUF_SIZE 8192 +#endif + +typedef H2O_VECTOR(h2o_iovec_t) iovec_vector_t; + +struct st_gzip_context_t { + h2o_compress_context_t super; + z_stream zs; + int zs_is_open; + iovec_vector_t bufs; +}; + +static void do_compress(h2o_compress_context_t *_self, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state, + h2o_iovec_t **outbufs, size_t *outbufcnt); +static void do_decompress(h2o_compress_context_t *_self, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state, + h2o_iovec_t **outbufs, size_t *outbufcnt); + +static void *alloc_cb(void *_unused, unsigned int cnt, unsigned int sz) +{ + return h2o_mem_alloc(cnt * (size_t)sz); +} + +static void free_cb(void *_unused, void *p) +{ + free(p); +} + +static void expand_buf(iovec_vector_t *bufs) +{ + h2o_vector_reserve(NULL, bufs, bufs->size + 1); + bufs->entries[bufs->size++] = h2o_iovec_init(h2o_mem_alloc(BUF_SIZE), 0); +} + +typedef int (*processor)(z_streamp strm, int flush); + +static size_t process_chunk(struct st_gzip_context_t *self, const void *src, size_t len, int flush, size_t bufindex, processor proc) +{ + int ret; + + self->zs.next_in = (void *)src; + self->zs.avail_in = (unsigned)len; + + /* man says: If inflate/deflate returns with avail_out == 0, this function must be called again with the same value of the flush + * parameter and more output space (updated avail_out), until the flush is complete (function returns with non-zero avail_out). + */ + do { + /* expand buffer (note: in case of Z_SYNC_FLUSH we need to supply at least 6 bytes of output buffer) */ + if (self->bufs.entries[bufindex].len + 32 > BUF_SIZE) { + ++bufindex; + if (bufindex == self->bufs.size) + expand_buf(&self->bufs); + self->bufs.entries[bufindex].len = 0; + } + self->zs.next_out = (void *)(self->bufs.entries[bufindex].base + self->bufs.entries[bufindex].len); + self->zs.avail_out = (unsigned)(BUF_SIZE - self->bufs.entries[bufindex].len); + ret = proc(&self->zs, flush); + /* inflate() returns Z_BUF_ERROR if flush is set to Z_FINISH at the middle of the compressed data */ + assert(ret == Z_OK || ret == Z_STREAM_END || ret == Z_BUF_ERROR); + self->bufs.entries[bufindex].len = BUF_SIZE - self->zs.avail_out; + } while (self->zs.avail_out == 0 && ret != Z_STREAM_END); + + return bufindex; +} + +static void do_process(h2o_compress_context_t *_self, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state, + h2o_iovec_t **outbufs, size_t *outbufcnt, processor proc) +{ + struct st_gzip_context_t *self = (void *)_self; + size_t outbufindex; + h2o_iovec_t last_buf; + + outbufindex = 0; + self->bufs.entries[0].len = 0; + + if (inbufcnt != 0) { + size_t i; + for (i = 0; i != inbufcnt - 1; ++i) + outbufindex = process_chunk(self, inbufs[i].base, inbufs[i].len, Z_NO_FLUSH, outbufindex, proc); + last_buf = inbufs[i]; + } else { + last_buf = h2o_iovec_init(NULL, 0); + } + outbufindex = process_chunk(self, last_buf.base, last_buf.len, h2o_send_state_is_in_progress(state) ? Z_SYNC_FLUSH : Z_FINISH, + outbufindex, proc); + + *outbufs = self->bufs.entries; + *outbufcnt = outbufindex + 1; + + if (!h2o_send_state_is_in_progress(state)) { + if (self->super.transform == do_compress) { + deflateEnd(&self->zs); + } else { + inflateEnd(&self->zs); + } + self->zs_is_open = 0; + } +} + +static void do_compress(h2o_compress_context_t *_self, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state, + h2o_iovec_t **outbufs, size_t *outbufcnt) +{ + do_process(_self, inbufs, inbufcnt, state, outbufs, outbufcnt, (processor)deflate); +} + +static void do_decompress(h2o_compress_context_t *_self, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state, + h2o_iovec_t **outbufs, size_t *outbufcnt) +{ + do_process(_self, inbufs, inbufcnt, state, outbufs, outbufcnt, (processor)inflate); +} + +static void do_free(void *_self) +{ + struct st_gzip_context_t *self = _self; + size_t i; + + if (self->zs_is_open) { + if (self->super.transform == do_compress) { + deflateEnd(&self->zs); + } else { + inflateEnd(&self->zs); + } + } + + for (i = 0; i != self->bufs.size; ++i) + free(self->bufs.entries[i].base); + free(self->bufs.entries); +} + +static struct st_gzip_context_t *gzip_open(h2o_mem_pool_t *pool) +{ + struct st_gzip_context_t *self = h2o_mem_alloc_shared(pool, sizeof(*self), do_free); + + self->super.name = h2o_iovec_init(H2O_STRLIT("gzip")); + self->super.transform = NULL; + self->zs.zalloc = alloc_cb; + self->zs.zfree = free_cb; + self->zs.opaque = NULL; + self->zs_is_open = 1; + self->bufs = (iovec_vector_t){NULL}; + expand_buf(&self->bufs); + + return self; +} + +h2o_compress_context_t *h2o_compress_gzip_open(h2o_mem_pool_t *pool, int quality) +{ + struct st_gzip_context_t *self = gzip_open(pool); + self->super.transform = do_compress; + /* Z_BEST_SPEED for on-the-fly compression, memlevel set to 8 as suggested by the manual */ + deflateInit2(&self->zs, quality, Z_DEFLATED, WINDOW_BITS, 8, Z_DEFAULT_STRATEGY); + + return &self->super; +} + +h2o_compress_context_t *h2o_compress_gunzip_open(h2o_mem_pool_t *pool) +{ + struct st_gzip_context_t *self = gzip_open(pool); + self->super.transform = do_decompress; + inflateInit2(&self->zs, WINDOW_BITS); + + return &self->super; +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/access_log.c b/web/server/h2o/libh2o/lib/handler/configurator/access_log.c new file mode 100644 index 000000000..de6380882 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/access_log.c @@ -0,0 +1,143 @@ +/* + * 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.h" +#include "h2o/configurator.h" + +typedef H2O_VECTOR(h2o_access_log_filehandle_t *) st_h2o_access_log_filehandle_vector_t; + +struct st_h2o_access_log_configurator_t { + h2o_configurator_t super; + st_h2o_access_log_filehandle_vector_t *handles; + st_h2o_access_log_filehandle_vector_t _handles_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_access_log_configurator_t *self = (void *)cmd->configurator; + const char *path, *fmt = NULL; + int escape = H2O_LOGCONF_ESCAPE_APACHE; + h2o_access_log_filehandle_t *fh; + + switch (node->type) { + case YOML_TYPE_SCALAR: + path = node->data.scalar; + break; + case YOML_TYPE_MAPPING: { + yoml_t *t; + /* get path */ + if ((t = yoml_get(node, "path")) == NULL) { + h2o_configurator_errprintf(cmd, node, "could not find mandatory key `path`"); + return -1; + } + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, t, "`path` must be scalar"); + return -1; + } + path = t->data.scalar; + /* get format */ + if ((t = yoml_get(node, "format")) != NULL) { + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, t, "`format` must be a scalar"); + return -1; + } + fmt = t->data.scalar; + } + /* get escape */ + if ((t = yoml_get(node, "escape")) != NULL) { + switch (h2o_configurator_get_one_of(cmd, t, "apache,json")) { + case 0: + escape = H2O_LOGCONF_ESCAPE_APACHE; + break; + case 1: + escape = H2O_LOGCONF_ESCAPE_JSON; + break; + default: + return -1; + } + } + } break; + default: + h2o_configurator_errprintf(cmd, node, "node must be a scalar or a mapping"); + return -1; + } + + if (!ctx->dry_run) { + if ((fh = h2o_access_log_open_handle(path, fmt, escape)) == NULL) + return -1; + h2o_vector_reserve(NULL, self->handles, self->handles->size + 1); + self->handles->entries[self->handles->size++] = fh; + } + + return 0; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_access_log_configurator_t *self = (void *)_self; + size_t i; + + /* push the stack pointer */ + ++self->handles; + + /* link the handles */ + memset(self->handles, 0, sizeof(*self->handles)); + h2o_vector_reserve(NULL, self->handles, self->handles[-1].size + 1); + for (i = 0; i != self->handles[-1].size; ++i) { + h2o_access_log_filehandle_t *fh = self->handles[-1].entries[i]; + self->handles[0].entries[self->handles[0].size++] = fh; + h2o_mem_addref_shared(fh); + } + + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_access_log_configurator_t *self = (void *)_self; + size_t i; + + /* register all handles, and decref them */ + for (i = 0; i != self->handles->size; ++i) { + h2o_access_log_filehandle_t *fh = self->handles->entries[i]; + if (ctx->pathconf != NULL) + h2o_access_log_register(ctx->pathconf, fh); + h2o_mem_release_shared(fh); + } + /* free the vector */ + free(self->handles->entries); + + /* pop the stack pointer */ + --self->handles; + + return 0; +} + +void h2o_access_log_register_configurator(h2o_globalconf_t *conf) +{ + struct st_h2o_access_log_configurator_t *self = (void *)h2o_configurator_create(conf, sizeof(*self)); + + self->super.enter = on_config_enter; + self->super.exit = on_config_exit; + self->handles = self->_handles_stack; + + h2o_configurator_define_command(&self->super, "access-log", H2O_CONFIGURATOR_FLAG_ALL_LEVELS, on_config); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/compress.c b/web/server/h2o/libh2o/lib/handler/configurator/compress.c new file mode 100644 index 000000000..c023dd5cf --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/compress.c @@ -0,0 +1,172 @@ +/* + * 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.h" +#include "h2o/configurator.h" + +#define DEFAULT_GZIP_QUALITY 1 +#define DEFAULT_BROTLI_QUALITY 1 + +struct compress_configurator_t { + h2o_configurator_t super; + h2o_compress_args_t *vars, _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static const h2o_compress_args_t all_off = {0, {-1}, {-1}}, all_on = {100, {DEFAULT_GZIP_QUALITY}, {DEFAULT_BROTLI_QUALITY}}; + +static int on_config_gzip(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct compress_configurator_t *self = (void *)cmd->configurator; + int mode; + + if ((mode = (int)h2o_configurator_get_one_of(cmd, node, "OFF,ON")) == -1) + return -1; + + *self->vars = all_off; + if (mode != 0) + self->vars->gzip.quality = DEFAULT_GZIP_QUALITY; + + return 0; +} + +static int obtain_quality(yoml_t *node, int min_quality, int max_quality, int default_quality, int *slot) +{ + int tmp; + if (node->type != YOML_TYPE_SCALAR) + return -1; + if (strcasecmp(node->data.scalar, "OFF") == 0) { + *slot = -1; + return 0; + } + if (strcasecmp(node->data.scalar, "ON") == 0) { + *slot = default_quality; + return 0; + } + if (sscanf(node->data.scalar, "%d", &tmp) == 1 && (min_quality <= tmp && tmp <= max_quality)) { + *slot = tmp; + return 0; + } + return -1; +} + +static int on_config_compress_min_size(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct compress_configurator_t *self = (void *)cmd->configurator; + return h2o_configurator_scanf(cmd, node, "%zu", &self->vars->min_size); +} + +static int on_config_compress(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct compress_configurator_t *self = (void *)cmd->configurator; + size_t i; + + switch (node->type) { + case YOML_TYPE_SCALAR: + if (strcasecmp(node->data.scalar, "OFF") == 0) { + *self->vars = all_off; + } else if (strcasecmp(node->data.scalar, "ON") == 0) { + *self->vars = all_on; + } else { + h2o_configurator_errprintf(cmd, node, "scalar argument must be either of: `OFF`, `ON`"); + return -1; + } + break; + case YOML_TYPE_SEQUENCE: + *self->vars = all_off; + for (i = 0; i != node->data.sequence.size; ++i) { + yoml_t *element = node->data.sequence.elements[i]; + if (element->type == YOML_TYPE_SCALAR && strcasecmp(element->data.scalar, "gzip") == 0) { + self->vars->gzip.quality = DEFAULT_GZIP_QUALITY; + } else if (element->type == YOML_TYPE_SCALAR && strcasecmp(element->data.scalar, "br") == 0) { + self->vars->brotli.quality = DEFAULT_BROTLI_QUALITY; + } else { + h2o_configurator_errprintf(cmd, element, "element of the sequence must be either of: `gzip`, `br`"); + return -1; + } + } + break; + case YOML_TYPE_MAPPING: + *self->vars = all_off; + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key; + yoml_t *value = node->data.mapping.elements[i].value; + if (key->type == YOML_TYPE_SCALAR && strcasecmp(key->data.scalar, "gzip") == 0) { + if (obtain_quality(value, 1, 9, DEFAULT_GZIP_QUALITY, &self->vars->gzip.quality) != 0) { + h2o_configurator_errprintf( + cmd, value, "value of gzip attribute must be either of `OFF`, `ON` or an integer value between 1 and 9"); + return -1; + } + } else if (key->type == YOML_TYPE_SCALAR && strcasecmp(key->data.scalar, "br") == 0) { + if (obtain_quality(value, 0, 11, DEFAULT_BROTLI_QUALITY, &self->vars->brotli.quality) != 0) { + h2o_configurator_errprintf( + cmd, value, "value of br attribute must be either of `OFF`, `ON` or an integer between 0 and 11"); + return -1; + } + } else { + h2o_configurator_errprintf(cmd, key, "key must be either of: `gzip`, `br`"); + return -1; + } + } + break; + default: + h2o_fatal("unexpected node type"); + break; + } + + return 0; +} + +static int on_config_enter(h2o_configurator_t *configurator, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct compress_configurator_t *self = (void *)configurator; + + ++self->vars; + self->vars[0] = self->vars[-1]; + return 0; +} + +static int on_config_exit(h2o_configurator_t *configurator, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct compress_configurator_t *self = (void *)configurator; + + if (ctx->pathconf != NULL && (self->vars->gzip.quality != -1 || self->vars->brotli.quality != -1)) + h2o_compress_register(ctx->pathconf, self->vars); + + --self->vars; + return 0; +} + +void h2o_compress_register_configurator(h2o_globalconf_t *conf) +{ + struct compress_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + h2o_configurator_define_command(&c->super, "compress", H2O_CONFIGURATOR_FLAG_ALL_LEVELS, on_config_compress); + h2o_configurator_define_command(&c->super, "compress-minimum-size", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_compress_min_size); + h2o_configurator_define_command(&c->super, "gzip", H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_gzip); + c->vars = c->_vars_stack; + c->vars->gzip.quality = -1; + c->vars->brotli.quality = -1; +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/errordoc.c b/web/server/h2o/libh2o/lib/handler/configurator/errordoc.c new file mode 100644 index 000000000..ab24923ee --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/errordoc.c @@ -0,0 +1,203 @@ +/* + * Copyright (c) 2015-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 "h2o.h" +#include "h2o/configurator.h" + +struct errordoc_configurator_t { + h2o_configurator_t super; + h2o_mem_pool_t pool; + H2O_VECTOR(h2o_errordoc_t) * vars, _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int scan_and_check_status(h2o_configurator_command_t *cmd, yoml_t *value, int *slot) +{ + if (value->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, value, "status must be must be either of: scalar, sequence of scalar"); + return -1; + } + if (h2o_configurator_scanf(cmd, value, "%d", slot) != 0) + return -1; + if (!(400 <= *slot && *slot <= 599)) { + h2o_configurator_errprintf(cmd, value, "status must be within range of 400 to 599"); + return -1; + } + return 0; +} + +static int register_errordoc(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *hash) +{ + struct errordoc_configurator_t *self = (void *)cmd->configurator; + int status[200]; + size_t status_len = 0; + int parsed; + const char *url = NULL; + size_t i, j, k; + yoml_t *key, *value; + + for (i = 0; i != hash->data.mapping.size; ++i) { + key = hash->data.mapping.elements[i].key; + value = hash->data.mapping.elements[i].value; + if (key->type != YOML_TYPE_SCALAR) + goto UnknownKeyError; + if (strcmp(key->data.scalar, "status") == 0) { + if (status_len != 0) + goto KeyAlreadyDefinedError; + + if (value->type == YOML_TYPE_SEQUENCE) { + if (value->data.sequence.size == 0) { + h2o_configurator_errprintf(cmd, value, "status sequence must not be empty"); + return -1; + } + for (j = 0; j != value->data.sequence.size; ++j) { + if (scan_and_check_status(cmd, value->data.sequence.elements[j], &parsed) != 0) + return -1; + /* check the scanned status hasn't already appeared */ + for (k = 0; k != status_len; ++k) { + if (status[k] == parsed) { + h2o_configurator_errprintf(cmd, value, "status %d appears multiple times", status[k]); + return -1; + } + } + status[status_len++] = parsed; + } + } else { + if (scan_and_check_status(cmd, value, &parsed) != 0) + return -1; + status[status_len++] = parsed; + } + + } else if (strcmp(key->data.scalar, "url") == 0) { + if (url != NULL) + goto KeyAlreadyDefinedError; + if (value->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, value, "URL must be a scalar"); + return -1; + } + url = value->data.scalar; + } else { + goto UnknownKeyError; + } + } + + if (status_len == 0) { + h2o_configurator_errprintf(cmd, hash, "mandatory key `status` is not defined"); + return -1; + } + if (url == NULL) { + h2o_configurator_errprintf(cmd, hash, "mandatory key `url` is not defined"); + return -1; + } + + h2o_iovec_t _url = h2o_strdup(&self->pool, url, SIZE_MAX); + for (i = 0; i != status_len; ++i){ + /* register */ + h2o_vector_reserve(&self->pool, self->vars, self->vars->size + 1); + h2o_errordoc_t *errordoc = self->vars->entries + self->vars->size++; + errordoc->status = status[i]; + errordoc->url = _url; + } + + return 0; + +UnknownKeyError: + h2o_configurator_errprintf(cmd, key, "key must be either of: `status`, `url`"); + return -1; +KeyAlreadyDefinedError: + h2o_configurator_errprintf(cmd, key, "the key cannot be defined more than once"); + return -1; +} + +static int on_config_errordoc(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + switch (node->type) { + case YOML_TYPE_SEQUENCE: { + size_t i; + for (i = 0; i != node->data.sequence.size; ++i) { + yoml_t *e = node->data.sequence.elements[i]; + if (e->type != YOML_TYPE_MAPPING) { + h2o_configurator_errprintf(cmd, e, "element must be a mapping"); + return -1; + } + if (register_errordoc(cmd, ctx, e) != 0) + return -1; + } + return 0; + } + case YOML_TYPE_MAPPING: + return register_errordoc(cmd, ctx, node); + default: + break; + } + + h2o_configurator_errprintf(cmd, node, "argument must be either of: sequence, mapping"); + return -1; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct errordoc_configurator_t *self = (void *)_self; + + if (self->vars == self->_vars_stack) { + /* entering global level */ + h2o_mem_init_pool(&self->pool); + } + + /* copy vars */ + memset(&self->vars[1], 0, sizeof(self->vars[1])); + h2o_vector_reserve(&self->pool, &self->vars[1], self->vars[0].size); + h2o_memcpy(self->vars[1].entries, self->vars[0].entries, sizeof(self->vars[0].entries[0]) * self->vars[0].size); + self->vars[1].size = self->vars[0].size; + + ++self->vars; + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct errordoc_configurator_t *self = (void *)_self; + + if (ctx->pathconf != NULL && self->vars->size != 0) + h2o_errordoc_register(ctx->pathconf, self->vars->entries, self->vars->size); + + --self->vars; + if (self->vars == self->_vars_stack) { + /* exitting global level */ + h2o_mem_clear_pool(&self->pool); + } + + return 0; +} + +void h2o_errordoc_register_configurator(h2o_globalconf_t *conf) +{ + struct errordoc_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + /* set default vars */ + c->vars = c->_vars_stack; + + /* setup handlers */ + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + + /* reproxy: ON | OFF */ + h2o_configurator_define_command(&c->super, "error-doc", H2O_CONFIGURATOR_FLAG_ALL_LEVELS, on_config_errordoc); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/expires.c b/web/server/h2o/libh2o/lib/handler/configurator/expires.c new file mode 100644 index 000000000..01d404dd5 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/expires.c @@ -0,0 +1,123 @@ +/* + * 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 <inttypes.h> +#include <stdio.h> +#include <string.h> +#include "h2o.h" +#include "h2o/configurator.h" + +struct expires_configurator_t { + h2o_configurator_t super; + h2o_expires_args_t **args; + h2o_expires_args_t *_args_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config_expires(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct expires_configurator_t *self = (void *)cmd->configurator; + uint64_t value; + char unit[32]; + + if (strcasecmp(node->data.scalar, "OFF") == 0) { + free(*self->args); + *self->args = NULL; + } else if (sscanf(node->data.scalar, "%" SCNu64 " %31s", &value, unit) == 2) { + /* convert value to seconds depending on the unit */ + if (strncasecmp(unit, H2O_STRLIT("second")) == 0) { + /* ok */ + } else if (strncasecmp(unit, H2O_STRLIT("minute")) == 0) { + value *= 60; + } else if (strncasecmp(unit, H2O_STRLIT("hour")) == 0) { + value *= 60 * 60; + } else if (strncasecmp(unit, H2O_STRLIT("day")) == 0) { + value *= 24 * 60 * 60; + } else if (strncasecmp(unit, H2O_STRLIT("month")) == 0) { + value *= 30 * 24 * 60 * 60; + } else if (strncasecmp(unit, H2O_STRLIT("year")) == 0) { + value *= 365 * 30 * 24 * 60 * 60; + } else { + /* TODO add support for H2O_EXPIRES_MODE_MAX_ABSOLUTE that sets the Expires header? */ + h2o_configurator_errprintf(cmd, node, "unknown unit:`%s` (see --help)", unit); + return -1; + } + /* save the value */ + if (*self->args == NULL) + *self->args = h2o_mem_alloc(sizeof(**self->args)); + (*self->args)->mode = H2O_EXPIRES_MODE_MAX_AGE; + (*self->args)->data.max_age = value; + } else { + h2o_configurator_errprintf(cmd, node, + "failed to parse the value, should be in form of: `<number> <unit>` or `OFF` (see --help)"); + return -1; + } + + return 0; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct expires_configurator_t *self = (void *)_self; + + if (self->args[0] != NULL) { + /* duplicate */ + assert(self->args[0]->mode == H2O_EXPIRES_MODE_MAX_AGE); + self->args[1] = h2o_mem_alloc(sizeof(**self->args)); + *self->args[1] = *self->args[0]; + } else { + self->args[1] = NULL; + } + ++self->args; + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct expires_configurator_t *self = (void *)_self; + + if (*self->args != NULL) { + /* setup */ + if (ctx->pathconf != NULL) { + h2o_expires_register(ctx->pathconf, *self->args); + } + /* destruct */ + assert((*self->args)->mode == H2O_EXPIRES_MODE_MAX_AGE); + free(*self->args); + *self->args = NULL; + } + + --self->args; + return 0; +} + +void h2o_expires_register_configurator(h2o_globalconf_t *conf) +{ + struct expires_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + /* set default vars */ + c->args = c->_args_stack; + + /* setup handlers */ + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + h2o_configurator_define_command(&c->super, "expires", H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_expires); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/fastcgi.c b/web/server/h2o/libh2o/lib/handler/configurator/fastcgi.c new file mode 100644 index 000000000..bf89b7b26 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/fastcgi.c @@ -0,0 +1,388 @@ +/* + * 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 <arpa/inet.h> +#include <errno.h> +#include <fcntl.h> +#include <inttypes.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <pwd.h> +#include <stdlib.h> +#include <sys/stat.h> +#include <sys/un.h> +#include "h2o.h" +#include "h2o/configurator.h" +#include "h2o/serverutil.h" + +struct fastcgi_configurator_t { + h2o_configurator_t super; + h2o_fastcgi_config_vars_t *vars; + h2o_fastcgi_config_vars_t _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config_timeout_io(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)cmd->configurator; + return h2o_configurator_scanf(cmd, node, "%" SCNu64, &self->vars->io_timeout); +} + +static int on_config_timeout_keepalive(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)cmd->configurator; + return h2o_configurator_scanf(cmd, node, "%" SCNu64, &self->vars->keepalive_timeout); +} + +static int on_config_document_root(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)cmd->configurator; + + if (node->data.scalar[0] == '\0') { + /* unset */ + self->vars->document_root = h2o_iovec_init(NULL, 0); + } else if (node->data.scalar[0] == '/') { + /* set */ + self->vars->document_root = h2o_iovec_init(node->data.scalar, strlen(node->data.scalar)); + } else { + h2o_configurator_errprintf(cmd, node, "value does not start from `/`"); + return -1; + } + return 0; +} + +static int on_config_send_delegated_uri(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)cmd->configurator; + ssize_t v; + + if ((v = h2o_configurator_get_one_of(cmd, node, "OFF,ON")) == -1) + return -1; + self->vars->send_delegated_uri = (int)v; + return 0; +} + +static int on_config_connect(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)cmd->configurator; + const char *hostname = "127.0.0.1", *servname = NULL, *type = "tcp"; + + /* fetch servname (and hostname) */ + switch (node->type) { + case YOML_TYPE_SCALAR: + servname = node->data.scalar; + break; + case YOML_TYPE_MAPPING: { + yoml_t *t; + if ((t = yoml_get(node, "host")) != NULL) { + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, t, "`host` is not a string"); + return -1; + } + hostname = t->data.scalar; + } + if ((t = yoml_get(node, "port")) == NULL) { + h2o_configurator_errprintf(cmd, node, "cannot find mandatory property `port`"); + return -1; + } + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, node, "`port` is not a string"); + return -1; + } + servname = t->data.scalar; + if ((t = yoml_get(node, "type")) != NULL) { + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, t, "`type` is not a string"); + return -1; + } + type = t->data.scalar; + } + } break; + default: + h2o_configurator_errprintf(cmd, node, + "value must be a string or a mapping (with keys: `port` and optionally `host` and `type`)"); + return -1; + } + + if (strcmp(type, "unix") == 0) { + /* unix socket */ + struct sockaddr_un sa; + memset(&sa, 0, sizeof(sa)); + if (strlen(servname) >= sizeof(sa.sun_path)) { + h2o_configurator_errprintf(cmd, node, "path:%s is too long as a unix socket name", servname); + return -1; + } + sa.sun_family = AF_UNIX; + strcpy(sa.sun_path, servname); + h2o_fastcgi_register_by_address(ctx->pathconf, (void *)&sa, sizeof(sa), self->vars); + } else if (strcmp(type, "tcp") == 0) { + /* tcp socket */ + uint16_t port; + if (sscanf(servname, "%" SCNu16, &port) != 1) { + h2o_configurator_errprintf(cmd, node, "invalid port number:%s", servname); + return -1; + } + h2o_fastcgi_register_by_hostport(ctx->pathconf, hostname, port, self->vars); + } else { + h2o_configurator_errprintf(cmd, node, "unknown listen type: %s", type); + return -1; + } + + return 0; +} + +static int create_spawnproc(h2o_configurator_command_t *cmd, yoml_t *node, const char *dirname, char *const *argv, + struct sockaddr_un *sa, struct passwd *pw) +{ + int ret, listen_fd = -1, pipe_fds[2] = {-1, -1}; + + /* build socket path */ + sa->sun_family = AF_UNIX; + ret = snprintf(sa->sun_path, sizeof(sa->sun_path), "%s/_", dirname); + if (ret < 0 || ret >= sizeof(sa->sun_path)) { + h2o_configurator_errprintf(cmd, node, "unix socket path too long: %s", dirname); + goto Error; + } + + /* create socket */ + if ((listen_fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { + h2o_configurator_errprintf(cmd, node, "socket(2) failed: %s", strerror(errno)); + goto Error; + } + if (bind(listen_fd, (void *)sa, sizeof(*sa)) != 0) { + h2o_configurator_errprintf(cmd, node, "bind(2) failed: %s", strerror(errno)); + goto Error; + } + if (listen(listen_fd, H2O_SOMAXCONN) != 0) { + h2o_configurator_errprintf(cmd, node, "listen(2) failed: %s", strerror(errno)); + goto Error; + } + /* change ownership of socket */ + if (pw != NULL && chown(sa->sun_path, pw->pw_uid, pw->pw_gid) != 0) { + h2o_configurator_errprintf(cmd, node, "chown(2) failed to change ownership of socket:%s:%s", sa->sun_path, strerror(errno)); + goto Error; + } + + /* create pipe which is used to notify the termination of the server */ + if (pipe(pipe_fds) != 0) { + h2o_configurator_errprintf(cmd, node, "pipe(2) failed: %s", strerror(errno)); + pipe_fds[0] = -1; + pipe_fds[1] = -1; + goto Error; + } + if (fcntl(pipe_fds[1], F_SETFD, FD_CLOEXEC) < 0) + goto Error; + + /* spawn */ + int mapped_fds[] = {listen_fd, 0, /* listen_fd to 0 */ + pipe_fds[0], 5, /* pipe_fds[0] to 5 */ + -1}; + pid_t pid = h2o_spawnp(argv[0], argv, mapped_fds, 0); + if (pid == -1) { + fprintf(stderr, "[lib/handler/fastcgi.c] failed to launch helper program %s:%s\n", argv[0], strerror(errno)); + goto Error; + } + + close(listen_fd); + listen_fd = -1; + close(pipe_fds[0]); + pipe_fds[0] = -1; + + return pipe_fds[1]; + +Error: + if (pipe_fds[0] != -1) + close(pipe_fds[0]); + if (pipe_fds[1]) + close(pipe_fds[1]); + if (listen_fd != -1) + close(listen_fd); + unlink(sa->sun_path); + return -1; +} + +static void spawnproc_on_dispose(h2o_fastcgi_handler_t *handler, void *data) +{ + int pipe_fd = (int)((char *)data - (char *)NULL); + close(pipe_fd); +} + +static int on_config_spawn(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)cmd->configurator; + char *spawn_user = NULL, *spawn_cmd; + char *kill_on_close_cmd_path = NULL, *setuidgid_cmd_path = NULL; + char dirname[] = "/tmp/h2o.fcgisock.XXXXXX"; + char *argv[10]; + int spawner_fd; + struct sockaddr_un sa; + h2o_fastcgi_config_vars_t config_vars; + int ret = -1; + struct passwd h2o_user_pwbuf, *h2o_user_pw; + char h2o_user_buf[65536]; + + memset(&sa, 0, sizeof(sa)); + + switch (node->type) { + case YOML_TYPE_SCALAR: + spawn_user = ctx->globalconf->user; + spawn_cmd = node->data.scalar; + break; + case YOML_TYPE_MAPPING: { + yoml_t *t; + if ((t = yoml_get(node, "command")) == NULL) { + h2o_configurator_errprintf(cmd, node, "mandatory attribute `command` does not exist"); + return -1; + } + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, node, "attribute `command` must be scalar"); + return -1; + } + spawn_cmd = t->data.scalar; + spawn_user = ctx->globalconf->user; + if ((t = yoml_get(node, "user")) != NULL) { + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, node, "attribute `user` must be scalar"); + return -1; + } + spawn_user = t->data.scalar; + } + } break; + default: + h2o_configurator_errprintf(cmd, node, "argument must be scalar or mapping"); + return -1; + } + + /* obtain uid & gid of the client that connects to the FastCGI daemon (i.e. H2O after dropping privileges) */ + if (ctx->globalconf->user != NULL) { + /* change ownership of temporary directory */ + if (getpwnam_r(ctx->globalconf->user, &h2o_user_pwbuf, h2o_user_buf, sizeof(h2o_user_buf), &h2o_user_pw) != 0 || + h2o_user_pw == NULL) { + h2o_configurator_errprintf(cmd, node, "getpwnam_r(3) failed to obtain uid of user:%s", ctx->globalconf->user); + goto Exit; + } + } else { + h2o_user_pw = NULL; + } + + { /* build args */ + size_t i = 0; + argv[i++] = kill_on_close_cmd_path = h2o_configurator_get_cmd_path("share/h2o/kill-on-close"); + argv[i++] = "--rm"; + argv[i++] = dirname; + argv[i++] = "--"; + if (spawn_user != NULL) { + argv[i++] = setuidgid_cmd_path = h2o_configurator_get_cmd_path("share/h2o/setuidgid"); + argv[i++] = spawn_user; + } + argv[i++] = "/bin/sh"; + argv[i++] = "-c"; + argv[i++] = spawn_cmd; + argv[i++] = NULL; + assert(i <= sizeof(argv) / sizeof(argv[0])); + } + + if (ctx->dry_run) { + dirname[0] = '\0'; + spawner_fd = -1; + sa.sun_family = AF_UNIX; + strcpy(sa.sun_path, "/dry-run.nonexistent"); + } else { + /* create temporary directory */ + if (mkdtemp(dirname) == NULL) { + h2o_configurator_errprintf(cmd, node, "mkdtemp(3) failed to create temporary directory:%s:%s", dirname, + strerror(errno)); + dirname[0] = '\0'; + goto Exit; + } + /* change ownership of temporary directory */ + if (h2o_user_pw != NULL && chown(dirname, h2o_user_pw->pw_uid, h2o_user_pw->pw_gid) != 0) { + h2o_configurator_errprintf(cmd, node, "chown(2) failed to change ownership of temporary directory:%s:%s", dirname, + strerror(errno)); + goto Exit; + } + /* launch spawnfcgi command */ + if ((spawner_fd = create_spawnproc(cmd, node, dirname, argv, &sa, h2o_user_pw)) == -1) { + goto Exit; + } + } + + config_vars = *self->vars; + config_vars.callbacks.dispose = spawnproc_on_dispose; + config_vars.callbacks.data = (char *)NULL + spawner_fd; + h2o_fastcgi_register_by_address(ctx->pathconf, (void *)&sa, sizeof(sa), &config_vars); + + ret = 0; +Exit: + if (dirname[0] != '\0') + unlink(dirname); + free(kill_on_close_cmd_path); + free(setuidgid_cmd_path); + return ret; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)_self; + + memcpy(self->vars + 1, self->vars, sizeof(*self->vars)); + ++self->vars; + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct fastcgi_configurator_t *self = (void *)_self; + + --self->vars; + return 0; +} + +void h2o_fastcgi_register_configurator(h2o_globalconf_t *conf) +{ + struct fastcgi_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + /* set default vars */ + c->vars = c->_vars_stack; + c->vars->io_timeout = H2O_DEFAULT_FASTCGI_IO_TIMEOUT; + c->vars->keepalive_timeout = 0; + + /* setup handlers */ + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + + h2o_configurator_define_command(&c->super, "fastcgi.connect", + H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_EXTENSION | H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_connect); + h2o_configurator_define_command(&c->super, "fastcgi.spawn", + H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_EXTENSION | H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_spawn); + h2o_configurator_define_command(&c->super, "fastcgi.timeout.io", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, on_config_timeout_io); + h2o_configurator_define_command(&c->super, "fastcgi.timeout.keepalive", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_timeout_keepalive); + h2o_configurator_define_command(&c->super, "fastcgi.document_root", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_document_root); + h2o_configurator_define_command(&c->super, "fastcgi.send-delegated-uri", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_send_delegated_uri); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/file.c b/web/server/h2o/libh2o/lib/handler/configurator/file.c new file mode 100644 index 000000000..c1c779c68 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/file.c @@ -0,0 +1,197 @@ +/* + * 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.h" +#include "h2o/configurator.h" + +struct st_h2o_file_config_vars_t { + const char **index_files; + int flags; +}; + +struct st_h2o_file_configurator_t { + h2o_configurator_t super; + struct st_h2o_file_config_vars_t *vars; + struct st_h2o_file_config_vars_t _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config_dir(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)cmd->configurator; + + h2o_file_register(ctx->pathconf, node->data.scalar, self->vars->index_files, *ctx->mimemap, self->vars->flags); + return 0; +} + +static int on_config_file(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)cmd->configurator; + h2o_mimemap_type_t *mime_type = + h2o_mimemap_get_type_by_extension(*ctx->mimemap, h2o_get_filext(node->data.scalar, strlen(node->data.scalar))); + h2o_file_register_file(ctx->pathconf, node->data.scalar, mime_type, self->vars->flags); + return 0; +} + +static int on_config_index(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)cmd->configurator; + size_t i; + + free(self->vars->index_files); + self->vars->index_files = h2o_mem_alloc(sizeof(self->vars->index_files[0]) * (node->data.sequence.size + 1)); + for (i = 0; i != node->data.sequence.size; ++i) { + yoml_t *element = node->data.sequence.elements[i]; + if (element->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, element, "argument must be a sequence of scalars"); + return -1; + } + self->vars->index_files[i] = element->data.scalar; + } + self->vars->index_files[i] = NULL; + + return 0; +} + +static int on_config_etag(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)cmd->configurator; + + switch (h2o_configurator_get_one_of(cmd, node, "OFF,ON")) { + case 0: /* off */ + self->vars->flags |= H2O_FILE_FLAG_NO_ETAG; + break; + case 1: /* on */ + self->vars->flags &= ~H2O_FILE_FLAG_NO_ETAG; + break; + default: /* error */ + return -1; + } + + return 0; +} + +static int on_config_send_compressed(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)cmd->configurator; + + switch (h2o_configurator_get_one_of(cmd, node, "OFF,ON,gunzip")) { + case 0: /* off */ + self->vars->flags &= ~H2O_FILE_FLAG_SEND_COMPRESSED; + break; + case 1: /* on */ + self->vars->flags |= H2O_FILE_FLAG_SEND_COMPRESSED; + break; + case 2: /* gunzip */ + self->vars->flags |= (H2O_FILE_FLAG_SEND_COMPRESSED | H2O_FILE_FLAG_GUNZIP); + break; + default: /* error */ + return -1; + } + + return 0; +} + +static int on_config_dir_listing(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)cmd->configurator; + + switch (h2o_configurator_get_one_of(cmd, node, "OFF,ON")) { + case 0: /* off */ + self->vars->flags &= ~H2O_FILE_FLAG_DIR_LISTING; + break; + case 1: /* on */ + self->vars->flags |= H2O_FILE_FLAG_DIR_LISTING; + break; + default: /* error */ + return -1; + } + + return 0; +} + +static const char **dup_strlist(const char **s) +{ + size_t i; + const char **ret; + + for (i = 0; s[i] != NULL; ++i) + ; + ret = h2o_mem_alloc(sizeof(*ret) * (i + 1)); + for (i = 0; s[i] != NULL; ++i) + ret[i] = s[i]; + ret[i] = NULL; + + return ret; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)_self; + ++self->vars; + self->vars[0].index_files = dup_strlist(self->vars[-1].index_files); + self->vars[0].flags = self->vars[-1].flags; + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_h2o_file_configurator_t *self = (void *)_self; + free(self->vars->index_files); + --self->vars; + return 0; +} + +void h2o_file_register_configurator(h2o_globalconf_t *globalconf) +{ + struct st_h2o_file_configurator_t *self = (void *)h2o_configurator_create(globalconf, sizeof(*self)); + + self->super.enter = on_config_enter; + self->super.exit = on_config_exit; + self->vars = self->_vars_stack; + self->vars->index_files = h2o_file_default_index_files; + + h2o_configurator_define_command(&self->super, "file.dir", H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR | + H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_dir); + h2o_configurator_define_command(&self->super, "file.file", H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR | + H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_file); + h2o_configurator_define_command(&self->super, "file.index", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_SEQUENCE, + on_config_index); + h2o_configurator_define_command(&self->super, "file.etag", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_etag); + h2o_configurator_define_command(&self->super, "file.send-compressed", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_send_compressed); + h2o_configurator_define_command(&self->super, "file.send-gzip", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_send_compressed); + h2o_configurator_define_command(&self->super, "file.dirlisting", + (H2O_CONFIGURATOR_FLAG_ALL_LEVELS & ~H2O_CONFIGURATOR_FLAG_EXTENSION) | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_dir_listing); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/headers.c b/web/server/h2o/libh2o/lib/handler/configurator/headers.c new file mode 100644 index 000000000..68536c052 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/headers.c @@ -0,0 +1,74 @@ +/* + * 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 <string.h> +#include "h2o.h" +#include "h2o/configurator.h" + +struct headers_configurator_t { + h2o_configurator_t super; + h2o_headers_command_t **cmds, *_cmd_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct headers_configurator_t *self = (void *)_self; + + self->cmds[1] = self->cmds[0]; + if (self->cmds[1] != NULL) + h2o_mem_addref_shared(self->cmds[1]); + + ++self->cmds; + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct headers_configurator_t *self = (void *)_self; + + if (ctx->pathconf != NULL && *self->cmds != NULL) { + if (*self->cmds != NULL) + h2o_mem_addref_shared(*self->cmds); + h2o_headers_register(ctx->pathconf, *self->cmds); + } + + if (*self->cmds != NULL) + h2o_mem_release_shared(*self->cmds); + --self->cmds; + return 0; +} + +static h2o_headers_command_t **get_headers_commands(h2o_configurator_t *_self) +{ + struct headers_configurator_t *self = (void *)_self; + return self->cmds; +} + +void h2o_headers_register_configurator(h2o_globalconf_t *conf) +{ + struct headers_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + + h2o_configurator_define_headers_commands(conf, &c->super, "header", get_headers_commands); + c->cmds = c->_cmd_stack; +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/headers_util.c b/web/server/h2o/libh2o/lib/handler/configurator/headers_util.c new file mode 100644 index 000000000..c05b9b7c2 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/headers_util.c @@ -0,0 +1,143 @@ +#include "h2o.h" +#include "h2o/configurator.h" + +struct headers_util_configurator_t { + h2o_configurator_t super; + h2o_configurator_t *child; + h2o_configurator_get_headers_commands_cb get_commands; +}; + +static int extract_name(const char *src, size_t len, h2o_iovec_t **_name) +{ + h2o_iovec_t name; + const h2o_token_t *name_token; + + name = h2o_str_stripws(src, len); + if (name.len == 0) + return -1; + + name = h2o_strdup(NULL, name.base, name.len); + h2o_strtolower(name.base, name.len); + + if ((name_token = h2o_lookup_token(name.base, name.len)) != NULL) { + *_name = (h2o_iovec_t *)&name_token->buf; + free(name.base); + } else { + *_name = h2o_mem_alloc(sizeof(**_name)); + **_name = name; + } + + return 0; +} + +static int extract_name_value(const char *src, h2o_iovec_t **name, h2o_iovec_t *value) +{ + const char *colon = strchr(src, ':'); + + if (colon == NULL) + return -1; + + if (extract_name(src, colon - src, name) != 0) + return -1; + *value = h2o_str_stripws(colon + 1, strlen(colon + 1)); + *value = h2o_strdup(NULL, value->base, value->len); + + return 0; +} + +static int add_cmd(h2o_configurator_command_t *cmd, yoml_t *node, int cmd_id, h2o_iovec_t *name, h2o_iovec_t value, + h2o_headers_command_t **cmds) +{ + if (h2o_iovec_is_token(name)) { + const h2o_token_t *token = (void *)name; + if (h2o_headers_is_prohibited_name(token)) { + h2o_configurator_errprintf(cmd, node, "the named header cannot be rewritten"); + return -1; + } + } + + h2o_headers_append_command(cmds, cmd_id, name, value); + return 0; +} + +static int on_config_header_2arg(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, int cmd_id, yoml_t *node, + h2o_headers_command_t **headers_cmds) +{ + h2o_iovec_t *name, value; + + if (extract_name_value(node->data.scalar, &name, &value) != 0) { + h2o_configurator_errprintf(cmd, node, "failed to parse the value; should be in form of `name: value`"); + return -1; + } + if (add_cmd(cmd, node, cmd_id, name, value, headers_cmds) != 0) { + if (!h2o_iovec_is_token(name)) + free(name->base); + free(value.base); + return -1; + } + return 0; +} + +static int on_config_header_unset(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + h2o_iovec_t *name; + struct headers_util_configurator_t *self = (void *)cmd->configurator; + + if (extract_name(node->data.scalar, strlen(node->data.scalar), &name) != 0) { + h2o_configurator_errprintf(cmd, node, "invalid header name"); + return -1; + } + if (add_cmd(cmd, node, H2O_HEADERS_CMD_UNSET, name, (h2o_iovec_t){NULL}, self->get_commands(self->child)) != 0) { + if (!h2o_iovec_is_token(name)) + free(name->base); + return -1; + } + return 0; +} + +#define DEFINE_2ARG(fn, cmd_id) \ + static int fn(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) \ + { \ + struct headers_util_configurator_t *self = (void *)cmd->configurator; \ + return on_config_header_2arg(cmd, ctx, cmd_id, node, self->get_commands(self->child)); \ + } + +DEFINE_2ARG(on_config_header_add, H2O_HEADERS_CMD_ADD) +DEFINE_2ARG(on_config_header_append, H2O_HEADERS_CMD_APPEND) +DEFINE_2ARG(on_config_header_merge, H2O_HEADERS_CMD_MERGE) +DEFINE_2ARG(on_config_header_set, H2O_HEADERS_CMD_SET) +DEFINE_2ARG(on_config_header_setifempty, H2O_HEADERS_CMD_SETIFEMPTY) + +#undef DEFINE_2ARG + +void h2o_configurator_define_headers_commands(h2o_globalconf_t *global_conf, h2o_configurator_t *conf, const char *prefix, + h2o_configurator_get_headers_commands_cb get_commands) +{ + struct headers_util_configurator_t *c = (void *)h2o_configurator_create(global_conf, sizeof(*c)); + c->child = conf; + c->get_commands = get_commands; + size_t prefix_len = strlen(prefix); + +#define DEFINE_CMD_NAME(name, suffix) \ + char *name = h2o_mem_alloc(prefix_len + sizeof(suffix)); \ + memcpy(name, prefix, prefix_len); \ + memcpy(name + prefix_len, suffix, sizeof(suffix)) + + DEFINE_CMD_NAME(add_directive, ".add"); + DEFINE_CMD_NAME(append_directive, ".append"); + DEFINE_CMD_NAME(merge_directive, ".merge"); + DEFINE_CMD_NAME(set_directive, ".set"); + DEFINE_CMD_NAME(setifempty_directive, ".setifempty"); + DEFINE_CMD_NAME(unset_directive, ".unset"); +#undef DEFINE_CMD_NAME + +#define DEFINE_CMD(name, cb) \ + h2o_configurator_define_command(&c->super, name, H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, cb) + DEFINE_CMD(add_directive, on_config_header_add); + DEFINE_CMD(append_directive, on_config_header_append); + DEFINE_CMD(merge_directive, on_config_header_merge); + DEFINE_CMD(set_directive, on_config_header_set); + DEFINE_CMD(setifempty_directive, on_config_header_setifempty); + DEFINE_CMD(unset_directive, on_config_header_unset); +#undef DEFINE_CMD +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/http2_debug_state.c b/web/server/h2o/libh2o/lib/handler/configurator/http2_debug_state.c new file mode 100644 index 000000000..419da9de8 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/http2_debug_state.c @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2016 DeNA Co., Ltd., Ichito Nagata + * + * 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.h" +#include "h2o/configurator.h" + +static int on_config_debug_state(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + switch (h2o_configurator_get_one_of(cmd, node, "minimum,hpack")) { + case 0: /* minimum */ + h2o_http2_debug_state_register(ctx->hostconf, 0); + return 0; + case 1: /* with hpack state*/ + h2o_http2_debug_state_register(ctx->hostconf, 1); + return 0; + default: /* error */ + return -1; + } +} + +void h2o_http2_debug_state_register_configurator(h2o_globalconf_t *conf) +{ + struct st_h2o_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + h2o_configurator_define_command(c, "http2-debug-state", H2O_CONFIGURATOR_FLAG_HOST | H2O_CONFIGURATOR_FLAG_DEFERRED | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_debug_state); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/mruby.c b/web/server/h2o/libh2o/lib/handler/configurator/mruby.c new file mode 100644 index 000000000..1cef8f499 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/mruby.c @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2015 DeNA Co., Ltd., Kazuho Oku, Ryosuke Matsumoto + * + * 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 <stdio.h> +#include <stdlib.h> +#include "h2o.h" +#include "h2o/configurator.h" +#include "h2o/mruby_.h" + +struct mruby_configurator_t { + h2o_configurator_t super; + h2o_mruby_config_vars_t *vars; + h2o_mruby_config_vars_t _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; + mrb_state *mrb; /* will be lazily initialized */ +}; + +static int compile_test(mrb_state *mrb, h2o_mruby_config_vars_t *config, char *errbuf) +{ + mrb_value result = h2o_mruby_compile_code(mrb, config, errbuf); + int ok = !mrb_nil_p(result); + return ok; +} + +static mrb_state *get_mrb(struct mruby_configurator_t *self) +{ + if (self->mrb == NULL) { + self->mrb = mrb_open(); + if (self->mrb == NULL) { + fprintf(stderr, "%s: no memory\n", H2O_MRUBY_MODULE_NAME); + abort(); + } + h2o_mruby_setup_globals(self->mrb); + } + return self->mrb; +} + +static int on_config_mruby_handler(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct mruby_configurator_t *self = (void *)cmd->configurator; + + /* set source */ + self->vars->source = h2o_strdup(NULL, node->data.scalar, SIZE_MAX); + self->vars->path = node->filename; + self->vars->lineno = (int)node->line + 1; + + /* check if there is any error in source */ + char errbuf[1024]; + if (!compile_test(get_mrb(self), self->vars, errbuf)) { + h2o_configurator_errprintf(cmd, node, "ruby compile error:%s", errbuf); + return -1; + } + + /* register */ + h2o_mruby_register(ctx->pathconf, self->vars); + + return 0; +} + +static int on_config_mruby_handler_file(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct mruby_configurator_t *self = (void *)cmd->configurator; + FILE *fp = NULL; + h2o_iovec_t buf = {NULL}; + int ret = -1; + + /* open and read file */ + if ((fp = fopen(node->data.scalar, "rt")) == NULL) { + h2o_configurator_errprintf(cmd, node, "failed to open file: %s:%s", node->data.scalar, strerror(errno)); + goto Exit; + } + while (!feof(fp)) { + buf.base = h2o_mem_realloc(buf.base, buf.len + 65536); + buf.len += fread(buf.base + buf.len, 1, 65536, fp); + if (ferror(fp)) { + h2o_configurator_errprintf(cmd, node, "I/O error occurred while reading file:%s:%s", node->data.scalar, + strerror(errno)); + goto Exit; + } + } + + /* set source */ + self->vars->source = buf; + buf.base = NULL; + self->vars->path = node->data.scalar; /* the value is retained until the end of the configuration phase */ + self->vars->lineno = 0; + + /* check if there is any error in source */ + char errbuf[1024]; + if (!compile_test(get_mrb(self), self->vars, errbuf)) { + h2o_configurator_errprintf(cmd, node, "failed to compile file:%s:%s", node->data.scalar, errbuf); + goto Exit; + } + + /* register */ + h2o_mruby_register(ctx->pathconf, self->vars); + + ret = 0; + +Exit: + if (fp != NULL) + fclose(fp); + if (buf.base != NULL) + free(buf.base); + return ret; +} + +static int on_config_mruby_handler_path(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + h2o_configurator_errprintf(cmd, node, "the command has been removed; see https://github.com/h2o/h2o/pull/467"); + return -1; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct mruby_configurator_t *self = (void *)_self; + + memcpy(self->vars + 1, self->vars, sizeof(*self->vars)); + ++self->vars; + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct mruby_configurator_t *self = (void *)_self; + + /* free if the to-be-exitted frame level contains a different source */ + if (self->vars[-1].source.base != self->vars[0].source.base) + free(self->vars->source.base); + + --self->vars; + + /* release mrb only when global configuration exited */ + if (self->mrb != NULL && ctx->parent == NULL) { + mrb_close(self->mrb); + self->mrb = NULL; + } + + return 0; +} + +void h2o_mruby_register_configurator(h2o_globalconf_t *conf) +{ + struct mruby_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + c->vars = c->_vars_stack; + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + + h2o_configurator_define_command(&c->super, "mruby.handler", H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_DEFERRED | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_mruby_handler); + h2o_configurator_define_command(&c->super, "mruby.handler-file", H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_DEFERRED | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_mruby_handler_file); + h2o_configurator_define_command(&c->super, "mruby.handler_path", H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_DEFERRED, + on_config_mruby_handler_path); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/proxy.c b/web/server/h2o/libh2o/lib/handler/configurator/proxy.c new file mode 100644 index 000000000..cfc9cbf40 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/proxy.c @@ -0,0 +1,392 @@ +/* + * 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 <inttypes.h> +#include <errno.h> +#include <stdio.h> +#include <openssl/crypto.h> +#include <openssl/err.h> +#include <openssl/ssl.h> +#include "h2o.h" +#include "h2o/configurator.h" + +struct proxy_configurator_t { + h2o_configurator_t super; + h2o_proxy_config_vars_t *vars; + h2o_proxy_config_vars_t _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config_timeout_io(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + return h2o_configurator_scanf(cmd, node, "%" SCNu64, &self->vars->io_timeout); +} + +static int on_config_timeout_keepalive(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + return h2o_configurator_scanf(cmd, node, "%" SCNu64, &self->vars->keepalive_timeout); +} + +static int on_config_preserve_host(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + self->vars->preserve_host = (int)ret; + return 0; +} + +static int on_config_proxy_protocol(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + self->vars->use_proxy_protocol = (int)ret; + return 0; +} + +static int on_config_websocket_timeout(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + return h2o_configurator_scanf(cmd, node, "%" SCNu64, &self->vars->websocket.timeout); +} + +static int on_config_websocket(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + self->vars->websocket.enabled = (int)ret; + return 0; +} + +static SSL_CTX *create_ssl_ctx(void) +{ + SSL_CTX *ctx = SSL_CTX_new(SSLv23_client_method()); + SSL_CTX_set_options(ctx, SSL_CTX_get_options(ctx) | SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3); + return ctx; +} + +static h2o_cache_t *create_ssl_session_cache(size_t capacity, uint64_t duration) +{ + return h2o_cache_create(H2O_CACHE_FLAG_MULTITHREADED, capacity, duration, h2o_socket_ssl_destroy_session_cache_entry); +} + +static void update_ssl_ctx(SSL_CTX **ctx, X509_STORE *cert_store, int verify_mode, h2o_cache_t **session_cache) +{ + assert(*ctx != NULL); + + /* inherit the properties that weren't specified */ + if (cert_store == NULL) + cert_store = SSL_CTX_get_cert_store(*ctx); + X509_STORE_up_ref(cert_store); + if (verify_mode == -1) + verify_mode = SSL_CTX_get_verify_mode(*ctx); + h2o_cache_t *new_session_cache; + if (session_cache == NULL) { + h2o_cache_t *current = h2o_socket_ssl_get_session_cache(*ctx); + new_session_cache = + current == NULL ? NULL : create_ssl_session_cache(h2o_cache_get_capacity(current), h2o_cache_get_duration(current)); + } else { + new_session_cache = *session_cache; + } + + /* free the existing context */ + if (*ctx != NULL) + SSL_CTX_free(*ctx); + + /* create new ctx */ + *ctx = create_ssl_ctx(); + SSL_CTX_set_cert_store(*ctx, cert_store); + SSL_CTX_set_verify(*ctx, verify_mode, NULL); + if (new_session_cache != NULL) + h2o_socket_ssl_set_session_cache(*ctx, new_session_cache); +} + +static int on_config_ssl_verify_peer(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + + update_ssl_ctx(&self->vars->ssl_ctx, NULL, ret != 0 ? SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT : SSL_VERIFY_NONE, + NULL); + + return 0; +} + +static int on_config_ssl_cafile(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + X509_STORE *store = X509_STORE_new(); + int ret = -1; + + if (X509_STORE_load_locations(store, node->data.scalar, NULL) == 1) { + update_ssl_ctx(&self->vars->ssl_ctx, store, -1, NULL); + ret = 0; + } else { + h2o_configurator_errprintf(cmd, node, "failed to load certificates file:%s", node->data.scalar); + ERR_print_errors_fp(stderr); + } + + X509_STORE_free(store); + return ret; +} + +static int on_config_ssl_session_cache(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + size_t capacity = 0; + uint64_t duration = 0; + h2o_cache_t *current_cache = h2o_socket_ssl_get_session_cache(self->vars->ssl_ctx); + + switch (node->type) { + case YOML_TYPE_SCALAR: + if (strcasecmp(node->data.scalar, "OFF") == 0) { + if (current_cache != NULL) { + /* set the cache NULL */ + h2o_cache_t *empty_cache = NULL; + update_ssl_ctx(&self->vars->ssl_ctx, NULL, -1, &empty_cache); + } + return 0; + } else if (strcasecmp(node->data.scalar, "ON") == 0) { + /* use default values */ + capacity = H2O_DEFAULT_PROXY_SSL_SESSION_CACHE_CAPACITY; + duration = H2O_DEFAULT_PROXY_SSL_SESSION_CACHE_DURATION; + } else { + h2o_configurator_errprintf(cmd, node, "scalar argument must be either of: `OFF`, `ON`"); + return -1; + } + break; + case YOML_TYPE_MAPPING: { + size_t i; + for (i = 0; i != node->data.mapping.size; ++i) { + yoml_t *key = node->data.mapping.elements[i].key; + yoml_t *value = node->data.mapping.elements[i].value; + if (key->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, key, "key must be a scalar"); + return -1; + } + if (strcasecmp(key->data.scalar, "capacity") == 0) { + if (h2o_configurator_scanf(cmd, value, "%zu", &capacity) != 0) + return -1; + if (capacity == 0) { + h2o_configurator_errprintf(cmd, key, "capacity must be greater than zero"); + return -1; + } + } else if (strcasecmp(key->data.scalar, "lifetime") == 0) { + unsigned lifetime = 0; + if (h2o_configurator_scanf(cmd, value, "%u", &lifetime) != 0) + return -1; + if (lifetime == 0) { + h2o_configurator_errprintf(cmd, key, "lifetime must be greater than zero"); + return -1; + } + duration = (uint64_t)lifetime * 1000; + } else { + h2o_configurator_errprintf(cmd, key, "key must be either of: `capacity`, `lifetime`"); + return -1; + } + } + if (capacity == 0 || duration == 0) { + h2o_configurator_errprintf(cmd, node, "`capacity` and `lifetime` are required"); + return -1; + } + } break; + default: + h2o_configurator_errprintf(cmd, node, "node must be a scalar or a mapping"); + return -1; + } + + if (current_cache != NULL) { + size_t current_capacity = h2o_cache_get_capacity(current_cache); + uint64_t current_duration = h2o_cache_get_duration(current_cache); + if (capacity == current_capacity && duration == current_duration) { + /* parameters aren't changed, so reuse it */ + return 0; + } + } + + h2o_cache_t *new_cache = create_ssl_session_cache(capacity, duration); + update_ssl_ctx(&self->vars->ssl_ctx, NULL, -1, &new_cache); + return 0; +} + +static int on_config_reverse_url(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)cmd->configurator; + h2o_url_t parsed; + + if (h2o_url_parse(node->data.scalar, SIZE_MAX, &parsed) != 0) { + h2o_configurator_errprintf(cmd, node, "failed to parse URL: %s\n", node->data.scalar); + return -1; + } + if (self->vars->keepalive_timeout != 0 && self->vars->use_proxy_protocol) { + h2o_configurator_errprintf(cmd, node, "please either set `proxy.use-proxy-protocol` to `OFF` or disable keep-alive by " + "setting `proxy.timeout.keepalive` to zero; the features are mutually exclusive"); + return -1; + } + + if (self->vars->headers_cmds != NULL) + h2o_mem_addref_shared(self->vars->headers_cmds); + + /* register */ + h2o_proxy_register_reverse_proxy(ctx->pathconf, &parsed, self->vars); + + return 0; +} + +static int on_config_emit_x_forwarded_headers(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + ctx->globalconf->proxy.emit_x_forwarded_headers = (int)ret; + return 0; +} + +static int on_config_emit_via_header(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + ctx->globalconf->proxy.emit_via_header = (int)ret; + return 0; +} + +static int on_config_preserve_x_forwarded_proto(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + ctx->globalconf->proxy.preserve_x_forwarded_proto = (int)ret; + return 0; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)_self; + + memcpy(self->vars + 1, self->vars, sizeof(*self->vars)); + if (self->vars[1].headers_cmds != NULL) + h2o_mem_addref_shared(self->vars[1].headers_cmds); + ++self->vars; + + if (ctx->pathconf == NULL && ctx->hostconf == NULL) { + /* is global conf, setup the default SSL context */ + self->vars->ssl_ctx = create_ssl_ctx(); + char *ca_bundle = h2o_configurator_get_cmd_path("share/h2o/ca-bundle.crt"); + if (SSL_CTX_load_verify_locations(self->vars->ssl_ctx, ca_bundle, NULL) != 1) + fprintf(stderr, "Warning: failed to load the default certificates file at %s. Proxying to HTTPS servers may fail.\n", + ca_bundle); + free(ca_bundle); + SSL_CTX_set_verify(self->vars->ssl_ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL); + h2o_cache_t *ssl_session_cache = + create_ssl_session_cache(H2O_DEFAULT_PROXY_SSL_SESSION_CACHE_CAPACITY, H2O_DEFAULT_PROXY_SSL_SESSION_CACHE_DURATION); + h2o_socket_ssl_set_session_cache(self->vars->ssl_ctx, ssl_session_cache); + } else { + SSL_CTX_up_ref(self->vars->ssl_ctx); + } + + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct proxy_configurator_t *self = (void *)_self; + + if (ctx->pathconf == NULL && ctx->hostconf == NULL) { + /* is global conf */ + ctx->globalconf->proxy.io_timeout = self->vars->io_timeout; + ctx->globalconf->proxy.ssl_ctx = self->vars->ssl_ctx; + } else { + SSL_CTX_free(self->vars->ssl_ctx); + } + + if (self->vars->headers_cmds != NULL) + h2o_mem_release_shared(self->vars->headers_cmds); + + --self->vars; + return 0; +} + +static h2o_headers_command_t **get_headers_commands(h2o_configurator_t *_self) +{ + struct proxy_configurator_t *self = (void *)_self; + return &self->vars->headers_cmds; +} + +void h2o_proxy_register_configurator(h2o_globalconf_t *conf) +{ + struct proxy_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + /* set default vars */ + c->vars = c->_vars_stack; + c->vars->io_timeout = H2O_DEFAULT_PROXY_IO_TIMEOUT; + c->vars->keepalive_timeout = 2000; + c->vars->websocket.enabled = 0; /* have websocket proxying disabled by default; until it becomes non-experimental */ + c->vars->websocket.timeout = H2O_DEFAULT_PROXY_WEBSOCKET_TIMEOUT; + + /* setup handlers */ + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + h2o_configurator_define_command( + &c->super, "proxy.reverse.url", + H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR | H2O_CONFIGURATOR_FLAG_DEFERRED, on_config_reverse_url); + h2o_configurator_define_command(&c->super, "proxy.preserve-host", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_preserve_host); + h2o_configurator_define_command(&c->super, "proxy.proxy-protocol", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_proxy_protocol); + h2o_configurator_define_command(&c->super, "proxy.timeout.io", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, on_config_timeout_io); + h2o_configurator_define_command(&c->super, "proxy.timeout.keepalive", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_timeout_keepalive); + h2o_configurator_define_command(&c->super, "proxy.websocket", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, on_config_websocket); + h2o_configurator_define_command(&c->super, "proxy.websocket.timeout", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_websocket_timeout); + h2o_configurator_define_command(&c->super, "proxy.ssl.verify-peer", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_ssl_verify_peer); + h2o_configurator_define_command(&c->super, "proxy.ssl.cafile", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, on_config_ssl_cafile); + h2o_configurator_define_command(&c->super, "proxy.ssl.session-cache", H2O_CONFIGURATOR_FLAG_ALL_LEVELS, + on_config_ssl_session_cache); + h2o_configurator_define_command(&c->super, "proxy.preserve-x-forwarded-proto", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_preserve_x_forwarded_proto); + h2o_configurator_define_command(&c->super, "proxy.emit-x-forwarded-headers", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_emit_x_forwarded_headers); + h2o_configurator_define_command(&c->super, "proxy.emit-via-header", + H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_emit_via_header); + h2o_configurator_define_headers_commands(conf, &c->super, "proxy.header", get_headers_commands); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/redirect.c b/web/server/h2o/libh2o/lib/handler/configurator/redirect.c new file mode 100644 index 000000000..4ebbb99c0 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/redirect.c @@ -0,0 +1,76 @@ +/* + * 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.h" +#include "h2o/configurator.h" + +static int on_config(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + const char *dest; + int status = 302; /* default is temporary redirect */ + int internal = 0; /* default is external redirect */ + yoml_t *t; + + switch (node->type) { + case YOML_TYPE_SCALAR: + dest = node->data.scalar; + break; + case YOML_TYPE_MAPPING: + if ((t = yoml_get(node, "url")) == NULL) { + h2o_configurator_errprintf(cmd, node, "mandatory property `url` is missing"); + return -1; + } + if (t->type != YOML_TYPE_SCALAR) { + h2o_configurator_errprintf(cmd, t, "property `url` must be a string"); + return -1; + } + dest = t->data.scalar; + if ((t = yoml_get(node, "status")) == NULL) { + h2o_configurator_errprintf(cmd, node, "mandatory property `status` is missing"); + return -1; + } + if (h2o_configurator_scanf(cmd, t, "%d", &status) != 0) + return -1; + if (!(300 <= status && status <= 399)) { + h2o_configurator_errprintf(cmd, t, "value of property `status` should be within 300 to 399"); + return -1; + } + if ((t = yoml_get(node, "internal")) != NULL) { + if ((internal = (int)h2o_configurator_get_one_of(cmd, t, "NO,YES")) == -1) + return -1; + } + break; + default: + h2o_configurator_errprintf(cmd, node, "value must be a string or a mapping"); + return -1; + } + + h2o_redirect_register(ctx->pathconf, internal, status, dest); + + return 0; +} + +void h2o_redirect_register_configurator(h2o_globalconf_t *conf) +{ + h2o_configurator_t *c = h2o_configurator_create(conf, sizeof(*c)); + + h2o_configurator_define_command(c, "redirect", H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_DEFERRED, on_config); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/reproxy.c b/web/server/h2o/libh2o/lib/handler/configurator/reproxy.c new file mode 100644 index 000000000..21650e4fb --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/reproxy.c @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2015 Daisuke Maki, 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 <inttypes.h> +#include "h2o.h" +#include "h2o/configurator.h" + +struct config_t { + int enabled; +}; + +struct reproxy_configurator_t { + h2o_configurator_t super; + struct config_t *vars, _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config_reproxy(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct reproxy_configurator_t *self = (void *)cmd->configurator; + + ssize_t ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON"); + if (ret == -1) + return -1; + self->vars->enabled = (int)ret; + + return 0; +} + +static int on_config_enter(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct reproxy_configurator_t *self = (void *)_self; + + self->vars[1] = self->vars[0]; + ++self->vars; + return 0; +} + +static int on_config_exit(h2o_configurator_t *_self, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct reproxy_configurator_t *self = (void *)_self; + + if (ctx->pathconf != NULL && self->vars->enabled != 0) + h2o_reproxy_register(ctx->pathconf); + + --self->vars; + return 0; +} + +void h2o_reproxy_register_configurator(h2o_globalconf_t *conf) +{ + struct reproxy_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + /* set default vars */ + c->vars = c->_vars_stack; + + /* setup handlers */ + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + + /* reproxy: ON | OFF */ + h2o_configurator_define_command(&c->super, "reproxy", H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_reproxy); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/status.c b/web/server/h2o/libh2o/lib/handler/configurator/status.c new file mode 100644 index 000000000..8645aa33d --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/status.c @@ -0,0 +1,87 @@ +/* + * Copyright (c) 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 "h2o.h" +#include "h2o/configurator.h" + +static int on_config_status(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + switch (h2o_configurator_get_one_of(cmd, node, "OFF,ON")) { + case 0: /* OFF */ + return 0; + case 1: /* ON */ + h2o_status_register(ctx->pathconf); + return 0; + default: /* error */ + return -1; + } +} + +struct st_status_configurator { + h2o_configurator_t super; + int stack; + int duration_stats; +}; + +static int on_config_duration_stats(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_status_configurator *c = (void *)cmd->configurator; + ssize_t ret; + switch (ret = h2o_configurator_get_one_of(cmd, node, "OFF,ON")) { + case 0: /* OFF */ + case 1: /* ON */ + c->duration_stats = (int)ret; + return 0; + default: /* error */ + return -1; + } +} + +int on_enter_status(h2o_configurator_t *_conf, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_status_configurator *c = (void *)_conf; + c->stack++; + return 0; +} + +int on_exit_status(h2o_configurator_t *_conf, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct st_status_configurator *c = (void *)_conf; + c->stack--; + if (!c->stack && c->duration_stats) { + h2o_duration_stats_register(ctx->globalconf); + } + return 0; +} + +void h2o_status_register_configurator(h2o_globalconf_t *conf) +{ + struct st_status_configurator *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + c->super.enter = on_enter_status; + c->super.exit = on_exit_status; + + h2o_configurator_define_command(&c->super, "status", H2O_CONFIGURATOR_FLAG_PATH | H2O_CONFIGURATOR_FLAG_DEFERRED | + H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_status); + + h2o_configurator_define_command(&c->super, "duration-stats", H2O_CONFIGURATOR_FLAG_GLOBAL | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_duration_stats); +} diff --git a/web/server/h2o/libh2o/lib/handler/configurator/throttle_resp.c b/web/server/h2o/libh2o/lib/handler/configurator/throttle_resp.c new file mode 100644 index 000000000..61431f756 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/configurator/throttle_resp.c @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2016 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 "h2o.h" +#include "h2o/configurator.h" + +struct throttle_resp_config_vars_t { + int on; +}; + +struct throttle_resp_configurator_t { + h2o_configurator_t super; + struct throttle_resp_config_vars_t *vars, _vars_stack[H2O_CONFIGURATOR_NUM_LEVELS + 1]; +}; + +static int on_config_throttle_resp(h2o_configurator_command_t *cmd, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct throttle_resp_configurator_t *self = (void *)cmd->configurator; + + if ((self->vars->on = (int)h2o_configurator_get_one_of(cmd, node, "OFF,ON")) == -1) + return -1; + return 0; +} + +static int on_config_enter(h2o_configurator_t *configurator, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct throttle_resp_configurator_t *self = (void *)configurator; + + ++self->vars; + self->vars[0] = self->vars[-1]; + return 0; +} + +static int on_config_exit(h2o_configurator_t *configurator, h2o_configurator_context_t *ctx, yoml_t *node) +{ + struct throttle_resp_configurator_t *self = (void *)configurator; + + if (ctx->pathconf != NULL && self->vars->on) + h2o_throttle_resp_register(ctx->pathconf); + + --self->vars; + return 0; +} + +void h2o_throttle_resp_register_configurator(h2o_globalconf_t *conf) +{ + struct throttle_resp_configurator_t *c = (void *)h2o_configurator_create(conf, sizeof(*c)); + + c->super.enter = on_config_enter; + c->super.exit = on_config_exit; + h2o_configurator_define_command(&c->super, "throttle-response", + H2O_CONFIGURATOR_FLAG_ALL_LEVELS | H2O_CONFIGURATOR_FLAG_EXPECT_SCALAR, + on_config_throttle_resp); + c->vars = c->_vars_stack; +} diff --git a/web/server/h2o/libh2o/lib/handler/errordoc.c b/web/server/h2o/libh2o/lib/handler/errordoc.c new file mode 100644 index 000000000..72744f358 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/errordoc.c @@ -0,0 +1,145 @@ +/* + * 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.h" + +/* used to rewrite status code to the original code */ +struct st_errordoc_prefilter_t { + h2o_req_prefilter_t super; + h2o_headers_t req_headers; + int status; + const char *reason; + h2o_headers_t res_headers; +}; + +/* used to capture an error response */ +struct st_errordoc_filter_t { + h2o_filter_t super; + H2O_VECTOR(h2o_errordoc_t) errordocs; +}; + +static void add_header(h2o_mem_pool_t *pool, h2o_headers_t *headers, const h2o_header_t *header) +{ + h2o_vector_reserve(pool, headers, headers->size + 1); + headers->entries[headers->size++] = *header; +} + +static void on_prefilter_setup_stream(h2o_req_prefilter_t *_self, h2o_req_t *req, h2o_ostream_t **slot) +{ + struct st_errordoc_prefilter_t *self = (void *)_self; + h2o_headers_t headers_merged = {NULL}; + size_t i; + + /* restore request headers (for logging) and response status */ + req->headers = self->req_headers; + req->res.status = self->status; + req->res.reason = self->reason; + + /* generate response headers (by merging the preserved and given) */ + for (i = 0; i != self->res_headers.size; ++i) + add_header(&req->pool, &headers_merged, self->res_headers.entries + i); + for (i = 0; i != req->res.headers.size; ++i) { + const h2o_header_t *header = req->res.headers.entries + i; + if (header->name == &H2O_TOKEN_CONTENT_TYPE->buf || header->name == &H2O_TOKEN_CONTENT_LANGUAGE->buf || + header->name == &H2O_TOKEN_SET_COOKIE->buf) + add_header(&req->pool, &headers_merged, header); + } + req->res.headers = headers_merged; + + h2o_setup_next_prefilter(&self->super, req, slot); +} + +static void on_ostream_send(h2o_ostream_t *self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state) +{ + /* nothing to do */ +} + +static int prefilter_is_registered(h2o_req_t *req) +{ + h2o_req_prefilter_t *prefilter; + for (prefilter = req->prefilters; prefilter != NULL; prefilter = prefilter->next) + if (prefilter->on_setup_ostream == on_prefilter_setup_stream) + return 1; + return 0; +} + +static void on_filter_setup_ostream(h2o_filter_t *_self, h2o_req_t *req, h2o_ostream_t **slot) +{ + struct st_errordoc_filter_t *self = (void *)_self; + h2o_errordoc_t *errordoc; + struct st_errordoc_prefilter_t *prefilter; + h2o_iovec_t method; + h2o_ostream_t *ostream; + size_t i; + + if (req->res.status >= 400 && !prefilter_is_registered(req)) { + size_t i; + for (i = 0; i != self->errordocs.size; ++i) { + errordoc = self->errordocs.entries + i; + if (errordoc->status == req->res.status) + goto Found; + } + } + + /* bypass to the next filter */ + h2o_setup_next_ostream(req, slot); + return; + +Found: + /* register prefilter that rewrites the status code after the internal redirect is processed */ + prefilter = (void *)h2o_add_prefilter(req, sizeof(*prefilter)); + prefilter->super.on_setup_ostream = on_prefilter_setup_stream; + prefilter->req_headers = req->headers; + prefilter->status = req->res.status; + prefilter->reason = req->res.reason; + prefilter->res_headers = (h2o_headers_t){NULL}; + for (i = 0; i != req->res.headers.size; ++i) { + const h2o_header_t *header = req->res.headers.entries + i; + if (!(header->name == &H2O_TOKEN_CONTENT_TYPE->buf || header->name == &H2O_TOKEN_CONTENT_LANGUAGE->buf)) + add_header(&req->pool, &prefilter->res_headers, header); + } + /* redirect internally to the error document */ + method = req->method; + if (h2o_memis(method.base, method.len, H2O_STRLIT("POST"))) + method = h2o_iovec_init(H2O_STRLIT("GET")); + req->headers = (h2o_headers_t){NULL}; + req->res.headers = (h2o_headers_t){NULL}; + h2o_send_redirect_internal(req, method, errordoc->url.base, errordoc->url.len, 0); + /* create fake ostream that swallows the contents emitted by the generator */ + ostream = h2o_add_ostream(req, sizeof(*ostream), slot); + ostream->do_send = on_ostream_send; +} + +void h2o_errordoc_register(h2o_pathconf_t *pathconf, h2o_errordoc_t *errdocs, size_t cnt) +{ + struct st_errordoc_filter_t *self = (void *)h2o_create_filter(pathconf, sizeof(*self)); + size_t i; + + self->super.on_setup_ostream = on_filter_setup_ostream; + h2o_vector_reserve(NULL, &self->errordocs, cnt); + self->errordocs.size = cnt; + for (i = 0; i != cnt; ++i) { + const h2o_errordoc_t *src = errdocs + i; + h2o_errordoc_t *dst = self->errordocs.entries + i; + dst->status = src->status; + dst->url = h2o_strdup(NULL, src->url.base, src->url.len); + } +} diff --git a/web/server/h2o/libh2o/lib/handler/expires.c b/web/server/h2o/libh2o/lib/handler/expires.c new file mode 100644 index 000000000..c77225649 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/expires.c @@ -0,0 +1,84 @@ +/* + * 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 <inttypes.h> +#include <stdio.h> +#include <stdlib.h> +#include "h2o.h" + +struct st_expires_t { + h2o_filter_t super; + int mode; + h2o_iovec_t value; +}; + +static void on_setup_ostream(h2o_filter_t *_self, h2o_req_t *req, h2o_ostream_t **slot) +{ + struct st_expires_t *self = (void *)_self; + + switch (req->res.status) { + case 200: + case 201: + case 204: + case 206: + case 301: + case 302: + case 303: + case 304: + case 307: + switch (self->mode) { + case H2O_EXPIRES_MODE_ABSOLUTE: + h2o_set_header(&req->pool, &req->res.headers, H2O_TOKEN_EXPIRES, self->value.base, self->value.len, 0); + break; + case H2O_EXPIRES_MODE_MAX_AGE: + h2o_set_header_token(&req->pool, &req->res.headers, H2O_TOKEN_CACHE_CONTROL, self->value.base, self->value.len); + break; + default: + assert(0); + break; + } + break; + default: + break; + } + + h2o_setup_next_ostream(req, slot); +} + +void h2o_expires_register(h2o_pathconf_t *pathconf, h2o_expires_args_t *args) +{ + struct st_expires_t *self = (void *)h2o_create_filter(pathconf, sizeof(*self)); + self->super.on_setup_ostream = on_setup_ostream; + self->mode = args->mode; + switch (args->mode) { + case H2O_EXPIRES_MODE_ABSOLUTE: + self->value = h2o_strdup(NULL, args->data.absolute, SIZE_MAX); + break; + case H2O_EXPIRES_MODE_MAX_AGE: + self->value.base = h2o_mem_alloc(128); + self->value.len = sprintf(self->value.base, "max-age=%" PRIu64, args->data.max_age); + break; + default: + assert(0); + break; + } +} diff --git a/web/server/h2o/libh2o/lib/handler/fastcgi.c b/web/server/h2o/libh2o/lib/handler/fastcgi.c new file mode 100644 index 000000000..d6bcf9ede --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/fastcgi.c @@ -0,0 +1,856 @@ +/* + * Copyright (c) 2015-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 <inttypes.h> +#include <stdio.h> +#include "picohttpparser.h" +#include "h2o.h" + +#define FCGI_VERSION_1 1 + +#define FCGI_RESPONDER 1 +#define FCGI_KEEP_CONN 1 + +#define FCGI_BEGIN_REQUEST 1 +#define FCGI_END_REQUEST 3 +#define FCGI_PARAMS 4 +#define FCGI_STDIN 5 +#define FCGI_STDOUT 6 +#define FCGI_STDERR 7 +#define FCGI_DATA 8 + +#define FCGI_RECORD_HEADER_SIZE (sizeof(struct st_fcgi_record_header_t)) +#define FCGI_BEGIN_REQUEST_BODY_SIZE 8 + +#define MODULE_NAME "lib/handler/fastcgi.c" + +#define APPEND_BLOCKSIZE 512 /* the size should be small enough to be allocated within the buffer of the memory pool */ + +struct st_fcgi_record_header_t { + uint8_t version; + uint8_t type; + uint16_t requestId; + uint16_t contentLength; + uint8_t paddingLength; + uint8_t reserved; +}; + +struct st_fcgi_begin_request_body_t { + uint16_t role; + uint8_t flags; + uint8_t reserved[5]; +}; + +typedef H2O_VECTOR(h2o_iovec_t) iovec_vector_t; + +struct st_fcgi_context_t { + h2o_fastcgi_handler_t *handler; + h2o_timeout_t io_timeout; +}; + +struct st_fcgi_generator_t { + h2o_generator_t super; + struct st_fcgi_context_t *ctx; + h2o_req_t *req; + h2o_socketpool_connect_request_t *connect_req; + h2o_socket_t *sock; + int sent_headers; + size_t leftsize; /* remaining amount of the content to receive (or SIZE_MAX if unknown) */ + struct { + h2o_doublebuffer_t sending; + h2o_buffer_t *receiving; + } resp; + h2o_timeout_entry_t timeout; +}; + +struct st_h2o_fastcgi_handler_t { + h2o_handler_t super; + h2o_socketpool_t sockpool; + h2o_fastcgi_config_vars_t config; +}; + +static void encode_uint16(void *_p, unsigned v) +{ + unsigned char *p = _p; + p[0] = (unsigned char)(v >> 8); + p[1] = (unsigned char)v; +} + +static void encode_record_header(void *p, uint8_t type, uint16_t reqId, uint16_t sz) +{ + struct st_fcgi_record_header_t *header = p; + header->version = FCGI_VERSION_1; + header->type = type; + encode_uint16(&header->requestId, reqId); + encode_uint16(&header->contentLength, sz); + header->paddingLength = 0; + header->reserved = 0; +} + +static void encode_begin_request(void *p, uint16_t reqId, uint16_t role, uint8_t flags) +{ + encode_record_header(p, FCGI_BEGIN_REQUEST, reqId, FCGI_BEGIN_REQUEST_BODY_SIZE); + struct st_fcgi_begin_request_body_t *body = (void *)((char *)p + FCGI_RECORD_HEADER_SIZE); + encode_uint16(&body->role, role); + body->flags = flags; + memset(body->reserved, 0, sizeof(body->reserved)); +} + +static h2o_iovec_t create_begin_request(h2o_mem_pool_t *pool, uint16_t reqId, uint16_t role, uint8_t flags) +{ + h2o_iovec_t rec = h2o_iovec_init(h2o_mem_alloc_pool(pool, FCGI_RECORD_HEADER_SIZE + FCGI_BEGIN_REQUEST_BODY_SIZE), + FCGI_RECORD_HEADER_SIZE + FCGI_BEGIN_REQUEST_BODY_SIZE); + encode_begin_request(rec.base, reqId, role, flags); + return rec; +} + +static h2o_iovec_t create_header(h2o_mem_pool_t *pool, uint8_t type, uint16_t reqId, uint16_t sz) +{ + h2o_iovec_t rec = h2o_iovec_init(h2o_mem_alloc_pool(pool, FCGI_RECORD_HEADER_SIZE), FCGI_RECORD_HEADER_SIZE); + encode_record_header(rec.base, type, reqId, sz); + return rec; +} + +static void decode_header(struct st_fcgi_record_header_t *decoded, const void *s) +{ + memcpy(decoded, s, sizeof(*decoded)); + decoded->requestId = htons(decoded->requestId); + decoded->contentLength = htons(decoded->contentLength); +} + +static void *append(h2o_mem_pool_t *pool, iovec_vector_t *blocks, const void *s, size_t len) +{ + h2o_iovec_t *slot; + + if (blocks->entries[blocks->size - 1].len + len > APPEND_BLOCKSIZE) { + h2o_vector_reserve(pool, blocks, blocks->size + 1); + slot = blocks->entries + blocks->size++; + slot->base = h2o_mem_alloc_pool(pool, len < APPEND_BLOCKSIZE ? APPEND_BLOCKSIZE : len); + slot->len = 0; + } else { + slot = blocks->entries + blocks->size - 1; + } + + if (s != NULL) + memcpy(slot->base + slot->len, s, len); + slot->len += len; + + return slot->base + slot->len - len; +} + +static char *encode_length_of_pair(char *p, size_t len) +{ + if (len < 127) { + *p++ = (char)len; + } else { + *p++ = (unsigned char)(len >> 24) | 0x80; + *p++ = (unsigned char)(len >> 16); + *p++ = (unsigned char)(len >> 8); + *p++ = (unsigned char)len; + } + return p; +} + +static void *append_pair(h2o_mem_pool_t *pool, iovec_vector_t *blocks, const char *name, size_t namelen, const char *value, + size_t valuelen) +{ + char lenbuf[8]; + void *name_buf; + + append(pool, blocks, lenbuf, encode_length_of_pair(encode_length_of_pair(lenbuf, namelen), valuelen) - lenbuf); + name_buf = append(pool, blocks, name, namelen); + if (valuelen != 0) + append(pool, blocks, value, valuelen); + + return name_buf; +} + +static void append_address_info(h2o_req_t *req, iovec_vector_t *vecs, const char *addrlabel, size_t addrlabel_len, + const char *portlabel, size_t portlabel_len, socklen_t (*cb)(h2o_conn_t *conn, struct sockaddr *)) +{ + struct sockaddr_storage ss; + socklen_t sslen; + char buf[NI_MAXHOST]; + + if ((sslen = cb(req->conn, (void *)&ss)) == 0) + return; + + size_t l = h2o_socket_getnumerichost((void *)&ss, sslen, buf); + if (l != SIZE_MAX) + append_pair(&req->pool, vecs, addrlabel, addrlabel_len, buf, l); + int32_t port = h2o_socket_getport((void *)&ss); + if (port != -1) { + char buf[6]; + int l = sprintf(buf, "%" PRIu16, (uint16_t)port); + append_pair(&req->pool, vecs, portlabel, portlabel_len, buf, (size_t)l); + } +} + +static int envname_is_headername(const h2o_iovec_t *env, const h2o_iovec_t *header) +{ + const char *ep, *hp, *hend; + + if (env->len != 5 + header->len) + return 0; + if (memcmp(env->base, "HTTP_", 5) != 0) + return 0; + for (ep = env->base + 5, hp = header->base, hend = hp + header->len; hp < hend; ++ep, ++hp) + if (*ep != h2o_toupper(*hp)) + return 0; + return 1; +} + +static void append_params(h2o_req_t *req, iovec_vector_t *vecs, h2o_fastcgi_config_vars_t *config) +{ + h2o_iovec_t path_info = {NULL}; + + /* CONTENT_LENGTH */ + if (req->entity.base != NULL) { + char buf[32]; + int l = sprintf(buf, "%zu", req->entity.len); + append_pair(&req->pool, vecs, H2O_STRLIT("CONTENT_LENGTH"), buf, (size_t)l); + } + /* SCRIPT_FILENAME, SCRIPT_NAME, PATH_INFO */ + if (req->filereq != NULL) { + h2o_filereq_t *filereq = req->filereq; + append_pair(&req->pool, vecs, H2O_STRLIT("SCRIPT_FILENAME"), filereq->local_path.base, filereq->local_path.len); + append_pair(&req->pool, vecs, H2O_STRLIT("SCRIPT_NAME"), filereq->script_name.base, filereq->script_name.len); + path_info = filereq->path_info; + } else { + append_pair(&req->pool, vecs, H2O_STRLIT("SCRIPT_NAME"), NULL, 0); + path_info = req->path_normalized; + } + if (path_info.base != NULL) + append_pair(&req->pool, vecs, H2O_STRLIT("PATH_INFO"), path_info.base, path_info.len); + /* DOCUMENT_ROOT and PATH_TRANSLATED */ + if (config->document_root.base != NULL) { + append_pair(&req->pool, vecs, H2O_STRLIT("DOCUMENT_ROOT"), config->document_root.base, config->document_root.len); + if (path_info.base != NULL) { + append_pair(&req->pool, vecs, H2O_STRLIT("PATH_TRANSLATED"), NULL, config->document_root.len + path_info.len); + char *dst_end = vecs->entries[vecs->size - 1].base + vecs->entries[vecs->size - 1].len; + memcpy(dst_end - path_info.len, path_info.base, path_info.len); + memcpy(dst_end - path_info.len - config->document_root.len, config->document_root.base, config->document_root.len); + } + } + /* QUERY_STRING (and adjust PATH_INFO) */ + if (req->query_at != SIZE_MAX) { + append_pair(&req->pool, vecs, H2O_STRLIT("QUERY_STRING"), req->path.base + req->query_at + 1, + req->path.len - (req->query_at + 1)); + } else { + append_pair(&req->pool, vecs, H2O_STRLIT("QUERY_STRING"), NULL, 0); + } + /* REMOTE_ADDR & REMOTE_PORT */ + append_address_info(req, vecs, H2O_STRLIT("REMOTE_ADDR"), H2O_STRLIT("REMOTE_PORT"), req->conn->callbacks->get_peername); + { /* environment variables (REMOTE_USER, etc.) */ + size_t i; + for (i = 0; i != req->env.size; i += 2) { + h2o_iovec_t *name = req->env.entries + i, *value = name + 1; + append_pair(&req->pool, vecs, name->base, name->len, value->base, value->len); + } + } + /* REQUEST_METHOD */ + append_pair(&req->pool, vecs, H2O_STRLIT("REQUEST_METHOD"), req->method.base, req->method.len); + /* HTTP_HOST & REQUEST_URI */ + if (config->send_delegated_uri) { + append_pair(&req->pool, vecs, H2O_STRLIT("HTTP_HOST"), req->authority.base, req->authority.len); + append_pair(&req->pool, vecs, H2O_STRLIT("REQUEST_URI"), req->path.base, req->path.len); + } else { + append_pair(&req->pool, vecs, H2O_STRLIT("HTTP_HOST"), req->input.authority.base, req->input.authority.len); + append_pair(&req->pool, vecs, H2O_STRLIT("REQUEST_URI"), req->input.path.base, req->input.path.len); + } + /* SERVER_ADDR & SERVER_PORT */ + append_address_info(req, vecs, H2O_STRLIT("SERVER_ADDR"), H2O_STRLIT("SERVER_PORT"), req->conn->callbacks->get_sockname); + /* SERVER_NAME */ + append_pair(&req->pool, vecs, H2O_STRLIT("SERVER_NAME"), req->hostconf->authority.host.base, req->hostconf->authority.host.len); + { /* SERVER_PROTOCOL */ + char buf[sizeof("HTTP/1.1")]; + size_t l = h2o_stringify_protocol_version(buf, req->version); + append_pair(&req->pool, vecs, H2O_STRLIT("SERVER_PROTOCOL"), buf, l); + } + /* SERVER_SOFTWARE */ + append_pair(&req->pool, vecs, H2O_STRLIT("SERVER_SOFTWARE"), req->conn->ctx->globalconf->server_name.base, + req->conn->ctx->globalconf->server_name.len); + /* set HTTPS: on if necessary */ + if (req->scheme == &H2O_URL_SCHEME_HTTPS) + append_pair(&req->pool, vecs, H2O_STRLIT("HTTPS"), H2O_STRLIT("on")); + { /* headers */ + const h2o_header_t *h = req->headers.entries, *h_end = h + req->headers.size; + size_t cookie_length = 0; + for (; h != h_end; ++h) { + if (h->name == &H2O_TOKEN_CONTENT_TYPE->buf) { + append_pair(&req->pool, vecs, H2O_STRLIT("CONTENT_TYPE"), h->value.base, h->value.len); + } else if (h->name == &H2O_TOKEN_COOKIE->buf) { + /* accumulate the length of the cookie, together with the separator */ + cookie_length += h->value.len + 1; + } else { + size_t i; + for (i = 0; i != req->env.size; i += 2) { + h2o_iovec_t *envname = req->env.entries + i; + if (envname_is_headername(envname, h->name)) + goto NextHeader; + } + char *dst = append_pair(&req->pool, vecs, NULL, h->name->len + sizeof("HTTP_") - 1, h->value.base, h->value.len); + const char *src = h->name->base, *src_end = src + h->name->len; + *dst++ = 'H'; + *dst++ = 'T'; + *dst++ = 'T'; + *dst++ = 'P'; + *dst++ = '_'; + for (; src != src_end; ++src) + *dst++ = *src == '-' ? '_' : h2o_toupper(*src); + } + NextHeader:; + } + if (cookie_length != 0) { + /* emit the cookie merged */ + cookie_length -= 1; + append_pair(&req->pool, vecs, H2O_STRLIT("HTTP_COOKIE"), NULL, cookie_length); + char *dst = vecs->entries[vecs->size - 1].base + vecs->entries[vecs->size - 1].len - cookie_length; + for (h = req->headers.entries;; ++h) { + if (h->name == &H2O_TOKEN_COOKIE->buf) { + if (cookie_length == h->value.len) + break; + memcpy(dst, h->value.base, h->value.len); + dst += h->value.len; + *dst++ = ';'; + cookie_length -= h->value.len + 1; + } + } + memcpy(dst, h->value.base, h->value.len); + } + } +} + +static void annotate_params(h2o_mem_pool_t *pool, iovec_vector_t *vecs, unsigned request_id, size_t max_record_size) +{ + size_t index = 2, recsize = 0, header_slot = 1; + + while (index != vecs->size) { + if (recsize + vecs->entries[index].len < max_record_size) { + recsize += vecs->entries[index].len; + ++index; + } else { + vecs->entries[header_slot] = create_header(pool, FCGI_PARAMS, request_id, max_record_size); + if (recsize + vecs->entries[index].len == max_record_size) { + h2o_vector_reserve(pool, vecs, vecs->size + 1); + memmove(vecs->entries + index + 2, vecs->entries + index + 1, + (vecs->size - (index + 1)) * sizeof(vecs->entries[0])); + ++vecs->size; + } else { + h2o_vector_reserve(pool, vecs, vecs->size + 2); + memmove(vecs->entries + index + 2, vecs->entries + index, (vecs->size - index) * sizeof(vecs->entries[0])); + vecs->size += 2; + size_t lastsz = max_record_size - recsize; + vecs->entries[index].len = lastsz; + vecs->entries[index + 2].base += lastsz; + vecs->entries[index + 2].len -= lastsz; + } + header_slot = index + 1; + index += 2; + recsize = 0; + } + } + + vecs->entries[header_slot] = create_header(pool, FCGI_PARAMS, request_id, recsize); + if (recsize != 0) { + h2o_vector_reserve(pool, vecs, vecs->size + 1); + vecs->entries[vecs->size++] = create_header(pool, FCGI_PARAMS, request_id, 0); + } +} + +static void build_request(h2o_req_t *req, iovec_vector_t *vecs, unsigned request_id, size_t max_record_size, + h2o_fastcgi_config_vars_t *config) +{ + *vecs = (iovec_vector_t){NULL}; + + /* first entry is FCGI_BEGIN_REQUEST */ + h2o_vector_reserve(&req->pool, vecs, 5 /* we send at least 5 iovecs */); + vecs->entries[0] = + create_begin_request(&req->pool, request_id, FCGI_RESPONDER, config->keepalive_timeout != 0 ? FCGI_KEEP_CONN : 0); + /* second entry is reserved for FCGI_PARAMS header */ + vecs->entries[1] = h2o_iovec_init(NULL, APPEND_BLOCKSIZE); /* dummy value set to prevent params being appended to the entry */ + vecs->size = 2; + /* accumulate the params data, and annotate them with FCGI_PARAM headers */ + append_params(req, vecs, config); + annotate_params(&req->pool, vecs, request_id, max_record_size); + /* setup FCGI_STDIN headers */ + if (req->entity.len != 0) { + size_t off = 0; + for (; off + max_record_size < req->entity.len; off += max_record_size) { + h2o_vector_reserve(&req->pool, vecs, vecs->size + 2); + vecs->entries[vecs->size++] = create_header(&req->pool, FCGI_STDIN, request_id, max_record_size); + vecs->entries[vecs->size++] = h2o_iovec_init(req->entity.base + off, max_record_size); + } + if (off != req->entity.len) { + h2o_vector_reserve(&req->pool, vecs, vecs->size + 2); + vecs->entries[vecs->size++] = create_header(&req->pool, FCGI_STDIN, request_id, req->entity.len - off); + vecs->entries[vecs->size++] = h2o_iovec_init(req->entity.base + off, req->entity.len - off); + } + } + h2o_vector_reserve(&req->pool, vecs, vecs->size + 1); + vecs->entries[vecs->size++] = create_header(&req->pool, FCGI_STDIN, request_id, 0); +} + +static void set_timeout(struct st_fcgi_generator_t *generator, h2o_timeout_t *timeout, h2o_timeout_cb cb) +{ + if (h2o_timeout_is_linked(&generator->timeout)) + h2o_timeout_unlink(&generator->timeout); + + generator->timeout.cb = cb; + h2o_timeout_link(generator->req->conn->ctx->loop, timeout, &generator->timeout); +} + +static void close_generator(struct st_fcgi_generator_t *generator) +{ + /* can be called more than once */ + + if (h2o_timeout_is_linked(&generator->timeout)) + h2o_timeout_unlink(&generator->timeout); + if (generator->connect_req != NULL) { + h2o_socketpool_cancel_connect(generator->connect_req); + generator->connect_req = NULL; + } + if (generator->sock != NULL) { + h2o_socket_close(generator->sock); + generator->sock = NULL; + } + if (generator->resp.sending.buf != NULL) + h2o_doublebuffer_dispose(&generator->resp.sending); + if (generator->resp.receiving != NULL) + h2o_buffer_dispose(&generator->resp.receiving); +} + +static void do_send(struct st_fcgi_generator_t *generator) +{ + h2o_iovec_t vecs[1]; + size_t veccnt; + int is_final; + + vecs[0] = h2o_doublebuffer_prepare(&generator->resp.sending, &generator->resp.receiving, generator->req->preferred_chunk_size); + veccnt = vecs[0].len != 0 ? 1 : 0; + if (generator->sock == NULL && vecs[0].len == generator->resp.sending.buf->size && generator->resp.receiving->size == 0) { + is_final = 1; + if (!(generator->leftsize == 0 || generator->leftsize == SIZE_MAX)) + generator->req->http1_is_persistent = 0; + } else { + if (veccnt == 0) + return; + is_final = 0; + } + h2o_send(generator->req, vecs, veccnt, is_final ? H2O_SEND_STATE_FINAL : H2O_SEND_STATE_IN_PROGRESS); +} + +static void send_eos_and_close(struct st_fcgi_generator_t *generator, int can_keepalive) +{ + if (generator->ctx->handler->config.keepalive_timeout != 0 && can_keepalive) + h2o_socketpool_return(&generator->ctx->handler->sockpool, generator->sock); + else + h2o_socket_close(generator->sock); + generator->sock = NULL; + + if (h2o_timeout_is_linked(&generator->timeout)) + h2o_timeout_unlink(&generator->timeout); + + if (generator->resp.sending.bytes_inflight == 0) + do_send(generator); +} + +static void errorclose(struct st_fcgi_generator_t *generator) +{ + if (generator->sent_headers) { + send_eos_and_close(generator, 0); + } else { + h2o_req_t *req = generator->req; + close_generator(generator); + h2o_send_error_503(req, "Internal Server Error", "Internal Server Error", 0); + } +} + +static int _isdigit(int ch) +{ + return '0' <= ch && ch <= '9'; +} + +static int fill_headers(h2o_req_t *req, struct phr_header *headers, size_t num_headers) +{ + size_t i; + + /* set the defaults */ + req->res.status = 200; + req->res.reason = "OK"; + req->res.content_length = SIZE_MAX; + + for (i = 0; i != num_headers; ++i) { + const h2o_token_t *token; + h2o_strtolower((char *)headers[i].name, headers[i].name_len); + if ((token = h2o_lookup_token(headers[i].name, headers[i].name_len)) != NULL) { + if (token->proxy_should_drop_for_res) { + /* skip */ + } else if (token == H2O_TOKEN_CONTENT_LENGTH) { + if (req->res.content_length != SIZE_MAX) { + h2o_req_log_error(req, MODULE_NAME, "received multiple content-length headers from fcgi"); + return -1; + } + if ((req->res.content_length = h2o_strtosize(headers[i].value, headers[i].value_len)) == SIZE_MAX) { + h2o_req_log_error(req, MODULE_NAME, "failed to parse content-length header sent from fcgi: %.*s", + (int)headers[i].value_len, headers[i].value); + return -1; + } + } else { + /* + RFC 3875 defines three headers to have special meaning: Content-Type, Status, Location. + Status is handled as below. + Content-Type does not seem to have any need to be handled specially. + RFC suggests abs-path-style Location headers should trigger an internal redirection, but is that how the web servers + work? + */ + h2o_add_header(&req->pool, &req->res.headers, token, NULL, + h2o_strdup(&req->pool, headers[i].value, headers[i].value_len).base, headers[i].value_len); + if (token == H2O_TOKEN_LINK) + h2o_push_path_in_link_header(req, headers[i].value, headers[i].value_len); + } + } else if (h2o_memis(headers[i].name, headers[i].name_len, H2O_STRLIT("status"))) { + h2o_iovec_t value = h2o_iovec_init(headers[i].value, headers[i].value_len); + if (value.len < 3 || !(_isdigit(value.base[0]) && _isdigit(value.base[1]) && _isdigit(value.base[2])) || + (value.len >= 4 && value.base[3] != ' ')) { + h2o_req_log_error(req, MODULE_NAME, "failed to parse Status header, got: %.*s", (int)value.len, value.base); + return -1; + } + req->res.status = (value.base[0] - '0') * 100 + (value.base[1] - '0') * 10 + (value.base[2] - '0'); + req->res.reason = value.len >= 5 ? h2o_strdup(&req->pool, value.base + 4, value.len - 4).base : "OK"; + } else { + h2o_iovec_t name_duped = h2o_strdup(&req->pool, headers[i].name, headers[i].name_len), + value_duped = h2o_strdup(&req->pool, headers[i].value, headers[i].value_len); + h2o_add_header_by_str(&req->pool, &req->res.headers, name_duped.base, name_duped.len, 0, NULL, value_duped.base, + value_duped.len); + } + } + + return 0; +} + +static void append_content(struct st_fcgi_generator_t *generator, const void *src, size_t len) +{ + /* do not accumulate more than content-length bytes */ + if (generator->leftsize != SIZE_MAX) { + if (generator->leftsize < len) { + len = generator->leftsize; + if (len == 0) + return; + } + generator->leftsize -= len; + } + + h2o_iovec_t reserved = h2o_buffer_reserve(&generator->resp.receiving, len); + memcpy(reserved.base, src, len); + generator->resp.receiving->size += len; +} + +static int handle_stdin_record(struct st_fcgi_generator_t *generator, struct st_fcgi_record_header_t *header) +{ + h2o_buffer_t *input = generator->sock->input; + struct phr_header headers[100]; + size_t num_headers; + int parse_result; + + if (header->contentLength == 0) + return 0; + + if (generator->sent_headers) { + /* simply accumulate the data to response buffer */ + append_content(generator, input->bytes + FCGI_RECORD_HEADER_SIZE, header->contentLength); + return 0; + } + + /* parse the headers using the input buffer (or keep it in response buffer and parse) */ + num_headers = sizeof(headers) / sizeof(headers[0]); + if (generator->resp.receiving->size == 0) { + parse_result = phr_parse_headers(input->bytes + FCGI_RECORD_HEADER_SIZE, header->contentLength, headers, &num_headers, 0); + } else { + size_t prevlen = generator->resp.receiving->size; + memcpy(h2o_buffer_reserve(&generator->resp.receiving, header->contentLength).base, input->bytes + FCGI_RECORD_HEADER_SIZE, + header->contentLength); + generator->resp.receiving->size = prevlen + header->contentLength; + parse_result = + phr_parse_headers(generator->resp.receiving->bytes, generator->resp.receiving->size, headers, &num_headers, prevlen); + } + if (parse_result < 0) { + if (parse_result == -2) { + /* incomplete */ + if (generator->resp.receiving->size == 0) { + memcpy(h2o_buffer_reserve(&generator->resp.receiving, header->contentLength).base, + input->bytes + FCGI_RECORD_HEADER_SIZE, header->contentLength); + generator->resp.receiving->size = header->contentLength; + } + return 0; + } else { + h2o_req_log_error(generator->req, MODULE_NAME, "received broken response"); + return -1; + } + } + + /* fill-in the headers, and start the response */ + if (fill_headers(generator->req, headers, num_headers) != 0) + return -1; + generator->leftsize = generator->req->res.content_length; + h2o_start_response(generator->req, &generator->super); + generator->sent_headers = 1; + + /* rest of the contents should be stored in the response buffer */ + if (generator->resp.receiving->size == 0) { + size_t leftlen = header->contentLength - parse_result; + if (leftlen != 0) { + append_content(generator, input->bytes + FCGI_RECORD_HEADER_SIZE + parse_result, leftlen); + } + } else { + h2o_buffer_consume(&generator->resp.receiving, parse_result); + } + + return 0; +} + +static void on_rw_timeout(h2o_timeout_entry_t *entry) +{ + struct st_fcgi_generator_t *generator = H2O_STRUCT_FROM_MEMBER(struct st_fcgi_generator_t, timeout, entry); + + h2o_req_log_error(generator->req, MODULE_NAME, "I/O timeout"); + errorclose(generator); +} + +static void on_read(h2o_socket_t *sock, const char *err) +{ + struct st_fcgi_generator_t *generator = sock->data; + int can_keepalive = 0; + + if (err != NULL) { + /* note: FastCGI server is allowed to close the connection any time after sending an empty FCGI_STDOUT record */ + if (!generator->sent_headers) + h2o_req_log_error(generator->req, MODULE_NAME, "fastcgi connection closed unexpectedly"); + errorclose(generator); + return; + } + + /* handle the records */ + while (1) { + struct st_fcgi_record_header_t header; + size_t recsize; + if (sock->input->size < FCGI_RECORD_HEADER_SIZE) + break; + decode_header(&header, sock->input->bytes); + recsize = FCGI_RECORD_HEADER_SIZE + header.contentLength + header.paddingLength; + if (sock->input->size < recsize) + break; + /* we have a complete record */ + switch (header.type) { + case FCGI_STDOUT: + if (handle_stdin_record(generator, &header) != 0) + goto Error; + h2o_buffer_consume(&sock->input, recsize); + break; + case FCGI_STDERR: + if (header.contentLength != 0) + h2o_req_log_error(generator->req, MODULE_NAME, "%.*s", (int)header.contentLength, + sock->input->bytes + FCGI_RECORD_HEADER_SIZE); + h2o_buffer_consume(&sock->input, recsize); + break; + case FCGI_END_REQUEST: + if (!generator->sent_headers) { + h2o_req_log_error(generator->req, MODULE_NAME, "received FCGI_END_REQUEST before end of the headers"); + goto Error; + } + h2o_buffer_consume(&sock->input, recsize); + can_keepalive = 1; + goto EOS_Received; + default: + h2o_req_log_error(generator->req, MODULE_NAME, "received unexpected record, type: %u", header.type); + h2o_buffer_consume(&sock->input, recsize); + if (!generator->sent_headers) + goto Error; + goto EOS_Received; + } + } + + /* send data if necessary */ + if (generator->sent_headers && generator->resp.sending.bytes_inflight == 0) + do_send(generator); + + set_timeout(generator, &generator->ctx->io_timeout, on_rw_timeout); + return; + +EOS_Received: + send_eos_and_close(generator, can_keepalive); + return; + +Error: + errorclose(generator); +} + +static void on_send_complete(h2o_socket_t *sock, const char *err) +{ + struct st_fcgi_generator_t *generator = sock->data; + + set_timeout(generator, &generator->ctx->io_timeout, on_rw_timeout); + /* do nothing else! all the rest is handled by the on_read */ +} + +static void on_connect(h2o_socket_t *sock, const char *errstr, void *data) +{ + struct st_fcgi_generator_t *generator = data; + iovec_vector_t vecs; + + generator->connect_req = NULL; + + if (sock == NULL) { + h2o_req_log_error(generator->req, MODULE_NAME, "connection failed:%s", errstr); + errorclose(generator); + return; + } + + generator->sock = sock; + sock->data = generator; + + build_request(generator->req, &vecs, 1, 65535, &generator->ctx->handler->config); + + /* start sending the response */ + h2o_socket_write(generator->sock, vecs.entries, vecs.size, on_send_complete); + + set_timeout(generator, &generator->ctx->io_timeout, on_rw_timeout); + + /* activate the receiver; note: FCGI spec allows the app to start sending the response before it receives FCGI_STDIN */ + h2o_socket_read_start(sock, on_read); +} + +static void do_proceed(h2o_generator_t *_generator, h2o_req_t *req) +{ + struct st_fcgi_generator_t *generator = (void *)_generator; + + h2o_doublebuffer_consume(&generator->resp.sending); + do_send(generator); +} + +static void do_stop(h2o_generator_t *_generator, h2o_req_t *req) +{ + struct st_fcgi_generator_t *generator = (void *)_generator; + close_generator(generator); +} + +static void on_connect_timeout(h2o_timeout_entry_t *entry) +{ + struct st_fcgi_generator_t *generator = H2O_STRUCT_FROM_MEMBER(struct st_fcgi_generator_t, timeout, entry); + + h2o_req_log_error(generator->req, MODULE_NAME, "connect timeout"); + errorclose(generator); +} + +static int on_req(h2o_handler_t *_handler, h2o_req_t *req) +{ + h2o_fastcgi_handler_t *handler = (void *)_handler; + struct st_fcgi_generator_t *generator; + + generator = h2o_mem_alloc_shared(&req->pool, sizeof(*generator), (void (*)(void *))close_generator); + generator->super.proceed = do_proceed; + generator->super.stop = do_stop; + generator->ctx = h2o_context_get_handler_context(req->conn->ctx, &handler->super); + generator->req = req; + generator->sock = NULL; + generator->sent_headers = 0; + h2o_doublebuffer_init(&generator->resp.sending, &h2o_socket_buffer_prototype); + h2o_buffer_init(&generator->resp.receiving, &h2o_socket_buffer_prototype); + generator->timeout = (h2o_timeout_entry_t){0}; + + set_timeout(generator, &generator->ctx->io_timeout, on_connect_timeout); + h2o_socketpool_connect(&generator->connect_req, &handler->sockpool, req->conn->ctx->loop, + &req->conn->ctx->receivers.hostinfo_getaddr, on_connect, generator); + + return 0; +} + +static void on_context_init(h2o_handler_t *_handler, h2o_context_t *ctx) +{ + h2o_fastcgi_handler_t *handler = (void *)_handler; + struct st_fcgi_context_t *handler_ctx = h2o_mem_alloc(sizeof(*handler_ctx)); + + /* use the first event loop for handling timeouts of the socket pool */ + if (handler->sockpool.timeout == UINT64_MAX) + h2o_socketpool_set_timeout(&handler->sockpool, ctx->loop, + handler->config.keepalive_timeout != 0 ? handler->config.keepalive_timeout : 60000); + + handler_ctx->handler = handler; + h2o_timeout_init(ctx->loop, &handler_ctx->io_timeout, handler->config.io_timeout); + + h2o_context_set_handler_context(ctx, &handler->super, handler_ctx); +} + +static void on_context_dispose(h2o_handler_t *_handler, h2o_context_t *ctx) +{ + h2o_fastcgi_handler_t *handler = (void *)_handler; + struct st_fcgi_context_t *handler_ctx = h2o_context_get_handler_context(ctx, &handler->super); + + if (handler_ctx == NULL) + return; + + h2o_timeout_dispose(ctx->loop, &handler_ctx->io_timeout); + free(handler_ctx); +} + +static void on_handler_dispose(h2o_handler_t *_handler) +{ + h2o_fastcgi_handler_t *handler = (void *)_handler; + + if (handler->config.callbacks.dispose != NULL) + handler->config.callbacks.dispose(handler, handler->config.callbacks.data); + + h2o_socketpool_dispose(&handler->sockpool); + free(handler->config.document_root.base); +} + +static h2o_fastcgi_handler_t *register_common(h2o_pathconf_t *pathconf, h2o_fastcgi_config_vars_t *vars) +{ + h2o_fastcgi_handler_t *handler = (void *)h2o_create_handler(pathconf, sizeof(*handler)); + + handler->super.on_context_init = on_context_init; + handler->super.on_context_dispose = on_context_dispose; + handler->super.dispose = on_handler_dispose; + handler->super.on_req = on_req; + handler->config = *vars; + if (vars->document_root.base != NULL) + handler->config.document_root = h2o_strdup(NULL, vars->document_root.base, vars->document_root.len); + + return handler; +} + +h2o_fastcgi_handler_t *h2o_fastcgi_register_by_hostport(h2o_pathconf_t *pathconf, const char *host, uint16_t port, + h2o_fastcgi_config_vars_t *vars) +{ + h2o_fastcgi_handler_t *handler = register_common(pathconf, vars); + + h2o_socketpool_init_by_hostport(&handler->sockpool, h2o_iovec_init(host, strlen(host)), port, 0, SIZE_MAX /* FIXME */); + return handler; +} + +h2o_fastcgi_handler_t *h2o_fastcgi_register_by_address(h2o_pathconf_t *pathconf, struct sockaddr *sa, socklen_t salen, + h2o_fastcgi_config_vars_t *vars) +{ + h2o_fastcgi_handler_t *handler = register_common(pathconf, vars); + + h2o_socketpool_init_by_address(&handler->sockpool, sa, salen, 0, SIZE_MAX /* FIXME */); + return handler; +} diff --git a/web/server/h2o/libh2o/lib/handler/file.c b/web/server/h2o/libh2o/lib/handler/file.c new file mode 100644 index 000000000..5d7c7a2a4 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/file.c @@ -0,0 +1,966 @@ +/* + * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Domingo Alvarez Duarte, + * Tatsuhiko Kubo, Nick Desaulniers, Marc Hoersken, + * Justin Zhu, Tatsuhiro Tsujikawa + * + * 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 <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <time.h> +#include <unistd.h> + +#include "h2o.h" + +#define MAX_BUF_SIZE 65000 +#define BOUNDARY_SIZE 20 +#define FIXED_PART_SIZE (sizeof("\r\n--") - 1 + BOUNDARY_SIZE + sizeof("\r\nContent-Range: bytes=-/\r\nContent-Type: \r\n\r\n") - 1) + +struct st_h2o_sendfile_generator_t { + h2o_generator_t super; + struct { + h2o_filecache_ref_t *ref; + off_t off; + } file; + h2o_req_t *req; + size_t bytesleft; + h2o_iovec_t content_encoding; + unsigned send_vary : 1; + unsigned send_etag : 1; + unsigned gunzip : 1; + char *buf; + struct { + size_t filesize; + size_t range_count; + size_t *range_infos; /* size_t shows in pair. first is start offset, then length */ + h2o_iovec_t boundary; /* boundary used for multipart/byteranges */ + h2o_iovec_t mimetype; /* original mimetype for multipart */ + size_t current_range; /* range that processing now */ + } ranged; + struct { + char last_modified[H2O_TIMESTR_RFC1123_LEN + 1]; + char etag[H2O_FILECACHE_ETAG_MAXLEN + 1]; + } header_bufs; +}; + +struct st_h2o_file_handler_t { + h2o_handler_t super; + h2o_iovec_t conf_path; /* has "/" appended at last */ + h2o_iovec_t real_path; /* has "/" appended at last */ + h2o_mimemap_t *mimemap; + int flags; + size_t max_index_file_len; + h2o_iovec_t index_files[1]; +}; + +struct st_h2o_specific_file_handler_t { + h2o_handler_t super; + h2o_iovec_t real_path; + h2o_mimemap_type_t *mime_type; + int flags; +}; + +struct st_gzip_decompress_t { + h2o_ostream_t super; + h2o_compress_context_t *decompressor; +}; + +static const char *default_index_files[] = {"index.html", "index.htm", "index.txt", NULL}; + +const char **h2o_file_default_index_files = default_index_files; + +#include "file/templates.c.h" + +static int tm_is_lessthan(struct tm *x, struct tm *y) +{ +#define CMP(f) \ + if (x->f < y->f) \ + return 1; \ + else if (x->f > y->f) \ + return 0; + CMP(tm_year); + CMP(tm_mon); + CMP(tm_mday); + CMP(tm_hour); + CMP(tm_min); + CMP(tm_sec); + return 0; +#undef CMP +} + +static void do_close(h2o_generator_t *_self, h2o_req_t *req) +{ + struct st_h2o_sendfile_generator_t *self = (void *)_self; + h2o_filecache_close_file(self->file.ref); +} + +static void do_proceed(h2o_generator_t *_self, h2o_req_t *req) +{ + struct st_h2o_sendfile_generator_t *self = (void *)_self; + size_t rlen; + ssize_t rret; + h2o_iovec_t vec; + h2o_send_state_t send_state; + + /* read the file */ + rlen = self->bytesleft; + if (rlen > MAX_BUF_SIZE) + rlen = MAX_BUF_SIZE; + while ((rret = pread(self->file.ref->fd, self->buf, rlen, self->file.off)) == -1 && errno == EINTR) + ; + if (rret == -1) { + h2o_send(req, NULL, 0, H2O_SEND_STATE_ERROR); + do_close(&self->super, req); + return; + } + self->file.off += rret; + self->bytesleft -= rret; + if (self->bytesleft == 0) { + send_state = H2O_SEND_STATE_FINAL; + } else { + send_state = H2O_SEND_STATE_IN_PROGRESS; + } + + /* send (and close if done) */ + vec.base = self->buf; + vec.len = rret; + h2o_send(req, &vec, 1, send_state); + if (send_state == H2O_SEND_STATE_FINAL) + do_close(&self->super, req); +} + +static void do_multirange_proceed(h2o_generator_t *_self, h2o_req_t *req) +{ + struct st_h2o_sendfile_generator_t *self = (void *)_self; + size_t rlen, used_buf = 0; + ssize_t rret, vecarrsize; + h2o_iovec_t vec[2]; + h2o_send_state_t send_state; + + if (self->bytesleft == 0) { + size_t *range_cur = self->ranged.range_infos + 2 * self->ranged.current_range; + size_t range_end = *range_cur + *(range_cur + 1) - 1; + if (H2O_LIKELY(self->ranged.current_range != 0)) + used_buf = + sprintf(self->buf, "\r\n--%s\r\nContent-Type: %s\r\nContent-Range: bytes %zd-%zd/%zd\r\n\r\n", + self->ranged.boundary.base, self->ranged.mimetype.base, *range_cur, range_end, self->ranged.filesize); + else + used_buf = + sprintf(self->buf, "--%s\r\nContent-Type: %s\r\nContent-Range: bytes %zd-%zd/%zd\r\n\r\n", + self->ranged.boundary.base, self->ranged.mimetype.base, *range_cur, range_end, self->ranged.filesize); + self->ranged.current_range++; + self->file.off = *range_cur; + self->bytesleft = *++range_cur; + } + rlen = self->bytesleft; + if (rlen + used_buf > MAX_BUF_SIZE) + rlen = MAX_BUF_SIZE - used_buf; + while ((rret = pread(self->file.ref->fd, self->buf + used_buf, rlen, self->file.off)) == -1 && errno == EINTR) + ; + if (rret == -1) + goto Error; + self->file.off += rret; + self->bytesleft -= rret; + + vec[0].base = self->buf; + vec[0].len = rret + used_buf; + if (self->ranged.current_range == self->ranged.range_count && self->bytesleft == 0) { + vec[1].base = h2o_mem_alloc_pool(&req->pool, sizeof("\r\n--") - 1 + BOUNDARY_SIZE + sizeof("--\r\n")); + vec[1].len = sprintf(vec[1].base, "\r\n--%s--\r\n", self->ranged.boundary.base); + vecarrsize = 2; + send_state = H2O_SEND_STATE_FINAL; + } else { + vecarrsize = 1; + send_state = H2O_SEND_STATE_IN_PROGRESS; + } + h2o_send(req, vec, vecarrsize, send_state); + if (send_state == H2O_SEND_STATE_FINAL) + do_close(&self->super, req); + return; + +Error: + h2o_send(req, NULL, 0, H2O_SEND_STATE_ERROR); + do_close(&self->super, req); + return; +} + +static h2o_send_state_t do_pull(h2o_generator_t *_self, h2o_req_t *req, h2o_iovec_t *buf) +{ + struct st_h2o_sendfile_generator_t *self = (void *)_self; + ssize_t rret; + + if (self->bytesleft < buf->len) + buf->len = self->bytesleft; + while ((rret = pread(self->file.ref->fd, buf->base, buf->len, self->file.off)) == -1 && errno == EINTR) + ; + if (rret <= 0) { + buf->len = 0; + self->bytesleft = 0; + do_close(&self->super, req); + return H2O_SEND_STATE_ERROR; + } else { + buf->len = rret; + self->file.off += rret; + self->bytesleft -= rret; + } + + if (self->bytesleft != 0) + return H2O_SEND_STATE_IN_PROGRESS; + do_close(&self->super, req); + return H2O_SEND_STATE_FINAL; +} + +static struct st_h2o_sendfile_generator_t *create_generator(h2o_req_t *req, const char *path, size_t path_len, int *is_dir, + int flags) +{ + struct st_h2o_sendfile_generator_t *self; + h2o_filecache_ref_t *fileref; + h2o_iovec_t content_encoding = (h2o_iovec_t){NULL}; + unsigned gunzip = 0; + + *is_dir = 0; + + if ((flags & H2O_FILE_FLAG_SEND_COMPRESSED) != 0 && req->version >= 0x101) { + int compressible_types = h2o_get_compressible_types(&req->headers); + if (compressible_types != 0) { + char *variant_path = h2o_mem_alloc_pool(&req->pool, path_len + sizeof(".gz")); + memcpy(variant_path, path, path_len); +#define TRY_VARIANT(mask, enc, ext) \ + if ((compressible_types & mask) != 0) { \ + strcpy(variant_path + path_len, ext); \ + if ((fileref = h2o_filecache_open_file(req->conn->ctx->filecache, variant_path, O_RDONLY | O_CLOEXEC)) != NULL) { \ + content_encoding = h2o_iovec_init(enc, sizeof(enc) - 1); \ + goto Opened; \ + } \ + } + TRY_VARIANT(H2O_COMPRESSIBLE_BROTLI, "br", ".br"); + TRY_VARIANT(H2O_COMPRESSIBLE_GZIP, "gzip", ".gz"); +#undef TRY_VARIANT + } + } + if ((fileref = h2o_filecache_open_file(req->conn->ctx->filecache, path, O_RDONLY | O_CLOEXEC)) != NULL) { + goto Opened; + } + if ((flags & H2O_FILE_FLAG_GUNZIP) != 0 && req->version >= 0x101) { + char *variant_path = h2o_mem_alloc_pool(&req->pool, path_len + sizeof(".gz")); + memcpy(variant_path, path, path_len); + strcpy(variant_path + path_len, ".gz"); + if ((fileref = h2o_filecache_open_file(req->conn->ctx->filecache, variant_path, O_RDONLY | O_CLOEXEC)) != NULL) { + gunzip = 1; + goto Opened; + } + } + return NULL; + +Opened: + if (S_ISDIR(fileref->st.st_mode)) { + h2o_filecache_close_file(fileref); + *is_dir = 1; + return NULL; + } + + self = h2o_mem_alloc_pool(&req->pool, sizeof(*self)); + self->super.proceed = do_proceed; + self->super.stop = do_close; + self->file.ref = fileref; + self->file.off = 0; + self->req = NULL; + self->bytesleft = self->file.ref->st.st_size; + self->ranged.range_count = 0; + self->ranged.range_infos = NULL; + self->content_encoding = content_encoding; + self->send_vary = (flags & H2O_FILE_FLAG_SEND_COMPRESSED) != 0; + self->send_etag = (flags & H2O_FILE_FLAG_NO_ETAG) == 0; + self->gunzip = gunzip; + + return self; +} + +static void add_headers_unconditional(struct st_h2o_sendfile_generator_t *self, h2o_req_t *req) +{ + /* RFC 7232 4.1: The server generating a 304 response MUST generate any of the following header fields that would have been sent + * in a 200 (OK) response to the same request: Cache-Control, Content-Location, Date, ETag, Expires, and Vary (snip) a sender + * SHOULD NOT generate representation metadata other than the above listed fields unless said metadata exists for the purpose of + * guiding cache updates. */ + if (self->send_etag) { + size_t etag_len = h2o_filecache_get_etag(self->file.ref, self->header_bufs.etag); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_ETAG, NULL, self->header_bufs.etag, etag_len); + } + if (self->send_vary) + h2o_set_header_token(&req->pool, &req->res.headers, H2O_TOKEN_VARY, H2O_STRLIT("accept-encoding")); +} + +static void send_decompressed(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state) +{ + struct st_gzip_decompress_t *self = (void *)_self; + h2o_iovec_t *outbufs; + size_t outbufcnt; + + self->decompressor->transform(self->decompressor, inbufs, inbufcnt, state, &outbufs, &outbufcnt); + h2o_ostream_send_next(&self->super, req, outbufs, outbufcnt, state); +} + +static void do_send_file(struct st_h2o_sendfile_generator_t *self, h2o_req_t *req, int status, const char *reason, + h2o_iovec_t mime_type, h2o_mime_attributes_t *mime_attr, int is_get) +{ + /* link the request */ + self->req = req; + + /* setup response */ + req->res.status = status; + req->res.reason = reason; + req->res.content_length = self->gunzip ? SIZE_MAX : self->bytesleft; + req->res.mime_attr = mime_attr; + + if (self->ranged.range_count > 1) { + mime_type.base = h2o_mem_alloc_pool(&req->pool, 52); + mime_type.len = sprintf(mime_type.base, "multipart/byteranges; boundary=%s", self->ranged.boundary.base); + } + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, mime_type.base, mime_type.len); + h2o_filecache_get_last_modified(self->file.ref, self->header_bufs.last_modified); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_LAST_MODIFIED, NULL, self->header_bufs.last_modified, + H2O_TIMESTR_RFC1123_LEN); + add_headers_unconditional(self, req); + if (self->content_encoding.base != NULL) + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_ENCODING, NULL, self->content_encoding.base, + self->content_encoding.len); + if (self->ranged.range_count == 0) + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_ACCEPT_RANGES, NULL, H2O_STRLIT("bytes")); + else if (self->ranged.range_count == 1) { + h2o_iovec_t content_range; + content_range.base = h2o_mem_alloc_pool(&req->pool, 128); + content_range.len = sprintf(content_range.base, "bytes %zd-%zd/%zd", self->ranged.range_infos[0], + self->ranged.range_infos[0] + self->ranged.range_infos[1] - 1, self->ranged.filesize); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_RANGE, NULL, content_range.base, content_range.len); + } + + /* special path for cases where we do not need to send any data */ + if (!is_get || self->bytesleft == 0) { + static h2o_generator_t generator = {NULL, NULL}; + h2o_start_response(req, &generator); + h2o_send(req, NULL, 0, H2O_SEND_STATE_FINAL); + do_close(&self->super, req); + return; + } + + /* send data */ + h2o_start_response(req, &self->super); + + /* dynamically setup gzip decompress ostream */ + if (self->gunzip) { + struct st_gzip_decompress_t *decoder = (void *)h2o_add_ostream(req, sizeof(struct st_gzip_decompress_t), &req->_ostr_top); + decoder->decompressor = h2o_compress_gunzip_open(&req->pool); + decoder->super.do_send = send_decompressed; + } + + if (self->ranged.range_count == 1) + self->file.off = self->ranged.range_infos[0]; + if (req->_ostr_top->start_pull != NULL && self->ranged.range_count < 2) { + req->_ostr_top->start_pull(req->_ostr_top, do_pull); + } else { + size_t bufsz = MAX_BUF_SIZE; + if (self->bytesleft < bufsz) + bufsz = self->bytesleft; + self->buf = h2o_mem_alloc_pool(&req->pool, bufsz); + if (self->ranged.range_count < 2) + do_proceed(&self->super, req); + else { + self->bytesleft = 0; + self->super.proceed = do_multirange_proceed; + do_multirange_proceed(&self->super, req); + } + } +} + +int h2o_file_send(h2o_req_t *req, int status, const char *reason, const char *path, h2o_iovec_t mime_type, int flags) +{ + struct st_h2o_sendfile_generator_t *self; + int is_dir; + + if ((self = create_generator(req, path, strlen(path), &is_dir, flags)) == NULL) + return -1; + /* note: is_dir is not handled */ + do_send_file(self, req, status, reason, mime_type, NULL, 1); + return 0; +} + +static int send_dir_listing(h2o_req_t *req, const char *path, size_t path_len, int is_get) +{ + static h2o_generator_t generator = {NULL, NULL}; + DIR *dp; + h2o_buffer_t *body; + h2o_iovec_t bodyvec; + + /* build html */ + if ((dp = opendir(path)) == NULL) + return -1; + body = build_dir_listing_html(&req->pool, req->path_normalized, dp); + closedir(dp); + + bodyvec = h2o_iovec_init(body->bytes, body->size); + h2o_buffer_link_to_pool(body, &req->pool); + + /* send response */ + req->res.status = 200; + req->res.reason = "OK"; + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, H2O_STRLIT("text/html; charset=utf-8")); + + /* send headers */ + if (!is_get) { + h2o_send_inline(req, NULL, 0); + return 0; + } + + /* send data */ + h2o_start_response(req, &generator); + h2o_send(req, &bodyvec, 1, H2O_SEND_STATE_FINAL); + return 0; +} + +static size_t *process_range(h2o_mem_pool_t *pool, h2o_iovec_t *range_value, size_t file_size, size_t *ret) +{ +#define CHECK_EOF() \ + if (buf == buf_end) \ + return NULL; + +#define CHECK_OVERFLOW(range) \ + if (range == SIZE_MAX) \ + return NULL; + + size_t range_start = SIZE_MAX, range_count = 0; + char *buf = range_value->base, *buf_end = buf + range_value->len; + int needs_comma = 0; + H2O_VECTOR(size_t) ranges = {NULL}; + + if (range_value->len < 6 || memcmp(buf, "bytes=", 6) != 0) + return NULL; + + buf += 6; + CHECK_EOF(); + + /* most range requests contain only one range */ + do { + while (1) { + if (*buf != ',') { + if (needs_comma) + return NULL; + break; + } + needs_comma = 0; + buf++; + while (H2O_UNLIKELY(*buf == ' ') || H2O_UNLIKELY(*buf == '\t')) { + buf++; + CHECK_EOF(); + } + } + if (H2O_UNLIKELY(buf == buf_end)) + break; + if (H2O_LIKELY((range_start = h2o_strtosizefwd(&buf, buf_end - buf)) != SIZE_MAX)) { + CHECK_EOF(); + if (*buf++ != '-') + return NULL; + range_count = h2o_strtosizefwd(&buf, buf_end - buf); + if (H2O_UNLIKELY(range_start >= file_size)) { + range_start = SIZE_MAX; + } else if (H2O_LIKELY(range_count != SIZE_MAX)) { + if (H2O_UNLIKELY(range_count > file_size - 1)) + range_count = file_size - 1; + if (H2O_LIKELY(range_start <= range_count)) + range_count -= range_start - 1; + else + range_start = SIZE_MAX; + } else { + range_count = file_size - range_start; + } + } else if (H2O_LIKELY(*buf++ == '-')) { + CHECK_EOF(); + range_count = h2o_strtosizefwd(&buf, buf_end - buf); + if (H2O_UNLIKELY(range_count == SIZE_MAX)) + return NULL; + if (H2O_LIKELY(range_count != 0)) { + if (H2O_UNLIKELY(range_count > file_size)) + range_count = file_size; + range_start = file_size - range_count; + } else { + range_start = SIZE_MAX; + } + } else { + return NULL; + } + + if (H2O_LIKELY(range_start != SIZE_MAX)) { + h2o_vector_reserve(pool, &ranges, ranges.size + 2); + ranges.entries[ranges.size++] = range_start; + ranges.entries[ranges.size++] = range_count; + } + if (buf != buf_end) + while (H2O_UNLIKELY(*buf == ' ') || H2O_UNLIKELY(*buf == '\t')) { + buf++; + CHECK_EOF(); + } + needs_comma = 1; + } while (H2O_UNLIKELY(buf < buf_end)); + *ret = ranges.size / 2; + return ranges.entries; +#undef CHECK_EOF +#undef CHECK_OVERFLOW +} + +static void gen_rand_string(h2o_iovec_t *s) +{ + int i; + static const char alphanum[] = "0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz"; + + for (i = 0; i < s->len; ++i) { + s->base[i] = alphanum[h2o_rand() % (sizeof(alphanum) - 1)]; + } + + s->base[s->len] = 0; +} + +static int delegate_dynamic_request(h2o_req_t *req, h2o_iovec_t script_name, h2o_iovec_t path_info, const char *local_path, + size_t local_path_len, h2o_mimemap_type_t *mime_type) +{ + h2o_filereq_t *filereq; + h2o_handler_t *handler; + + assert(mime_type->data.dynamic.pathconf.handlers.size == 1); + + filereq = h2o_mem_alloc_pool(&req->pool, sizeof(*filereq)); + filereq->script_name = script_name; + filereq->path_info = path_info; + filereq->local_path = h2o_strdup(&req->pool, local_path, local_path_len); + + h2o_req_bind_conf(req, req->hostconf, &mime_type->data.dynamic.pathconf); + req->filereq = filereq; + + handler = mime_type->data.dynamic.pathconf.handlers.entries[0]; + return handler->on_req(handler, req); +} + +static int try_dynamic_request(h2o_file_handler_t *self, h2o_req_t *req, char *rpath, size_t rpath_len) +{ + /* we have full local path in {rpath,rpath_len}, and need to split it into name and path_info */ + struct stat st; + size_t slash_at = self->real_path.len; + + while (1) { + /* find the next slash (or return -1 if failed) */ + for (++slash_at;; ++slash_at) { + if (slash_at >= rpath_len) + return -1; + if (rpath[slash_at] == '/') + break; + } + /* change the slash to '\0', and check if the file exists */ + rpath[slash_at] = '\0'; + if (stat(rpath, &st) != 0) + return -1; + if (!S_ISDIR(st.st_mode)) + break; + /* restore slash, and continue the search */ + rpath[slash_at] = '/'; + } + + /* file found! */ + h2o_mimemap_type_t *mime_type = h2o_mimemap_get_type_by_extension(self->mimemap, h2o_get_filext(rpath, slash_at)); + switch (mime_type->type) { + case H2O_MIMEMAP_TYPE_MIMETYPE: + return -1; + case H2O_MIMEMAP_TYPE_DYNAMIC: { + h2o_iovec_t script_name = h2o_iovec_init(req->path_normalized.base, self->conf_path.len + slash_at - self->real_path.len); + h2o_iovec_t path_info = + h2o_iovec_init(req->path_normalized.base + script_name.len, req->path_normalized.len - script_name.len); + return delegate_dynamic_request(req, script_name, path_info, rpath, slash_at, mime_type); + } + } + fprintf(stderr, "unknown h2o_miemmap_type_t::type (%d)\n", (int)mime_type->type); + abort(); +} + +static void send_method_not_allowed(h2o_req_t *req) +{ + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_ALLOW, NULL, H2O_STRLIT("GET, HEAD")); + h2o_send_error_405(req, "Method Not Allowed", "method not allowed", H2O_SEND_ERROR_KEEP_HEADERS); +} + +static int serve_with_generator(struct st_h2o_sendfile_generator_t *generator, h2o_req_t *req, h2o_iovec_t resolved_path, + const char *rpath, size_t rpath_len, h2o_mimemap_type_t *mime_type) +{ + enum { METHOD_IS_GET, METHOD_IS_HEAD, METHOD_IS_OTHER } method_type; + size_t if_modified_since_header_index, if_none_match_header_index; + size_t range_header_index; + + /* determine the method */ + if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("GET"))) { + method_type = METHOD_IS_GET; + } else if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("HEAD"))) { + method_type = METHOD_IS_HEAD; + } else { + method_type = METHOD_IS_OTHER; + } + + /* obtain mime type */ + if (mime_type->type == H2O_MIMEMAP_TYPE_DYNAMIC) { + do_close(&generator->super, req); + return delegate_dynamic_request(req, resolved_path, h2o_iovec_init(NULL, 0), rpath, rpath_len, mime_type); + } + assert(mime_type->type == H2O_MIMEMAP_TYPE_MIMETYPE); + + /* if-non-match and if-modified-since */ + if ((if_none_match_header_index = h2o_find_header(&req->headers, H2O_TOKEN_IF_NONE_MATCH, SIZE_MAX)) != -1) { + h2o_iovec_t *if_none_match = &req->headers.entries[if_none_match_header_index].value; + char etag[H2O_FILECACHE_ETAG_MAXLEN + 1]; + size_t etag_len = h2o_filecache_get_etag(generator->file.ref, etag); + if (h2o_memis(if_none_match->base, if_none_match->len, etag, etag_len)) + goto NotModified; + } else if ((if_modified_since_header_index = h2o_find_header(&req->headers, H2O_TOKEN_IF_MODIFIED_SINCE, SIZE_MAX)) != -1) { + h2o_iovec_t *ims_vec = &req->headers.entries[if_modified_since_header_index].value; + struct tm ims_tm, *last_modified_tm; + if (h2o_time_parse_rfc1123(ims_vec->base, ims_vec->len, &ims_tm) == 0) { + last_modified_tm = h2o_filecache_get_last_modified(generator->file.ref, NULL); + if (!tm_is_lessthan(&ims_tm, last_modified_tm)) + goto NotModified; + } + } + + /* only allow GET or POST for static files */ + if (method_type == METHOD_IS_OTHER) { + do_close(&generator->super, req); + send_method_not_allowed(req); + return 0; + } + + /* if-range */ + if ((range_header_index = h2o_find_header(&req->headers, H2O_TOKEN_RANGE, SIZE_MAX)) != -1) { + h2o_iovec_t *range = &req->headers.entries[range_header_index].value; + size_t *range_infos, range_count; + range_infos = process_range(&req->pool, range, generator->bytesleft, &range_count); + if (range_infos == NULL) { + h2o_iovec_t content_range; + content_range.base = h2o_mem_alloc_pool(&req->pool, 32); + content_range.len = sprintf(content_range.base, "bytes */%zu", generator->bytesleft); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_RANGE, NULL, content_range.base, content_range.len); + h2o_send_error_416(req, "Request Range Not Satisfiable", "requested range not satisfiable", + H2O_SEND_ERROR_KEEP_HEADERS); + goto Close; + } + generator->ranged.range_count = range_count; + generator->ranged.range_infos = range_infos; + generator->ranged.current_range = 0; + generator->ranged.filesize = generator->bytesleft; + + /* set content-length according to range */ + if (range_count == 1) + generator->bytesleft = range_infos[1]; + else { + generator->ranged.mimetype = h2o_strdup(&req->pool, mime_type->data.mimetype.base, mime_type->data.mimetype.len); + size_t final_content_len = 0, size_tmp = 0, size_fixed_each_part, i; + generator->ranged.boundary.base = h2o_mem_alloc_pool(&req->pool, BOUNDARY_SIZE + 1); + generator->ranged.boundary.len = BOUNDARY_SIZE; + gen_rand_string(&generator->ranged.boundary); + i = generator->bytesleft; + while (i) { + i /= 10; + size_tmp++; + } + size_fixed_each_part = FIXED_PART_SIZE + mime_type->data.mimetype.len + size_tmp; + for (i = 0; i < range_count; i++) { + size_tmp = *range_infos++; + if (size_tmp == 0) + final_content_len++; + while (size_tmp) { + size_tmp /= 10; + final_content_len++; + } + + size_tmp = *(range_infos - 1); + final_content_len += *range_infos; + + size_tmp += *range_infos++ - 1; + if (size_tmp == 0) + final_content_len++; + while (size_tmp) { + size_tmp /= 10; + final_content_len++; + } + } + final_content_len += sizeof("\r\n--") - 1 + BOUNDARY_SIZE + sizeof("--\r\n") - 1 + size_fixed_each_part * range_count - + (sizeof("\r\n") - 1); + generator->bytesleft = final_content_len; + } + do_send_file(generator, req, 206, "Partial Content", mime_type->data.mimetype, &h2o_mime_attributes_as_is, + method_type == METHOD_IS_GET); + return 0; + } + + /* return file */ + do_send_file(generator, req, 200, "OK", mime_type->data.mimetype, &mime_type->data.attr, method_type == METHOD_IS_GET); + return 0; + +NotModified: + req->res.status = 304; + req->res.reason = "Not Modified"; + add_headers_unconditional(generator, req); + h2o_send_inline(req, NULL, 0); +Close: + do_close(&generator->super, req); + return 0; +} + +static int on_req(h2o_handler_t *_self, h2o_req_t *req) +{ + h2o_file_handler_t *self = (void *)_self; + char *rpath; + size_t rpath_len, req_path_prefix; + struct st_h2o_sendfile_generator_t *generator = NULL; + int is_dir; + + if (req->path_normalized.len < self->conf_path.len) { + h2o_iovec_t dest = h2o_uri_escape(&req->pool, self->conf_path.base, self->conf_path.len, "/"); + if (req->query_at != SIZE_MAX) + dest = h2o_concat(&req->pool, dest, h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at)); + h2o_send_redirect(req, 301, "Moved Permanently", dest.base, dest.len); + return 0; + } + + /* build path (still unterminated at the end of the block) */ + req_path_prefix = self->conf_path.len; + rpath = alloca(self->real_path.len + (req->path_normalized.len - req_path_prefix) + self->max_index_file_len + 1); + rpath_len = 0; + memcpy(rpath + rpath_len, self->real_path.base, self->real_path.len); + rpath_len += self->real_path.len; + memcpy(rpath + rpath_len, req->path_normalized.base + req_path_prefix, req->path_normalized.len - req_path_prefix); + rpath_len += req->path_normalized.len - req_path_prefix; + + h2o_iovec_t resolved_path = req->path_normalized; + + /* build generator (as well as terminating the rpath and its length upon success) */ + if (rpath[rpath_len - 1] == '/') { + h2o_iovec_t *index_file; + for (index_file = self->index_files; index_file->base != NULL; ++index_file) { + memcpy(rpath + rpath_len, index_file->base, index_file->len); + rpath[rpath_len + index_file->len] = '\0'; + if ((generator = create_generator(req, rpath, rpath_len + index_file->len, &is_dir, self->flags)) != NULL) { + rpath_len += index_file->len; + resolved_path = h2o_concat(&req->pool, req->path_normalized, *index_file); + goto Opened; + } + if (is_dir) { + /* note: apache redirects "path/" to "path/index.txt/" if index.txt is a dir */ + h2o_iovec_t dest = h2o_concat(&req->pool, req->path_normalized, *index_file, h2o_iovec_init(H2O_STRLIT("/"))); + dest = h2o_uri_escape(&req->pool, dest.base, dest.len, "/"); + if (req->query_at != SIZE_MAX) + dest = + h2o_concat(&req->pool, dest, h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at)); + h2o_send_redirect(req, 301, "Moved Permantently", dest.base, dest.len); + return 0; + } + if (errno != ENOENT) + break; + } + if (index_file->base == NULL && (self->flags & H2O_FILE_FLAG_DIR_LISTING) != 0) { + rpath[rpath_len] = '\0'; + int is_get = 0; + if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("GET"))) { + is_get = 1; + } else if (h2o_memis(req->method.base, req->method.len, H2O_STRLIT("HEAD"))) { + /* ok */ + } else { + send_method_not_allowed(req); + return 0; + } + if (send_dir_listing(req, rpath, rpath_len, is_get) == 0) + return 0; + } + } else { + rpath[rpath_len] = '\0'; + if ((generator = create_generator(req, rpath, rpath_len, &is_dir, self->flags)) != NULL) + goto Opened; + if (is_dir) { + h2o_iovec_t dest = h2o_concat(&req->pool, req->path_normalized, h2o_iovec_init(H2O_STRLIT("/"))); + dest = h2o_uri_escape(&req->pool, dest.base, dest.len, "/"); + if (req->query_at != SIZE_MAX) + dest = h2o_concat(&req->pool, dest, h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at)); + h2o_send_redirect(req, 301, "Moved Permanently", dest.base, dest.len); + return 0; + } + } + /* failed to open */ + + if (errno == ENFILE || errno == EMFILE) { + h2o_send_error_503(req, "Service Unavailable", "please try again later", 0); + } else { + if (h2o_mimemap_has_dynamic_type(self->mimemap) && try_dynamic_request(self, req, rpath, rpath_len) == 0) + return 0; + if (errno == ENOENT || errno == ENOTDIR) { + return -1; + } else { + h2o_send_error_403(req, "Access Forbidden", "access forbidden", 0); + } + } + return 0; + +Opened: + return serve_with_generator(generator, req, resolved_path, rpath, rpath_len, + h2o_mimemap_get_type_by_extension(self->mimemap, h2o_get_filext(rpath, rpath_len))); +} + +static void on_context_init(h2o_handler_t *_self, h2o_context_t *ctx) +{ + h2o_file_handler_t *self = (void *)_self; + + h2o_mimemap_on_context_init(self->mimemap, ctx); +} + +static void on_context_dispose(h2o_handler_t *_self, h2o_context_t *ctx) +{ + h2o_file_handler_t *self = (void *)_self; + + h2o_mimemap_on_context_dispose(self->mimemap, ctx); +} + +static void on_dispose(h2o_handler_t *_self) +{ + h2o_file_handler_t *self = (void *)_self; + size_t i; + + free(self->conf_path.base); + free(self->real_path.base); + h2o_mem_release_shared(self->mimemap); + for (i = 0; self->index_files[i].base != NULL; ++i) + free(self->index_files[i].base); +} + +h2o_file_handler_t *h2o_file_register(h2o_pathconf_t *pathconf, const char *real_path, const char **index_files, + h2o_mimemap_t *mimemap, int flags) +{ + h2o_file_handler_t *self; + size_t i; + + if (index_files == NULL) + index_files = default_index_files; + + /* allocate memory */ + for (i = 0; index_files[i] != NULL; ++i) + ; + self = + (void *)h2o_create_handler(pathconf, offsetof(h2o_file_handler_t, index_files[0]) + sizeof(self->index_files[0]) * (i + 1)); + + /* setup callbacks */ + self->super.on_context_init = on_context_init; + self->super.on_context_dispose = on_context_dispose; + self->super.dispose = on_dispose; + self->super.on_req = on_req; + + /* setup attributes */ + self->conf_path = h2o_strdup_slashed(NULL, pathconf->path.base, pathconf->path.len); + self->real_path = h2o_strdup_slashed(NULL, real_path, SIZE_MAX); + if (mimemap != NULL) { + h2o_mem_addref_shared(mimemap); + self->mimemap = mimemap; + } else { + self->mimemap = h2o_mimemap_create(); + } + self->flags = flags; + for (i = 0; index_files[i] != NULL; ++i) { + self->index_files[i] = h2o_strdup(NULL, index_files[i], SIZE_MAX); + if (self->max_index_file_len < self->index_files[i].len) + self->max_index_file_len = self->index_files[i].len; + } + + return self; +} + +h2o_mimemap_t *h2o_file_get_mimemap(h2o_file_handler_t *handler) +{ + return handler->mimemap; +} + +static void specific_handler_on_context_init(h2o_handler_t *_self, h2o_context_t *ctx) +{ + struct st_h2o_specific_file_handler_t *self = (void *)_self; + + if (self->mime_type->type == H2O_MIMEMAP_TYPE_DYNAMIC) + h2o_context_init_pathconf_context(ctx, &self->mime_type->data.dynamic.pathconf); +} + +static void specific_handler_on_context_dispose(h2o_handler_t *_self, h2o_context_t *ctx) +{ + struct st_h2o_specific_file_handler_t *self = (void *)_self; + + if (self->mime_type->type == H2O_MIMEMAP_TYPE_DYNAMIC) + h2o_context_dispose_pathconf_context(ctx, &self->mime_type->data.dynamic.pathconf); +} + +static void specific_handler_on_dispose(h2o_handler_t *_self) +{ + struct st_h2o_specific_file_handler_t *self = (void *)_self; + + free(self->real_path.base); + h2o_mem_release_shared(self->mime_type); +} + +static int specific_handler_on_req(h2o_handler_t *_self, h2o_req_t *req) +{ + struct st_h2o_specific_file_handler_t *self = (void *)_self; + struct st_h2o_sendfile_generator_t *generator; + int is_dir; + + /* open file (or send error or return -1) */ + if ((generator = create_generator(req, self->real_path.base, self->real_path.len, &is_dir, self->flags)) == NULL) { + if (is_dir) { + h2o_send_error_403(req, "Access Forbidden", "access forbidden", 0); + } else if (errno == ENOENT) { + return -1; + } else if (errno == ENFILE || errno == EMFILE) { + h2o_send_error_503(req, "Service Unavailable", "please try again later", 0); + } else { + h2o_send_error_403(req, "Access Forbidden", "access forbidden", 0); + } + return 0; + } + + return serve_with_generator(generator, req, req->path_normalized, self->real_path.base, self->real_path.len, self->mime_type); +} + +h2o_handler_t *h2o_file_register_file(h2o_pathconf_t *pathconf, const char *real_path, h2o_mimemap_type_t *mime_type, int flags) +{ + struct st_h2o_specific_file_handler_t *self = (void *)h2o_create_handler(pathconf, sizeof(*self)); + + self->super.on_context_init = specific_handler_on_context_init; + self->super.on_context_dispose = specific_handler_on_context_dispose; + self->super.dispose = specific_handler_on_dispose; + self->super.on_req = specific_handler_on_req; + + self->real_path = h2o_strdup(NULL, real_path, SIZE_MAX); + h2o_mem_addref_shared(mime_type); + self->mime_type = mime_type; + self->flags = flags; + + return &self->super; +} diff --git a/web/server/h2o/libh2o/lib/handler/file/_templates.c.h b/web/server/h2o/libh2o/lib/handler/file/_templates.c.h new file mode 100644 index 000000000..11b73577c --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/file/_templates.c.h @@ -0,0 +1,90 @@ +/* + * 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. + * + * lib/file/templates.c.h is automatically generated from lib/file/_templates.h + * with command: + * picotemplate.pl --conf=misc/picotemplate-conf.pl lib/file/_templates.c.h + */ + +#include <limits.h> + +static int cmpstrptr(const void *_x, const void *_y) +{ + const char *x = *(const char **)_x; + const char *y = *(const char **)_y; + return strcmp(x, y); +} + +#if !defined(NAME_MAX) || defined(__linux__) +/* readdir(3) is known to be thread-safe on Linux and should be thread-safe on a platform that does not have a predefined value for + NAME_MAX */ +#define FOREACH_DIRENT(dp, dent) \ + struct dirent *dent; \ + while ((dent = readdir(dp)) != NULL) +#else +#define FOREACH_DIRENT(dp, dent) \ + struct { \ + struct dirent d; \ + char s[NAME_MAX + 1]; \ + } dent_; \ + struct dirent *dentp, *dent = &dent_.d; \ + int ret; \ + while ((ret = readdir_r(dp, dent, &dentp)) == 0 && dentp != NULL) +#endif /* FOREACH_DIRENT */ + +static h2o_buffer_t *build_dir_listing_html(h2o_mem_pool_t *pool, h2o_iovec_t path_normalized, DIR* dp) +{ + H2O_VECTOR(char *) files = {NULL}; + + { /* build list of files */ + FOREACH_DIRENT(dp, dent) + { + if (strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) + continue; + h2o_vector_reserve(pool, &files, files.size + 1); + files.entries[files.size++] = h2o_strdup(pool, dent->d_name, SIZE_MAX).base; + } + if (files.size > 1) + qsort(files.entries, files.size, sizeof(files.entries[0]), cmpstrptr); + } + + h2o_buffer_t *_; + h2o_iovec_t path_normalized_escaped = h2o_htmlescape(pool, path_normalized.base, path_normalized.len); + + h2o_buffer_init(&_, &h2o_socket_buffer_prototype); + +?<!DOCTYPE html> +?<TITLE>Index of <?= path_normalized_escaped ?></TITLE> +?<H2>Index of <?= path_normalized_escaped ?></H2> +?<UL> +?<LI><A HREF="..">Parent Directory</A> + + size_t i; + for (i = 0; i != files.size; ++i) { + h2o_iovec_t link_escaped = h2o_uri_escape(pool, files.entries[i], strlen(files.entries[i]), NULL); + link_escaped = h2o_htmlescape(pool, link_escaped.base, link_escaped.len); + h2o_iovec_t label_escaped = h2o_htmlescape(pool, files.entries[i], strlen(files.entries[i])); +?<LI><A HREF="<?= link_escaped ?>"><?= label_escaped ?></A> + } +?</UL> + + return _; +} diff --git a/web/server/h2o/libh2o/lib/handler/file/templates.c.h b/web/server/h2o/libh2o/lib/handler/file/templates.c.h new file mode 100644 index 000000000..24c12dae5 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/file/templates.c.h @@ -0,0 +1,171 @@ +/* + * 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. + * + * lib/file/templates.c.h is automatically generated from lib/file/_templates.h + * with command: + * picotemplate.pl --conf=misc/picotemplate-conf.pl lib/file/_templates.c.h + */ + +#include <limits.h> + +static int cmpstrptr(const void *_x, const void *_y) +{ + const char *x = *(const char **)_x; + const char *y = *(const char **)_y; + return strcmp(x, y); +} + +#if !defined(NAME_MAX) || defined(__linux__) +/* readdir(3) is known to be thread-safe on Linux and should be thread-safe on a platform that does not have a predefined value for + NAME_MAX */ +#define FOREACH_DIRENT(dp, dent) \ + struct dirent *dent; \ + while ((dent = readdir(dp)) != NULL) +#else +#define FOREACH_DIRENT(dp, dent) \ + struct { \ + struct dirent d; \ + char s[NAME_MAX + 1]; \ + } dent_; \ + struct dirent *dentp, *dent = &dent_.d; \ + int ret; \ + while ((ret = readdir_r(dp, dent, &dentp)) == 0 && dentp != NULL) +#endif /* FOREACH_DIRENT */ + +static h2o_buffer_t *build_dir_listing_html(h2o_mem_pool_t *pool, h2o_iovec_t path_normalized, DIR *dp) +{ + H2O_VECTOR(char *) files = {NULL}; + + { /* build list of files */ + FOREACH_DIRENT(dp, dent) + { + if (strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) + continue; + h2o_vector_reserve(pool, &files, files.size + 1); + files.entries[files.size++] = h2o_strdup(pool, dent->d_name, SIZE_MAX).base; + } + if (files.size > 1) + qsort(files.entries, files.size, sizeof(files.entries[0]), cmpstrptr); + } + + h2o_buffer_t *_; + h2o_iovec_t path_normalized_escaped = h2o_htmlescape(pool, path_normalized.base, path_normalized.len); + + h2o_buffer_init(&_, &h2o_socket_buffer_prototype); + + { + h2o_iovec_t _s = (h2o_iovec_init(H2O_STRLIT("<!DOCTYPE html>\n<TITLE>Index of "))); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (path_normalized_escaped); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (h2o_iovec_init(H2O_STRLIT("</TITLE>\n<H2>Index of "))); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (path_normalized_escaped); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (h2o_iovec_init(H2O_STRLIT("</H2>\n<UL>\n<LI><A HREF=\"..\">Parent Directory</A>\n"))); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + + size_t i; + for (i = 0; i != files.size; ++i) { + h2o_iovec_t link_escaped = h2o_uri_escape(pool, files.entries[i], strlen(files.entries[i]), NULL); + link_escaped = h2o_htmlescape(pool, link_escaped.base, link_escaped.len); + h2o_iovec_t label_escaped = h2o_htmlescape(pool, files.entries[i], strlen(files.entries[i])); + { + h2o_iovec_t _s = (h2o_iovec_init(H2O_STRLIT("<LI><A HREF=\""))); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (link_escaped); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (h2o_iovec_init(H2O_STRLIT("\">"))); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (label_escaped); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + { + h2o_iovec_t _s = (h2o_iovec_init(H2O_STRLIT("</A>\n"))); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + } + { + h2o_iovec_t _s = (h2o_iovec_init(H2O_STRLIT("</UL>\n"))); + if (_s.len != 0 && _s.base[_s.len - 1] == '\n') + --_s.len; + h2o_buffer_reserve(&_, _s.len); + memcpy(_->bytes + _->size, _s.base, _s.len); + _->size += _s.len; + } + + return _; +} diff --git a/web/server/h2o/libh2o/lib/handler/headers.c b/web/server/h2o/libh2o/lib/handler/headers.c new file mode 100644 index 000000000..973976b35 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/headers.c @@ -0,0 +1,58 @@ +/* + * 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.h" + +struct st_headers_filter_t { + h2o_filter_t super; + h2o_headers_command_t *cmds; +}; + +static void on_setup_ostream(h2o_filter_t *_self, h2o_req_t *req, h2o_ostream_t **slot) +{ + struct st_headers_filter_t *self = (void *)_self; + h2o_headers_command_t *cmd; + + for (cmd = self->cmds; cmd->cmd != H2O_HEADERS_CMD_NULL; ++cmd) + h2o_rewrite_headers(&req->pool, &req->res.headers, cmd); + + h2o_setup_next_ostream(req, slot); +} + +void h2o_headers_register(h2o_pathconf_t *pathconf, h2o_headers_command_t *cmds) +{ + struct st_headers_filter_t *self = (void *)h2o_create_filter(pathconf, sizeof(*self)); + + self->super.on_setup_ostream = on_setup_ostream; + self->cmds = cmds; +} + +int h2o_headers_is_prohibited_name(const h2o_token_t *token) +{ + /* prohibit connection-specific headers */ + if (token == H2O_TOKEN_CONNECTION || token == H2O_TOKEN_CONTENT_LENGTH || token == H2O_TOKEN_TRANSFER_ENCODING) + return 1; + /* prohibit headers added at protocol layer */ + if (token == H2O_TOKEN_DATE || token == H2O_TOKEN_SERVER) + return 1; + /* all others are permitted */ + return 0; +} diff --git a/web/server/h2o/libh2o/lib/handler/headers_util.c b/web/server/h2o/libh2o/lib/handler/headers_util.c new file mode 100644 index 000000000..5ecacfa54 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/headers_util.c @@ -0,0 +1,114 @@ +#include "h2o.h" + +static h2o_header_t *find_header(h2o_headers_t *headers, h2o_headers_command_t *cmd) +{ + size_t index; + + if (h2o_iovec_is_token(cmd->name)) { + index = h2o_find_header(headers, (void *)cmd->name, SIZE_MAX); + } else { + index = h2o_find_header_by_str(headers, cmd->name->base, cmd->name->len, SIZE_MAX); + } + if (index == SIZE_MAX) + return NULL; + return headers->entries + index; +} + +static void remove_header(h2o_headers_t *headers, h2o_headers_command_t *cmd) +{ + size_t src, dst = 0; + + for (src = 0; src != headers->size; ++src) { + if (h2o_iovec_is_token(cmd->name)) { + if (headers->entries[src].name == cmd->name) + continue; + } else { + if (h2o_memis(headers->entries[src].name->base, headers->entries[src].name->len, cmd->name->base, cmd->name->len)) + continue; + } + /* not matched */ + if (dst != src) + headers->entries[dst] = headers->entries[src]; + ++dst; + } + headers->size = dst; +} + +void h2o_headers_append_command(h2o_headers_command_t **cmds, int cmd, h2o_iovec_t *name, h2o_iovec_t value) +{ + h2o_headers_command_t *new_cmds; + size_t cnt; + + if (*cmds != NULL) { + for (cnt = 0; (*cmds)[cnt].cmd != H2O_HEADERS_CMD_NULL; ++cnt) + ; + } else { + cnt = 0; + } + + new_cmds = h2o_mem_alloc_shared(NULL, (cnt + 2) * sizeof(*new_cmds), NULL); + if (*cmds != NULL) + memcpy(new_cmds, *cmds, cnt * sizeof(*new_cmds)); + new_cmds[cnt] = (h2o_headers_command_t){cmd, name, value}; + new_cmds[cnt + 1] = (h2o_headers_command_t){H2O_HEADERS_CMD_NULL}; + + if (*cmds != NULL) + h2o_mem_release_shared(*cmds); + *cmds = new_cmds; +} + +void h2o_rewrite_headers(h2o_mem_pool_t *pool, h2o_headers_t *headers, h2o_headers_command_t *cmd) +{ + h2o_header_t *target; + + switch (cmd->cmd) { + case H2O_HEADERS_CMD_ADD: + goto AddHeader; + case H2O_HEADERS_CMD_APPEND: + if ((target = find_header(headers, cmd)) == NULL) + goto AddHeader; + goto AppendToken; + case H2O_HEADERS_CMD_MERGE: + if ((target = find_header(headers, cmd)) == NULL) + goto AddHeader; + if (h2o_contains_token(target->value.base, target->value.len, cmd->value.base, cmd->value.len, ',')) + return; + goto AppendToken; + case H2O_HEADERS_CMD_SET: + remove_header(headers, cmd); + goto AddHeader; + case H2O_HEADERS_CMD_SETIFEMPTY: + if (find_header(headers, cmd) != NULL) + return; + goto AddHeader; + case H2O_HEADERS_CMD_UNSET: + remove_header(headers, cmd); + return; + } + + assert(!"FIXME"); + return; + +AddHeader: + if (h2o_iovec_is_token(cmd->name)) { + h2o_add_header(pool, headers, (void *)cmd->name, NULL, cmd->value.base, cmd->value.len); + } else { + h2o_add_header_by_str(pool, headers, cmd->name->base, cmd->name->len, 0, NULL, cmd->value.base, cmd->value.len); + } + return; + +AppendToken: + if (target->value.len != 0) { + h2o_iovec_t v; + v.len = target->value.len + 2 + cmd->value.len; + v.base = h2o_mem_alloc_pool(pool, v.len); + memcpy(v.base, target->value.base, target->value.len); + v.base[target->value.len] = ','; + v.base[target->value.len + 1] = ' '; + memcpy(v.base + target->value.len + 2, cmd->value.base, cmd->value.len); + target->value = v; + } else { + target->value = cmd->value; + } + return; +} diff --git a/web/server/h2o/libh2o/lib/handler/http2_debug_state.c b/web/server/h2o/libh2o/lib/handler/http2_debug_state.c new file mode 100644 index 000000000..0aa0bd1b1 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/http2_debug_state.c @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2016 DeNA Co., Ltd., Ichito Nagata + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ +#include <inttypes.h> +#include "h2o.h" + +struct st_h2o_http2_debug_state_handler_t { + h2o_handler_t super; + int hpack_enabled; +}; + +static int on_req(h2o_handler_t *_self, h2o_req_t *req) +{ + struct st_h2o_http2_debug_state_handler_t *self = (void *)_self; + + static h2o_generator_t generator = {NULL, NULL}; + + if (req->conn->callbacks->get_debug_state == NULL) { + return -1; + } + + h2o_http2_debug_state_t *debug_state = req->conn->callbacks->get_debug_state(req, self->hpack_enabled); + + // stringify these variables to embed in Debug Header + h2o_iovec_t conn_flow_in, conn_flow_out; + conn_flow_in.base = h2o_mem_alloc_pool(&req->pool, sizeof(H2O_INT64_LONGEST_STR)); + conn_flow_in.len = sprintf(conn_flow_in.base, "%zd", debug_state->conn_flow_in); + conn_flow_out.base = h2o_mem_alloc_pool(&req->pool, sizeof(H2O_INT64_LONGEST_STR)); + conn_flow_out.len = sprintf(conn_flow_out.base, "%zd", debug_state->conn_flow_out); + + req->res.status = 200; + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, H2O_STRLIT("application/json; charset=utf-8")); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CACHE_CONTROL, NULL, H2O_STRLIT("no-cache, no-store")); + h2o_add_header_by_str(&req->pool, &req->res.headers, H2O_STRLIT("conn-flow-in"), 0, NULL, conn_flow_in.base, conn_flow_in.len); + h2o_add_header_by_str(&req->pool, &req->res.headers, H2O_STRLIT("conn-flow-out"), 0, NULL, conn_flow_out.base, + conn_flow_out.len); + + h2o_start_response(req, &generator); + h2o_send(req, debug_state->json.entries, + h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("HEAD")) ? 0 : debug_state->json.size, + H2O_SEND_STATE_FINAL); + return 0; +} + +void h2o_http2_debug_state_register(h2o_hostconf_t *conf, int hpack_enabled) +{ + h2o_pathconf_t *pathconf = h2o_config_register_path(conf, "/.well-known/h2/state", 0); + struct st_h2o_http2_debug_state_handler_t *self = (void *)h2o_create_handler(pathconf, sizeof(*self)); + self->super.on_req = on_req; + self->hpack_enabled = hpack_enabled; +} diff --git a/web/server/h2o/libh2o/lib/handler/mimemap.c b/web/server/h2o/libh2o/lib/handler/mimemap.c new file mode 100644 index 000000000..764362da0 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mimemap.c @@ -0,0 +1,419 @@ +/* + * 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 <stdlib.h> +#include <string.h> +#include "khash.h" +#include "h2o.h" + +KHASH_MAP_INIT_STR(extmap, h2o_mimemap_type_t *) + +static inline khint_t hash_mimemap_type(h2o_mimemap_type_t *mimetype) +{ + khint_t h = 0; + size_t i; + for (i = 0; i != mimetype->data.mimetype.len; ++i) + h = (h << 5) - h + (khint_t)mimetype->data.mimetype.base[i]; + return h; +} + +static inline int mimemap_type_equals(h2o_mimemap_type_t *x, h2o_mimemap_type_t *y) +{ + return h2o_memis(x->data.mimetype.base, x->data.mimetype.len, y->data.mimetype.base, y->data.mimetype.len); +} + +KHASH_INIT(typeset, h2o_mimemap_type_t *, char, 0, hash_mimemap_type, mimemap_type_equals) + +h2o_mime_attributes_t h2o_mime_attributes_as_is; + +struct st_h2o_mimemap_t { + khash_t(extmap) * extmap; + khash_t(typeset) * typeset; /* refs point to the entries in extmap */ + h2o_mimemap_type_t *default_type; + size_t num_dynamic; +}; + +static h2o_iovec_t dupref(const char *s) +{ + h2o_iovec_t ret; + ret.len = strlen(s); + ret.base = h2o_mem_alloc_shared(NULL, ret.len + 1, NULL); + memcpy(ret.base, s, ret.len + 1); + return ret; +} + +static void on_dispose(void *_mimemap) +{ + h2o_mimemap_t *mimemap = _mimemap; + const char *ext; + h2o_mimemap_type_t *type; + + kh_destroy(typeset, mimemap->typeset); + kh_foreach(mimemap->extmap, ext, type, { + h2o_mem_release_shared((char *)ext); + h2o_mem_release_shared(type); + }); + kh_destroy(extmap, mimemap->extmap); + h2o_mem_release_shared(mimemap->default_type); +} + +static void on_unlink(h2o_mimemap_t *mimemap, h2o_mimemap_type_t *type) +{ + switch (type->type) { + case H2O_MIMEMAP_TYPE_MIMETYPE: + break; + case H2O_MIMEMAP_TYPE_DYNAMIC: + --mimemap->num_dynamic; + break; + } +} + +static void on_link(h2o_mimemap_t *mimemap, h2o_mimemap_type_t *type) +{ + switch (type->type) { + case H2O_MIMEMAP_TYPE_MIMETYPE: + break; + case H2O_MIMEMAP_TYPE_DYNAMIC: + ++mimemap->num_dynamic; + break; + } +} + +static void rebuild_typeset(h2o_mimemap_t *mimemap) +{ + kh_clear(typeset, mimemap->typeset); + + const char *ext; + h2o_mimemap_type_t *mime; + kh_foreach(mimemap->extmap, ext, mime, { + if (mime->type == H2O_MIMEMAP_TYPE_MIMETYPE) { + khiter_t iter = kh_get(typeset, mimemap->typeset, mime); + if (iter == kh_end(mimemap->typeset)) { + int r; + kh_put(typeset, mimemap->typeset, mime, &r); + } + } + }); +} + +static h2o_mimemap_type_t *create_extension_type(const char *mime, h2o_mime_attributes_t *attr) +{ + h2o_mimemap_type_t *type = h2o_mem_alloc_shared(NULL, sizeof(*type) + strlen(mime) + 1, NULL); + size_t i; + + memset(type, 0, sizeof(*type)); + + type->type = H2O_MIMEMAP_TYPE_MIMETYPE; + + /* normalize-copy type->data.mimetype */ + type->data.mimetype.base = (char *)type + sizeof(*type); + for (i = 0; mime[i] != '\0' && mime[i] != ';'; ++i) + type->data.mimetype.base[i] = h2o_tolower(mime[i]); + for (; mime[i] != '\0'; ++i) + type->data.mimetype.base[i] = mime[i]; + type->data.mimetype.base[i] = '\0'; + type->data.mimetype.len = i; + + if (attr != NULL) { + type->data.attr = *attr; + } else { + h2o_mimemap_get_default_attributes(mime, &type->data.attr); + } + + return type; +} + +static void dispose_dynamic_type(h2o_mimemap_type_t *type) +{ + h2o_config_dispose_pathconf(&type->data.dynamic.pathconf); +} + +static h2o_mimemap_type_t *create_dynamic_type(h2o_globalconf_t *globalconf, h2o_mimemap_t *mimemap) +{ + h2o_mimemap_type_t *type = h2o_mem_alloc_shared(NULL, sizeof(*type), (void (*)(void *))dispose_dynamic_type); + + type->type = H2O_MIMEMAP_TYPE_DYNAMIC; + memset(&type->data.dynamic, 0, sizeof(type->data.dynamic)); + h2o_config_init_pathconf(&type->data.dynamic.pathconf, globalconf, NULL, mimemap); + + return type; +} + +h2o_mimemap_t *h2o_mimemap_create() +{ + h2o_mimemap_t *mimemap = h2o_mem_alloc_shared(NULL, sizeof(*mimemap), on_dispose); + + mimemap->extmap = kh_init(extmap); + mimemap->typeset = kh_init(typeset); + mimemap->default_type = create_extension_type("application/octet-stream", NULL); + mimemap->num_dynamic = 0; + on_link(mimemap, mimemap->default_type); + + { /* setup the tiny default */ + static const char *default_types[] = { +#define MIMEMAP(ext, mime) ext, mime, +#include "mimemap/defaults.c.h" +#undef MIMEMAP + NULL}; + const char **p; + for (p = default_types; *p != NULL; p += 2) + h2o_mimemap_define_mimetype(mimemap, p[0], p[1], NULL); + } + rebuild_typeset(mimemap); + + return mimemap; +} + +h2o_mimemap_t *h2o_mimemap_clone(h2o_mimemap_t *src) +{ + h2o_mimemap_t *dst = h2o_mem_alloc_shared(NULL, sizeof(*dst), on_dispose); + const char *ext; + h2o_mimemap_type_t *type; + + dst->extmap = kh_init(extmap); + dst->typeset = kh_init(typeset); + kh_foreach(src->extmap, ext, type, { + int r; + khiter_t iter = kh_put(extmap, dst->extmap, ext, &r); + kh_val(dst->extmap, iter) = type; + h2o_mem_addref_shared((char *)ext); + h2o_mem_addref_shared(type); + on_link(dst, type); + }); + dst->default_type = src->default_type; + h2o_mem_addref_shared(dst->default_type); + on_link(dst, dst->default_type); + rebuild_typeset(dst); + + return dst; +} + +void h2o_mimemap_on_context_init(h2o_mimemap_t *mimemap, h2o_context_t *ctx) +{ + const char *ext; + h2o_mimemap_type_t *type; + + kh_foreach(mimemap->extmap, ext, type, { + switch (type->type) { + case H2O_MIMEMAP_TYPE_DYNAMIC: + h2o_context_init_pathconf_context(ctx, &type->data.dynamic.pathconf); + break; + case H2O_MIMEMAP_TYPE_MIMETYPE: + break; + } + }); +} + +void h2o_mimemap_on_context_dispose(h2o_mimemap_t *mimemap, h2o_context_t *ctx) +{ + const char *ext; + h2o_mimemap_type_t *type; + + kh_foreach(mimemap->extmap, ext, type, { + switch (type->type) { + case H2O_MIMEMAP_TYPE_DYNAMIC: + h2o_context_dispose_pathconf_context(ctx, &type->data.dynamic.pathconf); + break; + case H2O_MIMEMAP_TYPE_MIMETYPE: + break; + } + }); +} + +int h2o_mimemap_has_dynamic_type(h2o_mimemap_t *mimemap) +{ + return mimemap->num_dynamic != 0; +} + +void h2o_mimemap_set_default_type(h2o_mimemap_t *mimemap, const char *mime, h2o_mime_attributes_t *attr) +{ + h2o_mimemap_type_t *new_type; + + /* obtain or create new type */ + if ((new_type = h2o_mimemap_get_type_by_mimetype(mimemap, h2o_iovec_init(mime, strlen(mime)), 1)) != NULL && + (attr == NULL || memcmp(&new_type->data.attr, attr, sizeof(*attr)) == 0)) { + h2o_mem_addref_shared(new_type); + } else { + new_type = create_extension_type(mime, attr); + } + + /* unlink the old one */ + on_unlink(mimemap, mimemap->default_type); + h2o_mem_release_shared(mimemap->default_type); + + /* update */ + mimemap->default_type = new_type; + on_link(mimemap, new_type); + rebuild_typeset(mimemap); +} + +static void set_type(h2o_mimemap_t *mimemap, const char *ext, h2o_mimemap_type_t *type) +{ + /* obtain key, and remove the old value */ + khiter_t iter = kh_get(extmap, mimemap->extmap, ext); + if (iter != kh_end(mimemap->extmap)) { + h2o_mimemap_type_t *oldtype = kh_val(mimemap->extmap, iter); + on_unlink(mimemap, oldtype); + h2o_mem_release_shared(oldtype); + } else { + int ret; + iter = kh_put(extmap, mimemap->extmap, dupref(ext).base, &ret); + assert(iter != kh_end(mimemap->extmap)); + } + + /* update */ + h2o_mem_addref_shared(type); + kh_val(mimemap->extmap, iter) = type; + on_link(mimemap, type); + rebuild_typeset(mimemap); +} + +void h2o_mimemap_define_mimetype(h2o_mimemap_t *mimemap, const char *ext, const char *mime, h2o_mime_attributes_t *attr) +{ + h2o_mimemap_type_t *new_type; + + if ((new_type = h2o_mimemap_get_type_by_mimetype(mimemap, h2o_iovec_init(mime, strlen(mime)), 1)) != NULL && + (attr == NULL || memcmp(&new_type->data.attr, attr, sizeof(*attr)) == 0)) { + h2o_mem_addref_shared(new_type); + } else { + new_type = create_extension_type(mime, attr); + } + set_type(mimemap, ext, new_type); + h2o_mem_release_shared(new_type); +} + +h2o_mimemap_type_t *h2o_mimemap_define_dynamic(h2o_mimemap_t *mimemap, const char **exts, h2o_globalconf_t *globalconf) +{ + /* FIXME: fix memory leak introduced by this a cyclic link (mimemap -> new_type -> mimemap) + * note also that we may want to update the reference from the dynamic type to the mimemap as we clone the mimemap, + * but doing so naively would cause unnecessary copies of fastcgi.spawns... */ + h2o_mimemap_type_t *new_type = create_dynamic_type(globalconf, mimemap); + size_t i; + + for (i = 0; exts[i] != NULL; ++i) + set_type(mimemap, exts[i], new_type); + h2o_mem_release_shared(new_type); + return new_type; +} + +void h2o_mimemap_remove_type(h2o_mimemap_t *mimemap, const char *ext) +{ + khiter_t iter = kh_get(extmap, mimemap->extmap, ext); + if (iter != kh_end(mimemap->extmap)) { + const char *key = kh_key(mimemap->extmap, iter); + h2o_mimemap_type_t *type = kh_val(mimemap->extmap, iter); + on_unlink(mimemap, type); + h2o_mem_release_shared(type); + kh_del(extmap, mimemap->extmap, iter); + h2o_mem_release_shared((char *)key); + rebuild_typeset(mimemap); + } +} + +void h2o_mimemap_clear_types(h2o_mimemap_t *mimemap) +{ + khiter_t iter; + + for (iter = kh_begin(mimemap->extmap); iter != kh_end(mimemap->extmap); ++iter) { + if (!kh_exist(mimemap->extmap, iter)) continue; + const char *key = kh_key(mimemap->extmap, iter); + h2o_mimemap_type_t *type = kh_val(mimemap->extmap, iter); + on_unlink(mimemap, type); + h2o_mem_release_shared(type); + kh_del(extmap, mimemap->extmap, iter); + h2o_mem_release_shared((char *)key); + } + rebuild_typeset(mimemap); +} + +h2o_mimemap_type_t *h2o_mimemap_get_default_type(h2o_mimemap_t *mimemap) +{ + return mimemap->default_type; +} + +h2o_mimemap_type_t *h2o_mimemap_get_type_by_extension(h2o_mimemap_t *mimemap, h2o_iovec_t ext) +{ + char lcbuf[256]; + + if (0 < ext.len && ext.len < sizeof(lcbuf)) { + memcpy(lcbuf, ext.base, ext.len); + h2o_strtolower(lcbuf, ext.len); + lcbuf[ext.len] = '\0'; + khiter_t iter = kh_get(extmap, mimemap->extmap, lcbuf); + if (iter != kh_end(mimemap->extmap)) + return kh_val(mimemap->extmap, iter); + } + return mimemap->default_type; +} + +h2o_mimemap_type_t *h2o_mimemap_get_type_by_mimetype(h2o_mimemap_t *mimemap, h2o_iovec_t mime, int exact_match_only) +{ + h2o_mimemap_type_t key = {H2O_MIMEMAP_TYPE_MIMETYPE}; + khiter_t iter; + size_t type_end_at; + + /* exact match */ + key.data.mimetype = mime; + if ((iter = kh_get(typeset, mimemap->typeset, &key)) != kh_end(mimemap->typeset)) + return kh_key(mimemap->typeset, iter); + + if (!exact_match_only) { + /* determine the end of the type */ + for (type_end_at = 0; type_end_at != mime.len; ++type_end_at) + if (mime.base[type_end_at] == ';' || mime.base[type_end_at] == ' ') + goto HasAttributes; + } + return NULL; + +HasAttributes: + /* perform search without attributes */ + key.data.mimetype.len = type_end_at; + if ((iter = kh_get(typeset, mimemap->typeset, &key)) != kh_end(mimemap->typeset)) + return kh_key(mimemap->typeset, iter); + + return NULL; +} + +void h2o_mimemap_get_default_attributes(const char *_mime, h2o_mime_attributes_t *attr) +{ + char *mime = alloca(strlen(_mime) + 1); + strcpy(mime, _mime); + + const char *type_end_at; + + if ((type_end_at = strchr(mime, ';')) == NULL) + type_end_at = mime + strlen(mime); + + *attr = (h2o_mime_attributes_t){0}; + + if (h2o_memis(mime, type_end_at - mime, H2O_STRLIT("text/css")) || + h2o_memis(mime, type_end_at - mime, H2O_STRLIT("application/ecmascript")) || + h2o_memis(mime, type_end_at - mime, H2O_STRLIT("application/javascript")) || + h2o_memis(mime, type_end_at - mime, H2O_STRLIT("text/ecmascript")) || + h2o_memis(mime, type_end_at - mime, H2O_STRLIT("text/javascript"))) { + attr->is_compressible = 1; + attr->priority = H2O_MIME_ATTRIBUTE_PRIORITY_HIGHEST; + } else if (h2o_memis(mime, type_end_at - mime, H2O_STRLIT("application/json")) || strncmp(mime, "text/", 5) == 0 || + h2o_strstr(mime, type_end_at - mime, H2O_STRLIT("+xml")) != SIZE_MAX) { + attr->is_compressible = 1; + } +} diff --git a/web/server/h2o/libh2o/lib/handler/mimemap/defaults.c.h b/web/server/h2o/libh2o/lib/handler/mimemap/defaults.c.h new file mode 100644 index 000000000..a395e0ccb --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mimemap/defaults.c.h @@ -0,0 +1,109 @@ +MIMEMAP("3gp", "video/3gpp") +MIMEMAP("3gpp", "video/3gpp") +MIMEMAP("7z", "application/x-7z-compressed") +MIMEMAP("ai", "application/postscript") +MIMEMAP("apng", "image/apng") +MIMEMAP("asf", "video/x-ms-asf") +MIMEMAP("asx", "video/x-ms-asf") +MIMEMAP("atom", "application/atom+xml") +MIMEMAP("avi", "video/x-msvideo") +MIMEMAP("bin", "application/octet-stream") +MIMEMAP("bmp", "image/x-ms-bmp") +MIMEMAP("cco", "application/x-cocoa") +MIMEMAP("crt", "application/x-x509-ca-cert") +MIMEMAP("css", "text/css") +MIMEMAP("csv", "text/csv") +MIMEMAP("deb", "application/octet-stream") +MIMEMAP("der", "application/x-x509-ca-cert") +MIMEMAP("dll", "application/octet-stream") +MIMEMAP("dmg", "application/octet-stream") +MIMEMAP("doc", "application/msword") +MIMEMAP("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document") +MIMEMAP("ear", "application/java-archive") +MIMEMAP("eot", "application/vnd.ms-fontobject") +MIMEMAP("eps", "application/postscript") +MIMEMAP("exe", "application/octet-stream") +MIMEMAP("flv", "video/x-flv") +MIMEMAP("gif", "image/gif") +MIMEMAP("hqx", "application/mac-binhex40") +MIMEMAP("htc", "text/x-component") +MIMEMAP("htm", "text/html") +MIMEMAP("html", "text/html") +MIMEMAP("ico", "image/x-icon") +MIMEMAP("img", "application/octet-stream") +MIMEMAP("iso", "application/octet-stream") +MIMEMAP("jad", "text/vnd.sun.j2me.app-descriptor") +MIMEMAP("jar", "application/java-archive") +MIMEMAP("jardiff", "application/x-java-archive-diff") +MIMEMAP("jng", "image/x-jng") +MIMEMAP("jnlp", "application/x-java-jnlp-file") +MIMEMAP("jpeg", "image/jpeg") +MIMEMAP("jpg", "image/jpeg") +MIMEMAP("jxr", "image/jxr") +MIMEMAP("js", "application/javascript") +MIMEMAP("json", "application/json") +MIMEMAP("kar", "audio/midi") +MIMEMAP("kml", "application/vnd.google-earth.kml+xml") +MIMEMAP("kmz", "application/vnd.google-earth.kmz") +MIMEMAP("m3u8", "application/vnd.apple.mpegurl") +MIMEMAP("m4a", "audio/x-m4a") +MIMEMAP("m4v", "video/x-m4v") +MIMEMAP("md", "text/markdown") +MIMEMAP("mid", "audio/midi") +MIMEMAP("midi", "audio/midi") +MIMEMAP("mml", "text/mathml") +MIMEMAP("mng", "video/x-mng") +MIMEMAP("mov", "video/quicktime") +MIMEMAP("mp3", "audio/mpeg") +MIMEMAP("mp4", "video/mp4") +MIMEMAP("mpeg", "video/mpeg") +MIMEMAP("mpg", "video/mpeg") +MIMEMAP("msi", "application/octet-stream") +MIMEMAP("msm", "application/octet-stream") +MIMEMAP("msp", "application/octet-stream") +MIMEMAP("ogg", "audio/ogg") +MIMEMAP("opus", "audio/ogg") +MIMEMAP("pdb", "application/x-pilot") +MIMEMAP("pdf", "application/pdf") +MIMEMAP("pem", "application/x-x509-ca-cert") +MIMEMAP("pl", "application/x-perl") +MIMEMAP("pm", "application/x-perl") +MIMEMAP("png", "image/png") +MIMEMAP("ppt", "application/vnd.ms-powerpoint") +MIMEMAP("pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation") +MIMEMAP("prc", "application/x-pilot") +MIMEMAP("ps", "application/postscript") +MIMEMAP("ra", "audio/x-realaudio") +MIMEMAP("rar", "application/x-rar-compressed") +MIMEMAP("rpm", "application/x-redhat-package-manager") +MIMEMAP("rss", "application/rss+xml") +MIMEMAP("rtf", "application/rtf") +MIMEMAP("run", "application/x-makeself") +MIMEMAP("sea", "application/x-sea") +MIMEMAP("shtml", "text/html") +MIMEMAP("sit", "application/x-stuffit") +MIMEMAP("svg", "image/svg+xml") +MIMEMAP("svgz", "image/svg+xml") +MIMEMAP("swf", "application/x-shockwave-flash") +MIMEMAP("tcl", "application/x-tcl") +MIMEMAP("tif", "image/tiff") +MIMEMAP("tiff", "image/tiff") +MIMEMAP("tk", "application/x-tcl") +MIMEMAP("ts", "video/mp2t") +MIMEMAP("txt", "text/plain") +MIMEMAP("war", "application/java-archive") +MIMEMAP("wbmp", "image/vnd.wap.wbmp") +MIMEMAP("webm", "video/webm") +MIMEMAP("webp", "image/webp") +MIMEMAP("wml", "text/vnd.wap.wml") +MIMEMAP("wmlc", "application/vnd.wap.wmlc") +MIMEMAP("wmv", "video/x-ms-wmv") +MIMEMAP("woff", "application/font-woff") +MIMEMAP("woff2", "font/woff2") +MIMEMAP("xhtml", "application/xhtml+xml") +MIMEMAP("xls", "application/vnd.ms-excel") +MIMEMAP("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") +MIMEMAP("xml", "text/xml") +MIMEMAP("xpi", "application/x-xpinstall") +MIMEMAP("xspf", "application/xspf+xml") +MIMEMAP("zip", "application/zip") diff --git a/web/server/h2o/libh2o/lib/handler/mruby.c b/web/server/h2o/libh2o/lib/handler/mruby.c new file mode 100644 index 000000000..af2af53fd --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mruby.c @@ -0,0 +1,938 @@ +/* + * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Ryosuke Matsumoto, + * Masayoshi Takahashi + * + * 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 <stdio.h> +#include <stdlib.h> +#include <mruby.h> +#include <mruby/proc.h> +#include <mruby/array.h> +#include <mruby/class.h> +#include <mruby/compile.h> +#include <mruby/error.h> +#include <mruby/hash.h> +#include <mruby/string.h> +#include <mruby/throw.h> +#include <mruby/variable.h> +#include <mruby_input_stream.h> +#include "h2o.h" +#include "h2o/mruby_.h" +#include "mruby/embedded.c.h" + +#define STATUS_FALLTHRU 399 +#define FALLTHRU_SET_PREFIX "x-fallthru-set-" + +#define FREEZE_STRING(v) MRB_SET_FROZEN_FLAG(mrb_obj_ptr(v)) + +__thread h2o_mruby_generator_t *h2o_mruby_current_generator = NULL; + +void h2o_mruby__assert_failed(mrb_state *mrb, const char *file, int line) +{ + mrb_value obj = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0); + struct RString *error = mrb_str_ptr(obj); + fprintf(stderr, "unexpected ruby error at file: \"%s\", line %d: %s", file, line, error->as.heap.ptr); + abort(); +} + +void h2o_mruby_setup_globals(mrb_state *mrb) +{ + const char *root = getenv("H2O_ROOT"); + if (root == NULL) + root = H2O_TO_STR(H2O_ROOT); + mrb_gv_set(mrb, mrb_intern_lit(mrb, "$H2O_ROOT"), mrb_str_new(mrb, root, strlen(root))); + + h2o_mruby_eval_expr(mrb, "$LOAD_PATH << \"#{$H2O_ROOT}/share/h2o/mruby\""); + h2o_mruby_assert(mrb); + + /* require core modules and include built-in libraries */ + h2o_mruby_eval_expr(mrb, "require \"#{$H2O_ROOT}/share/h2o/mruby/preloads.rb\""); + if (mrb->exc != NULL) { + if (mrb_obj_is_instance_of(mrb, mrb_obj_value(mrb->exc), mrb_class_get(mrb, "LoadError"))) { + fprintf(stderr, "file \"%s/%s\" not found. Did you forget to run `make install` ?", root, + "share/h2o/mruby/preloads.rb"); + } else { + mrb_value obj = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0); + struct RString *error = mrb_str_ptr(obj); + fprintf(stderr, "an error occurred while loading %s/%s: %s", root, "share/h2o/mruby/preloads.rb", error->as.heap.ptr); + } + abort(); + } +} + +mrb_value h2o_mruby_to_str(mrb_state *mrb, mrb_value v) +{ + if (!mrb_string_p(v)) + H2O_MRUBY_EXEC_GUARD({ v = mrb_str_to_str(mrb, v); }); + return v; +} + +mrb_value h2o_mruby_eval_expr(mrb_state *mrb, const char *expr) +{ + return mrb_funcall(mrb, mrb_top_self(mrb), "eval", 1, mrb_str_new_cstr(mrb, expr)); +} + +void h2o_mruby_define_callback(mrb_state *mrb, const char *name, int id) +{ + mrb_value args[2]; + args[0] = mrb_str_new_cstr(mrb, name); + args[1] = mrb_fixnum_value(id); + mrb_funcall_argv(mrb, mrb_top_self(mrb), mrb_intern_lit(mrb, "_h2o_define_callback"), 2, args); + + if (mrb->exc != NULL) { + fprintf(stderr, "failed to define mruby function: %s\n", name); + h2o_mruby_assert(mrb); + } +} + +mrb_value h2o_mruby_create_data_instance(mrb_state *mrb, mrb_value class_obj, void *ptr, const mrb_data_type *type) +{ + struct RClass *klass = mrb_class_ptr(class_obj); + struct RData *data = mrb_data_object_alloc(mrb, klass, ptr, type); + return mrb_obj_value(data); +} + +mrb_value h2o_mruby_compile_code(mrb_state *mrb, h2o_mruby_config_vars_t *config, char *errbuf) +{ + mrbc_context *cxt; + struct mrb_parser_state *parser; + struct RProc *proc = NULL; + mrb_value result = mrb_nil_value(); + + /* parse */ + if ((cxt = mrbc_context_new(mrb)) == NULL) { + fprintf(stderr, "%s: no memory\n", H2O_MRUBY_MODULE_NAME); + abort(); + } + if (config->path != NULL) + mrbc_filename(mrb, cxt, config->path); + cxt->capture_errors = 1; + cxt->lineno = config->lineno; + if ((parser = mrb_parse_nstring(mrb, config->source.base, (int)config->source.len, cxt)) == NULL) { + fprintf(stderr, "%s: no memory\n", H2O_MRUBY_MODULE_NAME); + abort(); + } + /* return erro if errbuf is supplied, or abort */ + if (parser->nerr != 0) { + if (errbuf == NULL) { + fprintf(stderr, "%s: internal error (unexpected state)\n", H2O_MRUBY_MODULE_NAME); + abort(); + } + snprintf(errbuf, 256, "line %d:%s", parser->error_buffer[0].lineno, parser->error_buffer[0].message); + strcat(errbuf, "\n\n"); + if (h2o_str_at_position(errbuf + strlen(errbuf), config->source.base, config->source.len, + parser->error_buffer[0].lineno - config->lineno + 1, parser->error_buffer[0].column) != 0) { + /* remove trailing "\n\n" in case we failed to append the source code at the error location */ + errbuf[strlen(errbuf) - 2] = '\0'; + } + goto Exit; + } + /* generate code */ + if ((proc = mrb_generate_code(mrb, parser)) == NULL) { + fprintf(stderr, "%s: internal error (mrb_generate_code failed)\n", H2O_MRUBY_MODULE_NAME); + abort(); + } + + /* adjust stack length of toplevel environment (see https://github.com/h2o/h2o/issues/1464#issuecomment-337880408) */ + if (mrb->c->cibase->env) { + struct REnv *e = mrb->c->cibase->env; + if (MRB_ENV_STACK_LEN(e) < proc->body.irep->nlocals) + MRB_SET_ENV_STACK_LEN(e, proc->body.irep->nlocals); + } + + /* reset configuration context */ + h2o_mruby_eval_expr(mrb, "H2O::ConfigurationContext.reset"); + h2o_mruby_assert(mrb); + + /* run code and generate handler */ + result = mrb_run(mrb, proc, mrb_top_self(mrb)); + if (mrb->exc != NULL) { + mrb_value obj = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0); + struct RString *error = mrb_str_ptr(obj); + snprintf(errbuf, 256, "%s", error->as.heap.ptr); + mrb->exc = 0; + result = mrb_nil_value(); + goto Exit; + } else if (mrb_nil_p(result)) { + snprintf(errbuf, 256, "returned value is not callable"); + goto Exit; + } + + /* call post_handler_generation hooks */ + mrb_funcall_argv(mrb, h2o_mruby_eval_expr(mrb, "H2O::ConfigurationContext.instance"), + mrb_intern_lit(mrb, "call_post_handler_generation_hooks"), 1, &result); + if (mrb->exc != NULL) { + mrb_value obj = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0); + struct RString *error = mrb_str_ptr(obj); + snprintf(errbuf, 256, "%s", error->as.heap.ptr); + mrb->exc = 0; + result = mrb_nil_value(); + goto Exit; + } + +Exit: + mrb_parser_free(parser); + mrbc_context_free(mrb, cxt); + return result; +} + +static h2o_iovec_t convert_header_name_to_env(h2o_mem_pool_t *pool, const char *name, size_t len) +{ +#define KEY_PREFIX "HTTP_" +#define KEY_PREFIX_LEN (sizeof(KEY_PREFIX) - 1) + + h2o_iovec_t ret; + + ret.len = len + KEY_PREFIX_LEN; + ret.base = h2o_mem_alloc_pool(pool, ret.len); + + memcpy(ret.base, KEY_PREFIX, KEY_PREFIX_LEN); + + char *d = ret.base + KEY_PREFIX_LEN; + for (; len != 0; ++name, --len) + *d++ = *name == '-' ? '_' : h2o_toupper(*name); + + return ret; + +#undef KEY_PREFIX +#undef KEY_PREFIX_LEN +} + +static mrb_value build_constants(mrb_state *mrb, const char *server_name, size_t server_name_len) +{ + mrb_value ary = mrb_ary_new_capa(mrb, H2O_MRUBY_NUM_CONSTANTS); + mrb_int i; + + int gc_arena = mrb_gc_arena_save(mrb); + + { + h2o_mem_pool_t pool; + h2o_mem_init_pool(&pool); + for (i = 0; i != H2O_MAX_TOKENS; ++i) { + const h2o_token_t *token = h2o__tokens + i; + mrb_value lit = mrb_nil_value(); + if (token == H2O_TOKEN_CONTENT_TYPE) { + lit = mrb_str_new_lit(mrb, "CONTENT_TYPE"); + } else if (token->buf.len != 0) { + h2o_iovec_t n = convert_header_name_to_env(&pool, token->buf.base, token->buf.len); + lit = mrb_str_new(mrb, n.base, n.len); + } + if (mrb_string_p(lit)) { + FREEZE_STRING(lit); + mrb_ary_set(mrb, ary, i, lit); + } + } + h2o_mem_clear_pool(&pool); + } + +#define SET_STRING(idx, value) \ + do { \ + mrb_value lit = (value); \ + FREEZE_STRING(lit); \ + mrb_ary_set(mrb, ary, idx, lit); \ + } while (0) +#define SET_LITERAL(idx, str) SET_STRING(idx, mrb_str_new_lit(mrb, str)) + + SET_LITERAL(H2O_MRUBY_LIT_REQUEST_METHOD, "REQUEST_METHOD"); + SET_LITERAL(H2O_MRUBY_LIT_SCRIPT_NAME, "SCRIPT_NAME"); + SET_LITERAL(H2O_MRUBY_LIT_PATH_INFO, "PATH_INFO"); + SET_LITERAL(H2O_MRUBY_LIT_QUERY_STRING, "QUERY_STRING"); + SET_LITERAL(H2O_MRUBY_LIT_SERVER_NAME, "SERVER_NAME"); + SET_LITERAL(H2O_MRUBY_LIT_SERVER_ADDR, "SERVER_ADDR"); + SET_LITERAL(H2O_MRUBY_LIT_SERVER_PORT, "SERVER_PORT"); + SET_LITERAL(H2O_MRUBY_LIT_SERVER_PROTOCOL, "SERVER_PROTOCOL"); + SET_LITERAL(H2O_MRUBY_LIT_CONTENT_LENGTH, "CONTENT_LENGTH"); + SET_LITERAL(H2O_MRUBY_LIT_REMOTE_ADDR, "REMOTE_ADDR"); + SET_LITERAL(H2O_MRUBY_LIT_REMOTE_PORT, "REMOTE_PORT"); + SET_LITERAL(H2O_MRUBY_LIT_REMOTE_USER, "REMOTE_USER"); + SET_LITERAL(H2O_MRUBY_LIT_RACK_URL_SCHEME, "rack.url_scheme"); + SET_LITERAL(H2O_MRUBY_LIT_RACK_MULTITHREAD, "rack.multithread"); + SET_LITERAL(H2O_MRUBY_LIT_RACK_MULTIPROCESS, "rack.multiprocess"); + SET_LITERAL(H2O_MRUBY_LIT_RACK_RUN_ONCE, "rack.run_once"); + SET_LITERAL(H2O_MRUBY_LIT_RACK_HIJACK_, "rack.hijack?"); + SET_LITERAL(H2O_MRUBY_LIT_RACK_INPUT, "rack.input"); + SET_LITERAL(H2O_MRUBY_LIT_RACK_ERRORS, "rack.errors"); + SET_LITERAL(H2O_MRUBY_LIT_SERVER_SOFTWARE, "SERVER_SOFTWARE"); + SET_STRING(H2O_MRUBY_LIT_SERVER_SOFTWARE_VALUE, mrb_str_new(mrb, server_name, server_name_len)); + SET_LITERAL(H2O_MRUBY_LIT_SEPARATOR_COMMA, ", "); + SET_LITERAL(H2O_MRUBY_LIT_SEPARATOR_SEMICOLON, "; "); + +#undef SET_LITERAL +#undef SET_STRING + + h2o_mruby_eval_expr(mrb, H2O_MRUBY_CODE_CORE); + h2o_mruby_assert(mrb); + + mrb_ary_set(mrb, ary, H2O_MRUBY_PROC_EACH_TO_ARRAY, + mrb_funcall(mrb, mrb_obj_value(mrb->kernel_module), "_h2o_proc_each_to_array", 0)); + h2o_mruby_assert(mrb); + + /* sends exception using H2O_MRUBY_CALLBACK_ID_EXCEPTION_RAISED */ + mrb_ary_set(mrb, ary, H2O_MRUBY_PROC_APP_TO_FIBER, + mrb_funcall(mrb, mrb_obj_value(mrb->kernel_module), "_h2o_proc_app_to_fiber", 0)); + h2o_mruby_assert(mrb); + + mrb_gc_arena_restore(mrb, gc_arena); + return ary; +} + +static h2o_mruby_shared_context_t *create_shared_context(h2o_context_t *ctx) +{ + /* init mruby in every thread */ + h2o_mruby_shared_context_t *shared_ctx = h2o_mem_alloc(sizeof(*shared_ctx)); + if ((shared_ctx->mrb = mrb_open()) == NULL) { + fprintf(stderr, "%s: no memory\n", H2O_MRUBY_MODULE_NAME); + abort(); + } + h2o_mruby_setup_globals(shared_ctx->mrb); + shared_ctx->constants = build_constants(shared_ctx->mrb, ctx->globalconf->server_name.base, ctx->globalconf->server_name.len); + shared_ctx->symbols.sym_call = mrb_intern_lit(shared_ctx->mrb, "call"); + shared_ctx->symbols.sym_close = mrb_intern_lit(shared_ctx->mrb, "close"); + shared_ctx->symbols.sym_method = mrb_intern_lit(shared_ctx->mrb, "method"); + shared_ctx->symbols.sym_headers = mrb_intern_lit(shared_ctx->mrb, "headers"); + shared_ctx->symbols.sym_body = mrb_intern_lit(shared_ctx->mrb, "body"); + shared_ctx->symbols.sym_async = mrb_intern_lit(shared_ctx->mrb, "async"); + + h2o_mruby_send_chunked_init_context(shared_ctx); + h2o_mruby_http_request_init_context(shared_ctx); + + return shared_ctx; +} + +static void dispose_shared_context(void *data) +{ + if (data == NULL) + return; + h2o_mruby_shared_context_t *shared_ctx = (h2o_mruby_shared_context_t *)data; + mrb_close(shared_ctx->mrb); + free(shared_ctx); +} + +static h2o_mruby_shared_context_t *get_shared_context(h2o_context_t *ctx) +{ + static size_t key = SIZE_MAX; + void **data = h2o_context_get_storage(ctx, &key, dispose_shared_context); + if (*data == NULL) { + *data = create_shared_context(ctx); + } + return *data; +} + +static void on_context_init(h2o_handler_t *_handler, h2o_context_t *ctx) +{ + h2o_mruby_handler_t *handler = (void *)_handler; + h2o_mruby_context_t *handler_ctx = h2o_mem_alloc(sizeof(*handler_ctx)); + + handler_ctx->handler = handler; + handler_ctx->shared = get_shared_context(ctx); + + /* compile code (must be done for each thread) */ + int arena = mrb_gc_arena_save(handler_ctx->shared->mrb); + mrb_value proc = h2o_mruby_compile_code(handler_ctx->shared->mrb, &handler->config, NULL); + + handler_ctx->proc = + mrb_funcall_argv(handler_ctx->shared->mrb, mrb_ary_entry(handler_ctx->shared->constants, H2O_MRUBY_PROC_APP_TO_FIBER), + handler_ctx->shared->symbols.sym_call, 1, &proc); + h2o_mruby_assert(handler_ctx->shared->mrb); + mrb_gc_arena_restore(handler_ctx->shared->mrb, arena); + mrb_gc_protect(handler_ctx->shared->mrb, handler_ctx->proc); + + h2o_context_set_handler_context(ctx, &handler->super, handler_ctx); +} + +static void on_context_dispose(h2o_handler_t *_handler, h2o_context_t *ctx) +{ + h2o_mruby_handler_t *handler = (void *)_handler; + h2o_mruby_context_t *handler_ctx = h2o_context_get_handler_context(ctx, &handler->super); + + if (handler_ctx == NULL) + return; + + free(handler_ctx); +} + +static void on_handler_dispose(h2o_handler_t *_handler) +{ + h2o_mruby_handler_t *handler = (void *)_handler; + + free(handler->config.source.base); + free(handler->config.path); + free(handler); +} + +static void report_exception(h2o_req_t *req, mrb_state *mrb) +{ + mrb_value obj = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0); + struct RString *error = mrb_str_ptr(obj); + h2o_req_log_error(req, H2O_MRUBY_MODULE_NAME, "mruby raised: %s\n", error->as.heap.ptr); + mrb->exc = NULL; +} + +static void stringify_address(h2o_conn_t *conn, socklen_t (*cb)(h2o_conn_t *conn, struct sockaddr *), mrb_state *mrb, + mrb_value *host, mrb_value *port) +{ + struct sockaddr_storage ss; + socklen_t sslen; + char buf[NI_MAXHOST]; + + *host = mrb_nil_value(); + *port = mrb_nil_value(); + + if ((sslen = cb(conn, (void *)&ss)) == 0) + return; + size_t l = h2o_socket_getnumerichost((void *)&ss, sslen, buf); + if (l != SIZE_MAX) + *host = mrb_str_new(mrb, buf, l); + int32_t p = h2o_socket_getport((void *)&ss); + if (p != -1) { + l = (int)sprintf(buf, "%" PRIu16, (uint16_t)p); + *port = mrb_str_new(mrb, buf, l); + } +} + +static void on_rack_input_free(mrb_state *mrb, const char *base, mrb_int len, void *_input_stream) +{ + /* reset ref to input_stream */ + mrb_value *input_stream = _input_stream; + *input_stream = mrb_nil_value(); +} + +static int build_env_sort_header_cb(const void *_x, const void *_y) +{ + const h2o_header_t *x = *(const h2o_header_t **)_x, *y = *(const h2o_header_t **)_y; + if (x->name->len < y->name->len) + return -1; + if (x->name->len > y->name->len) + return 1; + if (x->name->base != y->name->base) { + int r = memcmp(x->name->base, y->name->base, x->name->len); + if (r != 0) + return r; + } + assert(x != y); + /* the order of the headers having the same name needs to be retained */ + return x < y ? -1 : 1; +} + +static mrb_value build_path_info(mrb_state *mrb, h2o_req_t *req, size_t confpath_len_wo_slash) +{ + if (req->path_normalized.len == confpath_len_wo_slash) + return mrb_str_new_lit(mrb, ""); + + assert(req->path_normalized.len > confpath_len_wo_slash); + + size_t path_info_start, path_info_end = req->query_at != SIZE_MAX ? req->query_at : req->path.len; + + if (req->norm_indexes == NULL) { + path_info_start = confpath_len_wo_slash; + } else if (req->norm_indexes[0] == 0 && confpath_len_wo_slash == 0) { + /* path without leading slash */ + path_info_start = 0; + } else { + path_info_start = req->norm_indexes[confpath_len_wo_slash] - 1; + } + + return mrb_str_new(mrb, req->path.base + path_info_start, path_info_end - path_info_start); +} + +static mrb_value build_env(h2o_mruby_generator_t *generator) +{ + h2o_mruby_shared_context_t *shared = generator->ctx->shared; + mrb_state *mrb = shared->mrb; + mrb_value env = mrb_hash_new_capa(mrb, 16); + char http_version[sizeof("HTTP/1.0")]; + size_t http_version_sz; + + /* environment */ + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_REQUEST_METHOD), + mrb_str_new(mrb, generator->req->method.base, generator->req->method.len)); + + size_t confpath_len_wo_slash = generator->req->pathconf->path.len; + if (generator->req->pathconf->path.base[generator->req->pathconf->path.len - 1] == '/') + --confpath_len_wo_slash; + assert(confpath_len_wo_slash <= generator->req->path_normalized.len); + + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_SCRIPT_NAME), + mrb_str_new(mrb, generator->req->pathconf->path.base, confpath_len_wo_slash)); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_PATH_INFO), build_path_info(mrb, generator->req, confpath_len_wo_slash)); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_QUERY_STRING), + generator->req->query_at != SIZE_MAX ? mrb_str_new(mrb, generator->req->path.base + generator->req->query_at + 1, + generator->req->path.len - (generator->req->query_at + 1)) + : mrb_str_new_lit(mrb, "")); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_SERVER_NAME), + mrb_str_new(mrb, generator->req->hostconf->authority.host.base, generator->req->hostconf->authority.host.len)); + http_version_sz = h2o_stringify_protocol_version(http_version, generator->req->version); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_SERVER_PROTOCOL), + mrb_str_new(mrb, http_version, http_version_sz)); + { + mrb_value h, p; + stringify_address(generator->req->conn, generator->req->conn->callbacks->get_sockname, mrb, &h, &p); + if (!mrb_nil_p(h)) + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_SERVER_ADDR), h); + if (!mrb_nil_p(p)) + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_SERVER_PORT), p); + } + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_TOKEN_HOST - h2o__tokens), + mrb_str_new(mrb, generator->req->authority.base, generator->req->authority.len)); + if (generator->req->entity.base != NULL) { + char buf[32]; + int l = sprintf(buf, "%zu", generator->req->entity.len); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_CONTENT_LENGTH), mrb_str_new(mrb, buf, l)); + generator->rack_input = mrb_input_stream_value(mrb, NULL, 0); + mrb_input_stream_set_data(mrb, generator->rack_input, generator->req->entity.base, (mrb_int)generator->req->entity.len, 0, + on_rack_input_free, &generator->rack_input); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_RACK_INPUT), generator->rack_input); + } + { + mrb_value h, p; + stringify_address(generator->req->conn, generator->req->conn->callbacks->get_peername, mrb, &h, &p); + if (!mrb_nil_p(h)) + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_REMOTE_ADDR), h); + if (!mrb_nil_p(p)) + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_REMOTE_PORT), p); + } + { + size_t i; + for (i = 0; i != generator->req->env.size; i += 2) { + h2o_iovec_t *name = generator->req->env.entries + i, *value = name + 1; + mrb_hash_set(mrb, env, mrb_str_new(mrb, name->base, name->len), mrb_str_new(mrb, value->base, value->len)); + } + } + + { /* headers */ + h2o_header_t **headers_sorted = alloca(sizeof(*headers_sorted) * generator->req->headers.size); + size_t i; + for (i = 0; i != generator->req->headers.size; ++i) + headers_sorted[i] = generator->req->headers.entries + i; + qsort(headers_sorted, generator->req->headers.size, sizeof(*headers_sorted), build_env_sort_header_cb); + for (i = 0; i != generator->req->headers.size; ++i) { + const h2o_header_t *header = headers_sorted[i]; + mrb_value n, v; + if (h2o_iovec_is_token(header->name)) { + const h2o_token_t *token = H2O_STRUCT_FROM_MEMBER(h2o_token_t, buf, header->name); + if (token == H2O_TOKEN_TRANSFER_ENCODING) + continue; + n = mrb_ary_entry(shared->constants, (mrb_int)(token - h2o__tokens)); + } else { + h2o_iovec_t vec = convert_header_name_to_env(&generator->req->pool, header->name->base, header->name->len); + n = mrb_str_new(mrb, vec.base, vec.len); + } + v = mrb_str_new(mrb, header->value.base, header->value.len); + while (i < generator->req->headers.size - 1) { + if (!h2o_memis(headers_sorted[i + 1]->name->base, headers_sorted[i + 1]->name->len, header->name->base, + header->name->len)) + break; + header = headers_sorted[++i]; + v = mrb_str_append(mrb, v, mrb_ary_entry(shared->constants, + header->name == &H2O_TOKEN_COOKIE->buf ? H2O_MRUBY_LIT_SEPARATOR_SEMICOLON + : H2O_MRUBY_LIT_SEPARATOR_COMMA)); + v = mrb_str_append(mrb, v, mrb_str_new(mrb, header->value.base, header->value.len)); + } + mrb_hash_set(mrb, env, n, v); + } + } + + /* rack.* */ + /* TBD rack.version? */ + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_RACK_URL_SCHEME), + mrb_str_new(mrb, generator->req->scheme->name.base, generator->req->scheme->name.len)); + /* we are using shared-none architecture, and therefore declare ourselves as multiprocess */ + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_RACK_MULTITHREAD), mrb_false_value()); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_RACK_MULTIPROCESS), mrb_true_value()); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_RACK_RUN_ONCE), mrb_false_value()); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_RACK_HIJACK_), mrb_false_value()); + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_RACK_ERRORS), + mrb_gv_get(mrb, mrb_intern_lit(mrb, "$stderr"))); + + /* server name */ + mrb_hash_set(mrb, env, mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_SERVER_SOFTWARE), + mrb_ary_entry(shared->constants, H2O_MRUBY_LIT_SERVER_SOFTWARE_VALUE)); + + return env; +} + +static int handle_response_header(h2o_mruby_context_t *handler_ctx, h2o_iovec_t name, h2o_iovec_t value, void *_req) +{ + h2o_req_t *req = _req; + const h2o_token_t *token; + static const h2o_iovec_t fallthru_set_prefix = {H2O_STRLIT(FALLTHRU_SET_PREFIX)}; + + /* convert name to lowercase */ + name = h2o_strdup(&req->pool, name.base, name.len); + h2o_strtolower(name.base, name.len); + + if ((token = h2o_lookup_token(name.base, name.len)) != NULL) { + if (token->proxy_should_drop_for_res) { + /* skip */ + } else if (token == H2O_TOKEN_CONTENT_LENGTH) { + req->res.content_length = h2o_strtosize(value.base, value.len); + } else { + value = h2o_strdup(&req->pool, value.base, value.len); + if (token == H2O_TOKEN_LINK) { + h2o_iovec_t new_value = h2o_push_path_in_link_header(req, value.base, value.len); + if (new_value.len) + h2o_add_header(&req->pool, &req->res.headers, token, NULL, new_value.base, new_value.len); + } else { + h2o_add_header(&req->pool, &req->res.headers, token, NULL, value.base, value.len); + } + } + } else if (name.len > fallthru_set_prefix.len && + h2o_memis(name.base, fallthru_set_prefix.len, fallthru_set_prefix.base, fallthru_set_prefix.len)) { + /* register environment variables (with the name converted to uppercase, and using `_`) */ + size_t i; + name.base += fallthru_set_prefix.len; + name.len -= fallthru_set_prefix.len; + for (i = 0; i != name.len; ++i) + name.base[i] = name.base[i] == '-' ? '_' : h2o_toupper(name.base[i]); + h2o_iovec_t *slot = h2o_req_getenv(req, name.base, name.len, 1); + *slot = h2o_strdup(&req->pool, value.base, value.len); + } else { + value = h2o_strdup(&req->pool, value.base, value.len); + h2o_add_header_by_str(&req->pool, &req->res.headers, name.base, name.len, 0, NULL, value.base, value.len); + } + + return 0; +} + +static void clear_rack_input(h2o_mruby_generator_t *generator) +{ + if (!mrb_nil_p(generator->rack_input)) + mrb_input_stream_set_data(generator->ctx->shared->mrb, generator->rack_input, NULL, -1, 0, NULL, NULL); +} + +static void on_generator_dispose(void *_generator) +{ + h2o_mruby_generator_t *generator = _generator; + + clear_rack_input(generator); + generator->req = NULL; + + if (generator->chunked != NULL) + h2o_mruby_send_chunked_dispose(generator); +} + +static int on_req(h2o_handler_t *_handler, h2o_req_t *req) +{ + h2o_mruby_handler_t *handler = (void *)_handler; + h2o_mruby_shared_context_t *shared = get_shared_context(req->conn->ctx); + int gc_arena = mrb_gc_arena_save(shared->mrb); + + h2o_mruby_generator_t *generator = h2o_mem_alloc_shared(&req->pool, sizeof(*generator), on_generator_dispose); + generator->super.proceed = NULL; + generator->super.stop = NULL; + generator->req = req; + generator->ctx = h2o_context_get_handler_context(req->conn->ctx, &handler->super); + generator->rack_input = mrb_nil_value(); + generator->chunked = NULL; + + mrb_value env = build_env(generator); + + int is_delegate = 0; + h2o_mruby_run_fiber(generator, generator->ctx->proc, env, &is_delegate); + + mrb_gc_arena_restore(shared->mrb, gc_arena); + if (is_delegate) + return -1; + return 0; +} + +static void send_response(h2o_mruby_generator_t *generator, mrb_int status, mrb_value resp, int *is_delegate) +{ + mrb_state *mrb = generator->ctx->shared->mrb; + mrb_value body; + h2o_iovec_t content = {NULL}; + + /* set status */ + generator->req->res.status = (int)status; + + /* set headers */ + if (h2o_mruby_iterate_headers(generator->ctx, mrb_ary_entry(resp, 1), handle_response_header, generator->req) != 0) { + assert(mrb->exc != NULL); + goto GotException; + } + + /* return without processing body, if status is fallthru */ + if (generator->req->res.status == STATUS_FALLTHRU) { + if (is_delegate != NULL) + *is_delegate = 1; + else + h2o_delegate_request_deferred(generator->req, &generator->ctx->handler->super); + return; + } + + /* obtain body */ + body = mrb_ary_entry(resp, 2); + + /* flatten body if possible */ + if (mrb_array_p(body)) { + mrb_int i, len = RARRAY_LEN(body); + /* calculate the length of the output, while at the same time converting the elements of the output array to string */ + content.len = 0; + for (i = 0; i != len; ++i) { + mrb_value e = mrb_ary_entry(body, i); + if (!mrb_string_p(e)) { + e = h2o_mruby_to_str(mrb, e); + if (mrb->exc != NULL) + goto GotException; + mrb_ary_set(mrb, body, i, e); + } + content.len += RSTRING_LEN(e); + } + /* allocate memory, and copy the response */ + char *dst = content.base = h2o_mem_alloc_pool(&generator->req->pool, content.len); + for (i = 0; i != len; ++i) { + mrb_value e = mrb_ary_entry(body, i); + assert(mrb_string_p(e)); + memcpy(dst, RSTRING_PTR(e), RSTRING_LEN(e)); + dst += RSTRING_LEN(e); + } + /* reset body to nil, now that we have read all data */ + body = mrb_nil_value(); + } + + /* use fiber in case we need to call #each */ + if (!mrb_nil_p(body)) { + h2o_start_response(generator->req, &generator->super); + mrb_value receiver = h2o_mruby_send_chunked_init(generator, body); + if (!mrb_nil_p(receiver)) + h2o_mruby_run_fiber(generator, receiver, body, 0); + return; + } + + /* send the entire response immediately */ + if (status == 101 || status == 204 || status == 304 || + h2o_memis(generator->req->input.method.base, generator->req->input.method.len, H2O_STRLIT("HEAD"))) { + h2o_start_response(generator->req, &generator->super); + h2o_send(generator->req, NULL, 0, H2O_SEND_STATE_FINAL); + } else { + if (content.len < generator->req->res.content_length) { + generator->req->res.content_length = content.len; + } else { + content.len = generator->req->res.content_length; + } + h2o_start_response(generator->req, &generator->super); + h2o_send(generator->req, &content, 1, H2O_SEND_STATE_FINAL); + } + return; + +GotException: + report_exception(generator->req, mrb); + h2o_send_error_500(generator->req, "Internal Server Error", "Internal Server Error", 0); +} + +void h2o_mruby_run_fiber(h2o_mruby_generator_t *generator, mrb_value receiver, mrb_value input, int *is_delegate) +{ + mrb_state *mrb = generator->ctx->shared->mrb; + mrb_value output; + mrb_int status; + + if (!mrb_obj_eq(mrb, generator->ctx->proc, receiver)) { + mrb_gc_unregister(mrb, receiver); + mrb_gc_protect(mrb, receiver); + } + + h2o_mruby_current_generator = generator; + + while (1) { + /* send input to fiber */ + output = mrb_funcall_argv(mrb, receiver, generator->ctx->shared->symbols.sym_call, 1, &input); + if (mrb->exc != NULL) + goto GotException; + if (!mrb_array_p(output)) { + mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "rack app did not return an array")); + goto GotException; + } + /* fetch status */ + mrb_value v = mrb_to_int(mrb, mrb_ary_entry(output, 0)); + if (mrb->exc != NULL) + goto GotException; + status = mrb_fixnum(v); + /* take special action depending on the status code */ + if (status < 0) { + if (status == H2O_MRUBY_CALLBACK_ID_EXCEPTION_RAISED) { + mrb->exc = mrb_obj_ptr(mrb_ary_entry(output, 1)); + goto GotException; + } + receiver = mrb_ary_entry(output, 1); + int next_action = H2O_MRUBY_CALLBACK_NEXT_ACTION_IMMEDIATE; + mrb_value args = mrb_ary_entry(output, 2); + if (mrb_array_p(args)) { + switch (status) { + case H2O_MRUBY_CALLBACK_ID_SEND_CHUNKED_EOS: + input = h2o_mruby_send_chunked_eos_callback(generator, receiver, args, &next_action); + break; + case H2O_MRUBY_CALLBACK_ID_HTTP_JOIN_RESPONSE: + input = h2o_mruby_http_join_response_callback(generator, receiver, args, &next_action); + break; + case H2O_MRUBY_CALLBACK_ID_HTTP_FETCH_CHUNK: + input = h2o_mruby_http_fetch_chunk_callback(generator, receiver, args, &next_action); + break; + default: + input = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "unexpected callback id sent from rack app"); + break; + } + } else { + input = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "callback from rack app did not receive an array arg"); + } + switch (next_action) { + case H2O_MRUBY_CALLBACK_NEXT_ACTION_STOP: + return; + case H2O_MRUBY_CALLBACK_NEXT_ACTION_ASYNC: + goto Async; + default: + assert(next_action == H2O_MRUBY_CALLBACK_NEXT_ACTION_IMMEDIATE); + break; + } + goto Next; + } + /* if no special actions were necessary, then the output is a rack response */ + break; + Next: + mrb_gc_protect(mrb, receiver); + mrb_gc_protect(mrb, input); + } + + h2o_mruby_current_generator = NULL; + + if (!(100 <= status && status <= 999)) { + mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "status returned from rack app is out of range")); + goto GotException; + } + + /* send the response (unless req is already closed) */ + if (generator->req == NULL) + return; + if (generator->req->_generator != NULL) { + mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "unexpectedly received a rack response")); + goto GotException; + } + send_response(generator, status, output, is_delegate); + return; + +GotException: + h2o_mruby_current_generator = NULL; + if (generator->req != NULL) { + report_exception(generator->req, mrb); + if (generator->req->_generator == NULL) { + h2o_send_error_500(generator->req, "Internal Server Error", "Internal Server Error", 0); + } else { + h2o_mruby_send_chunked_close(generator); + } + } + return; + +Async: + h2o_mruby_current_generator = NULL; + if (!mrb_obj_eq(mrb, generator->ctx->proc, receiver)) + mrb_gc_register(mrb, receiver); + return; +} + +h2o_mruby_handler_t *h2o_mruby_register(h2o_pathconf_t *pathconf, h2o_mruby_config_vars_t *vars) +{ + h2o_mruby_handler_t *handler = (void *)h2o_create_handler(pathconf, sizeof(*handler)); + + handler->super.on_context_init = on_context_init; + handler->super.on_context_dispose = on_context_dispose; + handler->super.dispose = on_handler_dispose; + handler->super.on_req = on_req; + handler->config.source = h2o_strdup(NULL, vars->source.base, vars->source.len); + if (vars->path != NULL) + handler->config.path = h2o_strdup(NULL, vars->path, SIZE_MAX).base; + handler->config.lineno = vars->lineno; + + return handler; +} + +mrb_value h2o_mruby_each_to_array(h2o_mruby_context_t *handler_ctx, mrb_value src) +{ + return mrb_funcall_argv(handler_ctx->shared->mrb, mrb_ary_entry(handler_ctx->shared->constants, H2O_MRUBY_PROC_EACH_TO_ARRAY), + handler_ctx->shared->symbols.sym_call, 1, &src); +} + +static int iterate_headers_handle_pair(h2o_mruby_context_t *handler_ctx, mrb_value name, mrb_value value, + int (*cb)(h2o_mruby_context_t *, h2o_iovec_t, h2o_iovec_t, void *), void *cb_data) +{ + mrb_state *mrb = handler_ctx->shared->mrb; + + /* convert name and value to string */ + name = h2o_mruby_to_str(mrb, name); + if (mrb->exc != NULL) + return -1; + value = h2o_mruby_to_str(mrb, value); + if (mrb->exc != NULL) + return -1; + + /* call the callback, splitting the values with '\n' */ + const char *vstart = RSTRING_PTR(value), *vend = vstart + RSTRING_LEN(value), *eol; + while (1) { + for (eol = vstart; eol != vend; ++eol) + if (*eol == '\n') + break; + if (cb(handler_ctx, h2o_iovec_init(RSTRING_PTR(name), RSTRING_LEN(name)), h2o_iovec_init(vstart, eol - vstart), cb_data) != + 0) + return -1; + if (eol == vend) + break; + vstart = eol + 1; + } + + return 0; +} + +int h2o_mruby_iterate_headers(h2o_mruby_context_t *handler_ctx, mrb_value headers, + int (*cb)(h2o_mruby_context_t *, h2o_iovec_t, h2o_iovec_t, void *), void *cb_data) +{ + mrb_state *mrb = handler_ctx->shared->mrb; + + if (!(mrb_hash_p(headers) || mrb_array_p(headers))) { + headers = h2o_mruby_each_to_array(handler_ctx, headers); + if (mrb->exc != NULL) + return -1; + assert(mrb_array_p(headers)); + } + + if (mrb_hash_p(headers)) { + mrb_value keys = mrb_hash_keys(mrb, headers); + mrb_int i, len = RARRAY_LEN(keys); + for (i = 0; i != len; ++i) { + mrb_value k = mrb_ary_entry(keys, i); + mrb_value v = mrb_hash_get(mrb, headers, k); + if (iterate_headers_handle_pair(handler_ctx, k, v, cb, cb_data) != 0) + return -1; + } + } else { + assert(mrb_array_p(headers)); + mrb_int i, len = RARRAY_LEN(headers); + for (i = 0; i != len; ++i) { + mrb_value pair = mrb_ary_entry(headers, i); + if (!mrb_array_p(pair)) { + mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_ARGUMENT_ERROR, "array element of headers MUST by an array")); + return -1; + } + if (iterate_headers_handle_pair(handler_ctx, mrb_ary_entry(pair, 0), mrb_ary_entry(pair, 1), cb, cb_data) != 0) + return -1; + } + } + + return 0; +} diff --git a/web/server/h2o/libh2o/lib/handler/mruby/chunked.c b/web/server/h2o/libh2o/lib/handler/mruby/chunked.c new file mode 100644 index 000000000..28e3ae433 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mruby/chunked.c @@ -0,0 +1,270 @@ +/* + * Copyright (c) 2015-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 <stdlib.h> +#include <mruby.h> +#include <mruby/array.h> +#include <mruby/error.h> +#include <mruby/string.h> +#include "h2o/mruby_.h" +#include "embedded.c.h" + +struct st_h2o_mruby_chunked_t { + h2o_doublebuffer_t sending; + size_t bytes_left; /* SIZE_MAX indicates that the number is undermined */ + enum { H2O_MRUBY_CHUNKED_TYPE_CALLBACK, H2O_MRUBY_CHUNKED_TYPE_SHORTCUT } type; + union { + struct { + h2o_buffer_t *receiving; + mrb_value body_obj; /* becomes nil on eos */ + } callback; + struct { + h2o_mruby_http_request_context_t *client; + h2o_buffer_t *remaining; + } shortcut; + }; +}; + +static void do_send(h2o_mruby_generator_t *generator, h2o_buffer_t **input, int is_final) +{ + h2o_mruby_chunked_t *chunked = generator->chunked; + + assert(chunked->sending.bytes_inflight == 0); + + h2o_iovec_t buf = h2o_doublebuffer_prepare(&chunked->sending, input, generator->req->preferred_chunk_size); + size_t bufcnt = 1; + + if (is_final && buf.len == chunked->sending.buf->size && (*input)->size == 0) { + if (buf.len == 0) + --bufcnt; + /* terminate the H1 connection if the length of content served did not match the value sent in content-length header */ + if (chunked->bytes_left != SIZE_MAX && chunked->bytes_left != 0) + generator->req->http1_is_persistent = 0; + } else { + if (buf.len == 0) + return; + is_final = 0; + } + + h2o_send(generator->req, &buf, bufcnt, is_final ? H2O_SEND_STATE_FINAL : H2O_SEND_STATE_IN_PROGRESS); +} + +static void do_proceed(h2o_generator_t *_generator, h2o_req_t *req) +{ + h2o_mruby_generator_t *generator = (void *)_generator; + h2o_mruby_chunked_t *chunked = generator->chunked; + h2o_buffer_t **input; + int is_final; + + h2o_doublebuffer_consume(&chunked->sending); + + switch (chunked->type) { + case H2O_MRUBY_CHUNKED_TYPE_CALLBACK: + input = &chunked->callback.receiving; + is_final = mrb_nil_p(chunked->callback.body_obj); + break; + case H2O_MRUBY_CHUNKED_TYPE_SHORTCUT: + if (chunked->shortcut.client != NULL) { + input = h2o_mruby_http_peek_content(chunked->shortcut.client, &is_final); + assert(!is_final); + } else { + input = &chunked->shortcut.remaining; + is_final = 1; + } + break; + default: + h2o_fatal("unexpected type"); + break; + } + + do_send(generator, input, is_final); +} + +static void on_shortcut_notify(h2o_mruby_generator_t *generator) +{ + h2o_mruby_chunked_t *chunked = generator->chunked; + int is_final; + h2o_buffer_t **input = h2o_mruby_http_peek_content(chunked->shortcut.client, &is_final); + + if (chunked->bytes_left != SIZE_MAX) { + if (chunked->bytes_left < (*input)->size) + (*input)->size = chunked->bytes_left; /* trim data too long */ + chunked->bytes_left -= (*input)->size; + } + + /* if final, steal socket input buffer to shortcut.remaining, and reset pointer to client */ + if (is_final) { + chunked->shortcut.remaining = *input; + h2o_buffer_init(input, &h2o_socket_buffer_prototype); + input = &chunked->shortcut.remaining; + chunked->shortcut.client = NULL; + } + + if (chunked->sending.bytes_inflight == 0) + do_send(generator, input, is_final); +} + +static void close_body_obj(h2o_mruby_generator_t *generator) +{ + h2o_mruby_chunked_t *chunked = generator->chunked; + mrb_state *mrb = generator->ctx->shared->mrb; + + if (!mrb_nil_p(chunked->callback.body_obj)) { + /* call close and throw away error */ + if (mrb_respond_to(mrb, chunked->callback.body_obj, generator->ctx->shared->symbols.sym_close)) + mrb_funcall_argv(mrb, chunked->callback.body_obj, generator->ctx->shared->symbols.sym_close, 0, NULL); + mrb->exc = NULL; + mrb_gc_unregister(mrb, chunked->callback.body_obj); + chunked->callback.body_obj = mrb_nil_value(); + } +} + +mrb_value h2o_mruby_send_chunked_init(h2o_mruby_generator_t *generator, mrb_value body) +{ + h2o_mruby_chunked_t *chunked = h2o_mem_alloc_pool(&generator->req->pool, sizeof(*chunked)); + h2o_doublebuffer_init(&chunked->sending, &h2o_socket_buffer_prototype); + chunked->bytes_left = h2o_memis(generator->req->method.base, generator->req->method.len, H2O_STRLIT("HEAD")) + ? 0 + : generator->req->res.content_length; + generator->super.proceed = do_proceed; + generator->chunked = chunked; + + if ((chunked->shortcut.client = h2o_mruby_http_set_shortcut(generator->ctx->shared->mrb, body, on_shortcut_notify)) != NULL) { + chunked->type = H2O_MRUBY_CHUNKED_TYPE_SHORTCUT; + chunked->shortcut.remaining = NULL; + on_shortcut_notify(generator); + return mrb_nil_value(); + } else { + chunked->type = H2O_MRUBY_CHUNKED_TYPE_CALLBACK; + h2o_buffer_init(&chunked->callback.receiving, &h2o_socket_buffer_prototype); + mrb_gc_register(generator->ctx->shared->mrb, body); + chunked->callback.body_obj = body; + return mrb_ary_entry(generator->ctx->shared->constants, H2O_MRUBY_CHUNKED_PROC_EACH_TO_FIBER); + } +} + +void h2o_mruby_send_chunked_dispose(h2o_mruby_generator_t *generator) +{ + h2o_mruby_chunked_t *chunked = generator->chunked; + + h2o_doublebuffer_dispose(&chunked->sending); + + switch (chunked->type) { + case H2O_MRUBY_CHUNKED_TYPE_CALLBACK: + h2o_buffer_dispose(&chunked->callback.receiving); + close_body_obj(generator); + break; + case H2O_MRUBY_CHUNKED_TYPE_SHORTCUT: + /* note: no need to free reference from chunked->client, since it is disposed at the same moment */ + if (chunked->shortcut.remaining != NULL) + h2o_buffer_dispose(&chunked->shortcut.remaining); + break; + } +} + +static mrb_value check_precond(mrb_state *mrb, h2o_mruby_generator_t *generator) +{ + if (generator == NULL || generator->req == NULL) + return mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "downstream HTTP closed"); + if (generator->req->_generator == NULL) + return mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "cannot send chunk before sending headers"); + return mrb_nil_value(); +} + +static mrb_value send_chunked_method(mrb_state *mrb, mrb_value self) +{ + h2o_mruby_generator_t *generator = h2o_mruby_current_generator; + const char *s; + mrb_int len; + + /* parse args */ + mrb_get_args(mrb, "s", &s, &len); + + { /* precond check */ + mrb_value exc = check_precond(mrb, generator); + if (!mrb_nil_p(exc)) + mrb_exc_raise(mrb, exc); + } + + /* append to send buffer, and send out immediately if necessary */ + if (len != 0) { + h2o_mruby_chunked_t *chunked = generator->chunked; + if (chunked->bytes_left != SIZE_MAX) { + if (len > chunked->bytes_left) + len = chunked->bytes_left; + chunked->bytes_left -= len; + } + if (len != 0) { + h2o_buffer_reserve(&chunked->callback.receiving, len); + memcpy(chunked->callback.receiving->bytes + chunked->callback.receiving->size, s, len); + chunked->callback.receiving->size += len; + if (chunked->sending.bytes_inflight == 0) + do_send(generator, &chunked->callback.receiving, 0); + } + } + + return mrb_nil_value(); +} + +mrb_value h2o_mruby_send_chunked_eos_callback(h2o_mruby_generator_t *generator, mrb_value receiver, mrb_value input, + int *next_action) +{ + mrb_state *mrb = generator->ctx->shared->mrb; + + { /* precond check */ + mrb_value exc = check_precond(mrb, generator); + if (!mrb_nil_p(exc)) + return exc; + } + + h2o_mruby_send_chunked_close(generator); + + *next_action = H2O_MRUBY_CALLBACK_NEXT_ACTION_STOP; + return mrb_nil_value(); +} + +void h2o_mruby_send_chunked_close(h2o_mruby_generator_t *generator) +{ + h2o_mruby_chunked_t *chunked = generator->chunked; + + /* run_fiber will never be called once we enter the fast path, and therefore this function will never get called in that case */ + assert(chunked->type == H2O_MRUBY_CHUNKED_TYPE_CALLBACK); + + close_body_obj(generator); + + if (chunked->sending.bytes_inflight == 0) + do_send(generator, &chunked->callback.receiving, 1); +} + +void h2o_mruby_send_chunked_init_context(h2o_mruby_shared_context_t *shared_ctx) +{ + mrb_state *mrb = shared_ctx->mrb; + + h2o_mruby_eval_expr(mrb, H2O_MRUBY_CODE_CHUNKED); + h2o_mruby_assert(mrb); + + mrb_define_method(mrb, mrb->kernel_module, "_h2o_send_chunk", send_chunked_method, MRB_ARGS_ARG(1, 0)); + h2o_mruby_define_callback(mrb, "_h2o_send_chunk_eos", H2O_MRUBY_CALLBACK_ID_SEND_CHUNKED_EOS); + + mrb_ary_set(mrb, shared_ctx->constants, H2O_MRUBY_CHUNKED_PROC_EACH_TO_FIBER, + mrb_funcall(mrb, mrb_top_self(mrb), "_h2o_chunked_proc_each_to_fiber", 0)); + h2o_mruby_assert(mrb); +} diff --git a/web/server/h2o/libh2o/lib/handler/mruby/embedded.c.h b/web/server/h2o/libh2o/lib/handler/mruby/embedded.c.h new file mode 100644 index 000000000..db4bb2321 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mruby/embedded.c.h @@ -0,0 +1,111 @@ +/* + * DO NOT EDIT! generated by embed_mruby_code.pl + * Please refer to the respective source files for copyright information. + */ + +/* lib/handler/mruby/embedded/core.rb */ +#define H2O_MRUBY_CODE_CORE \ + "module Kernel\n" \ + " def _h2o_define_callback(name, id)\n" \ + " Kernel.define_method(name) do |*args|\n" \ + " ret = Fiber.yield([ id, _h2o_create_resumer(), args ])\n" \ + " if ret.kind_of? Exception\n" \ + " raise ret\n" \ + " end\n" \ + " ret\n" \ + " end\n" \ + " end\n" \ + " def _h2o_create_resumer()\n" \ + " me = Fiber.current\n" \ + " Proc.new do |v|\n" \ + " me.resume(v)\n" \ + " end\n" \ + " end\n" \ + " def _h2o_proc_each_to_array()\n" \ + " Proc.new do |o|\n" \ + " a = []\n" \ + " o.each do |x|\n" \ + " a << x\n" \ + " end\n" \ + " a\n" \ + " end\n" \ + " end\n" \ + " def _h2o_proc_app_to_fiber()\n" \ + " Proc.new do |app|\n" \ + " cached = nil\n" \ + " Proc.new do |req|\n" \ + " fiber = cached\n" \ + " cached = nil\n" \ + " if !fiber\n" \ + " fiber = Fiber.new do\n" \ + " self_fiber = Fiber.current\n" \ + " req = Fiber.yield\n" \ + " while 1\n" \ + " begin\n" \ + " while 1\n" \ + " resp = app.call(req)\n" \ + " cached = self_fiber\n" \ + " req = Fiber.yield(resp)\n" \ + " end\n" \ + " rescue => e\n" \ + " cached = self_fiber\n" \ + " req = Fiber.yield([-1, e])\n" \ + " end\n" \ + " end\n" \ + " end\n" \ + " fiber.resume\n" \ + " end\n" \ + " fiber.resume(req)\n" \ + " end\n" \ + " end\n" \ + " end\n" \ + "end\n" + +/* lib/handler/mruby/embedded/http_request.rb */ +#define H2O_MRUBY_CODE_HTTP_REQUEST \ + "module H2O\n" \ + " class HttpRequest\n" \ + " def join\n" \ + " if !@resp\n" \ + " @resp = _h2o__http_join_response(self)\n" \ + " end\n" \ + " @resp\n" \ + " end\n" \ + " def _set_response(resp)\n" \ + " @resp = resp\n" \ + " end\n" \ + " end\n" \ + " class HttpInputStream\n" \ + " def each\n" \ + " while c = _h2o__http_fetch_chunk(self)\n" \ + " yield c\n" \ + " end\n" \ + " end\n" \ + " def join\n" \ + " s = \"\"\n" \ + " each do |c|\n" \ + " s << c\n" \ + " end\n" \ + " s\n" \ + " end\n" \ + " class Empty < HttpInputStream\n" \ + " def each; end\n" \ + " end\n" \ + " end\n" \ + "end\n" + +/* lib/handler/mruby/embedded/chunked.rb */ +#define H2O_MRUBY_CODE_CHUNKED \ + "module Kernel\n" \ + " def _h2o_chunked_proc_each_to_fiber()\n" \ + " Proc.new do |src|\n" \ + " fiber = Fiber.new do\n" \ + " src.each do |chunk|\n" \ + " _h2o_send_chunk(chunk)\n" \ + " end\n" \ + " _h2o_send_chunk_eos()\n" \ + " end\n" \ + " fiber.resume\n" \ + " end\n" \ + " end\n" \ + "end\n" diff --git a/web/server/h2o/libh2o/lib/handler/mruby/embedded/chunked.rb b/web/server/h2o/libh2o/lib/handler/mruby/embedded/chunked.rb new file mode 100644 index 000000000..ff4e578f8 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mruby/embedded/chunked.rb @@ -0,0 +1,35 @@ +# 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. + +module Kernel + + def _h2o_chunked_proc_each_to_fiber() + Proc.new do |src| + fiber = Fiber.new do + src.each do |chunk| + _h2o_send_chunk(chunk) + end + _h2o_send_chunk_eos() + end + fiber.resume + end + end + +end diff --git a/web/server/h2o/libh2o/lib/handler/mruby/embedded/core.rb b/web/server/h2o/libh2o/lib/handler/mruby/embedded/core.rb new file mode 100644 index 000000000..e62583df4 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mruby/embedded/core.rb @@ -0,0 +1,81 @@ +# Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Ryosuke Matsumoto, +# Masayoshi Takahashi +# +# 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. + +module Kernel + + def _h2o_define_callback(name, id) + Kernel.define_method(name) do |*args| + ret = Fiber.yield([ id, _h2o_create_resumer(), args ]) + if ret.kind_of? Exception + raise ret + end + ret + end + end + + def _h2o_create_resumer() + me = Fiber.current + Proc.new do |v| + me.resume(v) + end + end + + def _h2o_proc_each_to_array() + Proc.new do |o| + a = [] + o.each do |x| + a << x + end + a + end + end + + def _h2o_proc_app_to_fiber() + Proc.new do |app| + cached = nil + Proc.new do |req| + fiber = cached + cached = nil + if !fiber + fiber = Fiber.new do + self_fiber = Fiber.current + req = Fiber.yield + while 1 + begin + while 1 + resp = app.call(req) + cached = self_fiber + req = Fiber.yield(resp) + end + rescue => e + cached = self_fiber + req = Fiber.yield([-1, e]) + end + end + end + fiber.resume + end + fiber.resume(req) + end + end + end + +end diff --git a/web/server/h2o/libh2o/lib/handler/mruby/embedded/http_request.rb b/web/server/h2o/libh2o/lib/handler/mruby/embedded/http_request.rb new file mode 100644 index 000000000..3f3247a3c --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mruby/embedded/http_request.rb @@ -0,0 +1,54 @@ +# Copyright (c) 2015-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. + +module H2O + + class HttpRequest + def join + if !@resp + @resp = _h2o__http_join_response(self) + end + @resp + end + def _set_response(resp) + @resp = resp + end + end + + class HttpInputStream + def each + while c = _h2o__http_fetch_chunk(self) + yield c + end + end + def join + s = "" + each do |c| + s << c + end + s + end + + class Empty < HttpInputStream + def each; end + end + end + +end diff --git a/web/server/h2o/libh2o/lib/handler/mruby/http_request.c b/web/server/h2o/libh2o/lib/handler/mruby/http_request.c new file mode 100644 index 000000000..964d03f19 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/mruby/http_request.c @@ -0,0 +1,500 @@ +/* + * Copyright (c) 2015-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 <mruby.h> +#include <mruby/array.h> +#include <mruby/error.h> +#include <mruby/hash.h> +#include <mruby/string.h> +#include <mruby_input_stream.h> +#include "h2o/mruby_.h" +#include "embedded.c.h" + +struct st_h2o_mruby_http_request_context_t { + h2o_mruby_generator_t *generator; + h2o_http1client_t *client; + mrb_value receiver; + struct { + h2o_buffer_t *buf; + h2o_iovec_t body; /* body.base != NULL indicates that post content exists (and the length MAY be zero) */ + unsigned method_is_head : 1; + unsigned has_transfer_encoding : 1; + } req; + struct { + h2o_buffer_t *after_closed; /* when client becomes NULL, rest of the data will be stored to this pointer */ + int has_content; + } resp; + struct { + mrb_value request; + mrb_value input_stream; + } refs; + void (*shortcut_notify_cb)(h2o_mruby_generator_t *generator); +}; + +static void on_gc_dispose_request(mrb_state *mrb, void *_ctx) +{ + struct st_h2o_mruby_http_request_context_t *ctx = _ctx; + if (ctx != NULL) + ctx->refs.request = mrb_nil_value(); +} + +const static struct mrb_data_type request_type = {"http_request", on_gc_dispose_request}; + +static void on_gc_dispose_input_stream(mrb_state *mrb, void *_ctx) +{ + struct st_h2o_mruby_http_request_context_t *ctx = _ctx; + if (ctx != NULL) + ctx->refs.input_stream = mrb_nil_value(); +} + +const static struct mrb_data_type input_stream_type = {"http_input_stream", on_gc_dispose_input_stream}; + +static mrb_value create_downstream_closed_exception(mrb_state *mrb) +{ + return mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "downstream HTTP closed"); +} + +static mrb_value detach_receiver(struct st_h2o_mruby_http_request_context_t *ctx) +{ + mrb_value ret = ctx->receiver; + assert(!mrb_nil_p(ret)); + ctx->receiver = mrb_nil_value(); + return ret; +} + +static void on_dispose(void *_ctx) +{ + struct st_h2o_mruby_http_request_context_t *ctx = _ctx; + + /* clear the refs */ + if (ctx->client != NULL) { + h2o_http1client_cancel(ctx->client); + ctx->client = NULL; + } + if (!mrb_nil_p(ctx->refs.request)) + DATA_PTR(ctx->refs.request) = NULL; + if (!mrb_nil_p(ctx->refs.input_stream)) + DATA_PTR(ctx->refs.input_stream) = NULL; + + /* clear bufs */ + h2o_buffer_dispose(&ctx->req.buf); + h2o_buffer_dispose(&ctx->resp.after_closed); + + /* notify the app, if it is waiting to hear from us */ + if (!mrb_nil_p(ctx->receiver)) { + mrb_state *mrb = ctx->generator->ctx->shared->mrb; + int gc_arena = mrb_gc_arena_save(mrb); + h2o_mruby_run_fiber(ctx->generator, detach_receiver(ctx), create_downstream_closed_exception(mrb), NULL); + mrb_gc_arena_restore(mrb, gc_arena); + } +} + +static void post_response(struct st_h2o_mruby_http_request_context_t *ctx, int status, const h2o_header_t *headers_sorted, + size_t num_headers) +{ + mrb_state *mrb = ctx->generator->ctx->shared->mrb; + int gc_arena = mrb_gc_arena_save(mrb); + size_t i; + + mrb_value resp = mrb_ary_new_capa(mrb, 3); + + /* set status */ + mrb_ary_set(mrb, resp, 0, mrb_fixnum_value(status)); + + /* set headers */ + mrb_value headers_hash = mrb_hash_new_capa(mrb, (int)num_headers); + for (i = 0; i < num_headers; ++i) { + /* skip the headers, we determine the eos! */ + if (h2o_memis(headers_sorted[i].name, headers_sorted[i].name->len, H2O_STRLIT("content-length")) || + h2o_memis(headers_sorted[i].name, headers_sorted[i].name->len, H2O_STRLIT("transfer-encoding"))) + continue; + /* build and set the hash entry */ + mrb_value k = mrb_str_new(mrb, headers_sorted[i].name->base, headers_sorted[i].name->len); + mrb_value v = mrb_str_new(mrb, headers_sorted[i].value.base, headers_sorted[i].value.len); + while (i + 1 < num_headers && h2o_memis(headers_sorted[i].name->base, headers_sorted[i].name->len, + headers_sorted[i + 1].name->base, headers_sorted[i + 1].name->len)) { + ++i; + v = mrb_str_cat_lit(mrb, v, "\n"); + v = mrb_str_cat(mrb, v, headers_sorted[i].value.base, headers_sorted[i].value.len); + } + mrb_hash_set(mrb, headers_hash, k, v); + } + mrb_ary_set(mrb, resp, 1, headers_hash); + + /* set input stream */ + assert(mrb_nil_p(ctx->refs.input_stream)); + mrb_value input_stream_class; + if (ctx->req.method_is_head || status == 101 || status == 204 || status == 304) { + input_stream_class = mrb_ary_entry(ctx->generator->ctx->shared->constants, H2O_MRUBY_HTTP_EMPTY_INPUT_STREAM_CLASS); + } else { + input_stream_class = mrb_ary_entry(ctx->generator->ctx->shared->constants, H2O_MRUBY_HTTP_INPUT_STREAM_CLASS); + } + ctx->refs.input_stream = h2o_mruby_create_data_instance(mrb, input_stream_class, ctx, &input_stream_type); + mrb_ary_set(mrb, resp, 2, ctx->refs.input_stream); + + if (mrb_nil_p(ctx->receiver)) { + /* is async */ + mrb_funcall(mrb, ctx->refs.request, "_set_response", 1, resp); + if (mrb->exc != NULL) { + fprintf(stderr, "_set_response failed\n"); + abort(); + } + } else { + /* send response to the waiting receiver */ + h2o_mruby_run_fiber(ctx->generator, detach_receiver(ctx), resp, NULL); + } + + mrb_gc_arena_restore(mrb, gc_arena); +} + +static void post_error(struct st_h2o_mruby_http_request_context_t *ctx, const char *errstr) +{ + static const h2o_header_t headers_sorted[] = { + {&H2O_TOKEN_CONTENT_TYPE->buf, NULL, {H2O_STRLIT("text/plain; charset=utf-8")}}, + }; + + ctx->client = NULL; + size_t errstr_len = strlen(errstr); + h2o_buffer_reserve(&ctx->resp.after_closed, errstr_len); + memcpy(ctx->resp.after_closed->bytes + ctx->resp.after_closed->size, errstr, errstr_len); + ctx->resp.after_closed->size += errstr_len; + ctx->resp.has_content = 1; + + post_response(ctx, 500, headers_sorted, sizeof(headers_sorted) / sizeof(headers_sorted[0])); +} + +static mrb_value build_chunk(struct st_h2o_mruby_http_request_context_t *ctx) +{ + mrb_value chunk; + + assert(ctx->resp.has_content); + + if (ctx->client != NULL) { + assert(ctx->client->sock->input->size != 0); + chunk = mrb_str_new(ctx->generator->ctx->shared->mrb, ctx->client->sock->input->bytes, ctx->client->sock->input->size); + h2o_buffer_consume(&ctx->client->sock->input, ctx->client->sock->input->size); + ctx->resp.has_content = 0; + } else { + if (ctx->resp.after_closed->size == 0) { + chunk = mrb_nil_value(); + } else { + chunk = mrb_str_new(ctx->generator->ctx->shared->mrb, ctx->resp.after_closed->bytes, ctx->resp.after_closed->size); + h2o_buffer_consume(&ctx->resp.after_closed, ctx->resp.after_closed->size); + } + /* has_content is retained as true, so that repeated calls will return nil immediately */ + } + + return chunk; +} + +static int on_body(h2o_http1client_t *client, const char *errstr) +{ + struct st_h2o_mruby_http_request_context_t *ctx = client->data; + + if (errstr != NULL) { + h2o_buffer_t *tmp = ctx->resp.after_closed; + ctx->resp.after_closed = client->sock->input; + client->sock->input = tmp; + ctx->client = NULL; + ctx->resp.has_content = 1; + } else if (client->sock->input->size != 0) { + ctx->resp.has_content = 1; + } + + if (ctx->resp.has_content) { + if (ctx->shortcut_notify_cb != NULL) { + ctx->shortcut_notify_cb(ctx->generator); + } else if (!mrb_nil_p(ctx->receiver)) { + int gc_arena = mrb_gc_arena_save(ctx->generator->ctx->shared->mrb); + mrb_value chunk = build_chunk(ctx); + h2o_mruby_run_fiber(ctx->generator, detach_receiver(ctx), chunk, NULL); + mrb_gc_arena_restore(ctx->generator->ctx->shared->mrb, gc_arena); + } + } + return 0; +} + +static int headers_sort_cb(const void *_x, const void *_y) +{ + const h2o_header_t *x = _x, *y = _y; + + if (x->name->len < y->name->len) + return -1; + if (x->name->len > y->name->len) + return 1; + return memcmp(x->name->base, y->name->base, x->name->len); +} + +static h2o_http1client_body_cb on_head(h2o_http1client_t *client, const char *errstr, int minor_version, int status, + h2o_iovec_t msg, h2o_header_t *headers, size_t num_headers, int rlen) +{ + struct st_h2o_mruby_http_request_context_t *ctx = client->data; + + if (errstr != NULL) { + if (errstr != h2o_http1client_error_is_eos) { + /* error */ + post_error(ctx, errstr); + return NULL; + } + /* closed without body */ + ctx->client = NULL; + } + + qsort(headers, num_headers, sizeof(headers[0]), headers_sort_cb); + post_response(ctx, status, headers, num_headers); + return on_body; +} + +static h2o_http1client_head_cb on_connect(h2o_http1client_t *client, const char *errstr, h2o_iovec_t **reqbufs, size_t *reqbufcnt, + int *method_is_head) +{ + struct st_h2o_mruby_http_request_context_t *ctx = client->data; + + if (errstr != NULL) { + post_error(ctx, errstr); + return NULL; + } + + *reqbufs = h2o_mem_alloc_pool(&ctx->generator->req->pool, sizeof(**reqbufs) * 2); + **reqbufs = h2o_iovec_init(ctx->req.buf->bytes, ctx->req.buf->size); + *reqbufcnt = 1; + if (ctx->req.body.base != NULL) + (*reqbufs)[(*reqbufcnt)++] = ctx->req.body; + *method_is_head = ctx->req.method_is_head; + return on_head; +} + +static inline void append_to_buffer(h2o_buffer_t **buf, const void *src, size_t len) +{ + memcpy((*buf)->bytes + (*buf)->size, src, len); + (*buf)->size += len; +} + +static int flatten_request_header(h2o_mruby_context_t *handler_ctx, h2o_iovec_t name, h2o_iovec_t value, void *_ctx) +{ + struct st_h2o_mruby_http_request_context_t *ctx = _ctx; + + /* ignore certain headers */ + if (h2o_lcstris(name.base, name.len, H2O_STRLIT("content-length")) || + h2o_lcstris(name.base, name.len, H2O_STRLIT("connection")) || h2o_lcstris(name.base, name.len, H2O_STRLIT("host"))) + return 0; + + /* mark the existence of transfer-encoding in order to prevent us from adding content-length header */ + if (h2o_lcstris(name.base, name.len, H2O_STRLIT("transfer-encoding"))) + ctx->req.has_transfer_encoding = 1; + + h2o_buffer_reserve(&ctx->req.buf, name.len + value.len + sizeof(": \r\n") - 1); + append_to_buffer(&ctx->req.buf, name.base, name.len); + append_to_buffer(&ctx->req.buf, H2O_STRLIT(": ")); + append_to_buffer(&ctx->req.buf, value.base, value.len); + append_to_buffer(&ctx->req.buf, H2O_STRLIT("\r\n")); + + return 0; +} + +static mrb_value http_request_method(mrb_state *mrb, mrb_value self) +{ + h2o_mruby_generator_t *generator; + struct st_h2o_mruby_http_request_context_t *ctx; + const char *arg_url; + mrb_int arg_url_len; + mrb_value arg_hash; + h2o_iovec_t method; + h2o_url_t url; + + /* parse args */ + arg_hash = mrb_nil_value(); + mrb_get_args(mrb, "s|H", &arg_url, &arg_url_len, &arg_hash); + + /* precond check */ + if ((generator = h2o_mruby_current_generator) == NULL || generator->req == NULL) + mrb_exc_raise(mrb, create_downstream_closed_exception(mrb)); + + /* allocate context and initialize */ + ctx = h2o_mem_alloc_shared(&generator->req->pool, sizeof(*ctx), on_dispose); + memset(ctx, 0, sizeof(*ctx)); + ctx->generator = generator; + ctx->receiver = mrb_nil_value(); + h2o_buffer_init(&ctx->req.buf, &h2o_socket_buffer_prototype); + h2o_buffer_init(&ctx->resp.after_closed, &h2o_socket_buffer_prototype); + ctx->refs.request = mrb_nil_value(); + ctx->refs.input_stream = mrb_nil_value(); + + /* uri */ + if (h2o_url_parse(arg_url, arg_url_len, &url) != 0) + mrb_raise(mrb, E_ARGUMENT_ERROR, "invaild URL"); + + /* method */ + method = h2o_iovec_init(H2O_STRLIT("GET")); + if (mrb_hash_p(arg_hash)) { + mrb_value t = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->shared->symbols.sym_method)); + if (!mrb_nil_p(t)) { + t = mrb_str_to_str(mrb, t); + method = h2o_iovec_init(RSTRING_PTR(t), RSTRING_LEN(t)); + if (h2o_memis(method.base, method.len, H2O_STRLIT("HEAD"))) { + ctx->req.method_is_head = 1; + } + } + } + + /* start building the request */ + h2o_buffer_reserve(&ctx->req.buf, method.len + 1); + append_to_buffer(&ctx->req.buf, method.base, method.len); + append_to_buffer(&ctx->req.buf, H2O_STRLIT(" ")); + h2o_buffer_reserve(&ctx->req.buf, + url.path.len + url.authority.len + sizeof(" HTTP/1.1\r\nConnection: close\r\nHost: \r\n") - 1); + append_to_buffer(&ctx->req.buf, url.path.base, url.path.len); + append_to_buffer(&ctx->req.buf, H2O_STRLIT(" HTTP/1.1\r\nConnection: close\r\nHost: ")); + append_to_buffer(&ctx->req.buf, url.authority.base, url.authority.len); + append_to_buffer(&ctx->req.buf, H2O_STRLIT("\r\n")); + + /* headers */ + if (mrb_hash_p(arg_hash)) { + mrb_value headers = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->shared->symbols.sym_headers)); + if (!mrb_nil_p(headers)) { + if (h2o_mruby_iterate_headers(generator->ctx, headers, flatten_request_header, ctx) != 0) { + mrb_value exc = mrb_obj_value(mrb->exc); + mrb->exc = NULL; + mrb_exc_raise(mrb, exc); + } + } + } + /* body */ + if (mrb_hash_p(arg_hash)) { + mrb_value body = mrb_hash_get(mrb, arg_hash, mrb_symbol_value(generator->ctx->shared->symbols.sym_body)); + if (!mrb_nil_p(body)) { + if (mrb_obj_eq(mrb, body, generator->rack_input)) { + /* fast path */ + mrb_int pos; + mrb_input_stream_get_data(mrb, body, NULL, NULL, &pos, NULL, NULL); + ctx->req.body = generator->req->entity; + ctx->req.body.base += pos; + ctx->req.body.len -= pos; + } else { + if (!mrb_string_p(body)) { + body = mrb_funcall(mrb, body, "read", 0); + if (!mrb_string_p(body)) + mrb_raise(mrb, E_ARGUMENT_ERROR, "body.read did not return string"); + } + ctx->req.body = h2o_strdup(&ctx->generator->req->pool, RSTRING_PTR(body), RSTRING_LEN(body)); + } + if (!ctx->req.has_transfer_encoding) { + char buf[64]; + size_t l = (size_t)sprintf(buf, "content-length: %zu\r\n", ctx->req.body.len); + h2o_buffer_reserve(&ctx->req.buf, l); + append_to_buffer(&ctx->req.buf, buf, l); + } + } + } + + h2o_buffer_reserve(&ctx->req.buf, 2); + append_to_buffer(&ctx->req.buf, H2O_STRLIT("\r\n")); + + /* build request and connect */ + ctx->refs.request = h2o_mruby_create_data_instance( + mrb, mrb_ary_entry(generator->ctx->shared->constants, H2O_MRUBY_HTTP_REQUEST_CLASS), ctx, &request_type); + h2o_http1client_connect(&ctx->client, ctx, &generator->req->conn->ctx->proxy.client_ctx, url.host, h2o_url_get_port(&url), + url.scheme == &H2O_URL_SCHEME_HTTPS, on_connect); + + return ctx->refs.request; +} + +mrb_value h2o_mruby_http_join_response_callback(h2o_mruby_generator_t *generator, mrb_value receiver, mrb_value args, + int *next_action) +{ + mrb_state *mrb = generator->ctx->shared->mrb; + struct st_h2o_mruby_http_request_context_t *ctx; + + if (generator->req == NULL) + return create_downstream_closed_exception(mrb); + + if ((ctx = mrb_data_check_get_ptr(mrb, mrb_ary_entry(args, 0), &request_type)) == NULL) + return mrb_exc_new_str_lit(mrb, E_ARGUMENT_ERROR, "HttpRequest#join wrong self"); + + ctx->receiver = receiver; + *next_action = H2O_MRUBY_CALLBACK_NEXT_ACTION_ASYNC; + return mrb_nil_value(); +} + +mrb_value h2o_mruby_http_fetch_chunk_callback(h2o_mruby_generator_t *generator, mrb_value receiver, mrb_value args, + int *next_action) +{ + mrb_state *mrb = generator->ctx->shared->mrb; + struct st_h2o_mruby_http_request_context_t *ctx; + mrb_value ret; + + if (generator->req == NULL) + return create_downstream_closed_exception(mrb); + + if ((ctx = mrb_data_check_get_ptr(mrb, mrb_ary_entry(args, 0), &input_stream_type)) == NULL) + return mrb_exc_new_str_lit(mrb, E_ARGUMENT_ERROR, "_HttpInputStream#each wrong self"); + + if (ctx->resp.has_content) { + ret = build_chunk(ctx); + } else { + ctx->receiver = receiver; + *next_action = H2O_MRUBY_CALLBACK_NEXT_ACTION_ASYNC; + ret = mrb_nil_value(); + } + + return ret; +} + +h2o_mruby_http_request_context_t *h2o_mruby_http_set_shortcut(mrb_state *mrb, mrb_value obj, void (*cb)(h2o_mruby_generator_t *)) +{ + struct st_h2o_mruby_http_request_context_t *ctx; + + if ((ctx = mrb_data_check_get_ptr(mrb, obj, &input_stream_type)) == NULL) + return NULL; + ctx->shortcut_notify_cb = cb; + return ctx; +} + +h2o_buffer_t **h2o_mruby_http_peek_content(h2o_mruby_http_request_context_t *ctx, int *is_final) +{ + *is_final = ctx->client == NULL; + return ctx->client != NULL && ctx->resp.has_content ? &ctx->client->sock->input : &ctx->resp.after_closed; +} + +void h2o_mruby_http_request_init_context(h2o_mruby_shared_context_t *ctx) +{ + mrb_state *mrb = ctx->mrb; + + h2o_mruby_eval_expr(mrb, H2O_MRUBY_CODE_HTTP_REQUEST); + h2o_mruby_assert(mrb); + + struct RClass *module, *klass; + module = mrb_define_module(mrb, "H2O"); + + mrb_define_method(mrb, mrb->kernel_module, "http_request", http_request_method, MRB_ARGS_ARG(1, 2)); + + klass = mrb_class_get_under(mrb, module, "HttpRequest"); + mrb_ary_set(mrb, ctx->constants, H2O_MRUBY_HTTP_REQUEST_CLASS, mrb_obj_value(klass)); + + klass = mrb_class_get_under(mrb, module, "HttpInputStream"); + mrb_ary_set(mrb, ctx->constants, H2O_MRUBY_HTTP_INPUT_STREAM_CLASS, mrb_obj_value(klass)); + + klass = mrb_class_get_under(mrb, klass, "Empty"); + mrb_ary_set(mrb, ctx->constants, H2O_MRUBY_HTTP_EMPTY_INPUT_STREAM_CLASS, mrb_obj_value(klass)); + + h2o_mruby_define_callback(mrb, "_h2o__http_join_response", H2O_MRUBY_CALLBACK_ID_HTTP_JOIN_RESPONSE); + h2o_mruby_define_callback(mrb, "_h2o__http_fetch_chunk", H2O_MRUBY_CALLBACK_ID_HTTP_FETCH_CHUNK); +} diff --git a/web/server/h2o/libh2o/lib/handler/proxy.c b/web/server/h2o/libh2o/lib/handler/proxy.c new file mode 100644 index 000000000..1d87225e1 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/proxy.c @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2014,2015 DeNA Co., Ltd., Masahiro Nagano + * + * 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/un.h> +#include "h2o.h" +#include "h2o/socketpool.h" + +struct rp_handler_t { + h2o_handler_t super; + h2o_url_t upstream; /* host should be NULL-terminated */ + h2o_socketpool_t *sockpool; /* non-NULL if config.use_keepalive == 1 */ + h2o_proxy_config_vars_t config; +}; + +static int on_req(h2o_handler_t *_self, h2o_req_t *req) +{ + struct rp_handler_t *self = (void *)_self; + h2o_req_overrides_t *overrides = h2o_mem_alloc_pool(&req->pool, sizeof(*overrides)); + const h2o_url_scheme_t *scheme; + h2o_iovec_t *authority; + + /* setup overrides */ + *overrides = (h2o_req_overrides_t){NULL}; + if (self->sockpool != NULL) { + overrides->socketpool = self->sockpool; + } else if (self->config.preserve_host) { + overrides->hostport.host = self->upstream.host; + overrides->hostport.port = h2o_url_get_port(&self->upstream); + } + overrides->location_rewrite.match = &self->upstream; + overrides->location_rewrite.path_prefix = req->pathconf->path; + overrides->use_proxy_protocol = self->config.use_proxy_protocol; + overrides->client_ctx = h2o_context_get_handler_context(req->conn->ctx, &self->super); + overrides->headers_cmds = self->config.headers_cmds; + + /* determine the scheme and authority */ + if (self->config.preserve_host) { + scheme = req->scheme; + authority = &req->authority; + } else { + scheme = self->upstream.scheme; + authority = &self->upstream.authority; + } + + /* request reprocess */ + h2o_reprocess_request(req, req->method, scheme, *authority, + h2o_build_destination(req, self->upstream.path.base, self->upstream.path.len, 0), overrides, 0); + + return 0; +} + +static void on_context_init(h2o_handler_t *_self, h2o_context_t *ctx) +{ + struct rp_handler_t *self = (void *)_self; + + /* use the loop of first context for handling socketpool timeouts */ + if (self->sockpool != NULL && self->sockpool->timeout == UINT64_MAX) + h2o_socketpool_set_timeout(self->sockpool, ctx->loop, self->config.keepalive_timeout); + + /* setup a specific client context only if we need to */ + if (ctx->globalconf->proxy.io_timeout == self->config.io_timeout && !self->config.websocket.enabled && + self->config.ssl_ctx == ctx->globalconf->proxy.ssl_ctx) + return; + + h2o_http1client_ctx_t *client_ctx = h2o_mem_alloc(sizeof(*ctx)); + client_ctx->loop = ctx->loop; + client_ctx->getaddr_receiver = &ctx->receivers.hostinfo_getaddr; + if (ctx->globalconf->proxy.io_timeout == self->config.io_timeout) { + client_ctx->io_timeout = &ctx->proxy.io_timeout; + } else { + client_ctx->io_timeout = h2o_mem_alloc(sizeof(*client_ctx->io_timeout)); + h2o_timeout_init(client_ctx->loop, client_ctx->io_timeout, self->config.io_timeout); + } + if (self->config.websocket.enabled) { + /* FIXME avoid creating h2o_timeout_t for every path-level context in case the timeout values are the same */ + client_ctx->websocket_timeout = h2o_mem_alloc(sizeof(*client_ctx->websocket_timeout)); + h2o_timeout_init(client_ctx->loop, client_ctx->websocket_timeout, self->config.websocket.timeout); + } else { + client_ctx->websocket_timeout = NULL; + } + client_ctx->ssl_ctx = self->config.ssl_ctx; + + h2o_context_set_handler_context(ctx, &self->super, client_ctx); +} + +static void on_context_dispose(h2o_handler_t *_self, h2o_context_t *ctx) +{ + struct rp_handler_t *self = (void *)_self; + h2o_http1client_ctx_t *client_ctx = h2o_context_get_handler_context(ctx, &self->super); + + if (client_ctx == NULL) + return; + + if (client_ctx->io_timeout != &ctx->proxy.io_timeout) { + h2o_timeout_dispose(client_ctx->loop, client_ctx->io_timeout); + free(client_ctx->io_timeout); + } + if (client_ctx->websocket_timeout != NULL) { + h2o_timeout_dispose(client_ctx->loop, client_ctx->websocket_timeout); + free(client_ctx->websocket_timeout); + } + free(client_ctx); +} + +static void on_handler_dispose(h2o_handler_t *_self) +{ + struct rp_handler_t *self = (void *)_self; + + if (self->config.ssl_ctx != NULL) + SSL_CTX_free(self->config.ssl_ctx); + free(self->upstream.host.base); + free(self->upstream.path.base); + if (self->sockpool != NULL) { + h2o_socketpool_dispose(self->sockpool); + free(self->sockpool); + } +} + +void h2o_proxy_register_reverse_proxy(h2o_pathconf_t *pathconf, h2o_url_t *upstream, h2o_proxy_config_vars_t *config) +{ + struct sockaddr_un sa; + const char *to_sa_err; + struct rp_handler_t *self = (void *)h2o_create_handler(pathconf, sizeof(*self)); + self->super.on_context_init = on_context_init; + self->super.on_context_dispose = on_context_dispose; + self->super.dispose = on_handler_dispose; + self->super.on_req = on_req; + to_sa_err = h2o_url_host_to_sun(upstream->host, &sa); + if (config->keepalive_timeout != 0) { + self->sockpool = h2o_mem_alloc(sizeof(*self->sockpool)); + int is_ssl = upstream->scheme == &H2O_URL_SCHEME_HTTPS; + if (to_sa_err == h2o_url_host_to_sun_err_is_not_unix_socket) { + h2o_socketpool_init_by_hostport(self->sockpool, upstream->host, h2o_url_get_port(upstream), is_ssl, + SIZE_MAX /* FIXME */); + } else { + assert(to_sa_err == NULL); + h2o_socketpool_init_by_address(self->sockpool, (void *)&sa, sizeof(sa), is_ssl, SIZE_MAX /* FIXME */); + } + } + h2o_url_copy(NULL, &self->upstream, upstream); + if (to_sa_err) { + h2o_strtolower(self->upstream.host.base, self->upstream.host.len); + } + self->config = *config; + if (self->config.ssl_ctx != NULL) + SSL_CTX_up_ref(self->config.ssl_ctx); +} diff --git a/web/server/h2o/libh2o/lib/handler/redirect.c b/web/server/h2o/libh2o/lib/handler/redirect.c new file mode 100644 index 000000000..c8b9c5086 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/redirect.c @@ -0,0 +1,106 @@ +/* + * 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 <stdlib.h> +#include "h2o.h" + +#define MODULE_NAME "lib/handler/redirect.c" + +struct st_h2o_redirect_handler_t { + h2o_handler_t super; + int internal; + int status; + h2o_iovec_t prefix; +}; + +static void on_dispose(h2o_handler_t *_self) +{ + h2o_redirect_handler_t *self = (void *)_self; + free(self->prefix.base); +} + +static void redirect_internally(h2o_redirect_handler_t *self, h2o_req_t *req, h2o_iovec_t dest) +{ + h2o_iovec_t method; + h2o_url_t input, resolved; + + /* resolve the URL */ + if (h2o_url_parse_relative(dest.base, dest.len, &input) != 0) { + h2o_req_log_error(req, MODULE_NAME, "invalid destination:%.*s", (int)dest.len, dest.base); + goto SendInternalError; + } + if (input.scheme != NULL && input.authority.base != NULL) { + resolved = input; + } else { + h2o_url_t base; + /* we MUST to set authority to that of hostconf, or internal redirect might create a TCP connection */ + if (h2o_url_init(&base, req->scheme, req->hostconf->authority.hostport, req->path) != 0) { + h2o_req_log_error(req, MODULE_NAME, "failed to parse current authority:%.*s", (int)req->authority.len, + req->authority.base); + goto SendInternalError; + } + h2o_url_resolve(&req->pool, &base, &input, &resolved); + } + + /* determine the method */ + switch (self->status) { + case 307: + case 308: + method = req->method; + break; + default: + method = h2o_iovec_init(H2O_STRLIT("GET")); + req->entity = (h2o_iovec_t){NULL}; + break; + } + + h2o_reprocess_request_deferred(req, method, resolved.scheme, resolved.authority, resolved.path, NULL, 1); + return; + +SendInternalError: + h2o_send_error_503(req, "Internal Server Error", "internal server error", 0); +} + +static int on_req(h2o_handler_t *_self, h2o_req_t *req) +{ + h2o_redirect_handler_t *self = (void *)_self; + h2o_iovec_t dest = h2o_build_destination(req, self->prefix.base, self->prefix.len, 1); + + /* redirect */ + if (self->internal) { + redirect_internally(self, req, dest); + } else { + h2o_send_redirect(req, self->status, "Redirected", dest.base, dest.len); + } + + return 0; +} + +h2o_redirect_handler_t *h2o_redirect_register(h2o_pathconf_t *pathconf, int internal, int status, const char *prefix) +{ + h2o_redirect_handler_t *self = (void *)h2o_create_handler(pathconf, sizeof(*self)); + self->super.dispose = on_dispose; + self->super.on_req = on_req; + self->internal = internal; + self->status = status; + self->prefix = h2o_strdup(NULL, prefix, SIZE_MAX); + return self; +} diff --git a/web/server/h2o/libh2o/lib/handler/reproxy.c b/web/server/h2o/libh2o/lib/handler/reproxy.c new file mode 100644 index 000000000..369386d27 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/reproxy.c @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2014,2015 DeNA Co., Ltd., Kazuho Oku, Daisuke Maki + * + * 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.h" + +static void on_send(h2o_ostream_t *self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state) +{ + /* nothing to do */ +} + +static void on_setup_ostream(h2o_filter_t *self, h2o_req_t *req, h2o_ostream_t **slot) +{ + h2o_iovec_t dest, method; + ssize_t xru_index; + + /* obtain x-reproxy-url header, or skip to next ostream */ + if ((xru_index = h2o_find_header(&req->res.headers, H2O_TOKEN_X_REPROXY_URL, -1)) == -1) { + h2o_setup_next_ostream(req, slot); + return; + } + dest = req->res.headers.entries[xru_index].value; + h2o_delete_header(&req->res.headers, xru_index); + + /* setup params */ + switch (req->res.status) { + case 307: + case 308: + method = req->method; + break; + default: + method = h2o_iovec_init(H2O_STRLIT("GET")); + req->entity = (h2o_iovec_t){NULL}; + break; + } + + /* request internal redirect (is deferred) */ + h2o_send_redirect_internal(req, method, dest.base, dest.len, 0); + + /* setup filter (that swallows the response until the timeout gets fired) */ + h2o_ostream_t *ostream = h2o_add_ostream(req, sizeof(*ostream), slot); + ostream->do_send = on_send; +} + +void h2o_reproxy_register(h2o_pathconf_t *pathconf) +{ + h2o_filter_t *self = h2o_create_filter(pathconf, sizeof(*self)); + self->on_setup_ostream = on_setup_ostream; +} diff --git a/web/server/h2o/libh2o/lib/handler/status.c b/web/server/h2o/libh2o/lib/handler/status.c new file mode 100644 index 000000000..93befed3b --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/status.c @@ -0,0 +1,270 @@ +/* + * Copyright (c) 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 "h2o.h" + +extern h2o_status_handler_t events_status_handler; +extern h2o_status_handler_t requests_status_handler; +extern h2o_status_handler_t durations_status_handler; + +struct st_h2o_status_logger_t { + h2o_logger_t super; +}; + +struct st_h2o_root_status_handler_t { + h2o_handler_t super; + H2O_VECTOR(h2o_multithread_receiver_t *) receivers; +}; + +struct st_h2o_status_context_t { + h2o_context_t *ctx; + h2o_multithread_receiver_t receiver; +}; + +struct st_status_ctx_t { + int active; + void *ctx; +}; +struct st_h2o_status_collector_t { + struct { + h2o_req_t *req; + h2o_multithread_receiver_t *receiver; + } src; + size_t num_remaining_threads_atomic; + H2O_VECTOR(struct st_status_ctx_t) status_ctx; +}; + +struct st_h2o_status_message_t { + h2o_multithread_message_t super; + struct st_h2o_status_collector_t *collector; +}; + +static void collect_reqs_of_context(struct st_h2o_status_collector_t *collector, h2o_context_t *ctx) +{ + int i; + + for (i = 0; i < ctx->globalconf->statuses.size; i++) { + struct st_status_ctx_t *sc = collector->status_ctx.entries + i; + h2o_status_handler_t *sh = ctx->globalconf->statuses.entries + i; + if (sc->active && sh->per_thread != NULL) + sh->per_thread(sc->ctx, ctx); + } + + if (__sync_sub_and_fetch(&collector->num_remaining_threads_atomic, 1) == 0) { + struct st_h2o_status_message_t *message = h2o_mem_alloc(sizeof(*message)); + message->super = (h2o_multithread_message_t){{NULL}}; + message->collector = collector; + h2o_multithread_send_message(collector->src.receiver, &message->super); + } +} + +static void send_response(struct st_h2o_status_collector_t *collector) +{ + static h2o_generator_t generator = {NULL, NULL}; + h2o_req_t *req; + size_t nr_statuses; + int i; + int cur_resp = 0; + + req = collector->src.req; + if (!req) { + h2o_mem_release_shared(collector); + return; + } + + nr_statuses = req->conn->ctx->globalconf->statuses.size; + size_t nr_resp = nr_statuses + 2; // 2 for the footer and header + h2o_iovec_t resp[nr_resp]; + + memset(resp, 0, sizeof(resp[0]) * nr_resp); + resp[cur_resp++] = (h2o_iovec_t){H2O_STRLIT("{\n")}; + + int coma_removed = 0; + for (i = 0; i < req->conn->ctx->globalconf->statuses.size; i++) { + h2o_status_handler_t *sh = &req->conn->ctx->globalconf->statuses.entries[i]; + if (!collector->status_ctx.entries[i].active) { + continue; + } + resp[cur_resp++] = sh->final(collector->status_ctx.entries[i].ctx, req->conn->ctx->globalconf, req); + if (resp[cur_resp - 1].len > 0 && !coma_removed) { + /* requests come in with a leading coma, replace if with a space */ + resp[cur_resp - 1].base[0] = ' '; + coma_removed = 1; + } + } + resp[cur_resp++] = (h2o_iovec_t){H2O_STRLIT("\n}\n")}; + + req->res.status = 200; + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, NULL, H2O_STRLIT("text/plain; charset=utf-8")); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CACHE_CONTROL, NULL, H2O_STRLIT("no-cache, no-store")); + h2o_start_response(req, &generator); + h2o_send(req, resp, h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("HEAD")) ? 0 : nr_resp, + H2O_SEND_STATE_FINAL); + h2o_mem_release_shared(collector); +} + +static void on_collect_notify(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages) +{ + struct st_h2o_status_context_t *status_ctx = H2O_STRUCT_FROM_MEMBER(struct st_h2o_status_context_t, receiver, receiver); + + while (!h2o_linklist_is_empty(messages)) { + struct st_h2o_status_message_t *message = H2O_STRUCT_FROM_MEMBER(struct st_h2o_status_message_t, super, messages->next); + struct st_h2o_status_collector_t *collector = message->collector; + h2o_linklist_unlink(&message->super.link); + free(message); + + if (__sync_add_and_fetch(&collector->num_remaining_threads_atomic, 0) != 0) { + collect_reqs_of_context(collector, status_ctx->ctx); + } else { + send_response(collector); + } + } +} + +static void on_collector_dispose(void *_collector) +{ +} + +static void on_req_close(void *p) +{ + struct st_h2o_status_collector_t *collector = *(void **)p; + collector->src.req = NULL; + h2o_mem_release_shared(collector); +} + +static int on_req_json(struct st_h2o_root_status_handler_t *self, h2o_req_t *req, h2o_iovec_t status_list) +{ + { /* construct collector and send request to every thread */ + struct st_h2o_status_context_t *status_ctx = h2o_context_get_handler_context(req->conn->ctx, &self->super); + struct st_h2o_status_collector_t *collector = h2o_mem_alloc_shared(NULL, sizeof(*collector), on_collector_dispose); + size_t i; + + memset(collector, 0, sizeof(*collector)); + for (i = 0; i < req->conn->ctx->globalconf->statuses.size; i++) { + h2o_status_handler_t *sh; + + h2o_vector_reserve(&req->pool, &collector->status_ctx, collector->status_ctx.size + 1); + sh = &req->conn->ctx->globalconf->statuses.entries[i]; + + if (status_list.base) { + if (!h2o_contains_token(status_list.base, status_list.len, sh->name.base, sh->name.len, ',')) { + collector->status_ctx.entries[collector->status_ctx.size].active = 0; + goto Skip; + } + } + if (sh->init) { + collector->status_ctx.entries[collector->status_ctx.size].ctx = sh->init(); + } + collector->status_ctx.entries[collector->status_ctx.size].active = 1; + Skip: + collector->status_ctx.size++; + } + collector->src.req = req; + collector->src.receiver = &status_ctx->receiver; + collector->num_remaining_threads_atomic = self->receivers.size; + + for (i = 0; i != self->receivers.size; ++i) { + struct st_h2o_status_message_t *message = h2o_mem_alloc(sizeof(*message)); + *message = (struct st_h2o_status_message_t){{{NULL}}, collector}; + h2o_multithread_send_message(self->receivers.entries[i], &message->super); + } + + /* collector is also retained by the on_req_close callback */ + *(struct st_h2o_status_collector_t **)h2o_mem_alloc_shared(&req->pool, sizeof(collector), on_req_close) = collector; + h2o_mem_addref_shared(collector); + } + + return 0; +} + +static int on_req(h2o_handler_t *_self, h2o_req_t *req) +{ + struct st_h2o_root_status_handler_t *self = (void *)_self; + size_t prefix_len = req->pathconf->path.len - (req->pathconf->path.base[req->pathconf->path.len - 1] == '/'); + h2o_iovec_t local_path = h2o_iovec_init(req->path_normalized.base + prefix_len, req->path_normalized.len - prefix_len); + + if (local_path.len == 0 || h2o_memis(local_path.base, local_path.len, H2O_STRLIT("/"))) { + /* root of the handler returns HTML that renders the status */ + h2o_iovec_t fn; + const char *root = getenv("H2O_ROOT"); + if (root == NULL) + root = H2O_TO_STR(H2O_ROOT); + fn = h2o_concat(&req->pool, h2o_iovec_init(root, strlen(root)), h2o_iovec_init(H2O_STRLIT("/share/h2o/status/index.html"))); + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CACHE_CONTROL, NULL, H2O_STRLIT("no-cache")); + return h2o_file_send(req, 200, "OK", fn.base, h2o_iovec_init(H2O_STRLIT("text/html; charset=utf-8")), 0); + } else if (h2o_memis(local_path.base, local_path.len, H2O_STRLIT("/json"))) { + int ret; + /* "/json" maps to the JSON API */ + h2o_iovec_t status_list = {NULL, 0}; /* NULL means we'll show all statuses */ + if (req->query_at != SIZE_MAX && (req->path.len - req->query_at > 6)) { + if (h2o_memis(&req->path.base[req->query_at], 6, "?show=", 6)) { + status_list = h2o_iovec_init(&req->path.base[req->query_at + 6], req->path.len - req->query_at - 6); + } + } + ret = on_req_json(self, req, status_list); + return ret; + } + + return -1; +} + +static void on_context_init(h2o_handler_t *_self, h2o_context_t *ctx) +{ + struct st_h2o_root_status_handler_t *self = (void *)_self; + struct st_h2o_status_context_t *status_ctx = h2o_mem_alloc(sizeof(*status_ctx)); + + status_ctx->ctx = ctx; + h2o_multithread_register_receiver(ctx->queue, &status_ctx->receiver, on_collect_notify); + + h2o_vector_reserve(NULL, &self->receivers, self->receivers.size + 1); + self->receivers.entries[self->receivers.size++] = &status_ctx->receiver; + + h2o_context_set_handler_context(ctx, &self->super, status_ctx); +} + +static void on_context_dispose(h2o_handler_t *_self, h2o_context_t *ctx) +{ + struct st_h2o_root_status_handler_t *self = (void *)_self; + struct st_h2o_status_context_t *status_ctx = h2o_context_get_handler_context(ctx, &self->super); + size_t i; + + for (i = 0; i != self->receivers.size; ++i) + if (self->receivers.entries[i] == &status_ctx->receiver) + break; + assert(i != self->receivers.size); + memmove(self->receivers.entries + i + 1, self->receivers.entries + i, self->receivers.size - i - 1); + --self->receivers.size; + + h2o_multithread_unregister_receiver(ctx->queue, &status_ctx->receiver); + + free(status_ctx); +} + +void h2o_status_register(h2o_pathconf_t *conf) +{ + struct st_h2o_root_status_handler_t *self = (void *)h2o_create_handler(conf, sizeof(*self)); + self->super.on_context_init = on_context_init; + self->super.on_context_dispose = on_context_dispose; + self->super.on_req = on_req; + h2o_config_register_status_handler(conf->global, requests_status_handler); + h2o_config_register_status_handler(conf->global, events_status_handler); + h2o_config_register_status_handler(conf->global, durations_status_handler); +} diff --git a/web/server/h2o/libh2o/lib/handler/status/durations.c b/web/server/h2o/libh2o/lib/handler/status/durations.c new file mode 100644 index 000000000..f011107bf --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/status/durations.c @@ -0,0 +1,207 @@ +/* + * Copyright (c) 2016 Fastly + * + * 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.h" +#include "gkc.h" +#include <inttypes.h> +#include <pthread.h> + +#define GK_EPSILON 0.01 + +struct st_duration_stats_t { + struct gkc_summary *connect_time; + struct gkc_summary *header_time; + struct gkc_summary *body_time; + struct gkc_summary *request_total_time; + struct gkc_summary *process_time; + struct gkc_summary *response_time; + struct gkc_summary *duration; +}; + +struct st_duration_agg_stats_t { + struct st_duration_stats_t stats; + pthread_mutex_t mutex; +}; + +static h2o_logger_t *durations_logger; +static void durations_status_per_thread(void *priv, h2o_context_t *ctx) +{ + struct st_duration_agg_stats_t *agg_stats = priv; + if (durations_logger) { + struct st_duration_stats_t *ctx_stats = h2o_context_get_logger_context(ctx, durations_logger); + pthread_mutex_lock(&agg_stats->mutex); +#define ADD_DURATION(x) \ + do { \ + struct gkc_summary *tmp; \ + tmp = gkc_combine(agg_stats->stats.x, ctx_stats->x); \ + gkc_summary_free(agg_stats->stats.x); \ + agg_stats->stats.x = tmp; \ + } while (0) + ADD_DURATION(connect_time); + ADD_DURATION(header_time); + ADD_DURATION(body_time); + ADD_DURATION(request_total_time); + ADD_DURATION(process_time); + ADD_DURATION(response_time); + ADD_DURATION(duration); +#undef ADD_DURATION + pthread_mutex_unlock(&agg_stats->mutex); + } +} + +static void duration_stats_init(struct st_duration_stats_t *stats) +{ + stats->connect_time = gkc_summary_alloc(GK_EPSILON); + stats->header_time = gkc_summary_alloc(GK_EPSILON); + stats->body_time = gkc_summary_alloc(GK_EPSILON); + stats->request_total_time = gkc_summary_alloc(GK_EPSILON); + stats->process_time = gkc_summary_alloc(GK_EPSILON); + stats->response_time = gkc_summary_alloc(GK_EPSILON); + stats->duration = gkc_summary_alloc(GK_EPSILON); +} + +static void *durations_status_init(void) +{ + struct st_duration_agg_stats_t *agg_stats; + + agg_stats = h2o_mem_alloc(sizeof(*agg_stats)); + + duration_stats_init(&agg_stats->stats); + pthread_mutex_init(&agg_stats->mutex, NULL); + + return agg_stats; +} + +static void duration_stats_free(struct st_duration_stats_t *stats) +{ + gkc_summary_free(stats->connect_time); + gkc_summary_free(stats->header_time); + gkc_summary_free(stats->body_time); + gkc_summary_free(stats->request_total_time); + gkc_summary_free(stats->process_time); + gkc_summary_free(stats->response_time); + gkc_summary_free(stats->duration); +} + +static h2o_iovec_t durations_status_final(void *priv, h2o_globalconf_t *gconf, h2o_req_t *req) +{ + struct st_duration_agg_stats_t *agg_stats = priv; + h2o_iovec_t ret; + +#define BUFSIZE 16384 +#define DURATION_FMT(x) \ + " \"" x "-0\": %lu,\n" \ + " \"" x "-25\": %lu,\n" \ + " \"" x "-50\": %lu,\n" \ + " \"" x "-75\": %lu,\n" \ + " \"" x "-99\": %lu\n" +#define DURATION_VALS(x) \ + gkc_query(agg_stats->stats.x, 0), gkc_query(agg_stats->stats.x, 0.25), gkc_query(agg_stats->stats.x, 0.5), \ + gkc_query(agg_stats->stats.x, 0.75), gkc_query(agg_stats->stats.x, 0.99) + + ret.base = h2o_mem_alloc_pool(&req->pool, BUFSIZE); + ret.len = snprintf( + ret.base, BUFSIZE, + ",\n" DURATION_FMT("connect-time") "," DURATION_FMT("header-time") "," DURATION_FMT("body-time") "," DURATION_FMT( + "request-total-time") "," DURATION_FMT("process-time") "," DURATION_FMT("response-time") "," DURATION_FMT("duration"), + DURATION_VALS(connect_time), DURATION_VALS(header_time), DURATION_VALS(body_time), DURATION_VALS(request_total_time), + DURATION_VALS(process_time), DURATION_VALS(response_time), DURATION_VALS(duration)); + +#undef BUFSIZE +#undef DURATION_FMT +#undef DURATION_VALS + + duration_stats_free(&agg_stats->stats); + pthread_mutex_destroy(&agg_stats->mutex); + + free(agg_stats); + return ret; +} + +static void stat_access(h2o_logger_t *_self, h2o_req_t *req) +{ + struct st_duration_stats_t *ctx_stats = h2o_context_get_logger_context(req->conn->ctx, _self); +#define ADD_OBSERVATION(x, from, until) \ + do { \ + int64_t dur; \ + if (h2o_time_compute_##x(req, &dur)) { \ + gkc_insert_value(ctx_stats->x, dur); \ + } \ + } while (0) + + ADD_OBSERVATION(connect_time, &req->conn->connected_at, &req->timestamps.request_begin_at); + ADD_OBSERVATION(header_time, &req->timestamps.request_begin_at, h2o_timeval_is_null(&req->timestamps.request_body_begin_at) + ? &req->processed_at.at + : &req->timestamps.request_body_begin_at); + ADD_OBSERVATION(body_time, h2o_timeval_is_null(&req->timestamps.request_body_begin_at) ? &req->processed_at.at + : &req->timestamps.request_body_begin_at, + &req->processed_at.at); + ADD_OBSERVATION(request_total_time, &req->timestamps.request_begin_at, &req->processed_at.at); + ADD_OBSERVATION(process_time, &req->processed_at.at, &req->timestamps.response_start_at); + ADD_OBSERVATION(response_time, &req->timestamps.response_start_at, &req->timestamps.response_end_at); + ADD_OBSERVATION(duration, &req->timestamps.request_begin_at, &req->timestamps.response_end_at); +#undef ADD_OBSERVATION +} + +void on_context_init(struct st_h2o_logger_t *self, h2o_context_t *ctx) +{ + struct st_duration_stats_t *duration_stats = h2o_mem_alloc(sizeof(struct st_duration_stats_t)); + duration_stats_init(duration_stats); + h2o_context_set_logger_context(ctx, self, duration_stats); +} + +void on_context_dispose(struct st_h2o_logger_t *self, h2o_context_t *ctx) +{ + struct st_duration_stats_t *duration_stats; + duration_stats = h2o_context_get_logger_context(ctx, self); + duration_stats_free(duration_stats); +} + +void h2o_duration_stats_register(h2o_globalconf_t *conf) +{ + int i, k; + h2o_logger_t *logger; + h2o_hostconf_t *hconf; + + durations_logger = logger = h2o_mem_alloc(sizeof(*logger)); + memset(logger, 0, sizeof(*logger)); + logger->_config_slot = conf->_num_config_slots++; + logger->log_access = stat_access; + logger->on_context_init = on_context_init; + logger->on_context_dispose = on_context_dispose; + + for (k = 0; conf->hosts[k]; k++) { + hconf = conf->hosts[k]; + for (i = 0; i < hconf->paths.size; i++) { + int j; + for (j = 0; j < hconf->paths.entries[i].handlers.size; j++) { + h2o_pathconf_t *pathconf = &hconf->paths.entries[i]; + h2o_vector_reserve(NULL, &pathconf->loggers, pathconf->loggers.size + 1); + pathconf->loggers.entries[pathconf->loggers.size++] = (void *)logger; + } + } + } +} + +h2o_status_handler_t durations_status_handler = { + {H2O_STRLIT("durations")}, durations_status_init, durations_status_per_thread, durations_status_final, +}; diff --git a/web/server/h2o/libh2o/lib/handler/status/events.c b/web/server/h2o/libh2o/lib/handler/status/events.c new file mode 100644 index 000000000..e6ed0b7c6 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/status/events.c @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2016 Fastly + * + * 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.h" +#include <inttypes.h> + +struct st_events_status_ctx_t { + uint64_t emitted_status_errors[H2O_STATUS_ERROR_MAX]; + uint64_t h2_protocol_level_errors[H2O_HTTP2_ERROR_MAX]; + uint64_t h2_read_closed; + uint64_t h2_write_closed; + pthread_mutex_t mutex; +}; + +static void events_status_per_thread(void *priv, h2o_context_t *ctx) +{ + size_t i; + struct st_events_status_ctx_t *esc = priv; + + pthread_mutex_lock(&esc->mutex); + + for (i = 0; i < H2O_STATUS_ERROR_MAX; i++) { + esc->emitted_status_errors[i] += ctx->emitted_error_status[i]; + } + for (i = 0; i < H2O_HTTP2_ERROR_MAX; i++) { + esc->h2_protocol_level_errors[i] += ctx->http2.events.protocol_level_errors[i]; + } + esc->h2_read_closed += ctx->http2.events.read_closed; + esc->h2_write_closed += ctx->http2.events.write_closed; + + pthread_mutex_unlock(&esc->mutex); +} + +static void *events_status_init(void) +{ + struct st_events_status_ctx_t *ret; + + ret = h2o_mem_alloc(sizeof(*ret)); + memset(ret, 0, sizeof(*ret)); + pthread_mutex_init(&ret->mutex, NULL); + + return ret; +} + +static h2o_iovec_t events_status_final(void *priv, h2o_globalconf_t *gconf, h2o_req_t *req) +{ + struct st_events_status_ctx_t *esc = priv; + h2o_iovec_t ret; + +#define H1_AGG_ERR(status_) esc->emitted_status_errors[H2O_STATUS_ERROR_##status_] +#define H2_AGG_ERR(err_) esc->h2_protocol_level_errors[-H2O_HTTP2_ERROR_##err_] +#define BUFSIZE (2 * 1024) + ret.base = h2o_mem_alloc_pool(&req->pool, BUFSIZE); + ret.len = snprintf(ret.base, BUFSIZE, ",\n" + " \"status-errors.400\": %" PRIu64 ",\n" + " \"status-errors.403\": %" PRIu64 ",\n" + " \"status-errors.404\": %" PRIu64 ",\n" + " \"status-errors.405\": %" PRIu64 ",\n" + " \"status-errors.416\": %" PRIu64 ",\n" + " \"status-errors.417\": %" PRIu64 ",\n" + " \"status-errors.500\": %" PRIu64 ",\n" + " \"status-errors.502\": %" PRIu64 ",\n" + " \"status-errors.503\": %" PRIu64 ",\n" + " \"http2-errors.protocol\": %" PRIu64 ", \n" + " \"http2-errors.internal\": %" PRIu64 ", \n" + " \"http2-errors.flow-control\": %" PRIu64 ", \n" + " \"http2-errors.settings-timeout\": %" PRIu64 ", \n" + " \"http2-errors.stream-closed\": %" PRIu64 ", \n" + " \"http2-errors.frame-size\": %" PRIu64 ", \n" + " \"http2-errors.refused-stream\": %" PRIu64 ", \n" + " \"http2-errors.cancel\": %" PRIu64 ", \n" + " \"http2-errors.compression\": %" PRIu64 ", \n" + " \"http2-errors.connect\": %" PRIu64 ", \n" + " \"http2-errors.enhance-your-calm\": %" PRIu64 ", \n" + " \"http2-errors.inadequate-security\": %" PRIu64 ", \n" + " \"http2.read-closed\": %" PRIu64 ", \n" + " \"http2.write-closed\": %" PRIu64 "\n", + H1_AGG_ERR(400), H1_AGG_ERR(403), H1_AGG_ERR(404), H1_AGG_ERR(405), H1_AGG_ERR(416), H1_AGG_ERR(417), + H1_AGG_ERR(500), H1_AGG_ERR(502), H1_AGG_ERR(503), H2_AGG_ERR(PROTOCOL), H2_AGG_ERR(INTERNAL), + H2_AGG_ERR(FLOW_CONTROL), H2_AGG_ERR(SETTINGS_TIMEOUT), H2_AGG_ERR(STREAM_CLOSED), H2_AGG_ERR(FRAME_SIZE), + H2_AGG_ERR(REFUSED_STREAM), H2_AGG_ERR(CANCEL), H2_AGG_ERR(COMPRESSION), H2_AGG_ERR(CONNECT), + H2_AGG_ERR(ENHANCE_YOUR_CALM), H2_AGG_ERR(INADEQUATE_SECURITY), esc->h2_read_closed, esc->h2_write_closed); + pthread_mutex_destroy(&esc->mutex); + free(esc); + return ret; +#undef BUFSIZE +#undef H1_AGG_ERR +#undef H2_AGG_ERR +} + +h2o_status_handler_t events_status_handler = { + {H2O_STRLIT("events")}, events_status_init, events_status_per_thread, events_status_final, +}; diff --git a/web/server/h2o/libh2o/lib/handler/status/requests.c b/web/server/h2o/libh2o/lib/handler/status/requests.c new file mode 100644 index 000000000..4854e4a1f --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/status/requests.c @@ -0,0 +1,151 @@ +/* + * Copyright (c) 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 "h2o.h" + +struct st_requests_status_ctx_t { + h2o_logconf_t *logconf; + h2o_iovec_t req_data; + pthread_mutex_t mutex; +}; + +struct st_collect_req_status_cbdata_t { + h2o_logconf_t *logconf; + h2o_buffer_t *buffer; +}; + +static int collect_req_status(h2o_req_t *req, void *_cbdata) +{ + struct st_collect_req_status_cbdata_t *cbdata = _cbdata; + + /* collect log */ + char buf[4096]; + size_t len = sizeof(buf); + char *logline = h2o_log_request(cbdata->logconf, req, &len, buf); + assert(len != 0); + --len; /* omit trailing LF */ + + /* append to buffer */ + h2o_buffer_reserve(&cbdata->buffer, len + 3); + memcpy(cbdata->buffer->bytes + cbdata->buffer->size, logline, len); + cbdata->buffer->size += len; + + if (logline != buf) + free(logline); + + return 0; +} + +static void requests_status_per_thread(void *priv, h2o_context_t *ctx) +{ + struct st_requests_status_ctx_t *rsc = priv; + struct st_collect_req_status_cbdata_t cbdata = {rsc->logconf}; + + /* we encountered an error at init() time, return early */ + if (rsc->logconf == NULL) + return; + + h2o_buffer_init(&cbdata.buffer, &h2o_socket_buffer_prototype); + ctx->globalconf->http1.callbacks.foreach_request(ctx, collect_req_status, &cbdata); + ctx->globalconf->http2.callbacks.foreach_request(ctx, collect_req_status, &cbdata); + + /* concat JSON elements */ + if (cbdata.buffer->size != 0) { + pthread_mutex_lock(&rsc->mutex); + if (rsc->req_data.len == 0) + h2o_buffer_consume(&cbdata.buffer, 1); /* skip preceeding comma */ + rsc->req_data.base = h2o_mem_realloc(rsc->req_data.base, rsc->req_data.len + cbdata.buffer->size); + memcpy(rsc->req_data.base + rsc->req_data.len, cbdata.buffer->bytes, cbdata.buffer->size); + rsc->req_data.len += cbdata.buffer->size; + pthread_mutex_unlock(&rsc->mutex); + } + + h2o_buffer_dispose(&cbdata.buffer); +} + +static void *requests_status_init(void) +{ + struct st_requests_status_ctx_t *rsc = h2o_mem_alloc(sizeof(*rsc)); + char errbuf[256]; + +#define ELEMENT(key, expr) "\"" key "\": \"" expr "\"" +#define X_ELEMENT(id) ELEMENT(id, "%{" id "}x") +#define SEPARATOR ", " + const char *fmt = ",\n {" + /* combined_log */ + ELEMENT("host", "%h") SEPARATOR ELEMENT("user", "%u") SEPARATOR ELEMENT("at", "%{%Y%m%dT%H%M%S}t.%{usec_frac}t%{%z}t") + SEPARATOR ELEMENT("method", "%m") SEPARATOR ELEMENT("path", "%U") SEPARATOR ELEMENT("query", "%q") + SEPARATOR ELEMENT("protocol", "%H") SEPARATOR ELEMENT("referer", "%{Referer}i") + SEPARATOR ELEMENT("user-agent", "%{User-agent}i") SEPARATOR + /* time */ + X_ELEMENT("connect-time") SEPARATOR X_ELEMENT("request-header-time") SEPARATOR X_ELEMENT("request-body-time") + SEPARATOR X_ELEMENT("request-total-time") SEPARATOR X_ELEMENT("process-time") SEPARATOR X_ELEMENT("response-time") + SEPARATOR + /* connection */ + X_ELEMENT("connection-id") SEPARATOR X_ELEMENT("ssl.protocol-version") SEPARATOR X_ELEMENT("ssl.session-reused") + SEPARATOR X_ELEMENT("ssl.cipher") SEPARATOR X_ELEMENT("ssl.cipher-bits") SEPARATOR X_ELEMENT("ssl.session-ticket") + SEPARATOR + /* http1 */ + X_ELEMENT("http1.request-index") SEPARATOR + /* http2 */ + X_ELEMENT("http2.stream-id") SEPARATOR X_ELEMENT("http2.priority.received.exclusive") + SEPARATOR X_ELEMENT("http2.priority.received.parent") SEPARATOR X_ELEMENT("http2.priority.received.weight") + SEPARATOR X_ELEMENT("http2.priority.actual.parent") SEPARATOR X_ELEMENT("http2.priority.actual.weight") SEPARATOR + /* misc */ + ELEMENT("authority", "%V") + /* end */ + "}"; +#undef ELEMENT +#undef X_ELEMENT +#undef SEPARATOR + + /* compile logconf */ + if ((rsc->logconf = h2o_logconf_compile(fmt, H2O_LOGCONF_ESCAPE_JSON, errbuf)) == NULL) + /* log format compilation error is an internal logic flaw, therefore we need not send the details to the client */ + fprintf(stderr, "[lib/handler/status/requests.c] failed to compile log format: %s", errbuf); + + rsc->req_data = (h2o_iovec_t){NULL}; + pthread_mutex_init(&rsc->mutex, NULL); + + return rsc; +} + +static h2o_iovec_t requests_status_final(void *priv, h2o_globalconf_t *gconf, h2o_req_t *req) +{ + h2o_iovec_t ret = {NULL}; + struct st_requests_status_ctx_t *rsc = priv; + + if (rsc->logconf != NULL) { + ret = h2o_concat(&req->pool, h2o_iovec_init(H2O_STRLIT(",\n \"requests\": [")), rsc->req_data, + h2o_iovec_init(H2O_STRLIT("\n ]"))); + h2o_logconf_dispose(rsc->logconf); + } + free(rsc->req_data.base); + pthread_mutex_destroy(&rsc->mutex); + + free(rsc); + return ret; +} + +h2o_status_handler_t requests_status_handler = { + {H2O_STRLIT("requests")}, requests_status_init, requests_status_per_thread, requests_status_final, +}; diff --git a/web/server/h2o/libh2o/lib/handler/throttle_resp.c b/web/server/h2o/libh2o/lib/handler/throttle_resp.c new file mode 100644 index 000000000..a0028b502 --- /dev/null +++ b/web/server/h2o/libh2o/lib/handler/throttle_resp.c @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2016 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 <stdlib.h> +#include "h2o.h" + +#ifndef HUNDRED_MS +#define HUNDRED_MS 100 +#endif + +#ifndef ONE_SECOND +#define ONE_SECOND 1000 +#endif + +typedef H2O_VECTOR(h2o_iovec_t) iovec_vector_t; + +typedef struct st_throttle_resp_t { + h2o_ostream_t super; + h2o_timeout_entry_t timeout_entry; + int64_t tokens; + size_t token_inc; + h2o_context_t *ctx; + h2o_req_t *req; + struct { + iovec_vector_t bufs; + h2o_send_state_t stream_state; + } state; +} throttle_resp_t; + +static void real_send(throttle_resp_t *self) +{ + /* a really simple token bucket implementation */ + assert(self->tokens > 0); + size_t i, token_consume; + + token_consume = 0; + + for (i = 0; i < self->state.bufs.size; i++) { + token_consume += self->state.bufs.entries[i].len; + } + + self->tokens -= token_consume; + + h2o_ostream_send_next(&self->super, self->req, self->state.bufs.entries, self->state.bufs.size, self->state.stream_state); + if (!h2o_send_state_is_in_progress(self->state.stream_state)) + h2o_timeout_unlink(&self->timeout_entry); +} + +static void add_token(h2o_timeout_entry_t *entry) +{ + throttle_resp_t *self = H2O_STRUCT_FROM_MEMBER(throttle_resp_t, timeout_entry, entry); + + h2o_timeout_link(self->ctx->loop, &self->ctx->hundred_ms_timeout, &self->timeout_entry); + self->tokens += self->token_inc; + + if (self->tokens > 0) + real_send(self); +} + +static void on_send(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state) +{ + throttle_resp_t *self = (void *)_self; + size_t i; + + /* I don't know if this is a proper way. */ + h2o_vector_reserve(&req->pool, &self->state.bufs, inbufcnt); + /* start to save state */ + for (i = 0; i < inbufcnt; ++i) { + self->state.bufs.entries[i] = inbufs[i]; + } + self->state.bufs.size = inbufcnt; + self->state.stream_state = state; + + /* if there's token, we try to send */ + if (self->tokens > 0) + real_send(self); +} + +static void on_stop(h2o_ostream_t *_self, h2o_req_t *req) +{ + throttle_resp_t *self = (void *)_self; + if (h2o_timeout_is_linked(&self->timeout_entry)) { + h2o_timeout_unlink(&self->timeout_entry); + } +} + +static void on_setup_ostream(h2o_filter_t *self, h2o_req_t *req, h2o_ostream_t **slot) +{ + throttle_resp_t *throttle; + h2o_iovec_t traffic_header_value; + size_t traffic_limit; + + if (req->res.status != 200) + goto Next; + if (h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("HEAD"))) + goto Next; + + ssize_t xt_index; + if ((xt_index = h2o_find_header(&req->res.headers, H2O_TOKEN_X_TRAFFIC, -1)) == -1) + goto Next; + + traffic_header_value = req->res.headers.entries[xt_index].value; + char *buf = traffic_header_value.base; + + if (H2O_UNLIKELY((traffic_limit = h2o_strtosizefwd(&buf, traffic_header_value.len)) == SIZE_MAX)) + goto Next; + + throttle = (void *)h2o_add_ostream(req, sizeof(throttle_resp_t), slot); + + /* calculate the token increment per 100ms */ + throttle->token_inc = traffic_limit * HUNDRED_MS / ONE_SECOND; + if (req->preferred_chunk_size > throttle->token_inc) + req->preferred_chunk_size = throttle->token_inc; + + h2o_delete_header(&req->res.headers, xt_index); + + throttle->super.do_send = on_send; + throttle->super.stop = on_stop; + throttle->ctx = req->conn->ctx; + throttle->req = req; + throttle->state.bufs.capacity = 0; + throttle->state.bufs.size = 0; + throttle->timeout_entry = (h2o_timeout_entry_t){0}; + throttle->timeout_entry.cb = add_token; + throttle->tokens = throttle->token_inc; + slot = &throttle->super.next; + + h2o_timeout_link(throttle->ctx->loop, &throttle->ctx->hundred_ms_timeout, &throttle->timeout_entry); + +Next: + h2o_setup_next_ostream(req, slot); +} + +void h2o_throttle_resp_register(h2o_pathconf_t *pathconf) +{ + h2o_filter_t *self = h2o_create_filter(pathconf, sizeof(*self)); + self->on_setup_ostream = on_setup_ostream; +} diff --git a/web/server/h2o/libh2o/lib/http1.c b/web/server/h2o/libh2o/lib/http1.c new file mode 100644 index 000000000..98c4e55ab --- /dev/null +++ b/web/server/h2o/libh2o/lib/http1.c @@ -0,0 +1,859 @@ +/* + * Copyright (c) 2014-2016 DeNA Co., Ltd., Kazuho Oku, Shota Fukumori, + * Fastly, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ +#include <inttypes.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include "picohttpparser.h" +#include "h2o.h" +#include "h2o/http1.h" +#include "h2o/http2.h" + +#define MAX_PULL_BUF_SZ 65536 + +struct st_h2o_http1_finalostream_t { + h2o_ostream_t super; + int sent_headers; + struct { + void *buf; + h2o_ostream_pull_cb cb; + } pull; +}; + +struct st_h2o_http1_conn_t { + h2o_conn_t super; + h2o_socket_t *sock; + /* internal structure */ + h2o_linklist_t _conns; + h2o_timeout_t *_timeout; + h2o_timeout_entry_t _timeout_entry; + uint64_t _req_index; + size_t _prevreqlen; + size_t _reqsize; + struct st_h2o_http1_req_entity_reader *_req_entity_reader; + struct st_h2o_http1_finalostream_t _ostr_final; + struct { + void *data; + h2o_http1_upgrade_cb cb; + } upgrade; + /* the HTTP request / response (intentionally placed at the last, since it is a large structure and has it's own ctor) */ + h2o_req_t req; +}; + +struct st_h2o_http1_req_entity_reader { + void (*handle_incoming_entity)(struct st_h2o_http1_conn_t *conn); +}; + +struct st_h2o_http1_content_length_entity_reader { + struct st_h2o_http1_req_entity_reader super; + size_t content_length; +}; + +struct st_h2o_http1_chunked_entity_reader { + struct st_h2o_http1_req_entity_reader super; + struct phr_chunked_decoder decoder; + size_t prev_input_size; +}; + +static void proceed_pull(struct st_h2o_http1_conn_t *conn, size_t nfilled); +static void finalostream_start_pull(h2o_ostream_t *_self, h2o_ostream_pull_cb cb); +static void finalostream_send(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t state); +static void reqread_on_read(h2o_socket_t *sock, const char *err); +static int foreach_request(h2o_context_t *ctx, int (*cb)(h2o_req_t *req, void *cbdata), void *cbdata); + +const h2o_protocol_callbacks_t H2O_HTTP1_CALLBACKS = { + NULL, /* graceful_shutdown (note: nothing special needs to be done for handling graceful shutdown) */ + foreach_request}; + +static int is_msie(h2o_req_t *req) +{ + ssize_t cursor = h2o_find_header(&req->headers, H2O_TOKEN_USER_AGENT, -1); + if (cursor == -1) + return 0; + if (h2o_strstr(req->headers.entries[cursor].value.base, req->headers.entries[cursor].value.len, H2O_STRLIT("; MSIE ")) == + SIZE_MAX) + return 0; + return 1; +} + +static void init_request(struct st_h2o_http1_conn_t *conn, int reinit) +{ + if (reinit) + h2o_dispose_request(&conn->req); + h2o_init_request(&conn->req, &conn->super, NULL); + + ++conn->_req_index; + conn->req._ostr_top = &conn->_ostr_final.super; + conn->_ostr_final.super.do_send = finalostream_send; + conn->_ostr_final.super.start_pull = finalostream_start_pull; + conn->_ostr_final.sent_headers = 0; +} + +static void close_connection(struct st_h2o_http1_conn_t *conn, int close_socket) +{ + h2o_timeout_unlink(&conn->_timeout_entry); + h2o_dispose_request(&conn->req); + if (conn->sock != NULL && close_socket) + h2o_socket_close(conn->sock); + h2o_linklist_unlink(&conn->_conns); + free(conn); +} + +static void set_timeout(struct st_h2o_http1_conn_t *conn, h2o_timeout_t *timeout, h2o_timeout_cb cb) +{ + if (conn->_timeout != NULL) { + h2o_timeout_unlink(&conn->_timeout_entry); + conn->_timeout_entry.cb = NULL; + } + conn->_timeout = timeout; + if (timeout != NULL) { + h2o_timeout_link(conn->super.ctx->loop, timeout, &conn->_timeout_entry); + conn->_timeout_entry.cb = cb; + } +} + +static void process_request(struct st_h2o_http1_conn_t *conn) +{ + if (conn->sock->ssl == NULL && conn->req.upgrade.base != NULL && conn->super.ctx->globalconf->http1.upgrade_to_http2 && + conn->req.upgrade.len >= 3 && h2o_lcstris(conn->req.upgrade.base, 3, H2O_STRLIT("h2c")) && + (conn->req.upgrade.len == 3 || + (conn->req.upgrade.len == 6 && (memcmp(conn->req.upgrade.base + 3, H2O_STRLIT("-14")) == 0 || + memcmp(conn->req.upgrade.base + 3, H2O_STRLIT("-16")) == 0)))) { + if (h2o_http2_handle_upgrade(&conn->req, conn->super.connected_at) == 0) { + return; + } + } + h2o_process_request(&conn->req); +} + +#define DECL_ENTITY_READ_SEND_ERROR_XXX(status_) \ + static void entity_read_send_error_##status_(struct st_h2o_http1_conn_t *conn, const char *reason, const char *body) \ + { \ + conn->_req_entity_reader = NULL; \ + set_timeout(conn, NULL, NULL); \ + h2o_socket_read_stop(conn->sock); \ + conn->req.http1_is_persistent = 0; \ + conn->super.ctx->emitted_error_status[H2O_STATUS_ERROR_##status_]++; \ + h2o_send_error_generic(&conn->req, status_, reason, body, H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION); \ + } + +DECL_ENTITY_READ_SEND_ERROR_XXX(400) +DECL_ENTITY_READ_SEND_ERROR_XXX(413) + +static void on_entity_read_complete(struct st_h2o_http1_conn_t *conn) +{ + conn->_req_entity_reader = NULL; + set_timeout(conn, NULL, NULL); + h2o_socket_read_stop(conn->sock); + process_request(conn); +} + +static void handle_chunked_entity_read(struct st_h2o_http1_conn_t *conn) +{ + struct st_h2o_http1_chunked_entity_reader *reader = (void *)conn->_req_entity_reader; + h2o_buffer_t *inbuf = conn->sock->input; + size_t bufsz; + ssize_t ret; + + /* decode the incoming data */ + if ((bufsz = inbuf->size - reader->prev_input_size) == 0) + return; + ret = phr_decode_chunked(&reader->decoder, inbuf->bytes + reader->prev_input_size, &bufsz); + inbuf->size = reader->prev_input_size + bufsz; + reader->prev_input_size = inbuf->size; + if (ret != -1 && inbuf->size - conn->_reqsize >= conn->super.ctx->globalconf->max_request_entity_size) { + entity_read_send_error_413(conn, "Request Entity Too Large", "request entity is too large"); + return; + } + if (ret < 0) { + if (ret == -2) { + /* incomplete */ + return; + } + /* error */ + entity_read_send_error_400(conn, "Invalid Request", "broken chunked-encoding"); + return; + } + /* complete */ + conn->req.entity = h2o_iovec_init(inbuf->bytes + conn->_reqsize, inbuf->size - conn->_reqsize); + conn->_reqsize = inbuf->size; + inbuf->size += ret; /* restore the number of extra bytes */ + + on_entity_read_complete(conn); +} + +static int create_chunked_entity_reader(struct st_h2o_http1_conn_t *conn) +{ + struct st_h2o_http1_chunked_entity_reader *reader = h2o_mem_alloc_pool(&conn->req.pool, sizeof(*reader)); + conn->_req_entity_reader = &reader->super; + + reader->super.handle_incoming_entity = handle_chunked_entity_read; + memset(&reader->decoder, 0, sizeof(reader->decoder)); + reader->decoder.consume_trailer = 1; + reader->prev_input_size = conn->_reqsize; + + return 0; +} + +static void handle_content_length_entity_read(struct st_h2o_http1_conn_t *conn) +{ + struct st_h2o_http1_content_length_entity_reader *reader = (void *)conn->_req_entity_reader; + + /* wait until: reqsize == conn->_input.size */ + if (conn->sock->input->size < conn->_reqsize) + return; + + /* all input has arrived */ + conn->req.entity = h2o_iovec_init(conn->sock->input->bytes + conn->_reqsize - reader->content_length, reader->content_length); + on_entity_read_complete(conn); +} + +static int create_content_length_entity_reader(struct st_h2o_http1_conn_t *conn, size_t content_length) +{ + struct st_h2o_http1_content_length_entity_reader *reader = h2o_mem_alloc_pool(&conn->req.pool, sizeof(*reader)); + conn->_req_entity_reader = &reader->super; + + reader->super.handle_incoming_entity = handle_content_length_entity_read; + reader->content_length = content_length; + conn->_reqsize += content_length; + + return 0; +} + +static int create_entity_reader(struct st_h2o_http1_conn_t *conn, const struct phr_header *entity_header) +{ + /* strlen("content-length") is unequal to sizeof("transfer-encoding"), and thus checking the length only is sufficient */ + if (entity_header->name_len == sizeof("transfer-encoding") - 1) { + /* transfer-encoding */ + if (!h2o_lcstris(entity_header->value, entity_header->value_len, H2O_STRLIT("chunked"))) { + entity_read_send_error_400(conn, "Invalid Request", "unknown transfer-encoding"); + return -1; + } + return create_chunked_entity_reader(conn); + } else { + /* content-length */ + size_t content_length = h2o_strtosize(entity_header->value, entity_header->value_len); + if (content_length == SIZE_MAX) { + entity_read_send_error_400(conn, "Invalid Request", "broken content-length header"); + return -1; + } + if (content_length > conn->super.ctx->globalconf->max_request_entity_size) { + entity_read_send_error_413(conn, "Request Entity Too Large", "request entity is too large"); + return -1; + } + return create_content_length_entity_reader(conn, (size_t)content_length); + } + /* failed */ + return -1; +} + +static ssize_t init_headers(h2o_mem_pool_t *pool, h2o_headers_t *headers, const struct phr_header *src, size_t len, + h2o_iovec_t *connection, h2o_iovec_t *host, h2o_iovec_t *upgrade, h2o_iovec_t *expect) +{ + ssize_t entity_header_index = -1; + + assert(headers->size == 0); + + /* setup */ + if (len != 0) { + size_t i; + h2o_vector_reserve(pool, headers, len); + for (i = 0; i != len; ++i) { + const h2o_token_t *name_token; + char orig_case[src[i].name_len]; + + /* preserve the original case */ + memcpy(orig_case, src[i].name, src[i].name_len); + /* convert to lower-case in-place */ + h2o_strtolower((char *)src[i].name, src[i].name_len); + if ((name_token = h2o_lookup_token(src[i].name, src[i].name_len)) != NULL) { + if (name_token->is_init_header_special) { + if (name_token == H2O_TOKEN_HOST) { + host->base = (char *)src[i].value; + host->len = src[i].value_len; + } else if (name_token == H2O_TOKEN_CONTENT_LENGTH) { + if (entity_header_index == -1) + entity_header_index = i; + } else if (name_token == H2O_TOKEN_TRANSFER_ENCODING) { + entity_header_index = i; + } else if (name_token == H2O_TOKEN_EXPECT) { + expect->base = (char *)src[i].value; + expect->len = src[i].value_len; + } else if (name_token == H2O_TOKEN_UPGRADE) { + upgrade->base = (char *)src[i].value; + upgrade->len = src[i].value_len; + } else { + assert(!"logic flaw"); + } + } else { + h2o_add_header(pool, headers, name_token, orig_case, src[i].value, src[i].value_len); + if (name_token == H2O_TOKEN_CONNECTION) + *connection = headers->entries[headers->size - 1].value; + } + } else { + h2o_add_header_by_str(pool, headers, src[i].name, src[i].name_len, 0, orig_case, src[i].value, src[i].value_len); + } + } + } + + return entity_header_index; +} + +static ssize_t fixup_request(struct st_h2o_http1_conn_t *conn, struct phr_header *headers, size_t num_headers, int minor_version, + h2o_iovec_t *expect) +{ + ssize_t entity_header_index; + h2o_iovec_t connection = {NULL, 0}, host = {NULL, 0}, upgrade = {NULL, 0}; + + expect->base = NULL; + expect->len = 0; + + conn->req.input.scheme = conn->sock->ssl != NULL ? &H2O_URL_SCHEME_HTTPS : &H2O_URL_SCHEME_HTTP; + conn->req.version = 0x100 | (minor_version != 0); + + /* init headers */ + entity_header_index = + init_headers(&conn->req.pool, &conn->req.headers, headers, num_headers, &connection, &host, &upgrade, expect); + + /* copy the values to pool, since the buffer pointed by the headers may get realloced */ + if (entity_header_index != -1) { + size_t i; + conn->req.input.method = h2o_strdup(&conn->req.pool, conn->req.input.method.base, conn->req.input.method.len); + conn->req.input.path = h2o_strdup(&conn->req.pool, conn->req.input.path.base, conn->req.input.path.len); + for (i = 0; i != conn->req.headers.size; ++i) { + h2o_header_t *header = conn->req.headers.entries + i; + if (!h2o_iovec_is_token(header->name)) { + *header->name = h2o_strdup(&conn->req.pool, header->name->base, header->name->len); + } + header->value = h2o_strdup(&conn->req.pool, header->value.base, header->value.len); + } + if (host.base != NULL) + host = h2o_strdup(&conn->req.pool, host.base, host.len); + if (upgrade.base != NULL) + upgrade = h2o_strdup(&conn->req.pool, upgrade.base, upgrade.len); + } + + /* move host header to req->authority */ + if (host.base != NULL) + conn->req.input.authority = host; + + /* setup persistent flag (and upgrade info) */ + if (connection.base != NULL) { + /* TODO contains_token function can be faster */ + if (h2o_contains_token(connection.base, connection.len, H2O_STRLIT("keep-alive"), ',')) { + conn->req.http1_is_persistent = 1; + } + if (upgrade.base != NULL && h2o_contains_token(connection.base, connection.len, H2O_STRLIT("upgrade"), ',')) { + conn->req.upgrade = upgrade; + } + } else if (conn->req.version >= 0x101) { + /* defaults to keep-alive if >= HTTP/1.1 */ + conn->req.http1_is_persistent = 1; + } + /* disable keep-alive if shutdown is requested */ + if (conn->req.http1_is_persistent && conn->super.ctx->shutdown_requested) + conn->req.http1_is_persistent = 0; + + return entity_header_index; +} + +static void on_continue_sent(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_http1_conn_t *conn = sock->data; + + if (err != NULL) { + close_connection(conn, 1); + return; + } + + h2o_socket_read_start(sock, reqread_on_read); + conn->_req_entity_reader->handle_incoming_entity(conn); +} + +static int contains_crlf_only(const char *s, size_t len) +{ + for (; len != 0; ++s, --len) + if (!(*s == '\r' || *s == '\n')) + return 0; + return 1; +} + +static void send_bad_request_on_complete(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_http1_conn_t *conn = sock->data; + close_connection(conn, 1); +} + +static void send_bad_request(struct st_h2o_http1_conn_t *conn) +{ + const static h2o_iovec_t resp = {H2O_STRLIT("HTTP/1.1 400 Bad Request\r\n" + "Content-Type: text/plain; charset=utf-8\r\n" + "Connection: close\r\n" + "Content-Length: 11\r\n" + "\r\n" + "Bad Request")}; + + assert(conn->req.version == 0 && "request has not been parsed successfully"); + assert(conn->req.http1_is_persistent == 0); + h2o_socket_write(conn->sock, (h2o_iovec_t *)&resp, 1, send_bad_request_on_complete); + h2o_socket_read_stop(conn->sock); +} + +static void handle_incoming_request(struct st_h2o_http1_conn_t *conn) +{ + size_t inreqlen = conn->sock->input->size < H2O_MAX_REQLEN ? conn->sock->input->size : H2O_MAX_REQLEN; + int reqlen, minor_version; + struct phr_header headers[H2O_MAX_HEADERS]; + size_t num_headers = H2O_MAX_HEADERS; + ssize_t entity_body_header_index; + h2o_iovec_t expect; + + /* need to set request_begin_at here for keep-alive connection */ + if (conn->req.timestamps.request_begin_at.tv_sec == 0) + conn->req.timestamps.request_begin_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL); + + reqlen = phr_parse_request(conn->sock->input->bytes, inreqlen, (const char **)&conn->req.input.method.base, + &conn->req.input.method.len, (const char **)&conn->req.input.path.base, &conn->req.input.path.len, + &minor_version, headers, &num_headers, conn->_prevreqlen); + conn->_prevreqlen = inreqlen; + + switch (reqlen) { + default: // parse complete + conn->_reqsize = reqlen; + if ((entity_body_header_index = fixup_request(conn, headers, num_headers, minor_version, &expect)) != -1) { + conn->req.timestamps.request_body_begin_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL); + if (expect.base != NULL) { + if (!h2o_lcstris(expect.base, expect.len, H2O_STRLIT("100-continue"))) { + set_timeout(conn, NULL, NULL); + h2o_socket_read_stop(conn->sock); + h2o_send_error_417(&conn->req, "Expectation Failed", "unknown expectation", + H2O_SEND_ERROR_HTTP1_CLOSE_CONNECTION); + return; + } + } + if (create_entity_reader(conn, headers + entity_body_header_index) != 0) { + return; + } + if (expect.base != NULL) { + static const h2o_iovec_t res = {H2O_STRLIT("HTTP/1.1 100 Continue\r\n\r\n")}; + h2o_socket_write(conn->sock, (void *)&res, 1, on_continue_sent); + /* processing of the incoming entity is postponed until the 100 response is sent */ + h2o_socket_read_stop(conn->sock); + return; + } + conn->_req_entity_reader->handle_incoming_entity(conn); + } else { + set_timeout(conn, NULL, NULL); + h2o_socket_read_stop(conn->sock); + process_request(conn); + } + return; + case -2: // incomplete + if (inreqlen == H2O_MAX_REQLEN) { + send_bad_request(conn); + } + return; + case -1: // error + /* upgrade to HTTP/2 if the request starts with: PRI * HTTP/2 */ + if (conn->super.ctx->globalconf->http1.upgrade_to_http2) { + /* should check up to the first octet that phr_parse_request returns an error */ + static const h2o_iovec_t HTTP2_SIG = {H2O_STRLIT("PRI * HTTP/2")}; + if (conn->sock->input->size >= HTTP2_SIG.len && memcmp(conn->sock->input->bytes, HTTP2_SIG.base, HTTP2_SIG.len) == 0) { + h2o_accept_ctx_t accept_ctx = {conn->super.ctx, conn->super.hosts}; + h2o_socket_t *sock = conn->sock; + struct timeval connected_at = conn->super.connected_at; + /* destruct the connection after detatching the socket */ + conn->sock = NULL; + close_connection(conn, 1); + /* and accept as http2 connection */ + h2o_http2_accept(&accept_ctx, sock, connected_at); + return; + } + } + if (inreqlen <= 4 && contains_crlf_only(conn->sock->input->bytes, inreqlen)) { + close_connection(conn, 1); + } else { + send_bad_request(conn); + } + return; + } +} + +void reqread_on_read(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_http1_conn_t *conn = sock->data; + + if (err != NULL) { + close_connection(conn, 1); + return; + } + + if (conn->_req_entity_reader == NULL) + handle_incoming_request(conn); + else + conn->_req_entity_reader->handle_incoming_entity(conn); +} + +static void reqread_on_timeout(h2o_timeout_entry_t *entry) +{ + struct st_h2o_http1_conn_t *conn = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1_conn_t, _timeout_entry, entry); + + /* TODO log */ + conn->req.http1_is_persistent = 0; + close_connection(conn, 1); +} + +static inline void reqread_start(struct st_h2o_http1_conn_t *conn) +{ + set_timeout(conn, &conn->super.ctx->http1.req_timeout, reqread_on_timeout); + h2o_socket_read_start(conn->sock, reqread_on_read); + if (conn->sock->input->size != 0) + handle_incoming_request(conn); +} + +static void on_send_next_push(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_http1_conn_t *conn = sock->data; + + if (err != NULL) + close_connection(conn, 1); + else + h2o_proceed_response(&conn->req); +} + +static void on_send_next_pull(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_http1_conn_t *conn = sock->data; + + if (err != NULL) + close_connection(conn, 1); + else + proceed_pull(conn, 0); +} + +static void on_send_complete(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_http1_conn_t *conn = sock->data; + + assert(conn->req._ostr_top == &conn->_ostr_final.super); + + conn->req.timestamps.response_end_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL); + + if (!conn->req.http1_is_persistent) { + /* TODO use lingering close */ + close_connection(conn, 1); + return; + } + + /* handle next request */ + init_request(conn, 1); + h2o_buffer_consume(&conn->sock->input, conn->_reqsize); + conn->_prevreqlen = 0; + conn->_reqsize = 0; + reqread_start(conn); +} + +static void on_upgrade_complete(h2o_socket_t *socket, const char *err) +{ + struct st_h2o_http1_conn_t *conn = socket->data; + h2o_http1_upgrade_cb cb = conn->upgrade.cb; + void *data = conn->upgrade.data; + h2o_socket_t *sock = NULL; + size_t reqsize = 0; + + /* destruct the connection (after detaching the socket) */ + if (err == 0) { + sock = conn->sock; + reqsize = conn->_reqsize; + close_connection(conn, 0); + } else { + close_connection(conn, 1); + } + + cb(data, sock, reqsize); +} + +static size_t flatten_headers_estimate_size(h2o_req_t *req, size_t server_name_and_connection_len) +{ + size_t len = sizeof("HTTP/1.1 \r\ndate: \r\nserver: \r\nconnection: \r\ncontent-length: \r\n\r\n") + 3 + + strlen(req->res.reason) + H2O_TIMESTR_RFC1123_LEN + server_name_and_connection_len + + sizeof(H2O_UINT64_LONGEST_STR) - 1 + sizeof("cache-control: private") - 1; + const h2o_header_t *header, *end; + + for (header = req->res.headers.entries, end = header + req->res.headers.size; header != end; ++header) + len += header->name->len + header->value.len + 4; + + return len; +} + +static size_t flatten_headers(char *buf, h2o_req_t *req, const char *connection) +{ + h2o_context_t *ctx = req->conn->ctx; + h2o_timestamp_t ts; + char *dst = buf; + + h2o_get_timestamp(ctx, &req->pool, &ts); + + assert(req->res.status <= 999); + + /* send essential headers with the first chars uppercased for max. interoperability (#72) */ + if (req->res.content_length != SIZE_MAX) { + dst += sprintf(dst, "HTTP/1.1 %d %s\r\nDate: %s\r\nConnection: %s\r\nContent-Length: %zu\r\n", req->res.status, + req->res.reason, ts.str->rfc1123, connection, req->res.content_length); + } else { + dst += sprintf(dst, "HTTP/1.1 %d %s\r\nDate: %s\r\nConnection: %s\r\n", req->res.status, req->res.reason, ts.str->rfc1123, + connection); + } + if (ctx->globalconf->server_name.len) { + dst += sprintf(dst, "Server: %s\r\n", ctx->globalconf->server_name.base); + } + + { /* flatten the normal headers */ + size_t i; + for (i = 0; i != req->res.headers.size; ++i) { + const h2o_header_t *header = req->res.headers.entries + i; + if (header->name == &H2O_TOKEN_VARY->buf) { + /* replace Vary with Cache-Control: private; see the following URLs to understand why this is necessary + * - http://blogs.msdn.com/b/ieinternals/archive/2009/06/17/vary-header-prevents-caching-in-ie.aspx + * - https://www.igvita.com/2013/05/01/deploying-webp-via-accept-content-negotiation/ + */ + if (is_msie(req)) { + static h2o_header_t cache_control_private = {&H2O_TOKEN_CACHE_CONTROL->buf, NULL, {H2O_STRLIT("private")}}; + header = &cache_control_private; + } + } + memcpy(dst, header->orig_name ? header->orig_name : header->name->base, header->name->len); + dst += header->name->len; + *dst++ = ':'; + *dst++ = ' '; + memcpy(dst, header->value.base, header->value.len); + dst += header->value.len; + *dst++ = '\r'; + *dst++ = '\n'; + } + *dst++ = '\r'; + *dst++ = '\n'; + } + + return dst - buf; +} + +static void proceed_pull(struct st_h2o_http1_conn_t *conn, size_t nfilled) +{ + h2o_iovec_t buf = {conn->_ostr_final.pull.buf, nfilled}; + h2o_send_state_t send_state; + + if (buf.len < MAX_PULL_BUF_SZ) { + h2o_iovec_t cbuf = {buf.base + buf.len, MAX_PULL_BUF_SZ - buf.len}; + send_state = h2o_pull(&conn->req, conn->_ostr_final.pull.cb, &cbuf); + if (send_state == H2O_SEND_STATE_ERROR) { + conn->req.http1_is_persistent = 0; + } + buf.len += cbuf.len; + conn->req.bytes_sent += cbuf.len; + } else { + send_state = H2O_SEND_STATE_IN_PROGRESS; + } + + /* write */ + h2o_socket_write(conn->sock, &buf, 1, h2o_send_state_is_in_progress(send_state) ? on_send_next_pull : on_send_complete); +} + +static void finalostream_start_pull(h2o_ostream_t *_self, h2o_ostream_pull_cb cb) +{ + struct st_h2o_http1_conn_t *conn = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1_conn_t, _ostr_final.super, _self); + const char *connection = conn->req.http1_is_persistent ? "keep-alive" : "close"; + size_t bufsz, headers_len; + + assert(conn->req._ostr_top == &conn->_ostr_final.super); + assert(!conn->_ostr_final.sent_headers); + + conn->req.timestamps.response_start_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL); + + /* register the pull callback */ + conn->_ostr_final.pull.cb = cb; + + /* setup the buffer */ + bufsz = flatten_headers_estimate_size(&conn->req, conn->super.ctx->globalconf->server_name.len + strlen(connection)); + if (bufsz < MAX_PULL_BUF_SZ) { + if (MAX_PULL_BUF_SZ - bufsz < conn->req.res.content_length) { + bufsz = MAX_PULL_BUF_SZ; + } else { + bufsz += conn->req.res.content_length; + } + } + conn->_ostr_final.pull.buf = h2o_mem_alloc_pool(&conn->req.pool, bufsz); + + /* fill-in the header */ + headers_len = flatten_headers(conn->_ostr_final.pull.buf, &conn->req, connection); + conn->_ostr_final.sent_headers = 1; + + proceed_pull(conn, headers_len); +} + +void finalostream_send(h2o_ostream_t *_self, h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_send_state_t send_state) +{ + struct st_h2o_http1_finalostream_t *self = (void *)_self; + struct st_h2o_http1_conn_t *conn = (struct st_h2o_http1_conn_t *)req->conn; + h2o_iovec_t *bufs = alloca(sizeof(h2o_iovec_t) * (inbufcnt + 1)); + int i; + int bufcnt = 0; + + assert(self == &conn->_ostr_final); + + /* count bytes_sent if other ostreams haven't counted */ + if (req->bytes_counted_by_ostream == 0) { + for (i = 0; i != inbufcnt; ++i) { + req->bytes_sent += inbufs[i].len; + } + } + + if (!self->sent_headers) { + conn->req.timestamps.response_start_at = *h2o_get_timestamp(conn->super.ctx, NULL, NULL); + /* build headers and send */ + const char *connection = req->http1_is_persistent ? "keep-alive" : "close"; + bufs[bufcnt].base = h2o_mem_alloc_pool( + &req->pool, flatten_headers_estimate_size(req, conn->super.ctx->globalconf->server_name.len + strlen(connection))); + bufs[bufcnt].len = flatten_headers(bufs[bufcnt].base, req, connection); + ++bufcnt; + self->sent_headers = 1; + } + memcpy(bufs + bufcnt, inbufs, sizeof(h2o_iovec_t) * inbufcnt); + bufcnt += inbufcnt; + + if (send_state == H2O_SEND_STATE_ERROR) { + conn->req.http1_is_persistent = 0; + } + + if (bufcnt != 0) { + h2o_socket_write(conn->sock, bufs, bufcnt, + h2o_send_state_is_in_progress(send_state) ? on_send_next_push : on_send_complete); + } else { + on_send_complete(conn->sock, 0); + } +} + +static socklen_t get_sockname(h2o_conn_t *_conn, struct sockaddr *sa) +{ + struct st_h2o_http1_conn_t *conn = (void *)_conn; + return h2o_socket_getsockname(conn->sock, sa); +} + +static socklen_t get_peername(h2o_conn_t *_conn, struct sockaddr *sa) +{ + struct st_h2o_http1_conn_t *conn = (void *)_conn; + return h2o_socket_getpeername(conn->sock, sa); +} + +static h2o_socket_t *get_socket(h2o_conn_t *_conn) +{ + struct st_h2o_http1_conn_t *conn = (void *)_conn; + return conn->sock; +} + +#define DEFINE_TLS_LOGGER(name) \ + static h2o_iovec_t log_##name(h2o_req_t *req) \ + { \ + struct st_h2o_http1_conn_t *conn = (void *)req->conn; \ + return h2o_socket_log_ssl_##name(conn->sock, &req->pool); \ + } + +DEFINE_TLS_LOGGER(protocol_version) +DEFINE_TLS_LOGGER(session_reused) +DEFINE_TLS_LOGGER(cipher) +DEFINE_TLS_LOGGER(cipher_bits) +DEFINE_TLS_LOGGER(session_id) + +#undef DEFINE_TLS_LOGGER + +static h2o_iovec_t log_request_index(h2o_req_t *req) +{ + struct st_h2o_http1_conn_t *conn = (void *)req->conn; + char *s = h2o_mem_alloc_pool(&req->pool, sizeof(H2O_UINT64_LONGEST_STR)); + size_t len = sprintf(s, "%" PRIu64, conn->_req_index); + return h2o_iovec_init(s, len); +} + +static int foreach_request(h2o_context_t *ctx, int (*cb)(h2o_req_t *req, void *cbdata), void *cbdata) +{ + h2o_linklist_t *node; + + for (node = ctx->http1._conns.next; node != &ctx->http1._conns; node = node->next) { + struct st_h2o_http1_conn_t *conn = H2O_STRUCT_FROM_MEMBER(struct st_h2o_http1_conn_t, _conns, node); + int ret = cb(&conn->req, cbdata); + if (ret != 0) + return ret; + } + return 0; +} + +void h2o_http1_accept(h2o_accept_ctx_t *ctx, h2o_socket_t *sock, struct timeval connected_at) +{ + static const h2o_conn_callbacks_t callbacks = { + get_sockname, /* stringify address */ + get_peername, /* ditto */ + NULL, /* push */ + get_socket, /* get underlying socket */ + NULL, /* get debug state */ + {{ + {log_protocol_version, log_session_reused, log_cipher, log_cipher_bits, log_session_id}, /* ssl */ + {log_request_index}, /* http1 */ + {NULL} /* http2 */ + }}}; + struct st_h2o_http1_conn_t *conn = (void *)h2o_create_connection(sizeof(*conn), ctx->ctx, ctx->hosts, connected_at, &callbacks); + + /* zero-fill all properties expect req */ + memset((char *)conn + sizeof(conn->super), 0, offsetof(struct st_h2o_http1_conn_t, req) - sizeof(conn->super)); + + /* init properties that need to be non-zero */ + conn->super.ctx = ctx->ctx; + conn->super.hosts = ctx->hosts; + conn->super.connected_at = connected_at; + conn->super.callbacks = &callbacks; + conn->sock = sock; + sock->data = conn; + h2o_linklist_insert(&ctx->ctx->http1._conns, &conn->_conns); + + init_request(conn, 0); + reqread_start(conn); +} + +void h2o_http1_upgrade(h2o_req_t *req, h2o_iovec_t *inbufs, size_t inbufcnt, h2o_http1_upgrade_cb on_complete, void *user_data) +{ + struct st_h2o_http1_conn_t *conn = (void *)req->conn; + + assert(req->version <= 0x200); /* TODO find a better way to assert instanceof(req->conn) == struct st_h2o_http1_conn_t */ + + h2o_iovec_t *bufs = alloca(sizeof(h2o_iovec_t) * (inbufcnt + 1)); + + conn->upgrade.data = user_data; + conn->upgrade.cb = on_complete; + + bufs[0].base = + h2o_mem_alloc_pool(&conn->req.pool, flatten_headers_estimate_size(&conn->req, conn->super.ctx->globalconf->server_name.len + + sizeof("upgrade") - 1)); + bufs[0].len = flatten_headers(bufs[0].base, &conn->req, "upgrade"); + h2o_memcpy(bufs + 1, inbufs, sizeof(h2o_iovec_t) * inbufcnt); + + h2o_socket_write(conn->sock, bufs, inbufcnt + 1, on_upgrade_complete); +} diff --git a/web/server/h2o/libh2o/lib/http2/cache_digests.c b/web/server/h2o/libh2o/lib/http2/cache_digests.c new file mode 100644 index 000000000..fa28bd238 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/cache_digests.c @@ -0,0 +1,201 @@ +/* + * Copyright (c) 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 <limits.h> +#include <openssl/sha.h> +#include <stdlib.h> +#include "golombset.h" +#include "h2o/string_.h" +#include "h2o/cache_digests.h" + +struct st_h2o_cache_digests_frame_t { + H2O_VECTOR(uint64_t) keys; + unsigned capacity_bits; +}; + +static void dispose_frame_vector(h2o_cache_digests_frame_vector_t *v) +{ + size_t i; + for (i = 0; i != v->size; ++i) + free(v->entries[i].keys.entries); + free(v->entries); +} + +static void dispose_digests(h2o_cache_digests_t *digests) +{ + dispose_frame_vector(&digests->fresh.url_only); + dispose_frame_vector(&digests->fresh.url_and_etag); +} + +void h2o_cache_digests_destroy(h2o_cache_digests_t *digests) +{ + dispose_digests(digests); + free(digests); +} + +static void load_digest(h2o_cache_digests_t **digests, const char *gcs_base64, size_t gcs_base64_len, int with_validators, + int complete) +{ + h2o_cache_digests_frame_t frame = {{NULL}}; + h2o_iovec_t gcs_bin; + struct st_golombset_decode_t ctx = {NULL}; + uint64_t nbits, pbits; + + /* decode base64 */ + if ((gcs_bin = h2o_decode_base64url(NULL, gcs_base64, gcs_base64_len)).base == NULL) + goto Exit; + + /* prepare GCS context */ + ctx.src = (void *)(gcs_bin.base - 1); + ctx.src_max = (void *)(gcs_bin.base + gcs_bin.len); + ctx.src_shift = 0; + + /* decode nbits and pbits */ + if (golombset_decode_bits(&ctx, 5, &nbits) != 0 || golombset_decode_bits(&ctx, 5, &pbits) != 0) + goto Exit; + frame.capacity_bits = (unsigned)(nbits + pbits); + + /* decode the values */ + uint64_t value = UINT64_MAX, decoded; + while (golombset_decode_value(&ctx, (unsigned)pbits, &decoded) == 0) { + value += decoded + 1; + if (value >= (uint64_t)1 << frame.capacity_bits) + goto Exit; + h2o_vector_reserve(NULL, &frame.keys, frame.keys.size + 1); + frame.keys.entries[frame.keys.size++] = value; + } + + /* store the result */ + if (*digests == NULL) { + *digests = h2o_mem_alloc(sizeof(**digests)); + **digests = (h2o_cache_digests_t){{{NULL}}}; + } + h2o_cache_digests_frame_vector_t *target = with_validators ? &(*digests)->fresh.url_and_etag : &(*digests)->fresh.url_only; + h2o_vector_reserve(NULL, target, target->size + 1); + target->entries[target->size++] = frame; + frame = (h2o_cache_digests_frame_t){{NULL}}; + (*digests)->fresh.complete = complete; + +Exit: + free(frame.keys.entries); + free(gcs_bin.base); +} + +void h2o_cache_digests_load_header(h2o_cache_digests_t **digests, const char *value, size_t len) +{ + h2o_iovec_t iter = h2o_iovec_init(value, len); + const char *token; + size_t token_len; + + do { + const char *gcs_base64; + size_t gcs_base64_len; + int reset = 0, validators = 0, complete = 0, skip = 0; + h2o_iovec_t token_value; + + if ((gcs_base64 = h2o_next_token(&iter, ';', &gcs_base64_len, NULL)) == NULL) + return; + while ((token = h2o_next_token(&iter, ';', &token_len, &token_value)) != NULL && + !h2o_memis(token, token_len, H2O_STRLIT(","))) { + if (h2o_lcstris(token, token_len, H2O_STRLIT("reset"))) { + reset = 1; + } else if (h2o_lcstris(token, token_len, H2O_STRLIT("validators"))) { + validators = 1; + } else if (h2o_lcstris(token, token_len, H2O_STRLIT("complete"))) { + complete = 1; + } else { + skip = 1; + } + } + + if (reset && *digests != NULL) { + h2o_cache_digests_destroy(*digests); + *digests = NULL; + } + + if (skip) { + /* not supported for the time being */ + } else { + load_digest(digests, gcs_base64, gcs_base64_len, validators, complete); + } + } while (token != NULL); +} + +static uint64_t calc_hash(const char *url, size_t url_len, const char *etag, size_t etag_len) +{ + SHA256_CTX ctx; + union { + unsigned char bytes[SHA256_DIGEST_LENGTH]; + uint64_t u64; + } md; + + SHA256_Init(&ctx); + SHA256_Update(&ctx, url, url_len); + SHA256_Update(&ctx, etag, etag_len); + SHA256_Final(md.bytes, &ctx); + + if (*(uint16_t *)"\xde\xad" == 0xdead) + return md.u64; + else + return __builtin_bswap64(md.u64); +} + +static int cmp_key(const void *_x, const void *_y) +{ + uint64_t x = *(uint64_t *)_x, y = *(uint64_t *)_y; + + if (x < y) { + return -1; + } else if (x > y) { + return 1; + } else { + return 0; + } +} + +static int lookup(h2o_cache_digests_frame_vector_t *vector, const char *url, size_t url_len, const char *etag, size_t etag_len, + int is_fresh, int is_complete) +{ + if (vector->size != 0) { + uint64_t hash = calc_hash(url, url_len, etag, etag_len); + size_t i = 0; + do { + h2o_cache_digests_frame_t *frame = vector->entries + i; + uint64_t key = hash >> (64 - frame->capacity_bits); + if (frame->keys.entries != NULL && + bsearch(&key, frame->keys.entries, frame->keys.size, sizeof(frame->keys.entries[0]), cmp_key) != NULL) + return is_fresh ? H2O_CACHE_DIGESTS_STATE_FRESH : H2O_CACHE_DIGESTS_STATE_STALE; + } while (++i != vector->size); + } + + return is_complete ? H2O_CACHE_DIGESTS_STATE_NOT_CACHED : H2O_CACHE_DIGESTS_STATE_UNKNOWN; +} + +h2o_cache_digests_state_t h2o_cache_digests_lookup_by_url(h2o_cache_digests_t *digests, const char *url, size_t url_len) +{ + return lookup(&digests->fresh.url_only, url, url_len, "", 0, 1, digests->fresh.complete); +} + +h2o_cache_digests_state_t h2o_cache_digests_lookup_by_url_and_etag(h2o_cache_digests_t *digests, const char *url, size_t url_len, + const char *etag, size_t etag_len) +{ + return lookup(&digests->fresh.url_and_etag, url, url_len, etag, etag_len, 1, digests->fresh.complete); +} diff --git a/web/server/h2o/libh2o/lib/http2/casper.c b/web/server/h2o/libh2o/lib/http2/casper.c new file mode 100644 index 000000000..56e00d71f --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/casper.c @@ -0,0 +1,205 @@ +/* + * 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 <openssl/sha.h> +#include "golombset.h" +#include "h2o/string_.h" +#include "h2o/http2_casper.h" + +#define COOKIE_NAME "h2o_casper" +#define COOKIE_ATTRIBUTES "; Path=/; Expires=Tue, 01 Jan 2030 00:00:00 GMT; Secure" + +struct st_h2o_http2_casper_t { + H2O_VECTOR(uint64_t) keys; + unsigned capacity_bits; + unsigned remainder_bits; + h2o_iovec_t cookie_cache; +}; + +static unsigned calc_key(h2o_http2_casper_t *casper, const char *path, size_t path_len) +{ + SHA_CTX ctx; + SHA1_Init(&ctx); + SHA1_Update(&ctx, path, path_len); + + union { + unsigned key; + unsigned char bytes[SHA_DIGEST_LENGTH]; + } md; + SHA1_Final(md.bytes, &ctx); + + return md.key & ((1 << casper->capacity_bits) - 1); +} + +h2o_http2_casper_t *h2o_http2_casper_create(unsigned capacity_bits, unsigned remainder_bits) +{ + h2o_http2_casper_t *casper = h2o_mem_alloc(sizeof(*casper)); + + memset(&casper->keys, 0, sizeof(casper->keys)); + casper->capacity_bits = capacity_bits; + casper->remainder_bits = remainder_bits; + casper->cookie_cache = (h2o_iovec_t){NULL}; + + return casper; +} + +void h2o_http2_casper_destroy(h2o_http2_casper_t *casper) +{ + free(casper->keys.entries); + free(casper->cookie_cache.base); + free(casper); +} + +size_t h2o_http2_casper_num_entries(h2o_http2_casper_t *casper) +{ + return casper->keys.size; +} + +int h2o_http2_casper_lookup(h2o_http2_casper_t *casper, const char *path, size_t path_len, int set) +{ + unsigned key = calc_key(casper, path, path_len); + size_t i; + + /* FIXME use binary search */ + for (i = 0; i != casper->keys.size; ++i) + if (key <= casper->keys.entries[i]) + break; + if (i != casper->keys.size && key == casper->keys.entries[i]) + return 1; + if (!set) + return 0; + + /* we need to set a new value */ + free(casper->cookie_cache.base); + casper->cookie_cache = (h2o_iovec_t){NULL}; + h2o_vector_reserve(NULL, &casper->keys, casper->keys.size + 1); + memmove(casper->keys.entries + i + 1, casper->keys.entries + i, (casper->keys.size - i) * sizeof(casper->keys.entries[0])); + ++casper->keys.size; + casper->keys.entries[i] = key; + return 0; +} + +void h2o_http2_casper_consume_cookie(h2o_http2_casper_t *casper, const char *cookie, size_t cookie_len) +{ + h2o_iovec_t binary = {NULL}; + uint64_t tiny_keys_buf[128], *keys = tiny_keys_buf; + + /* check the name of the cookie */ + if (!(cookie_len > sizeof(COOKIE_NAME "=") - 1 && memcmp(cookie, H2O_STRLIT(COOKIE_NAME "=")) == 0)) + goto Exit; + + /* base64 decode */ + if ((binary = h2o_decode_base64url(NULL, cookie + sizeof(COOKIE_NAME "=") - 1, cookie_len - (sizeof(COOKIE_NAME "=") - 1))) + .base == NULL) + goto Exit; + + /* decode GCS, either using tiny_keys_buf or using heap */ + size_t capacity = sizeof(tiny_keys_buf) / sizeof(tiny_keys_buf[0]), num_keys; + while (num_keys = capacity, golombset_decode(casper->remainder_bits, binary.base, binary.len, keys, &num_keys) != 0) { + if (keys != tiny_keys_buf) { + free(keys); + keys = tiny_keys_buf; /* reset to something that would not trigger call to free(3) */ + } + if (capacity >= (size_t)1 << casper->capacity_bits) + goto Exit; + capacity *= 2; + keys = h2o_mem_alloc(capacity * sizeof(*keys)); + } + + /* copy or merge the entries */ + if (num_keys == 0) { + /* nothing to do */ + } else if (casper->keys.size == 0) { + h2o_vector_reserve(NULL, &casper->keys, num_keys); + memcpy(casper->keys.entries, keys, num_keys * sizeof(*keys)); + casper->keys.size = num_keys; + } else { + uint64_t *orig_keys = casper->keys.entries; + size_t num_orig_keys = casper->keys.size, orig_index = 0, new_index = 0; + memset(&casper->keys, 0, sizeof(casper->keys)); + h2o_vector_reserve(NULL, &casper->keys, num_keys + num_orig_keys); + do { + if (orig_keys[orig_index] < keys[new_index]) { + casper->keys.entries[casper->keys.size++] = orig_keys[orig_index++]; + } else if (orig_keys[orig_index] > keys[new_index]) { + casper->keys.entries[casper->keys.size++] = keys[new_index++]; + } else { + casper->keys.entries[casper->keys.size++] = orig_keys[orig_index]; + ++orig_index; + ++new_index; + } + } while (orig_index != num_orig_keys && new_index != num_keys); + if (orig_index != num_orig_keys) { + do { + casper->keys.entries[casper->keys.size++] = orig_keys[orig_index++]; + } while (orig_index != num_orig_keys); + } else if (new_index != num_keys) { + do { + casper->keys.entries[casper->keys.size++] = keys[new_index++]; + } while (new_index != num_keys); + } + free(orig_keys); + } + +Exit: + if (keys != tiny_keys_buf) + free(keys); + free(binary.base); +} + +static size_t append_str(char *dst, const char *s, size_t l) +{ + memcpy(dst, s, l); + return l; +} + +h2o_iovec_t h2o_http2_casper_get_cookie(h2o_http2_casper_t *casper) +{ + if (casper->cookie_cache.base != NULL) + return casper->cookie_cache; + + if (casper->keys.size == 0) + return (h2o_iovec_t){NULL}; + + /* encode as binary */ + char tiny_bin_buf[128], *bin_buf = tiny_bin_buf; + size_t bin_capacity = sizeof(tiny_bin_buf), bin_size; + while (bin_size = bin_capacity, + golombset_encode(casper->remainder_bits, casper->keys.entries, casper->keys.size, bin_buf, &bin_size) != 0) { + if (bin_buf != tiny_bin_buf) + free(bin_buf); + bin_capacity *= 2; + bin_buf = h2o_mem_alloc(bin_capacity); + } + + char *header_bytes = h2o_mem_alloc(sizeof(COOKIE_NAME "=" COOKIE_ATTRIBUTES) - 1 + (bin_size + 3) * 4 / 3); + size_t header_len = 0; + + header_len += append_str(header_bytes + header_len, H2O_STRLIT(COOKIE_NAME "=")); + header_len += h2o_base64_encode(header_bytes + header_len, bin_buf, bin_size, 1); + header_len += append_str(header_bytes + header_len, H2O_STRLIT(COOKIE_ATTRIBUTES)); + + if (bin_buf != tiny_bin_buf) + free(bin_buf); + + casper->cookie_cache = h2o_iovec_init(header_bytes, header_len); + return casper->cookie_cache; +} diff --git a/web/server/h2o/libh2o/lib/http2/connection.c b/web/server/h2o/libh2o/lib/http2/connection.c new file mode 100644 index 000000000..e2da29304 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/connection.c @@ -0,0 +1,1419 @@ +/* + * 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 <inttypes.h> +#include <stdio.h> +#include <stdlib.h> +#include "h2o.h" +#include "h2o/http1.h" +#include "h2o/http2.h" +#include "h2o/http2_internal.h" + +static const h2o_iovec_t CONNECTION_PREFACE = {H2O_STRLIT("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")}; + +const h2o_http2_priority_t h2o_http2_default_priority = { + 0, /* exclusive */ + 0, /* dependency */ + 16 /* weight */ +}; + +const h2o_http2_settings_t H2O_HTTP2_SETTINGS_HOST = { + 4096, /* header_table_size */ + 0, /* enable_push (clients are never allowed to initiate server push; RFC 7540 Section 8.2) */ + 100, /* max_concurrent_streams */ + 16777216, /* initial_window_size */ + 16384 /* max_frame_size */ +}; + +static const h2o_iovec_t SETTINGS_HOST_BIN = {H2O_STRLIT("\x00\x00\x0c" /* frame size */ + "\x04" /* settings frame */ + "\x00" /* no flags */ + "\x00\x00\x00\x00" /* stream id */ + "\x00\x03" + "\x00\x00\x00\x64" /* max_concurrent_streams = 100 */ + "\x00\x04" + "\x01\x00\x00\x00" /* initial_window_size = 16777216 */ + )}; + +static __thread h2o_buffer_prototype_t wbuf_buffer_prototype = {{16}, {H2O_HTTP2_DEFAULT_OUTBUF_SIZE}}; + +static void initiate_graceful_shutdown(h2o_context_t *ctx); +static void close_connection_now(h2o_http2_conn_t *conn); +static int close_connection(h2o_http2_conn_t *conn); +static ssize_t expect_default(h2o_http2_conn_t *conn, const uint8_t *src, size_t len, const char **err_desc); +static void do_emit_writereq(h2o_http2_conn_t *conn); +static void on_read(h2o_socket_t *sock, const char *err); +static void push_path(h2o_req_t *src_req, const char *abspath, size_t abspath_len); +static int foreach_request(h2o_context_t *ctx, int (*cb)(h2o_req_t *req, void *cbdata), void *cbdata); +static void stream_send_error(h2o_http2_conn_t *conn, uint32_t stream_id, int errnum); + +const h2o_protocol_callbacks_t H2O_HTTP2_CALLBACKS = {initiate_graceful_shutdown, foreach_request}; + +static int is_idle_stream_id(h2o_http2_conn_t *conn, uint32_t stream_id) +{ + return (h2o_http2_stream_is_push(stream_id) ? conn->push_stream_ids.max_open : conn->pull_stream_ids.max_open) < stream_id; +} + +static void enqueue_goaway(h2o_http2_conn_t *conn, int errnum, h2o_iovec_t additional_data) +{ + if (conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING) { + /* http2 spec allows sending GOAWAY more than once (for one reason since errors may arise after sending the first one) */ + h2o_http2_encode_goaway_frame(&conn->_write.buf, conn->pull_stream_ids.max_open, errnum, additional_data); + h2o_http2_conn_request_write(conn); + conn->state = H2O_HTTP2_CONN_STATE_HALF_CLOSED; + } +} + +static void graceful_shutdown_close_stragglers(h2o_timeout_entry_t *entry) +{ + h2o_context_t *ctx = H2O_STRUCT_FROM_MEMBER(h2o_context_t, http2._graceful_shutdown_timeout, entry); + h2o_linklist_t *node, *next; + + /* We've sent two GOAWAY frames, close the remaining connections */ + for (node = ctx->http2._conns.next; node != &ctx->http2._conns; node = next) { + h2o_http2_conn_t *conn = H2O_STRUCT_FROM_MEMBER(h2o_http2_conn_t, _conns, node); + next = node->next; + close_connection(conn); + } +} + +static void graceful_shutdown_resend_goaway(h2o_timeout_entry_t *entry) +{ + h2o_context_t *ctx = H2O_STRUCT_FROM_MEMBER(h2o_context_t, http2._graceful_shutdown_timeout, entry); + h2o_linklist_t *node; + int do_close_stragglers = 0; + + for (node = ctx->http2._conns.next; node != &ctx->http2._conns; node = node->next) { + h2o_http2_conn_t *conn = H2O_STRUCT_FROM_MEMBER(h2o_http2_conn_t, _conns, node); + if (conn->state < H2O_HTTP2_CONN_STATE_HALF_CLOSED) { + enqueue_goaway(conn, H2O_HTTP2_ERROR_NONE, (h2o_iovec_t){NULL}); + do_close_stragglers = 1; + } + } + + /* After waiting a second, we still had active connections. If configured, wait one + * final timeout before closing the connections */ + if (do_close_stragglers && ctx->globalconf->http2.graceful_shutdown_timeout) { + ctx->http2._graceful_shutdown_timeout.cb = graceful_shutdown_close_stragglers; + h2o_timeout_link(ctx->loop, &ctx->http2.graceful_shutdown_timeout, &ctx->http2._graceful_shutdown_timeout); + } +} + +static void initiate_graceful_shutdown(h2o_context_t *ctx) +{ + /* draft-16 6.8 + * A server that is attempting to gracefully shut down a connection SHOULD send an initial GOAWAY frame with the last stream + * identifier set to 231-1 and a NO_ERROR code. This signals to the client that a shutdown is imminent and that no further + * requests can be initiated. After waiting at least one round trip time, the server can send another GOAWAY frame with an + * updated last stream identifier. This ensures that a connection can be cleanly shut down without losing requests. + */ + h2o_linklist_t *node; + + /* only doit once */ + if (ctx->http2._graceful_shutdown_timeout.cb != NULL) + return; + ctx->http2._graceful_shutdown_timeout.cb = graceful_shutdown_resend_goaway; + + for (node = ctx->http2._conns.next; node != &ctx->http2._conns; node = node->next) { + h2o_http2_conn_t *conn = H2O_STRUCT_FROM_MEMBER(h2o_http2_conn_t, _conns, node); + if (conn->state < H2O_HTTP2_CONN_STATE_HALF_CLOSED) { + h2o_http2_encode_goaway_frame(&conn->_write.buf, INT32_MAX, H2O_HTTP2_ERROR_NONE, + (h2o_iovec_t){H2O_STRLIT("graceful shutdown")}); + h2o_http2_conn_request_write(conn); + } + } + h2o_timeout_link(ctx->loop, &ctx->one_sec_timeout, &ctx->http2._graceful_shutdown_timeout); +} + +static void on_idle_timeout(h2o_timeout_entry_t *entry) +{ + h2o_http2_conn_t *conn = H2O_STRUCT_FROM_MEMBER(h2o_http2_conn_t, _timeout_entry, entry); + + enqueue_goaway(conn, H2O_HTTP2_ERROR_NONE, h2o_iovec_init(H2O_STRLIT("idle timeout"))); + if (conn->_write.buf_in_flight != NULL) { + close_connection_now(conn); + } else { + enqueue_goaway(conn, H2O_HTTP2_ERROR_NONE, h2o_iovec_init(H2O_STRLIT("idle timeout"))); + close_connection(conn); + } +} + +static void update_idle_timeout(h2o_http2_conn_t *conn) +{ + h2o_timeout_unlink(&conn->_timeout_entry); + + if (conn->num_streams.pull.half_closed + conn->num_streams.push.half_closed == 0) { + assert(h2o_linklist_is_empty(&conn->_pending_reqs)); + conn->_timeout_entry.cb = on_idle_timeout; + h2o_timeout_link(conn->super.ctx->loop, &conn->super.ctx->http2.idle_timeout, &conn->_timeout_entry); + } +} + +static int can_run_requests(h2o_http2_conn_t *conn) +{ + return conn->num_streams.pull.half_closed + conn->num_streams.push.half_closed < + conn->super.ctx->globalconf->http2.max_concurrent_requests_per_connection; +} + +static void run_pending_requests(h2o_http2_conn_t *conn) +{ + while (!h2o_linklist_is_empty(&conn->_pending_reqs) && can_run_requests(conn)) { + /* fetch and detach a pending stream */ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, _refs.link, conn->_pending_reqs.next); + h2o_linklist_unlink(&stream->_refs.link); + /* handle it */ + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_SEND_HEADERS); + if (!h2o_http2_stream_is_push(stream->stream_id) && conn->pull_stream_ids.max_processed < stream->stream_id) + conn->pull_stream_ids.max_processed = stream->stream_id; + h2o_process_request(&stream->req); + } +} + +static void execute_or_enqueue_request(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + assert(stream->state < H2O_HTTP2_STREAM_STATE_REQ_PENDING); + + if (stream->_req_body != NULL && stream->_expected_content_length != SIZE_MAX && + stream->_req_body->size != stream->_expected_content_length) { + stream_send_error(conn, stream->stream_id, H2O_HTTP2_ERROR_PROTOCOL); + h2o_http2_stream_reset(conn, stream); + return; + } + + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_REQ_PENDING); + + /* TODO schedule the pending reqs using the scheduler */ + h2o_linklist_insert(&conn->_pending_reqs, &stream->_refs.link); + + run_pending_requests(conn); + update_idle_timeout(conn); +} + +void h2o_http2_conn_register_stream(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + khiter_t iter; + int r; + + iter = kh_put(h2o_http2_stream_t, conn->streams, stream->stream_id, &r); + assert(iter != kh_end(conn->streams)); + kh_val(conn->streams, iter) = stream; +} + +void h2o_http2_conn_unregister_stream(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + khiter_t iter = kh_get(h2o_http2_stream_t, conn->streams, stream->stream_id); + assert(iter != kh_end(conn->streams)); + kh_del(h2o_http2_stream_t, conn->streams, iter); + + assert(h2o_http2_scheduler_is_open(&stream->_refs.scheduler)); + h2o_http2_scheduler_close(&stream->_refs.scheduler); + + switch (stream->state) { + case H2O_HTTP2_STREAM_STATE_IDLE: + case H2O_HTTP2_STREAM_STATE_RECV_HEADERS: + case H2O_HTTP2_STREAM_STATE_RECV_BODY: + assert(!h2o_linklist_is_linked(&stream->_refs.link)); + break; + case H2O_HTTP2_STREAM_STATE_REQ_PENDING: + assert(h2o_linklist_is_linked(&stream->_refs.link)); + h2o_linklist_unlink(&stream->_refs.link); + break; + case H2O_HTTP2_STREAM_STATE_SEND_HEADERS: + case H2O_HTTP2_STREAM_STATE_SEND_BODY: + case H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL: + case H2O_HTTP2_STREAM_STATE_END_STREAM: + if (h2o_linklist_is_linked(&stream->_refs.link)) + h2o_linklist_unlink(&stream->_refs.link); + break; + } + if (stream->state != H2O_HTTP2_STREAM_STATE_END_STREAM) + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_END_STREAM); + + if (conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING) { + run_pending_requests(conn); + update_idle_timeout(conn); + } +} + +void close_connection_now(h2o_http2_conn_t *conn) +{ + h2o_http2_stream_t *stream; + + assert(!h2o_timeout_is_linked(&conn->_write.timeout_entry)); + + kh_foreach_value(conn->streams, stream, { h2o_http2_stream_close(conn, stream); }); + assert(conn->num_streams.pull.open == 0); + assert(conn->num_streams.pull.half_closed == 0); + assert(conn->num_streams.pull.send_body == 0); + assert(conn->num_streams.push.half_closed == 0); + assert(conn->num_streams.push.send_body == 0); + assert(conn->num_streams.priority.open == 0); + kh_destroy(h2o_http2_stream_t, conn->streams); + assert(conn->_http1_req_input == NULL); + h2o_hpack_dispose_header_table(&conn->_input_header_table); + h2o_hpack_dispose_header_table(&conn->_output_header_table); + assert(h2o_linklist_is_empty(&conn->_pending_reqs)); + h2o_timeout_unlink(&conn->_timeout_entry); + h2o_buffer_dispose(&conn->_write.buf); + if (conn->_write.buf_in_flight != NULL) + h2o_buffer_dispose(&conn->_write.buf_in_flight); + h2o_http2_scheduler_dispose(&conn->scheduler); + assert(h2o_linklist_is_empty(&conn->_write.streams_to_proceed)); + assert(!h2o_timeout_is_linked(&conn->_write.timeout_entry)); + if (conn->_headers_unparsed != NULL) + h2o_buffer_dispose(&conn->_headers_unparsed); + if (conn->push_memo != NULL) + h2o_cache_destroy(conn->push_memo); + if (conn->casper != NULL) + h2o_http2_casper_destroy(conn->casper); + h2o_linklist_unlink(&conn->_conns); + + if (conn->sock != NULL) + h2o_socket_close(conn->sock); + free(conn); +} + +int close_connection(h2o_http2_conn_t *conn) +{ + conn->state = H2O_HTTP2_CONN_STATE_IS_CLOSING; + + if (conn->_write.buf_in_flight != NULL || h2o_timeout_is_linked(&conn->_write.timeout_entry)) { + /* there is a pending write, let on_write_complete actually close the connection */ + } else { + close_connection_now(conn); + return -1; + } + return 0; +} + +static void stream_send_error(h2o_http2_conn_t *conn, uint32_t stream_id, int errnum) +{ + assert(stream_id != 0); + assert(conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING); + + conn->super.ctx->http2.events.protocol_level_errors[-errnum]++; + + h2o_http2_encode_rst_stream_frame(&conn->_write.buf, stream_id, -errnum); + h2o_http2_conn_request_write(conn); +} + +static void request_gathered_write(h2o_http2_conn_t *conn) +{ + assert(conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING); + if (conn->sock->_cb.write == NULL && !h2o_timeout_is_linked(&conn->_write.timeout_entry)) + h2o_timeout_link(conn->super.ctx->loop, &conn->super.ctx->zero_timeout, &conn->_write.timeout_entry); +} + +static int update_stream_output_window(h2o_http2_stream_t *stream, ssize_t delta) +{ + ssize_t cur = h2o_http2_window_get_window(&stream->output_window); + if (h2o_http2_window_update(&stream->output_window, delta) != 0) + return -1; + if (cur <= 0 && h2o_http2_window_get_window(&stream->output_window) > 0 && + (h2o_http2_stream_has_pending_data(stream) || stream->state >= H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL)) { + assert(!h2o_linklist_is_linked(&stream->_refs.link)); + h2o_http2_scheduler_activate(&stream->_refs.scheduler); + } + return 0; +} + +static int handle_incoming_request(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream, const uint8_t *src, size_t len, + const char **err_desc) +{ + int ret, header_exists_map; + + assert(stream->state == H2O_HTTP2_STREAM_STATE_RECV_HEADERS); + + header_exists_map = 0; + if ((ret = h2o_hpack_parse_headers(&stream->req, &conn->_input_header_table, src, len, &header_exists_map, + &stream->_expected_content_length, &stream->cache_digests, err_desc)) != 0) { + /* all errors except invalid-header-char are connection errors */ + if (ret != H2O_HTTP2_ERROR_INVALID_HEADER_CHAR) + return ret; + } + + /* handle stream-level errors */ +#define EXPECTED_MAP \ + (H2O_HPACK_PARSE_HEADERS_METHOD_EXISTS | H2O_HPACK_PARSE_HEADERS_PATH_EXISTS | H2O_HPACK_PARSE_HEADERS_SCHEME_EXISTS) + if ((header_exists_map & EXPECTED_MAP) != EXPECTED_MAP) { + ret = H2O_HTTP2_ERROR_PROTOCOL; + goto SendRSTStream; + } +#undef EXPECTED_MAP + if (conn->num_streams.pull.open > H2O_HTTP2_SETTINGS_HOST.max_concurrent_streams) { + ret = H2O_HTTP2_ERROR_REFUSED_STREAM; + goto SendRSTStream; + } + + /* handle request to send response */ + if (ret != 0) { + assert(ret == H2O_HTTP2_ERROR_INVALID_HEADER_CHAR); + /* fast forward the stream's state so that we can start sending the response */ + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_REQ_PENDING); + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_SEND_HEADERS); + h2o_send_error_400(&stream->req, "Invalid Headers", *err_desc, 0); + return 0; + } + + if (stream->_req_body == NULL) { + execute_or_enqueue_request(conn, stream); + } else { + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_RECV_BODY); + } + return 0; + +SendRSTStream: + stream_send_error(conn, stream->stream_id, ret); + h2o_http2_stream_reset(conn, stream); + return 0; +} + +static int handle_trailing_headers(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream, const uint8_t *src, size_t len, + const char **err_desc) +{ + size_t dummy_content_length; + int ret; + + assert(stream->state == H2O_HTTP2_STREAM_STATE_RECV_BODY); + + if ((ret = h2o_hpack_parse_headers(&stream->req, &conn->_input_header_table, src, len, NULL, &dummy_content_length, NULL, + err_desc)) != 0) + return ret; + + execute_or_enqueue_request(conn, stream); + return 0; +} + +static ssize_t expect_continuation_of_headers(h2o_http2_conn_t *conn, const uint8_t *src, size_t len, const char **err_desc) +{ + h2o_http2_frame_t frame; + ssize_t ret; + h2o_http2_stream_t *stream; + int hret; + + if ((ret = h2o_http2_decode_frame(&frame, src, len, &H2O_HTTP2_SETTINGS_HOST, err_desc)) < 0) + return ret; + if (frame.type != H2O_HTTP2_FRAME_TYPE_CONTINUATION) { + *err_desc = "expected CONTINUATION frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + if (conn->state >= H2O_HTTP2_CONN_STATE_HALF_CLOSED) + return 0; + + if ((stream = h2o_http2_conn_get_stream(conn, frame.stream_id)) == NULL || + !(stream->state == H2O_HTTP2_STREAM_STATE_RECV_HEADERS || stream->state == H2O_HTTP2_STREAM_STATE_RECV_BODY)) { + *err_desc = "unexpected stream id in CONTINUATION frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + if (conn->_headers_unparsed->size + frame.length <= H2O_MAX_REQLEN) { + h2o_buffer_reserve(&conn->_headers_unparsed, frame.length); + memcpy(conn->_headers_unparsed->bytes + conn->_headers_unparsed->size, frame.payload, frame.length); + conn->_headers_unparsed->size += frame.length; + + if ((frame.flags & H2O_HTTP2_FRAME_FLAG_END_HEADERS) != 0) { + conn->_read_expect = expect_default; + if (stream->state == H2O_HTTP2_STREAM_STATE_RECV_HEADERS) { + hret = handle_incoming_request(conn, stream, (const uint8_t *)conn->_headers_unparsed->bytes, + conn->_headers_unparsed->size, err_desc); + } else { + hret = handle_trailing_headers(conn, stream, (const uint8_t *)conn->_headers_unparsed->bytes, + conn->_headers_unparsed->size, err_desc); + } + if (hret != 0) + ret = hret; + h2o_buffer_dispose(&conn->_headers_unparsed); + conn->_headers_unparsed = NULL; + } + } else { + /* request is too large (TODO log) */ + stream_send_error(conn, stream->stream_id, H2O_HTTP2_ERROR_REFUSED_STREAM); + h2o_http2_stream_reset(conn, stream); + } + + return ret; +} + +static void update_input_window(h2o_http2_conn_t *conn, uint32_t stream_id, h2o_http2_window_t *window, size_t consumed) +{ + h2o_http2_window_consume_window(window, consumed); + if (h2o_http2_window_get_window(window) * 2 < H2O_HTTP2_SETTINGS_HOST.initial_window_size) { + int32_t delta = (int32_t)(H2O_HTTP2_SETTINGS_HOST.initial_window_size - h2o_http2_window_get_window(window)); + h2o_http2_encode_window_update_frame(&conn->_write.buf, stream_id, delta); + h2o_http2_conn_request_write(conn); + h2o_http2_window_update(window, delta); + } +} + +static void set_priority(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream, const h2o_http2_priority_t *priority, + int scheduler_is_open) +{ + h2o_http2_scheduler_node_t *parent_sched; + + /* determine the parent */ + if (priority->dependency != 0) { + h2o_http2_stream_t *parent_stream = h2o_http2_conn_get_stream(conn, priority->dependency); + if (parent_stream != NULL) { + parent_sched = &parent_stream->_refs.scheduler.node; + } else { + /* A dependency on a stream that is not currently in the tree - such as a stream in the "idle" state - results in that + * stream being given a default priority. (RFC 7540 5.3.1) + * It is possible for a stream to become closed while prioritization information that creates a dependency on that + * stream is in transit. If a stream identified in a dependency has no associated priority information, then the + * dependent stream is instead assigned a default priority. (RFC 7540 5.3.4) + */ + parent_sched = &conn->scheduler; + priority = &h2o_http2_default_priority; + } + } else { + parent_sched = &conn->scheduler; + } + + /* setup the scheduler */ + if (!scheduler_is_open) { + h2o_http2_scheduler_open(&stream->_refs.scheduler, parent_sched, priority->weight, priority->exclusive); + } else { + h2o_http2_scheduler_rebind(&stream->_refs.scheduler, parent_sched, priority->weight, priority->exclusive); + } +} + +static int handle_data_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + h2o_http2_data_payload_t payload; + h2o_http2_stream_t *stream; + int ret; + + if ((ret = h2o_http2_decode_data_payload(&payload, frame, err_desc)) != 0) + return ret; + + if (conn->state >= H2O_HTTP2_CONN_STATE_HALF_CLOSED) + return 0; + + stream = h2o_http2_conn_get_stream(conn, frame->stream_id); + + /* save the input in the request body buffer, or send error (and close the stream) */ + if (stream == NULL) { + if (frame->stream_id <= conn->pull_stream_ids.max_open) { + stream_send_error(conn, frame->stream_id, H2O_HTTP2_ERROR_STREAM_CLOSED); + } else { + *err_desc = "invalid DATA frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + } else if (stream->state != H2O_HTTP2_STREAM_STATE_RECV_BODY) { + stream_send_error(conn, frame->stream_id, H2O_HTTP2_ERROR_STREAM_CLOSED); + h2o_http2_stream_reset(conn, stream); + stream = NULL; + } else if (stream->_req_body->size + payload.length > conn->super.ctx->globalconf->max_request_entity_size) { + stream_send_error(conn, frame->stream_id, H2O_HTTP2_ERROR_REFUSED_STREAM); + h2o_http2_stream_reset(conn, stream); + stream = NULL; + } else { + h2o_iovec_t buf = h2o_buffer_reserve(&stream->_req_body, payload.length); + if (buf.base != NULL) { + memcpy(buf.base, payload.data, payload.length); + stream->_req_body->size += payload.length; + /* handle request if request body is complete */ + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_END_STREAM) != 0) { + stream->req.entity = h2o_iovec_init(stream->_req_body->bytes, stream->_req_body->size); + execute_or_enqueue_request(conn, stream); + stream = NULL; /* no need to send window update for this stream */ + } + } else { + /* memory allocation failed */ + stream_send_error(conn, frame->stream_id, H2O_HTTP2_ERROR_STREAM_CLOSED); + h2o_http2_stream_reset(conn, stream); + stream = NULL; + } + } + + /* consume buffer (and set window_update) */ + update_input_window(conn, 0, &conn->_input_window, frame->length); + if (stream != NULL) + update_input_window(conn, stream->stream_id, &stream->input_window, frame->length); + + return 0; +} + +static int handle_headers_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + h2o_http2_headers_payload_t payload; + h2o_http2_stream_t *stream; + int ret; + + /* decode */ + if ((ret = h2o_http2_decode_headers_payload(&payload, frame, err_desc)) != 0) + return ret; + if ((frame->stream_id & 1) == 0) { + *err_desc = "invalid stream id in HEADERS frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + if (!(conn->pull_stream_ids.max_open < frame->stream_id)) { + if ((stream = h2o_http2_conn_get_stream(conn, frame->stream_id)) != NULL && + stream->state == H2O_HTTP2_STREAM_STATE_RECV_BODY) { + /* is a trailer */ + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_END_STREAM) == 0) { + *err_desc = "trailing HEADERS frame MUST have END_STREAM flag set"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + stream->req.entity = h2o_iovec_init(stream->_req_body->bytes, stream->_req_body->size); + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_END_HEADERS) == 0) + goto PREPARE_FOR_CONTINUATION; + return handle_trailing_headers(conn, stream, payload.headers, payload.headers_len, err_desc); + } else if (!stream || stream->state != H2O_HTTP2_STREAM_STATE_IDLE) { + /* it's legit that stream exists and is IDLE if a PRIORITY frame was received earlier */ + *err_desc = "invalid stream id in HEADERS frame"; + return H2O_HTTP2_ERROR_STREAM_CLOSED; + } + } + if (frame->stream_id == payload.priority.dependency) { + *err_desc = "stream cannot depend on itself"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + if (conn->state >= H2O_HTTP2_CONN_STATE_HALF_CLOSED) + return 0; + + /* open or determine the stream and prepare */ + if ((stream = h2o_http2_conn_get_stream(conn, frame->stream_id)) != NULL) { + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_PRIORITY) != 0) { + set_priority(conn, stream, &payload.priority, 1); + stream->received_priority = payload.priority; + } + } else { + stream = h2o_http2_stream_open(conn, frame->stream_id, NULL, &payload.priority); + set_priority(conn, stream, &payload.priority, 0); + } + h2o_http2_stream_prepare_for_request(conn, stream); + + /* setup container for request body if it is expected to arrive */ + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_END_STREAM) == 0) + h2o_buffer_init(&stream->_req_body, &h2o_socket_buffer_prototype); + + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_END_HEADERS) != 0) { + /* request is complete, handle it */ + return handle_incoming_request(conn, stream, payload.headers, payload.headers_len, err_desc); + } + +PREPARE_FOR_CONTINUATION: + /* request is not complete, store in buffer */ + conn->_read_expect = expect_continuation_of_headers; + h2o_buffer_init(&conn->_headers_unparsed, &h2o_socket_buffer_prototype); + h2o_buffer_reserve(&conn->_headers_unparsed, payload.headers_len); + memcpy(conn->_headers_unparsed->bytes, payload.headers, payload.headers_len); + conn->_headers_unparsed->size = payload.headers_len; + return 0; +} + +static int handle_priority_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + h2o_http2_priority_t payload; + h2o_http2_stream_t *stream; + int ret; + + if ((ret = h2o_http2_decode_priority_payload(&payload, frame, err_desc)) != 0) + return ret; + if (frame->stream_id == payload.dependency) { + *err_desc = "stream cannot depend on itself"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + if ((stream = h2o_http2_conn_get_stream(conn, frame->stream_id)) != NULL) { + stream->received_priority = payload; + /* ignore priority changes to pushed streams with weight=257, since that is where we are trying to be smarter than the web + * browsers + */ + if (h2o_http2_scheduler_get_weight(&stream->_refs.scheduler) != 257) + set_priority(conn, stream, &payload, 1); + } else { + if (h2o_http2_stream_is_push(frame->stream_id)) { + /* Ignore PRIORITY frames for closed or idle pushed streams */ + return 0; + } else { + /* Ignore PRIORITY frames for closed pull streams */ + if (frame->stream_id <= conn->pull_stream_ids.max_open) + return 0; + } + if (conn->num_streams.priority.open >= conn->super.ctx->globalconf->http2.max_streams_for_priority) { + *err_desc = "too many streams in idle/closed state"; + /* RFC 7540 10.5: An endpoint MAY treat activity that is suspicious as a connection error (Section 5.4.1) of type + * ENHANCE_YOUR_CALM. + */ + return H2O_HTTP2_ERROR_ENHANCE_YOUR_CALM; + } + stream = h2o_http2_stream_open(conn, frame->stream_id, NULL, &payload); + set_priority(conn, stream, &payload, 0); + } + + return 0; +} + +static void resume_send(h2o_http2_conn_t *conn) +{ + if (h2o_http2_conn_get_buffer_window(conn) <= 0) + return; +#if 0 /* TODO reenable this check for performance? */ + if (conn->scheduler.list.size == 0) + return; +#endif + request_gathered_write(conn); +} + +static int handle_settings_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + if (frame->stream_id != 0) { + *err_desc = "invalid stream id in SETTINGS frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_ACK) != 0) { + if (frame->length != 0) { + *err_desc = "invalid SETTINGS frame (+ACK)"; + return H2O_HTTP2_ERROR_FRAME_SIZE; + } + } else { + uint32_t prev_initial_window_size = conn->peer_settings.initial_window_size; + /* FIXME handle SETTINGS_HEADER_TABLE_SIZE */ + int ret = h2o_http2_update_peer_settings(&conn->peer_settings, frame->payload, frame->length, err_desc); + if (ret != 0) + return ret; + { /* schedule ack */ + h2o_iovec_t header_buf = h2o_buffer_reserve(&conn->_write.buf, H2O_HTTP2_FRAME_HEADER_SIZE); + h2o_http2_encode_frame_header((void *)header_buf.base, 0, H2O_HTTP2_FRAME_TYPE_SETTINGS, H2O_HTTP2_FRAME_FLAG_ACK, 0); + conn->_write.buf->size += H2O_HTTP2_FRAME_HEADER_SIZE; + h2o_http2_conn_request_write(conn); + } + /* apply the change to window size (to all the streams but not the connection, see 6.9.2 of draft-15) */ + if (prev_initial_window_size != conn->peer_settings.initial_window_size) { + ssize_t delta = (int32_t)conn->peer_settings.initial_window_size - (int32_t)prev_initial_window_size; + h2o_http2_stream_t *stream; + kh_foreach_value(conn->streams, stream, { update_stream_output_window(stream, delta); }); + resume_send(conn); + } + } + + return 0; +} + +static int handle_window_update_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + h2o_http2_window_update_payload_t payload; + int ret, err_is_stream_level; + + if ((ret = h2o_http2_decode_window_update_payload(&payload, frame, err_desc, &err_is_stream_level)) != 0) { + if (err_is_stream_level) { + h2o_http2_stream_t *stream = h2o_http2_conn_get_stream(conn, frame->stream_id); + if (stream != NULL) + h2o_http2_stream_reset(conn, stream); + stream_send_error(conn, frame->stream_id, ret); + return 0; + } else { + return ret; + } + } + + if (frame->stream_id == 0) { + if (h2o_http2_window_update(&conn->_write.window, payload.window_size_increment) != 0) { + *err_desc = "flow control window overflow"; + return H2O_HTTP2_ERROR_FLOW_CONTROL; + } + } else if (!is_idle_stream_id(conn, frame->stream_id)) { + h2o_http2_stream_t *stream = h2o_http2_conn_get_stream(conn, frame->stream_id); + if (stream != NULL) { + if (update_stream_output_window(stream, payload.window_size_increment) != 0) { + h2o_http2_stream_reset(conn, stream); + stream_send_error(conn, frame->stream_id, H2O_HTTP2_ERROR_FLOW_CONTROL); + return 0; + } + } + } else { + *err_desc = "invalid stream id in WINDOW_UPDATE frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + resume_send(conn); + + return 0; +} + +static int handle_goaway_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + h2o_http2_goaway_payload_t payload; + int ret; + + if ((ret = h2o_http2_decode_goaway_payload(&payload, frame, err_desc)) != 0) + return ret; + + /* stop opening new push streams hereafter */ + conn->push_stream_ids.max_open = 0x7ffffffe; + + return 0; +} + +static int handle_ping_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + h2o_http2_ping_payload_t payload; + int ret; + + if ((ret = h2o_http2_decode_ping_payload(&payload, frame, err_desc)) != 0) + return ret; + + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_ACK) == 0) { + h2o_http2_encode_ping_frame(&conn->_write.buf, 1, payload.data); + h2o_http2_conn_request_write(conn); + } + + return 0; +} + +static int handle_rst_stream_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + h2o_http2_rst_stream_payload_t payload; + h2o_http2_stream_t *stream; + int ret; + + if ((ret = h2o_http2_decode_rst_stream_payload(&payload, frame, err_desc)) != 0) + return ret; + if (is_idle_stream_id(conn, frame->stream_id)) { + *err_desc = "unexpected stream id in RST_STREAM frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + stream = h2o_http2_conn_get_stream(conn, frame->stream_id); + if (stream != NULL) { + /* reset the stream */ + h2o_http2_stream_reset(conn, stream); + } + /* TODO log */ + + return 0; +} + +static int handle_push_promise_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + *err_desc = "received PUSH_PROMISE frame"; + return H2O_HTTP2_ERROR_PROTOCOL; +} + +static int handle_invalid_continuation_frame(h2o_http2_conn_t *conn, h2o_http2_frame_t *frame, const char **err_desc) +{ + *err_desc = "received invalid CONTINUATION frame"; + return H2O_HTTP2_ERROR_PROTOCOL; +} + +ssize_t expect_default(h2o_http2_conn_t *conn, const uint8_t *src, size_t len, const char **err_desc) +{ + h2o_http2_frame_t frame; + ssize_t ret; + static int (*FRAME_HANDLERS[])(h2o_http2_conn_t * conn, h2o_http2_frame_t * frame, const char **err_desc) = { + handle_data_frame, /* DATA */ + handle_headers_frame, /* HEADERS */ + handle_priority_frame, /* PRIORITY */ + handle_rst_stream_frame, /* RST_STREAM */ + handle_settings_frame, /* SETTINGS */ + handle_push_promise_frame, /* PUSH_PROMISE */ + handle_ping_frame, /* PING */ + handle_goaway_frame, /* GOAWAY */ + handle_window_update_frame, /* WINDOW_UPDATE */ + handle_invalid_continuation_frame /* CONTINUATION */ + }; + + if ((ret = h2o_http2_decode_frame(&frame, src, len, &H2O_HTTP2_SETTINGS_HOST, err_desc)) < 0) + return ret; + + if (frame.type < sizeof(FRAME_HANDLERS) / sizeof(FRAME_HANDLERS[0])) { + int hret = FRAME_HANDLERS[frame.type](conn, &frame, err_desc); + if (hret != 0) + ret = hret; + } else { + fprintf(stderr, "skipping frame (type:%d)\n", frame.type); + } + + return ret; +} + +static ssize_t expect_preface(h2o_http2_conn_t *conn, const uint8_t *src, size_t len, const char **err_desc) +{ + if (len < CONNECTION_PREFACE.len) { + return H2O_HTTP2_ERROR_INCOMPLETE; + } + if (memcmp(src, CONNECTION_PREFACE.base, CONNECTION_PREFACE.len) != 0) { + return H2O_HTTP2_ERROR_PROTOCOL_CLOSE_IMMEDIATELY; + } + + { /* send SETTINGS */ + h2o_iovec_t vec = h2o_buffer_reserve(&conn->_write.buf, SETTINGS_HOST_BIN.len); + memcpy(vec.base, SETTINGS_HOST_BIN.base, SETTINGS_HOST_BIN.len); + conn->_write.buf->size += SETTINGS_HOST_BIN.len; + h2o_http2_conn_request_write(conn); + } + + conn->_read_expect = expect_default; + return CONNECTION_PREFACE.len; +} + +static int parse_input(h2o_http2_conn_t *conn) +{ + /* handle the input */ + while (conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING && conn->sock->input->size != 0) { + /* process a frame */ + const char *err_desc = NULL; + ssize_t ret = conn->_read_expect(conn, (uint8_t *)conn->sock->input->bytes, conn->sock->input->size, &err_desc); + if (ret == H2O_HTTP2_ERROR_INCOMPLETE) { + break; + } else if (ret < 0) { + if (ret != H2O_HTTP2_ERROR_PROTOCOL_CLOSE_IMMEDIATELY) { + enqueue_goaway(conn, (int)ret, + err_desc != NULL ? (h2o_iovec_t){(char *)err_desc, strlen(err_desc)} : (h2o_iovec_t){NULL}); + } + return close_connection(conn); + } + /* advance to the next frame */ + h2o_buffer_consume(&conn->sock->input, ret); + } + return 0; +} + +static void on_read(h2o_socket_t *sock, const char *err) +{ + h2o_http2_conn_t *conn = sock->data; + + if (err != NULL) { + conn->super.ctx->http2.events.read_closed++; + h2o_socket_read_stop(conn->sock); + close_connection(conn); + return; + } + + update_idle_timeout(conn); + if (parse_input(conn) != 0) + return; + + /* write immediately, if there is no write in flight and if pending write exists */ + if (h2o_timeout_is_linked(&conn->_write.timeout_entry)) { + h2o_timeout_unlink(&conn->_write.timeout_entry); + do_emit_writereq(conn); + } +} + +static void on_upgrade_complete(void *_conn, h2o_socket_t *sock, size_t reqsize) +{ + h2o_http2_conn_t *conn = _conn; + + if (sock == NULL) { + close_connection(conn); + return; + } + + conn->sock = sock; + sock->data = conn; + conn->_http1_req_input = sock->input; + h2o_buffer_init(&sock->input, &h2o_socket_buffer_prototype); + + /* setup inbound */ + h2o_socket_read_start(conn->sock, on_read); + + /* handle the request */ + execute_or_enqueue_request(conn, h2o_http2_conn_get_stream(conn, 1)); + + if (conn->_http1_req_input->size > reqsize) { + size_t remaining_bytes = conn->_http1_req_input->size - reqsize; + h2o_buffer_reserve(&sock->input, remaining_bytes); + memcpy(sock->input->bytes, conn->_http1_req_input->bytes + reqsize, remaining_bytes); + sock->input->size += remaining_bytes; + on_read(conn->sock, NULL); + } +} + +static size_t bytes_in_buf(h2o_http2_conn_t *conn) +{ + size_t size = conn->_write.buf->size; + if (conn->_write.buf_in_flight != 0) + size += conn->_write.buf_in_flight->size; + return size; +} + +void h2o_http2_conn_request_write(h2o_http2_conn_t *conn) +{ + if (conn->state == H2O_HTTP2_CONN_STATE_IS_CLOSING) + return; + if (h2o_socket_is_reading(conn->sock) && bytes_in_buf(conn) >= H2O_HTTP2_DEFAULT_OUTBUF_SOFT_MAX_SIZE) + h2o_socket_read_stop(conn->sock); + request_gathered_write(conn); +} + +void h2o_http2_conn_register_for_proceed_callback(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + h2o_http2_conn_request_write(conn); + + if (h2o_http2_stream_has_pending_data(stream) || stream->state >= H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL) { + if (h2o_http2_window_get_window(&stream->output_window) > 0) { + assert(!h2o_linklist_is_linked(&stream->_refs.link)); + h2o_http2_scheduler_activate(&stream->_refs.scheduler); + } + } else { + h2o_linklist_insert(&conn->_write.streams_to_proceed, &stream->_refs.link); + } +} + +static void on_notify_write(h2o_socket_t *sock, const char *err) +{ + h2o_http2_conn_t *conn = sock->data; + + if (err != NULL) { + close_connection_now(conn); + return; + } + do_emit_writereq(conn); +} + +static void on_write_complete(h2o_socket_t *sock, const char *err) +{ + h2o_http2_conn_t *conn = sock->data; + + assert(conn->_write.buf_in_flight != NULL); + + /* close by error if necessary */ + if (err != NULL) { + conn->super.ctx->http2.events.write_closed++; + close_connection_now(conn); + return; + } + + /* reset the other memory pool */ + h2o_buffer_dispose(&conn->_write.buf_in_flight); + assert(conn->_write.buf_in_flight == NULL); + + /* call the proceed callback of the streams that have been flushed (while unlinking them from the list) */ + if (conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING) { + while (!h2o_linklist_is_empty(&conn->_write.streams_to_proceed)) { + h2o_http2_stream_t *stream = + H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, _refs.link, conn->_write.streams_to_proceed.next); + assert(!h2o_http2_stream_has_pending_data(stream)); + h2o_linklist_unlink(&stream->_refs.link); + h2o_http2_stream_proceed(conn, stream); + } + } + + /* cancel the write callback if scheduled (as the generator may have scheduled a write just before this function gets called) */ + if (h2o_timeout_is_linked(&conn->_write.timeout_entry)) + h2o_timeout_unlink(&conn->_write.timeout_entry); + + if (conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING) { + if (!h2o_socket_is_reading(conn->sock) && bytes_in_buf(conn) < H2O_HTTP2_DEFAULT_OUTBUF_SOFT_MAX_SIZE) + h2o_socket_read_start(conn->sock, on_read); + } + +#if !H2O_USE_LIBUV + if (conn->state == H2O_HTTP2_CONN_STATE_OPEN) { + if (conn->_write.buf->size != 0 || h2o_http2_scheduler_is_active(&conn->scheduler)) + h2o_socket_notify_write(sock, on_notify_write); + return; + } +#endif + + /* write more, if possible */ + do_emit_writereq(conn); +} + +static int emit_writereq_of_openref(h2o_http2_scheduler_openref_t *ref, int *still_is_active, void *cb_arg) +{ + h2o_http2_conn_t *conn = cb_arg; + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, _refs.scheduler, ref); + + assert(h2o_http2_stream_has_pending_data(stream) || stream->state >= H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL); + + *still_is_active = 0; + + h2o_http2_stream_send_pending_data(conn, stream); + if (h2o_http2_stream_has_pending_data(stream) || stream->state == H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL) { + if (h2o_http2_window_get_window(&stream->output_window) <= 0) { + /* is blocked */ + } else { + *still_is_active = 1; + } + } else { + h2o_linklist_insert(&conn->_write.streams_to_proceed, &stream->_refs.link); + } + + return h2o_http2_conn_get_buffer_window(conn) > 0 ? 0 : -1; +} + +void do_emit_writereq(h2o_http2_conn_t *conn) +{ + assert(conn->_write.buf_in_flight == NULL); + + /* push DATA frames */ + if (conn->state < H2O_HTTP2_CONN_STATE_IS_CLOSING && h2o_http2_conn_get_buffer_window(conn) > 0) + h2o_http2_scheduler_run(&conn->scheduler, emit_writereq_of_openref, conn); + + if (conn->_write.buf->size != 0) { + /* write and wait for completion */ + h2o_iovec_t buf = {conn->_write.buf->bytes, conn->_write.buf->size}; + h2o_socket_write(conn->sock, &buf, 1, on_write_complete); + conn->_write.buf_in_flight = conn->_write.buf; + h2o_buffer_init(&conn->_write.buf, &wbuf_buffer_prototype); + } + + /* close the connection if necessary */ + switch (conn->state) { + case H2O_HTTP2_CONN_STATE_OPEN: + break; + case H2O_HTTP2_CONN_STATE_HALF_CLOSED: + if (conn->num_streams.pull.half_closed + conn->num_streams.push.half_closed != 0) + break; + conn->state = H2O_HTTP2_CONN_STATE_IS_CLOSING; + /* fall-thru */ + case H2O_HTTP2_CONN_STATE_IS_CLOSING: + close_connection_now(conn); + break; + } +} + +static void emit_writereq(h2o_timeout_entry_t *entry) +{ + h2o_http2_conn_t *conn = H2O_STRUCT_FROM_MEMBER(h2o_http2_conn_t, _write.timeout_entry, entry); + + do_emit_writereq(conn); +} + +static socklen_t get_sockname(h2o_conn_t *_conn, struct sockaddr *sa) +{ + h2o_http2_conn_t *conn = (void *)_conn; + return h2o_socket_getsockname(conn->sock, sa); +} + +static socklen_t get_peername(h2o_conn_t *_conn, struct sockaddr *sa) +{ + h2o_http2_conn_t *conn = (void *)_conn; + return h2o_socket_getpeername(conn->sock, sa); +} + +static h2o_socket_t *get_socket(h2o_conn_t *_conn) +{ + h2o_http2_conn_t *conn = (void *)_conn; + return conn->sock; +} + +#define DEFINE_TLS_LOGGER(name) \ + static h2o_iovec_t log_##name(h2o_req_t *req) \ + { \ + h2o_http2_conn_t *conn = (void *)req->conn; \ + return h2o_socket_log_ssl_##name(conn->sock, &req->pool); \ + } + +DEFINE_TLS_LOGGER(protocol_version) +DEFINE_TLS_LOGGER(session_reused) +DEFINE_TLS_LOGGER(cipher) +DEFINE_TLS_LOGGER(cipher_bits) +DEFINE_TLS_LOGGER(session_id) +#undef DEFINE_TLS_LOGGER + +static h2o_iovec_t log_stream_id(h2o_req_t *req) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + char *s = h2o_mem_alloc_pool(&stream->req.pool, sizeof(H2O_UINT32_LONGEST_STR)); + size_t len = (size_t)sprintf(s, "%" PRIu32, stream->stream_id); + return h2o_iovec_init(s, len); +} + +static h2o_iovec_t log_priority_received(h2o_req_t *req) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + char *s = h2o_mem_alloc_pool(&stream->req.pool, sizeof("1:" H2O_UINT32_LONGEST_STR ":" H2O_UINT16_LONGEST_STR)); + size_t len = (size_t)sprintf(s, "%c:%" PRIu32 ":%" PRIu16, stream->received_priority.exclusive ? '1' : '0', + stream->received_priority.dependency, stream->received_priority.weight); + return h2o_iovec_init(s, len); +} + +static h2o_iovec_t log_priority_received_exclusive(h2o_req_t *req) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + return h2o_iovec_init(stream->received_priority.exclusive ? "1" : "0", 1); +} + +static h2o_iovec_t log_priority_received_parent(h2o_req_t *req) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + char *s = h2o_mem_alloc_pool(&stream->req.pool, sizeof(H2O_UINT32_LONGEST_STR)); + size_t len = sprintf(s, "%" PRIu32, stream->received_priority.dependency); + return h2o_iovec_init(s, len); +} + +static h2o_iovec_t log_priority_received_weight(h2o_req_t *req) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + char *s = h2o_mem_alloc_pool(&stream->req.pool, sizeof(H2O_UINT16_LONGEST_STR)); + size_t len = sprintf(s, "%" PRIu16, stream->received_priority.weight); + return h2o_iovec_init(s, len); +} + +static uint32_t get_parent_stream_id(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + h2o_http2_scheduler_node_t *parent_sched = h2o_http2_scheduler_get_parent(&stream->_refs.scheduler); + if (parent_sched == &conn->scheduler) { + return 0; + } else { + h2o_http2_stream_t *parent_stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, _refs.scheduler, parent_sched); + return parent_stream->stream_id; + } +} + +static h2o_iovec_t log_priority_actual(h2o_req_t *req) +{ + h2o_http2_conn_t *conn = (void *)req->conn; + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + char *s = h2o_mem_alloc_pool(&stream->req.pool, sizeof(H2O_UINT32_LONGEST_STR ":" H2O_UINT16_LONGEST_STR)); + size_t len = (size_t)sprintf(s, "%" PRIu32 ":%" PRIu16, get_parent_stream_id(conn, stream), + h2o_http2_scheduler_get_weight(&stream->_refs.scheduler)); + return h2o_iovec_init(s, len); +} + +static h2o_iovec_t log_priority_actual_parent(h2o_req_t *req) +{ + h2o_http2_conn_t *conn = (void *)req->conn; + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + char *s = h2o_mem_alloc_pool(&stream->req.pool, sizeof(H2O_UINT32_LONGEST_STR)); + size_t len = (size_t)sprintf(s, "%" PRIu32, get_parent_stream_id(conn, stream)); + return h2o_iovec_init(s, len); +} + +static h2o_iovec_t log_priority_actual_weight(h2o_req_t *req) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, req); + char *s = h2o_mem_alloc_pool(&stream->req.pool, sizeof(H2O_UINT16_LONGEST_STR)); + size_t len = (size_t)sprintf(s, "%" PRIu16, h2o_http2_scheduler_get_weight(&stream->_refs.scheduler)); + return h2o_iovec_init(s, len); +} + +static h2o_http2_conn_t *create_conn(h2o_context_t *ctx, h2o_hostconf_t **hosts, h2o_socket_t *sock, struct timeval connected_at) +{ + static const h2o_conn_callbacks_t callbacks = { + get_sockname, /* stringify address */ + get_peername, /* ditto */ + push_path, /* HTTP2 push */ + get_socket, /* get underlying socket */ + h2o_http2_get_debug_state, /* get debug state */ + {{ + {log_protocol_version, log_session_reused, log_cipher, log_cipher_bits, log_session_id}, /* ssl */ + {NULL}, /* http1 */ + {log_stream_id, log_priority_received, log_priority_received_exclusive, log_priority_received_parent, + log_priority_received_weight, log_priority_actual, log_priority_actual_parent, log_priority_actual_weight} /* http2 */ + }} /* loggers */ + }; + + h2o_http2_conn_t *conn = (void *)h2o_create_connection(sizeof(*conn), ctx, hosts, connected_at, &callbacks); + + memset((char *)conn + sizeof(conn->super), 0, sizeof(*conn) - sizeof(conn->super)); + conn->sock = sock; + conn->peer_settings = H2O_HTTP2_SETTINGS_DEFAULT; + conn->streams = kh_init(h2o_http2_stream_t); + h2o_http2_scheduler_init(&conn->scheduler); + conn->state = H2O_HTTP2_CONN_STATE_OPEN; + h2o_linklist_insert(&ctx->http2._conns, &conn->_conns); + conn->_read_expect = expect_preface; + conn->_input_header_table.hpack_capacity = conn->_input_header_table.hpack_max_capacity = + H2O_HTTP2_SETTINGS_DEFAULT.header_table_size; + h2o_http2_window_init(&conn->_input_window, &H2O_HTTP2_SETTINGS_DEFAULT); + conn->_output_header_table.hpack_capacity = H2O_HTTP2_SETTINGS_HOST.header_table_size; + h2o_linklist_init_anchor(&conn->_pending_reqs); + h2o_buffer_init(&conn->_write.buf, &wbuf_buffer_prototype); + h2o_linklist_init_anchor(&conn->_write.streams_to_proceed); + conn->_write.timeout_entry.cb = emit_writereq; + h2o_http2_window_init(&conn->_write.window, &conn->peer_settings); + + return conn; +} + +static int update_push_memo(h2o_http2_conn_t *conn, h2o_req_t *src_req, const char *abspath, size_t abspath_len) +{ + + if (conn->push_memo == NULL) + conn->push_memo = h2o_cache_create(0, 1024, 1, NULL); + + /* uses the hash as the key */ + h2o_cache_hashcode_t url_hash = h2o_cache_calchash(src_req->input.scheme->name.base, src_req->input.scheme->name.len) ^ + h2o_cache_calchash(src_req->input.authority.base, src_req->input.authority.len) ^ + h2o_cache_calchash(abspath, abspath_len); + return h2o_cache_set(conn->push_memo, 0, h2o_iovec_init(&url_hash, sizeof(url_hash)), url_hash, h2o_iovec_init(NULL, 0)); +} + +static void push_path(h2o_req_t *src_req, const char *abspath, size_t abspath_len) +{ + h2o_http2_conn_t *conn = (void *)src_req->conn; + h2o_http2_stream_t *src_stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, req, src_req); + + /* RFC 7540 8.2.1: PUSH_PROMISE frames can be sent by the server in response to any client-initiated stream */ + if (h2o_http2_stream_is_push(src_stream->stream_id)) + return; + + if (!src_stream->req.hostconf->http2.push_preload || !conn->peer_settings.enable_push || + conn->num_streams.push.open >= conn->peer_settings.max_concurrent_streams) + return; + + if (conn->push_stream_ids.max_open >= 0x7ffffff0) + return; + if (!(h2o_linklist_is_empty(&conn->_pending_reqs) && can_run_requests(conn))) + return; + + if (h2o_find_header(&src_stream->req.headers, H2O_TOKEN_X_FORWARDED_FOR, -1) != -1) + return; + + if (src_stream->cache_digests != NULL) { + h2o_iovec_t url = h2o_concat(&src_stream->req.pool, src_stream->req.input.scheme->name, h2o_iovec_init(H2O_STRLIT("://")), + src_stream->req.input.authority, h2o_iovec_init(abspath, abspath_len)); + if (h2o_cache_digests_lookup_by_url(src_stream->cache_digests, url.base, url.len) == H2O_CACHE_DIGESTS_STATE_FRESH) + return; + } + + /* delayed initialization of casper (cookie-based), that MAY be used together to cache-digests */ + if (src_stream->req.hostconf->http2.casper.capacity_bits != 0) { + if (!src_stream->pull.casper_is_ready) { + src_stream->pull.casper_is_ready = 1; + if (conn->casper == NULL) + h2o_http2_conn_init_casper(conn, src_stream->req.hostconf->http2.casper.capacity_bits); + ssize_t header_index; + for (header_index = -1; + (header_index = h2o_find_header(&src_stream->req.headers, H2O_TOKEN_COOKIE, header_index)) != -1;) { + h2o_header_t *header = src_stream->req.headers.entries + header_index; + h2o_http2_casper_consume_cookie(conn->casper, header->value.base, header->value.len); + } + } + } + + /* update the push memo, and if it already pushed on the same connection, return */ + if (update_push_memo(conn, &src_stream->req, abspath, abspath_len)) + return; + + /* open the stream */ + h2o_http2_stream_t *stream = h2o_http2_stream_open(conn, conn->push_stream_ids.max_open + 2, NULL, &h2o_http2_default_priority); + stream->received_priority.dependency = src_stream->stream_id; + stream->push.parent_stream_id = src_stream->stream_id; + h2o_http2_scheduler_open(&stream->_refs.scheduler, &src_stream->_refs.scheduler.node, 16, 0); + h2o_http2_stream_prepare_for_request(conn, stream); + + /* setup request */ + stream->req.input.method = (h2o_iovec_t){H2O_STRLIT("GET")}; + stream->req.input.scheme = src_stream->req.input.scheme; + stream->req.input.authority = + h2o_strdup(&stream->req.pool, src_stream->req.input.authority.base, src_stream->req.input.authority.len); + stream->req.input.path = h2o_strdup(&stream->req.pool, abspath, abspath_len); + stream->req.version = 0x200; + + { /* copy headers that may affect the response (of a cacheable response) */ + size_t i; + for (i = 0; i != src_stream->req.headers.size; ++i) { + h2o_header_t *src_header = src_stream->req.headers.entries + i; + if (h2o_iovec_is_token(src_header->name)) { + h2o_token_t *token = H2O_STRUCT_FROM_MEMBER(h2o_token_t, buf, src_header->name); + if (token->copy_for_push_request) { + h2o_add_header(&stream->req.pool, &stream->req.headers, token, NULL, + h2o_strdup(&stream->req.pool, src_header->value.base, src_header->value.len).base, + src_header->value.len); + } + } + } + } + + execute_or_enqueue_request(conn, stream); + + /* send push-promise ASAP (before the parent stream gets closed), even if execute_or_enqueue_request did not trigger the + * invocation of send_headers */ + if (!stream->push.promise_sent && stream->state != H2O_HTTP2_STREAM_STATE_END_STREAM) + h2o_http2_stream_send_push_promise(conn, stream); +} + +static int foreach_request(h2o_context_t *ctx, int (*cb)(h2o_req_t *req, void *cbdata), void *cbdata) +{ + h2o_linklist_t *node; + + for (node = ctx->http2._conns.next; node != &ctx->http2._conns; node = node->next) { + h2o_http2_conn_t *conn = H2O_STRUCT_FROM_MEMBER(h2o_http2_conn_t, _conns, node); + h2o_http2_stream_t *stream; + kh_foreach_value(conn->streams, stream, { + int ret = cb(&stream->req, cbdata); + if (ret != 0) + return ret; + }); + } + return 0; +} + +void h2o_http2_accept(h2o_accept_ctx_t *ctx, h2o_socket_t *sock, struct timeval connected_at) +{ + h2o_http2_conn_t *conn = create_conn(ctx->ctx, ctx->hosts, sock, connected_at); + sock->data = conn; + h2o_socket_read_start(conn->sock, on_read); + update_idle_timeout(conn); + if (sock->input->size != 0) + on_read(sock, 0); +} + +int h2o_http2_handle_upgrade(h2o_req_t *req, struct timeval connected_at) +{ + h2o_http2_conn_t *http2conn = create_conn(req->conn->ctx, req->conn->hosts, NULL, connected_at); + h2o_http2_stream_t *stream; + ssize_t connection_index, settings_index; + h2o_iovec_t settings_decoded; + const char *err_desc; + + assert(req->version < 0x200); /* from HTTP/1.x */ + + /* check that "HTTP2-Settings" is declared in the connection header */ + connection_index = h2o_find_header(&req->headers, H2O_TOKEN_CONNECTION, -1); + assert(connection_index != -1); + if (!h2o_contains_token(req->headers.entries[connection_index].value.base, req->headers.entries[connection_index].value.len, + H2O_STRLIT("http2-settings"), ',')) { + goto Error; + } + + /* decode the settings */ + if ((settings_index = h2o_find_header(&req->headers, H2O_TOKEN_HTTP2_SETTINGS, -1)) == -1) { + goto Error; + } + if ((settings_decoded = h2o_decode_base64url(&req->pool, req->headers.entries[settings_index].value.base, + req->headers.entries[settings_index].value.len)) + .base == NULL) { + goto Error; + } + if (h2o_http2_update_peer_settings(&http2conn->peer_settings, (uint8_t *)settings_decoded.base, settings_decoded.len, + &err_desc) != 0) { + goto Error; + } + + /* open the stream, now that the function is guaranteed to succeed */ + stream = h2o_http2_stream_open(http2conn, 1, req, &h2o_http2_default_priority); + h2o_http2_scheduler_open(&stream->_refs.scheduler, &http2conn->scheduler, h2o_http2_default_priority.weight, 0); + h2o_http2_stream_prepare_for_request(http2conn, stream); + + /* send response */ + req->res.status = 101; + req->res.reason = "Switching Protocols"; + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_UPGRADE, NULL, H2O_STRLIT("h2c")); + h2o_http1_upgrade(req, (h2o_iovec_t *)&SETTINGS_HOST_BIN, 1, on_upgrade_complete, http2conn); + + return 0; +Error: + h2o_linklist_unlink(&http2conn->_conns); + kh_destroy(h2o_http2_stream_t, http2conn->streams); + free(http2conn); + return -1; +} diff --git a/web/server/h2o/libh2o/lib/http2/frame.c b/web/server/h2o/libh2o/lib/http2/frame.c new file mode 100644 index 000000000..86abdaa48 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/frame.c @@ -0,0 +1,290 @@ +/* + * 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.h" +#include "h2o/http2.h" +#include "h2o/http2_internal.h" + +const h2o_http2_settings_t H2O_HTTP2_SETTINGS_DEFAULT = { + /* header_table_size */ 4096, + /* enable_push */ 1, + /* max_concurrent_streams */ UINT32_MAX, + /* initial_window_size */ 65535, + /* max_frame_size */ 16384}; + +int h2o_http2_update_peer_settings(h2o_http2_settings_t *settings, const uint8_t *src, size_t len, const char **err_desc) +{ + for (; len >= 6; len -= 6, src += 6) { + uint16_t identifier = h2o_http2_decode16u(src); + uint32_t value = h2o_http2_decode32u(src + 2); + switch (identifier) { +#define SET(label, member, min, max, err_code) \ + case H2O_HTTP2_SETTINGS_##label: \ + if (!(min <= value && value <= max)) { \ + *err_desc = "invalid SETTINGS frame"; \ + return err_code; \ + } \ + settings->member = value; \ + break + SET(HEADER_TABLE_SIZE, header_table_size, 0, UINT32_MAX, 0); + SET(ENABLE_PUSH, enable_push, 0, 1, H2O_HTTP2_ERROR_PROTOCOL); + SET(MAX_CONCURRENT_STREAMS, max_concurrent_streams, 0, UINT32_MAX, 0); + SET(INITIAL_WINDOW_SIZE, initial_window_size, 0, 0x7fffffff, H2O_HTTP2_ERROR_FLOW_CONTROL); + SET(MAX_FRAME_SIZE, max_frame_size, 16384, 16777215, H2O_HTTP2_ERROR_PROTOCOL); +#undef SET + default: + /* ignore unknown (5.5) */ + break; + } + } + + if (len != 0) + return H2O_HTTP2_ERROR_FRAME_SIZE; + return 0; +} + +uint8_t *h2o_http2_encode_frame_header(uint8_t *dst, size_t length, uint8_t type, uint8_t flags, int32_t stream_id) +{ + if (length > 0xffffff) + h2o_fatal("invalid length"); + + dst = h2o_http2_encode24u(dst, (uint32_t)length); + *dst++ = type; + *dst++ = flags; + dst = h2o_http2_encode32u(dst, stream_id); + + return dst; +} + +static uint8_t *allocate_frame(h2o_buffer_t **buf, size_t length, uint8_t type, uint8_t flags, int32_t stream_id) +{ + h2o_iovec_t alloced = h2o_buffer_reserve(buf, H2O_HTTP2_FRAME_HEADER_SIZE + length); + (*buf)->size += H2O_HTTP2_FRAME_HEADER_SIZE + length; + return h2o_http2_encode_frame_header((uint8_t *)alloced.base, length, type, flags, stream_id); +} + +void h2o_http2__encode_rst_stream_frame(h2o_buffer_t **buf, uint32_t stream_id, int errnum) +{ + uint8_t *dst = allocate_frame(buf, 4, H2O_HTTP2_FRAME_TYPE_RST_STREAM, 0, stream_id); + dst = h2o_http2_encode32u(dst, errnum); +} + +void h2o_http2_encode_ping_frame(h2o_buffer_t **buf, int is_ack, const uint8_t *data) +{ + uint8_t *dst = allocate_frame(buf, 8, H2O_HTTP2_FRAME_TYPE_PING, is_ack ? H2O_HTTP2_FRAME_FLAG_ACK : 0, 0); + memcpy(dst, data, 8); + dst += 8; +} + +void h2o_http2_encode_goaway_frame(h2o_buffer_t **buf, uint32_t last_stream_id, int errnum, h2o_iovec_t additional_data) +{ + uint8_t *dst = allocate_frame(buf, 8 + additional_data.len, H2O_HTTP2_FRAME_TYPE_GOAWAY, 0, 0); + dst = h2o_http2_encode32u(dst, last_stream_id); + dst = h2o_http2_encode32u(dst, (uint32_t)-errnum); + h2o_memcpy(dst, additional_data.base, additional_data.len); +} + +void h2o_http2_encode_window_update_frame(h2o_buffer_t **buf, uint32_t stream_id, int32_t window_size_increment) +{ + uint8_t *dst = allocate_frame(buf, 4, H2O_HTTP2_FRAME_TYPE_WINDOW_UPDATE, 0, stream_id); + dst = h2o_http2_encode32u(dst, window_size_increment); +} + +ssize_t h2o_http2_decode_frame(h2o_http2_frame_t *frame, const uint8_t *src, size_t len, const h2o_http2_settings_t *host_settings, + const char **err_desc) +{ + if (len < H2O_HTTP2_FRAME_HEADER_SIZE) + return H2O_HTTP2_ERROR_INCOMPLETE; + + frame->length = h2o_http2_decode24u(src); + frame->type = src[3]; + frame->flags = src[4]; + frame->stream_id = h2o_http2_decode32u(src + 5) & 0x7fffffff; + + if (frame->length > host_settings->max_frame_size) + return H2O_HTTP2_ERROR_FRAME_SIZE; + + if (len < H2O_HTTP2_FRAME_HEADER_SIZE + frame->length) + return H2O_HTTP2_ERROR_INCOMPLETE; + + frame->payload = src + H2O_HTTP2_FRAME_HEADER_SIZE; + + return H2O_HTTP2_FRAME_HEADER_SIZE + frame->length; +} + +int h2o_http2_decode_data_payload(h2o_http2_data_payload_t *payload, const h2o_http2_frame_t *frame, const char **err_desc) +{ + if (frame->stream_id == 0) { + *err_desc = "invalid stream id in DATA frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_PADDED) != 0) { + uint8_t padding_length; + if (frame->length < 1) { + *err_desc = "invalid DATA frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + padding_length = frame->payload[0]; + if (frame->length < 1 + padding_length) { + *err_desc = "invalid DATA frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + payload->data = frame->payload + 1; + payload->length = frame->length - (1 + padding_length); + } else { + payload->data = frame->payload; + payload->length = frame->length; + } + return 0; +} + +static const uint8_t *decode_priority(h2o_http2_priority_t *priority, const uint8_t *src) +{ + uint32_t u4 = h2o_http2_decode32u(src); + src += 4; + priority->exclusive = u4 >> 31; + priority->dependency = u4 & 0x7fffffff; + priority->weight = (uint16_t)*src++ + 1; + return src; +} + +int h2o_http2_decode_headers_payload(h2o_http2_headers_payload_t *payload, const h2o_http2_frame_t *frame, const char **err_desc) +{ + const uint8_t *src = frame->payload, *src_end = frame->payload + frame->length; + + if (frame->stream_id == 0) { + *err_desc = "invalid stream id in HEADERS frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_PADDED) != 0) { + uint32_t padlen; + if (src == src_end) { + *err_desc = "invalid HEADERS frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + padlen = *src++; + if (src_end - src < padlen) { + *err_desc = "invalid HEADERS frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + src_end -= padlen; + } + + if ((frame->flags & H2O_HTTP2_FRAME_FLAG_PRIORITY) != 0) { + if (src_end - src < 5) + return -1; + src = decode_priority(&payload->priority, src); + } else { + payload->priority = h2o_http2_default_priority; + } + + payload->headers = src; + payload->headers_len = src_end - src; + + return 0; +} + +int h2o_http2_decode_priority_payload(h2o_http2_priority_t *payload, const h2o_http2_frame_t *frame, const char **err_desc) +{ + if (frame->stream_id == 0) { + *err_desc = "invalid stream id in PRIORITY frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + if (frame->length != 5) { + *err_desc = "invalid PRIORITY frame"; + return H2O_HTTP2_ERROR_FRAME_SIZE; + } + + decode_priority(payload, frame->payload); + return 0; +} + +int h2o_http2_decode_rst_stream_payload(h2o_http2_rst_stream_payload_t *payload, const h2o_http2_frame_t *frame, + const char **err_desc) +{ + if (frame->stream_id == 0) { + *err_desc = "invalid stream id in RST_STREAM frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + if (frame->length != sizeof(payload->error_code)) { + *err_desc = "invalid RST_STREAM frame"; + return H2O_HTTP2_ERROR_FRAME_SIZE; + } + + payload->error_code = h2o_http2_decode32u(frame->payload); + return 0; +} + +int h2o_http2_decode_ping_payload(h2o_http2_ping_payload_t *payload, const h2o_http2_frame_t *frame, const char **err_desc) +{ + if (frame->stream_id != 0) { + *err_desc = "invalid PING frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + if (frame->length != sizeof(payload->data)) { + *err_desc = "invalid PING frame"; + return H2O_HTTP2_ERROR_FRAME_SIZE; + } + + memcpy(payload->data, frame->payload, sizeof(payload->data)); + return 0; +} + +int h2o_http2_decode_goaway_payload(h2o_http2_goaway_payload_t *payload, const h2o_http2_frame_t *frame, const char **err_desc) +{ + if (frame->stream_id != 0) { + *err_desc = "invalid stream id in GOAWAY frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + if (frame->length < 8) { + *err_desc = "invalid GOAWAY frame"; + return H2O_HTTP2_ERROR_FRAME_SIZE; + } + + payload->last_stream_id = h2o_http2_decode32u(frame->payload) & 0x7fffffff; + payload->error_code = h2o_http2_decode32u(frame->payload + 4); + if ((payload->debug_data.len = frame->length - 8) != 0) + payload->debug_data.base = (char *)frame->payload + 8; + else + payload->debug_data.base = NULL; + + return 0; +} + +int h2o_http2_decode_window_update_payload(h2o_http2_window_update_payload_t *payload, const h2o_http2_frame_t *frame, + const char **err_desc, int *err_is_stream_level) +{ + if (frame->length != 4) { + *err_is_stream_level = 0; + return H2O_HTTP2_ERROR_FRAME_SIZE; + } + + payload->window_size_increment = h2o_http2_decode32u(frame->payload) & 0x7fffffff; + if (payload->window_size_increment == 0) { + *err_is_stream_level = frame->stream_id != 0; + *err_desc = "invalid WINDOW_UPDATE frame"; + return H2O_HTTP2_ERROR_PROTOCOL; + } + + return 0; +} diff --git a/web/server/h2o/libh2o/lib/http2/hpack.c b/web/server/h2o/libh2o/lib/http2/hpack.c new file mode 100644 index 000000000..4adb15cd7 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/hpack.c @@ -0,0 +1,917 @@ +/* + * 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 <stddef.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include "h2o.h" +#include "h2o/http2.h" +#include "h2o/http2_internal.h" + +#define HEADER_TABLE_OFFSET 62 +#define HEADER_TABLE_ENTRY_SIZE_OFFSET 32 +#define STATUS_HEADER_MAX_SIZE 5 +#define CONTENT_LENGTH_HEADER_MAX_SIZE \ + (3 + sizeof(H2O_UINT64_LONGEST_STR) - 1) /* uses Literal Header Field without Indexing (RFC7541 6.2.2) */ + +struct st_h2o_hpack_static_table_entry_t { + const h2o_token_t *name; + const h2o_iovec_t value; +}; + +struct st_h2o_decode_header_result_t { + h2o_iovec_t *name; + h2o_iovec_t *value; +}; + +#include "hpack_huffman_table.h" +#include "hpack_static_table.h" + +static inline int value_is_part_of_static_table(const h2o_iovec_t *value) +{ + return &h2o_hpack_static_table[0].value <= value && + value <= &h2o_hpack_static_table[sizeof(h2o_hpack_static_table) / sizeof(h2o_hpack_static_table[0]) - 1].value; +} + +static h2o_iovec_t *alloc_buf(h2o_mem_pool_t *pool, size_t len) +{ + h2o_iovec_t *buf = h2o_mem_alloc_shared(pool, sizeof(h2o_iovec_t) + len + 1, NULL); + buf->base = (char *)buf + sizeof(h2o_iovec_t); + buf->len = len; + return buf; +} + +/* validate a header value against https://tools.ietf.org/html/rfc7230#section-3.2 */ +static int contains_invalid_field_value_char(const char *s, size_t len) +{ + /* all printable chars + horizontal tab */ + static const char valid_h2_field_value_char[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0-31 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 32-63 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 64-95 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, /* 96-127 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 128-159 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 160-191 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 192-223 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 224-255 */ + }; + + for (; len != 0; ++s, --len) { + unsigned char ch = (unsigned char)*s; + if (!valid_h2_field_value_char[ch]) { + return 1; + } + } + return 0; +} + +static const char *err_found_upper_case_in_header_name = "found an upper-case letter in header name"; +static const char *soft_err_found_invalid_char_in_header_name = "found an invalid character in header name"; +static const char *soft_err_found_invalid_char_in_header_value = "found an invalid character in header value"; + +/* validate a header name against https://tools.ietf.org/html/rfc7230#section-3.2, + * in addition to that, we disallow upper case chars as well. + * This sets @err_desc for all invalid characters, but only returns true + * for upper case characters, this is because we return a protocol error + * in that case. */ +static const char *validate_header_name(const char *s, size_t len) +{ + const char *ret = NULL; + /* all printable chars, except upper case and separator characters */ + static const char valid_h2_header_name_char[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0-31 */ + 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 32-63 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, /* 64-95 */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, /* 96-127 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 128-159 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 160-191 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 192-223 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 224-255 */ + }; + + for (; len != 0; ++s, --len) { + unsigned char ch = (unsigned char)*s; + if (!valid_h2_header_name_char[ch]) { + if (ch - 'A' < 26U) { + return err_found_upper_case_in_header_name; + } + ret = soft_err_found_invalid_char_in_header_name; + } + } + return ret; +} + +static int32_t decode_int(const uint8_t **src, const uint8_t *src_end, size_t prefix_bits) +{ + int32_t value, mult; + uint8_t prefix_max = (1 << prefix_bits) - 1; + + if (*src >= src_end) + return -1; + + value = (uint8_t) * (*src)++ & prefix_max; + if (value != prefix_max) { + return value; + } + + /* we only allow at most 4 octets (excluding prefix) to be used as int (== 2**(4*7) == 2**28) */ + if (src_end - *src > 4) + src_end = *src + 4; + + value = prefix_max; + for (mult = 1;; mult *= 128) { + if (*src >= src_end) + return -1; + value += (**src & 127) * mult; + if ((*(*src)++ & 128) == 0) + return value; + } +} + +static char *huffdecode4(char *dst, uint8_t in, uint8_t *state, int *maybe_eos, uint8_t *seen_char_types) +{ + const nghttp2_huff_decode *entry = huff_decode_table[*state] + in; + + if ((entry->flags & NGHTTP2_HUFF_FAIL) != 0) + return NULL; + if ((entry->flags & NGHTTP2_HUFF_SYM) != 0) { + *dst++ = entry->sym; + *seen_char_types |= (entry->flags & NGHTTP2_HUFF_INVALID_CHARS); + } + *state = entry->state; + *maybe_eos = (entry->flags & NGHTTP2_HUFF_ACCEPTED) != 0; + + return dst; +} + +static h2o_iovec_t *decode_huffman(h2o_mem_pool_t *pool, const uint8_t *src, size_t len, uint8_t *seen_char_types) +{ + const uint8_t *src_end = src + len; + char *dst; + uint8_t state = 0; + int maybe_eos = 1; + h2o_iovec_t *dst_buf = alloc_buf(pool, len * 2); /* max compression ratio is >= 0.5 */ + + dst = dst_buf->base; + for (; src < src_end; src++) { + if ((dst = huffdecode4(dst, *src >> 4, &state, &maybe_eos, seen_char_types)) == NULL) + return NULL; + if ((dst = huffdecode4(dst, *src & 0xf, &state, &maybe_eos, seen_char_types)) == NULL) + return NULL; + } + + if (!maybe_eos) + return NULL; + + *dst = '\0'; + dst_buf->len = dst - dst_buf->base; + return dst_buf; +} + +static h2o_iovec_t *decode_string(h2o_mem_pool_t *pool, const uint8_t **src, const uint8_t *src_end, int is_header_name, + const char **err_desc) +{ + h2o_iovec_t *ret; + int is_huffman; + int32_t len; + + if (*src >= src_end) + return NULL; + + is_huffman = (**src & 0x80) != 0; + if ((len = decode_int(src, src_end, 7)) == -1) + return NULL; + + if (is_huffman) { + uint8_t hflags = 0; + if (*src + len > src_end) + return NULL; + if ((ret = decode_huffman(pool, *src, len, &hflags)) == NULL) + return NULL; + if (is_header_name) { + if (ret->len <= 0) { + return NULL; + } + /* pseudo-headers are checked later in `decode_header` */ + if (hflags & NGHTTP2_HUFF_INVALID_FOR_HEADER_NAME && ret->base[0] != ':') { + if (hflags & NGHTTP2_HUFF_UPPER_CASE_CHAR) { + *err_desc = err_found_upper_case_in_header_name; + return NULL; + } else { + *err_desc = soft_err_found_invalid_char_in_header_name; + } + } + } else { + if (hflags & NGHTTP2_HUFF_INVALID_FOR_HEADER_VALUE) { + *err_desc = soft_err_found_invalid_char_in_header_value; + } + } + } else { + if (*src + len > src_end) + return NULL; + if (is_header_name) { + /* pseudo-headers are checked later in `decode_header` */ + if (**src != (uint8_t)':') { + *err_desc = validate_header_name((char *)*src, len); + if (*err_desc == err_found_upper_case_in_header_name) { + return NULL; + } + } + } else { + if (contains_invalid_field_value_char((char *)*src, len)) { + *err_desc = soft_err_found_invalid_char_in_header_value; + } + } + ret = alloc_buf(pool, len); + memcpy(ret->base, *src, len); + ret->base[len] = '\0'; + } + *src += len; + + return ret; +} + +static void header_table_evict_one(h2o_hpack_header_table_t *table) +{ + struct st_h2o_hpack_header_table_entry_t *entry; + assert(table->num_entries != 0); + + entry = h2o_hpack_header_table_get(table, --table->num_entries); + table->hpack_size -= entry->name->len + entry->value->len + HEADER_TABLE_ENTRY_SIZE_OFFSET; + if (!h2o_iovec_is_token(entry->name)) + h2o_mem_release_shared(entry->name); + if (!value_is_part_of_static_table(entry->value)) + h2o_mem_release_shared(entry->value); + memset(entry, 0, sizeof(*entry)); +} + +static struct st_h2o_hpack_header_table_entry_t *header_table_add(h2o_hpack_header_table_t *table, size_t size_add, + size_t max_num_entries) +{ + /* adjust the size */ + while (table->num_entries != 0 && table->hpack_size + size_add > table->hpack_capacity) + header_table_evict_one(table); + while (max_num_entries <= table->num_entries) + header_table_evict_one(table); + if (table->num_entries == 0) { + assert(table->hpack_size == 0); + if (size_add > table->hpack_capacity) + return NULL; + } + table->hpack_size += size_add; + + /* grow the entries if full */ + if (table->num_entries == table->entry_capacity) { + size_t new_capacity = table->num_entries * 2; + if (new_capacity < 16) + new_capacity = 16; + struct st_h2o_hpack_header_table_entry_t *new_entries = + h2o_mem_alloc(new_capacity * sizeof(struct st_h2o_hpack_header_table_entry_t)); + if (table->num_entries != 0) { + size_t src_index = table->entry_start_index, dst_index = 0; + do { + new_entries[dst_index] = table->entries[src_index]; + ++dst_index; + src_index = (src_index + 1) % table->entry_capacity; + } while (dst_index != table->num_entries); + } + memset(new_entries + table->num_entries, 0, sizeof(*new_entries) * (new_capacity - table->num_entries)); + free(table->entries); + table->entries = new_entries; + table->entry_capacity = new_capacity; + table->entry_start_index = 0; + } + + ++table->num_entries; + table->entry_start_index = (table->entry_start_index + table->entry_capacity - 1) % table->entry_capacity; + return table->entries + table->entry_start_index; +} + +static int decode_header(h2o_mem_pool_t *pool, struct st_h2o_decode_header_result_t *result, + h2o_hpack_header_table_t *hpack_header_table, const uint8_t **const src, const uint8_t *src_end, + const char **err_desc) +{ + int32_t index = 0; + int value_is_indexed = 0, do_index = 0; + +Redo: + if (*src >= src_end) + return H2O_HTTP2_ERROR_COMPRESSION; + + /* determine the mode and handle accordingly */ + if (**src >= 128) { + /* indexed header field representation */ + if ((index = decode_int(src, src_end, 7)) <= 0) + return H2O_HTTP2_ERROR_COMPRESSION; + value_is_indexed = 1; + } else if (**src >= 64) { + /* literal header field with incremental handling */ + if (**src == 64) { + ++*src; + } else if ((index = decode_int(src, src_end, 6)) <= 0) { + return H2O_HTTP2_ERROR_COMPRESSION; + } + do_index = 1; + } else if (**src < 32) { + /* literal header field without indexing / never indexed */ + if ((**src & 0xf) == 0) { + ++*src; + } else if ((index = decode_int(src, src_end, 4)) <= 0) { + return H2O_HTTP2_ERROR_COMPRESSION; + } + } else { + /* size update */ + int new_apacity; + if ((new_apacity = decode_int(src, src_end, 5)) < 0) { + return H2O_HTTP2_ERROR_COMPRESSION; + } + if (new_apacity > hpack_header_table->hpack_max_capacity) { + return H2O_HTTP2_ERROR_COMPRESSION; + } + hpack_header_table->hpack_capacity = new_apacity; + while (hpack_header_table->num_entries != 0 && hpack_header_table->hpack_size > hpack_header_table->hpack_capacity) { + header_table_evict_one(hpack_header_table); + } + goto Redo; + } + + /* determine the header */ + if (index > 0) { + /* existing name (and value?) */ + if (index < HEADER_TABLE_OFFSET) { + result->name = (h2o_iovec_t *)h2o_hpack_static_table[index - 1].name; + if (value_is_indexed) { + result->value = (h2o_iovec_t *)&h2o_hpack_static_table[index - 1].value; + } + } else if (index - HEADER_TABLE_OFFSET < hpack_header_table->num_entries) { + struct st_h2o_hpack_header_table_entry_t *entry = + h2o_hpack_header_table_get(hpack_header_table, index - HEADER_TABLE_OFFSET); + *err_desc = entry->err_desc; + result->name = entry->name; + if (!h2o_iovec_is_token(result->name)) + h2o_mem_link_shared(pool, result->name); + if (value_is_indexed) { + result->value = entry->value; + h2o_mem_link_shared(pool, result->value); + } + } else { + return H2O_HTTP2_ERROR_COMPRESSION; + } + } else { + /* non-existing name */ + const h2o_token_t *name_token; + if ((result->name = decode_string(pool, src, src_end, 1, err_desc)) == NULL) { + if (*err_desc == err_found_upper_case_in_header_name) { + return H2O_HTTP2_ERROR_PROTOCOL; + } + return H2O_HTTP2_ERROR_COMPRESSION; + } + if (!*err_desc) { + /* predefined header names should be interned */ + if ((name_token = h2o_lookup_token(result->name->base, result->name->len)) != NULL) { + result->name = (h2o_iovec_t *)&name_token->buf; + } + } + } + + /* determine the value (if necessary) */ + if (!value_is_indexed) { + if ((result->value = decode_string(pool, src, src_end, 0, err_desc)) == NULL) { + return H2O_HTTP2_ERROR_COMPRESSION; + } + } + + /* add the decoded header to the header table if necessary */ + if (do_index) { + struct st_h2o_hpack_header_table_entry_t *entry = + header_table_add(hpack_header_table, result->name->len + result->value->len + HEADER_TABLE_ENTRY_SIZE_OFFSET, SIZE_MAX); + if (entry != NULL) { + entry->err_desc = *err_desc; + entry->name = result->name; + if (!h2o_iovec_is_token(entry->name)) + h2o_mem_addref_shared(entry->name); + entry->value = result->value; + if (!value_is_part_of_static_table(entry->value)) + h2o_mem_addref_shared(entry->value); + } + } + + return *err_desc ? H2O_HTTP2_ERROR_INVALID_HEADER_CHAR : 0; +} + +static uint8_t *encode_status(uint8_t *dst, int status) +{ + /* see also: STATUS_HEADER_MAX_SIZE */ + + assert(100 <= status && status <= 999); + + switch (status) { +#define COMMON_CODE(code, st) \ + case st: \ + *dst++ = 0x80 | code; \ + break + COMMON_CODE(8, 200); + COMMON_CODE(9, 204); + COMMON_CODE(10, 206); + COMMON_CODE(11, 304); + COMMON_CODE(12, 400); + COMMON_CODE(13, 404); + COMMON_CODE(14, 500); +#undef COMMON_CODE + default: + /* use literal header field without indexing - indexed name */ + *dst++ = 8; + *dst++ = 3; + sprintf((char *)dst, "%d", status); + dst += 3; + break; + } + + return dst; +} + +static uint8_t *encode_content_length(uint8_t *dst, size_t value) +{ + char buf[32], *p = buf + sizeof(buf); + size_t l; + + do { + *--p = '0' + value % 10; + } while ((value /= 10) != 0); + l = buf + sizeof(buf) - p; + *dst++ = 0x0f; + *dst++ = 0x0d; + *dst++ = (uint8_t)l; + memcpy(dst, p, l); + dst += l; + + return dst; +} + +void h2o_hpack_dispose_header_table(h2o_hpack_header_table_t *header_table) +{ + if (header_table->num_entries != 0) { + size_t index = header_table->entry_start_index; + do { + struct st_h2o_hpack_header_table_entry_t *entry = header_table->entries + index; + if (!h2o_iovec_is_token(entry->name)) + h2o_mem_release_shared(entry->name); + if (!value_is_part_of_static_table(entry->value)) + h2o_mem_release_shared(entry->value); + index = (index + 1) % header_table->entry_capacity; + } while (--header_table->num_entries != 0); + } + free(header_table->entries); +} + +int h2o_hpack_parse_headers(h2o_req_t *req, h2o_hpack_header_table_t *header_table, const uint8_t *src, size_t len, + int *pseudo_header_exists_map, size_t *content_length, h2o_cache_digests_t **digests, + const char **err_desc) +{ + const uint8_t *src_end = src + len; + + *content_length = SIZE_MAX; + + while (src != src_end) { + struct st_h2o_decode_header_result_t r; + const char *decode_err = NULL; + int ret = decode_header(&req->pool, &r, header_table, &src, src_end, &decode_err); + if (ret != 0) { + if (ret == H2O_HTTP2_ERROR_INVALID_HEADER_CHAR) { + /* this is a soft error, we continue parsing, but register only the first error */ + if (*err_desc == NULL) { + *err_desc = decode_err; + } + } else { + *err_desc = decode_err; + return ret; + } + } + if (r.name->base[0] == ':') { + if (pseudo_header_exists_map != NULL) { + /* FIXME validate the chars in the value (e.g. reject SP in path) */ + if (r.name == &H2O_TOKEN_AUTHORITY->buf) { + /* FIXME should we perform this check? */ + if (req->input.authority.base != NULL) + return H2O_HTTP2_ERROR_PROTOCOL; + req->input.authority = *r.value; + *pseudo_header_exists_map |= H2O_HPACK_PARSE_HEADERS_AUTHORITY_EXISTS; + } else if (r.name == &H2O_TOKEN_METHOD->buf) { + if (req->input.method.base != NULL) + return H2O_HTTP2_ERROR_PROTOCOL; + req->input.method = *r.value; + *pseudo_header_exists_map |= H2O_HPACK_PARSE_HEADERS_METHOD_EXISTS; + } else if (r.name == &H2O_TOKEN_PATH->buf) { + if (req->input.path.base != NULL) + return H2O_HTTP2_ERROR_PROTOCOL; + req->input.path = *r.value; + *pseudo_header_exists_map |= H2O_HPACK_PARSE_HEADERS_PATH_EXISTS; + } else if (r.name == &H2O_TOKEN_SCHEME->buf) { + if (req->input.scheme != NULL) + return H2O_HTTP2_ERROR_PROTOCOL; + if (h2o_memis(r.value->base, r.value->len, H2O_STRLIT("https"))) { + req->input.scheme = &H2O_URL_SCHEME_HTTPS; + } else { + /* draft-16 8.1.2.3 suggests quote: ":scheme is not restricted to http and https schemed URIs" */ + req->input.scheme = &H2O_URL_SCHEME_HTTP; + } + *pseudo_header_exists_map |= H2O_HPACK_PARSE_HEADERS_SCHEME_EXISTS; + } else { + return H2O_HTTP2_ERROR_PROTOCOL; + } + } else { + return H2O_HTTP2_ERROR_PROTOCOL; + } + } else { + pseudo_header_exists_map = NULL; + if (h2o_iovec_is_token(r.name)) { + h2o_token_t *token = H2O_STRUCT_FROM_MEMBER(h2o_token_t, buf, r.name); + if (token == H2O_TOKEN_CONTENT_LENGTH) { + if ((*content_length = h2o_strtosize(r.value->base, r.value->len)) == SIZE_MAX) + return H2O_HTTP2_ERROR_PROTOCOL; + } else { + /* reject headers as defined in draft-16 8.1.2.2 */ + if (token->http2_should_reject) { + if (token == H2O_TOKEN_HOST) { + /* just skip (and :authority is used) */ + goto Next; + } else if (token == H2O_TOKEN_TE && h2o_lcstris(r.value->base, r.value->len, H2O_STRLIT("trailers"))) { + /* do not reject */ + } else { + return H2O_HTTP2_ERROR_PROTOCOL; + } + } + if (token == H2O_TOKEN_CACHE_DIGEST && digests != NULL) { + /* TODO cache the decoded result in HPACK, as well as delay the decoding of the digest until being used */ + h2o_cache_digests_load_header(digests, r.value->base, r.value->len); + } + h2o_add_header(&req->pool, &req->headers, token, NULL, r.value->base, r.value->len); + } + } else { + h2o_add_header_by_str(&req->pool, &req->headers, r.name->base, r.name->len, 0, NULL, r.value->base, r.value->len); + } + } + Next:; + } + + if (*err_desc) { + return H2O_HTTP2_ERROR_INVALID_HEADER_CHAR; + } + return 0; +} + +static inline int encode_int_is_onebyte(uint32_t value, size_t prefix_bits) +{ + return value < (1 << prefix_bits) - 1; +} + +static uint8_t *encode_int(uint8_t *dst, uint32_t value, size_t prefix_bits) +{ + if (encode_int_is_onebyte(value, prefix_bits)) { + *dst++ |= value; + } else { + /* see also: MAX_ENCODE_INT_LENGTH */ + value -= (1 << prefix_bits) - 1; + if (value > 0x0fffffff) + h2o_fatal("value out of range"); + *dst++ |= (1 << prefix_bits) - 1; + for (; value >= 128; value >>= 7) { + *dst++ = 0x80 | value; + } + *dst++ = value; + } + return dst; +} + +static size_t encode_huffman(uint8_t *_dst, const uint8_t *src, size_t len) +{ + uint8_t *dst = _dst, *dst_end = dst + len; + const uint8_t *src_end = src + len; + uint64_t bits = 0; + int bits_left = 40; + + while (src != src_end) { + const nghttp2_huff_sym *sym = huff_sym_table + *src++; + bits |= (uint64_t)sym->code << (bits_left - sym->nbits); + bits_left -= sym->nbits; + while (bits_left <= 32) { + *dst++ = bits >> 32; + bits <<= 8; + bits_left += 8; + if (dst == dst_end) { + return 0; + } + } + } + + if (bits_left != 40) { + bits |= ((uint64_t)1 << bits_left) - 1; + *dst++ = bits >> 32; + } + if (dst == dst_end) { + return 0; + } + + return dst - _dst; +} + +static size_t encode_as_is(uint8_t *dst, const char *s, size_t len) +{ + uint8_t *start = dst; + *dst = '\0'; + dst = encode_int(dst, (uint32_t)len, 7); + memcpy(dst, s, len); + dst += len; + return dst - start; +} + +size_t h2o_hpack_encode_string(uint8_t *dst, const char *s, size_t len) +{ + if (H2O_LIKELY(len != 0)) { + /* try to encode using huffman */ + size_t hufflen = encode_huffman(dst + 1, (const uint8_t *)s, len); + if (H2O_LIKELY(hufflen != 0)) { + size_t head_len; + if (H2O_LIKELY(encode_int_is_onebyte((uint32_t)hufflen, 7))) { + dst[0] = (uint8_t)(0x80 | hufflen); + head_len = 1; + } else { + uint8_t head[8]; + head[0] = '\x80'; + head_len = encode_int(head, (uint32_t)hufflen, 7) - head; + memmove(dst + head_len, dst + 1, hufflen); + memcpy(dst, head, head_len); + } + return head_len + hufflen; + } + } + return encode_as_is(dst, s, len); +} + +static uint8_t *encode_header(h2o_hpack_header_table_t *header_table, uint8_t *dst, const h2o_iovec_t *name, + const h2o_iovec_t *value) +{ + int name_index = 0, dont_compress = 0, name_is_token = h2o_iovec_is_token(name); + + /* try to send as indexed */ + { + size_t header_table_index = header_table->entry_start_index, n; + for (n = header_table->num_entries; n != 0; --n) { + struct st_h2o_hpack_header_table_entry_t *entry = header_table->entries + header_table_index; + if (name_is_token) { + if (name != entry->name) + goto Next; + } else { + if (!h2o_memis(name->base, name->len, entry->name->base, entry->name->len)) + goto Next; + if (name_index == 0) + name_index = (int)(header_table->num_entries - n + HEADER_TABLE_OFFSET); + } + /* name matched! */ + if (!h2o_memis(value->base, value->len, entry->value->base, entry->value->len)) + goto Next; + /* name and value matched! */ + *dst = 0x80; + dst = encode_int(dst, (uint32_t)(header_table->num_entries - n + HEADER_TABLE_OFFSET), 7); + return dst; + Next: + ++header_table_index; + if (header_table_index == header_table->entry_capacity) + header_table_index = 0; + } + } + + if (name_is_token) { + const h2o_token_t *name_token = H2O_STRUCT_FROM_MEMBER(h2o_token_t, buf, name); + name_index = name_token->http2_static_table_name_index; + dont_compress = (name_token->dont_compress == 1 && value->len < 20) ? 1 : 0; + } + + if (name_index != 0) { + /* literal header field with indexing (indexed name). */ + if (dont_compress == 1) { + /* mark the field as 'never indexed' */ + *dst = 0x10; + dst = encode_int(dst, name_index, 4); + } else { + *dst = 0x40; + dst = encode_int(dst, name_index, 6); + } + } else { + /* literal header field with indexing (new name) */ + *dst++ = 0x40; + dst += h2o_hpack_encode_string(dst, name->base, name->len); + } + if (dont_compress == 1) { + /* bypass huffman encoding */ + dst += encode_as_is(dst, value->base, value->len); + } else { + /* add to header table (maximum number of entries in output header table is limited to 32 so that the search (see above) would + not take too long) */ + dst += h2o_hpack_encode_string(dst, value->base, value->len); + struct st_h2o_hpack_header_table_entry_t *entry = + header_table_add(header_table, name->len + value->len + HEADER_TABLE_ENTRY_SIZE_OFFSET, 32); + if (entry != NULL) { + if (name_is_token) { + entry->name = (h2o_iovec_t *)name; + } else { + entry->name = alloc_buf(NULL, name->len); + entry->name->base[name->len] = '\0'; + memcpy(entry->name->base, name->base, name->len); + } + entry->value = alloc_buf(NULL, value->len); + entry->value->base[value->len] = '\0'; + memcpy(entry->value->base, value->base, value->len); + } + } + + return dst; +} + +static uint8_t *encode_method(h2o_hpack_header_table_t *header_table, uint8_t *dst, h2o_iovec_t value) +{ + if (h2o_memis(value.base, value.len, H2O_STRLIT("GET"))) { + *dst++ = 0x82; + return dst; + } + if (h2o_memis(value.base, value.len, H2O_STRLIT("POST"))) { + *dst++ = 0x83; + return dst; + } + return encode_header(header_table, dst, &H2O_TOKEN_METHOD->buf, &value); +} + +static uint8_t *encode_scheme(h2o_hpack_header_table_t *header_table, uint8_t *dst, const h2o_url_scheme_t *scheme) +{ + if (scheme == &H2O_URL_SCHEME_HTTPS) { + *dst++ = 0x87; + return dst; + } + if (scheme == &H2O_URL_SCHEME_HTTP) { + *dst++ = 0x86; + return dst; + } + return encode_header(header_table, dst, &H2O_TOKEN_SCHEME->buf, &scheme->name); +} + +static uint8_t *encode_path(h2o_hpack_header_table_t *header_table, uint8_t *dst, h2o_iovec_t value) +{ + if (h2o_memis(value.base, value.len, H2O_STRLIT("/"))) { + *dst++ = 0x84; + return dst; + } + if (h2o_memis(value.base, value.len, H2O_STRLIT("/index.html"))) { + *dst++ = 0x85; + return dst; + } + return encode_header(header_table, dst, &H2O_TOKEN_PATH->buf, &value); +} + +static uint8_t *encode_literal_header_without_indexing(uint8_t *dst, const h2o_iovec_t *name, const h2o_iovec_t *value) +{ + /* literal header field without indexing / never indexed */ + *dst++ = 0; + dst += h2o_hpack_encode_string(dst, name->base, name->len); + dst += h2o_hpack_encode_string(dst, value->base, value->len); + return dst; +} + +static size_t calc_capacity(size_t name_len, size_t value_len) +{ + return name_len + value_len + 1 + H2O_HTTP2_ENCODE_INT_MAX_LENGTH * 2; +} + +static size_t calc_headers_capacity(const h2o_header_t *headers, size_t num_headers) +{ + const h2o_header_t *header; + size_t capacity = 0; + for (header = headers; num_headers != 0; ++header, --num_headers) + capacity += calc_capacity(header->name->len, header->value.len); + return capacity; +} + +static void fixup_frame_headers(h2o_buffer_t **buf, size_t start_at, uint8_t type, uint32_t stream_id, size_t max_frame_size) +{ + /* try to fit all data into single frame, using the preallocated space for the frame header */ + size_t payload_size = (*buf)->size - start_at - H2O_HTTP2_FRAME_HEADER_SIZE; + if (payload_size <= max_frame_size) { + h2o_http2_encode_frame_header((uint8_t *)((*buf)->bytes + start_at), payload_size, type, H2O_HTTP2_FRAME_FLAG_END_HEADERS, + stream_id); + return; + } + + /* need to setup continuation frames */ + size_t off; + h2o_http2_encode_frame_header((uint8_t *)((*buf)->bytes + start_at), max_frame_size, type, 0, stream_id); + off = start_at + H2O_HTTP2_FRAME_HEADER_SIZE + max_frame_size; + while (1) { + size_t left = (*buf)->size - off; + h2o_buffer_reserve(buf, H2O_HTTP2_FRAME_HEADER_SIZE); + memmove((*buf)->bytes + off + H2O_HTTP2_FRAME_HEADER_SIZE, (*buf)->bytes + off, left); + (*buf)->size += H2O_HTTP2_FRAME_HEADER_SIZE; + if (left <= max_frame_size) { + h2o_http2_encode_frame_header((uint8_t *)((*buf)->bytes + off), left, H2O_HTTP2_FRAME_TYPE_CONTINUATION, + H2O_HTTP2_FRAME_FLAG_END_HEADERS, stream_id); + break; + } else { + h2o_http2_encode_frame_header((uint8_t *)((*buf)->bytes + off), max_frame_size, H2O_HTTP2_FRAME_TYPE_CONTINUATION, 0, + stream_id); + off += H2O_HTTP2_FRAME_HEADER_SIZE + max_frame_size; + } + } +} + +void h2o_hpack_flatten_request(h2o_buffer_t **buf, h2o_hpack_header_table_t *header_table, uint32_t stream_id, + size_t max_frame_size, h2o_req_t *req, uint32_t parent_stream_id) +{ + size_t capacity = calc_headers_capacity(req->headers.entries, req->headers.size); + capacity += H2O_HTTP2_FRAME_HEADER_SIZE /* first frame header */ + + 4; /* promised stream id */ + capacity += calc_capacity(H2O_TOKEN_METHOD->buf.len, req->input.method.len); + capacity += calc_capacity(H2O_TOKEN_SCHEME->buf.len, req->input.scheme->name.len); + capacity += calc_capacity(H2O_TOKEN_AUTHORITY->buf.len, req->input.authority.len); + capacity += calc_capacity(H2O_TOKEN_PATH->buf.len, req->input.path.len); + + size_t start_at = (*buf)->size; + uint8_t *dst = (void *)(h2o_buffer_reserve(buf, capacity).base + H2O_HTTP2_FRAME_HEADER_SIZE); + + /* encode */ + dst = h2o_http2_encode32u(dst, stream_id); + dst = encode_method(header_table, dst, req->input.method); + dst = encode_scheme(header_table, dst, req->input.scheme); + dst = encode_header(header_table, dst, &H2O_TOKEN_AUTHORITY->buf, &req->input.authority); + dst = encode_path(header_table, dst, req->input.path); + size_t i; + for (i = 0; i != req->headers.size; ++i) { + const h2o_header_t *header = req->headers.entries + i; + if (header->name == &H2O_TOKEN_ACCEPT_ENCODING->buf && + h2o_memis(header->value.base, header->value.len, H2O_STRLIT("gzip, deflate"))) { + *dst++ = 0x90; + } else { + dst = encode_header(header_table, dst, header->name, &header->value); + } + } + (*buf)->size = (char *)dst - (*buf)->bytes; + + /* setup the frame headers */ + fixup_frame_headers(buf, start_at, H2O_HTTP2_FRAME_TYPE_PUSH_PROMISE, parent_stream_id, max_frame_size); +} + +void h2o_hpack_flatten_response(h2o_buffer_t **buf, h2o_hpack_header_table_t *header_table, uint32_t stream_id, + size_t max_frame_size, h2o_res_t *res, h2o_timestamp_t *ts, const h2o_iovec_t *server_name, + size_t content_length) +{ + size_t capacity = calc_headers_capacity(res->headers.entries, res->headers.size); + capacity += H2O_HTTP2_FRAME_HEADER_SIZE; /* for the first header */ + capacity += STATUS_HEADER_MAX_SIZE; /* for :status: */ +#ifndef H2O_UNITTEST + capacity += 2 + H2O_TIMESTR_RFC1123_LEN; /* for Date: */ + if (server_name->len) { + capacity += 5 + server_name->len; /* for Server: */ + } +#endif + if (content_length != SIZE_MAX) + capacity += CONTENT_LENGTH_HEADER_MAX_SIZE; /* for content-length: UINT64_MAX (with huffman compression applied) */ + + size_t start_at = (*buf)->size; + uint8_t *dst = (void *)(h2o_buffer_reserve(buf, capacity).base + H2O_HTTP2_FRAME_HEADER_SIZE); /* skip frame header */ + + /* encode */ + dst = encode_status(dst, res->status); +#ifndef H2O_UNITTEST + /* TODO keep some kind of reference to the indexed headers of Server and Date, and reuse them */ + if (server_name->len) { + dst = encode_header(header_table, dst, &H2O_TOKEN_SERVER->buf, server_name); + } + h2o_iovec_t date_value = {ts->str->rfc1123, H2O_TIMESTR_RFC1123_LEN}; + dst = encode_header(header_table, dst, &H2O_TOKEN_DATE->buf, &date_value); +#endif + size_t i; + for (i = 0; i != res->headers.size; ++i) + dst = encode_header(header_table, dst, res->headers.entries[i].name, &res->headers.entries[i].value); + if (content_length != SIZE_MAX) + dst = encode_content_length(dst, content_length); + (*buf)->size = (char *)dst - (*buf)->bytes; + + /* setup the frame headers */ + fixup_frame_headers(buf, start_at, H2O_HTTP2_FRAME_TYPE_HEADERS, stream_id, max_frame_size); +} diff --git a/web/server/h2o/libh2o/lib/http2/hpack_huffman_table.h b/web/server/h2o/libh2o/lib/http2/hpack_huffman_table.h new file mode 100644 index 000000000..8f6afab90 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/hpack_huffman_table.h @@ -0,0 +1,4954 @@ +// !!! DO NOT EDIT !!! Generated by misc/mkhufftbl.c +/* + * The MIT License + * + * Copyright (c) 2012, 2014, 2015, 2016 Tatsuhiro Tsujikawa + * Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors + * Copyright (c) 2016 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. + */ + +typedef struct { + uint32_t nbits; + uint32_t code; +} nghttp2_huff_sym; + +static const nghttp2_huff_sym huff_sym_table[] = { + {13, 0x1ff8u}, {23, 0x7fffd8u}, {28, 0xfffffe2u}, {28, 0xfffffe3u}, {28, 0xfffffe4u}, {28, 0xfffffe5u}, {28, 0xfffffe6u}, + {28, 0xfffffe7u}, {28, 0xfffffe8u}, {24, 0xffffeau}, {30, 0x3ffffffcu}, {28, 0xfffffe9u}, {28, 0xfffffeau}, {30, 0x3ffffffdu}, + {28, 0xfffffebu}, {28, 0xfffffecu}, {28, 0xfffffedu}, {28, 0xfffffeeu}, {28, 0xfffffefu}, {28, 0xffffff0u}, {28, 0xffffff1u}, + {28, 0xffffff2u}, {30, 0x3ffffffeu}, {28, 0xffffff3u}, {28, 0xffffff4u}, {28, 0xffffff5u}, {28, 0xffffff6u}, {28, 0xffffff7u}, + {28, 0xffffff8u}, {28, 0xffffff9u}, {28, 0xffffffau}, {28, 0xffffffbu}, {6, 0x14u}, {10, 0x3f8u}, {10, 0x3f9u}, + {12, 0xffau}, {13, 0x1ff9u}, {6, 0x15u}, {8, 0xf8u}, {11, 0x7fau}, {10, 0x3fau}, {10, 0x3fbu}, + {8, 0xf9u}, {11, 0x7fbu}, {8, 0xfau}, {6, 0x16u}, {6, 0x17u}, {6, 0x18u}, {5, 0x0u}, + {5, 0x1u}, {5, 0x2u}, {6, 0x19u}, {6, 0x1au}, {6, 0x1bu}, {6, 0x1cu}, {6, 0x1du}, + {6, 0x1eu}, {6, 0x1fu}, {7, 0x5cu}, {8, 0xfbu}, {15, 0x7ffcu}, {6, 0x20u}, {12, 0xffbu}, + {10, 0x3fcu}, {13, 0x1ffau}, {6, 0x21u}, {7, 0x5du}, {7, 0x5eu}, {7, 0x5fu}, {7, 0x60u}, + {7, 0x61u}, {7, 0x62u}, {7, 0x63u}, {7, 0x64u}, {7, 0x65u}, {7, 0x66u}, {7, 0x67u}, + {7, 0x68u}, {7, 0x69u}, {7, 0x6au}, {7, 0x6bu}, {7, 0x6cu}, {7, 0x6du}, {7, 0x6eu}, + {7, 0x6fu}, {7, 0x70u}, {7, 0x71u}, {7, 0x72u}, {8, 0xfcu}, {7, 0x73u}, {8, 0xfdu}, + {13, 0x1ffbu}, {19, 0x7fff0u}, {13, 0x1ffcu}, {14, 0x3ffcu}, {6, 0x22u}, {15, 0x7ffdu}, {5, 0x3u}, + {6, 0x23u}, {5, 0x4u}, {6, 0x24u}, {5, 0x5u}, {6, 0x25u}, {6, 0x26u}, {6, 0x27u}, + {5, 0x6u}, {7, 0x74u}, {7, 0x75u}, {6, 0x28u}, {6, 0x29u}, {6, 0x2au}, {5, 0x7u}, + {6, 0x2bu}, {7, 0x76u}, {6, 0x2cu}, {5, 0x8u}, {5, 0x9u}, {6, 0x2du}, {7, 0x77u}, + {7, 0x78u}, {7, 0x79u}, {7, 0x7au}, {7, 0x7bu}, {15, 0x7ffeu}, {11, 0x7fcu}, {14, 0x3ffdu}, + {13, 0x1ffdu}, {28, 0xffffffcu}, {20, 0xfffe6u}, {22, 0x3fffd2u}, {20, 0xfffe7u}, {20, 0xfffe8u}, {22, 0x3fffd3u}, + {22, 0x3fffd4u}, {22, 0x3fffd5u}, {23, 0x7fffd9u}, {22, 0x3fffd6u}, {23, 0x7fffdau}, {23, 0x7fffdbu}, {23, 0x7fffdcu}, + {23, 0x7fffddu}, {23, 0x7fffdeu}, {24, 0xffffebu}, {23, 0x7fffdfu}, {24, 0xffffecu}, {24, 0xffffedu}, {22, 0x3fffd7u}, + {23, 0x7fffe0u}, {24, 0xffffeeu}, {23, 0x7fffe1u}, {23, 0x7fffe2u}, {23, 0x7fffe3u}, {23, 0x7fffe4u}, {21, 0x1fffdcu}, + {22, 0x3fffd8u}, {23, 0x7fffe5u}, {22, 0x3fffd9u}, {23, 0x7fffe6u}, {23, 0x7fffe7u}, {24, 0xffffefu}, {22, 0x3fffdau}, + {21, 0x1fffddu}, {20, 0xfffe9u}, {22, 0x3fffdbu}, {22, 0x3fffdcu}, {23, 0x7fffe8u}, {23, 0x7fffe9u}, {21, 0x1fffdeu}, + {23, 0x7fffeau}, {22, 0x3fffddu}, {22, 0x3fffdeu}, {24, 0xfffff0u}, {21, 0x1fffdfu}, {22, 0x3fffdfu}, {23, 0x7fffebu}, + {23, 0x7fffecu}, {21, 0x1fffe0u}, {21, 0x1fffe1u}, {22, 0x3fffe0u}, {21, 0x1fffe2u}, {23, 0x7fffedu}, {22, 0x3fffe1u}, + {23, 0x7fffeeu}, {23, 0x7fffefu}, {20, 0xfffeau}, {22, 0x3fffe2u}, {22, 0x3fffe3u}, {22, 0x3fffe4u}, {23, 0x7ffff0u}, + {22, 0x3fffe5u}, {22, 0x3fffe6u}, {23, 0x7ffff1u}, {26, 0x3ffffe0u}, {26, 0x3ffffe1u}, {20, 0xfffebu}, {19, 0x7fff1u}, + {22, 0x3fffe7u}, {23, 0x7ffff2u}, {22, 0x3fffe8u}, {25, 0x1ffffecu}, {26, 0x3ffffe2u}, {26, 0x3ffffe3u}, {26, 0x3ffffe4u}, + {27, 0x7ffffdeu}, {27, 0x7ffffdfu}, {26, 0x3ffffe5u}, {24, 0xfffff1u}, {25, 0x1ffffedu}, {19, 0x7fff2u}, {21, 0x1fffe3u}, + {26, 0x3ffffe6u}, {27, 0x7ffffe0u}, {27, 0x7ffffe1u}, {26, 0x3ffffe7u}, {27, 0x7ffffe2u}, {24, 0xfffff2u}, {21, 0x1fffe4u}, + {21, 0x1fffe5u}, {26, 0x3ffffe8u}, {26, 0x3ffffe9u}, {28, 0xffffffdu}, {27, 0x7ffffe3u}, {27, 0x7ffffe4u}, {27, 0x7ffffe5u}, + {20, 0xfffecu}, {24, 0xfffff3u}, {20, 0xfffedu}, {21, 0x1fffe6u}, {22, 0x3fffe9u}, {21, 0x1fffe7u}, {21, 0x1fffe8u}, + {23, 0x7ffff3u}, {22, 0x3fffeau}, {22, 0x3fffebu}, {25, 0x1ffffeeu}, {25, 0x1ffffefu}, {24, 0xfffff4u}, {24, 0xfffff5u}, + {26, 0x3ffffeau}, {23, 0x7ffff4u}, {26, 0x3ffffebu}, {27, 0x7ffffe6u}, {26, 0x3ffffecu}, {26, 0x3ffffedu}, {27, 0x7ffffe7u}, + {27, 0x7ffffe8u}, {27, 0x7ffffe9u}, {27, 0x7ffffeau}, {27, 0x7ffffebu}, {28, 0xffffffeu}, {27, 0x7ffffecu}, {27, 0x7ffffedu}, + {27, 0x7ffffeeu}, {27, 0x7ffffefu}, {27, 0x7fffff0u}, {26, 0x3ffffeeu}, {30, 0x3fffffffu}}; + +typedef enum { + NGHTTP2_HUFF_ACCEPTED = 1, + NGHTTP2_HUFF_SYM = 2, + NGHTTP2_HUFF_FAIL = 4, + NGHTTP2_HUFF_INVALID_FOR_HEADER_NAME = 8, + NGHTTP2_HUFF_INVALID_FOR_HEADER_VALUE = 16, + NGHTTP2_HUFF_UPPER_CASE_CHAR = 32, +#define NGHTTP2_HUFF_INVALID_CHARS (NGHTTP2_HUFF_INVALID_FOR_HEADER_NAME | NGHTTP2_HUFF_INVALID_FOR_HEADER_VALUE) +} nghttp2_huff_decode_flag; + +typedef struct { + uint8_t state; + uint8_t flags; + uint8_t sym; +} nghttp2_huff_decode; + +static const nghttp2_huff_decode huff_decode_table[][16] = { + /* 0 */ + { + {4, 0x00, 0}, + {5, 0x00, 0}, + {7, 0x00, 0}, + {8, 0x00, 0}, + {11, 0x00, 0}, + {12, 0x00, 0}, + {16, 0x00, 0}, + {19, 0x00, 0}, + {25, 0x00, 0}, + {28, 0x00, 0}, + {32, 0x00, 0}, + {35, 0x00, 0}, + {42, 0x00, 0}, + {49, 0x00, 0}, + {57, 0x00, 0}, + {64, 0x01, 0}, + }, + /* 1 */ + { + {0, 0x03, 48}, + {0, 0x03, 49}, + {0, 0x03, 50}, + {0, 0x03, 97}, + {0, 0x03, 99}, + {0, 0x03, 101}, + {0, 0x03, 105}, + {0, 0x03, 111}, + {0, 0x03, 115}, + {0, 0x03, 116}, + {13, 0x00, 0}, + {14, 0x00, 0}, + {17, 0x00, 0}, + {18, 0x00, 0}, + {20, 0x00, 0}, + {21, 0x00, 0}, + }, + /* 2 */ + { + {1, 0x02, 48}, + {22, 0x03, 48}, + {1, 0x02, 49}, + {22, 0x03, 49}, + {1, 0x02, 50}, + {22, 0x03, 50}, + {1, 0x02, 97}, + {22, 0x03, 97}, + {1, 0x02, 99}, + {22, 0x03, 99}, + {1, 0x02, 101}, + {22, 0x03, 101}, + {1, 0x02, 105}, + {22, 0x03, 105}, + {1, 0x02, 111}, + {22, 0x03, 111}, + }, + /* 3 */ + { + {2, 0x02, 48}, + {9, 0x02, 48}, + {23, 0x02, 48}, + {40, 0x03, 48}, + {2, 0x02, 49}, + {9, 0x02, 49}, + {23, 0x02, 49}, + {40, 0x03, 49}, + {2, 0x02, 50}, + {9, 0x02, 50}, + {23, 0x02, 50}, + {40, 0x03, 50}, + {2, 0x02, 97}, + {9, 0x02, 97}, + {23, 0x02, 97}, + {40, 0x03, 97}, + }, + /* 4 */ + { + {3, 0x02, 48}, + {6, 0x02, 48}, + {10, 0x02, 48}, + {15, 0x02, 48}, + {24, 0x02, 48}, + {31, 0x02, 48}, + {41, 0x02, 48}, + {56, 0x03, 48}, + {3, 0x02, 49}, + {6, 0x02, 49}, + {10, 0x02, 49}, + {15, 0x02, 49}, + {24, 0x02, 49}, + {31, 0x02, 49}, + {41, 0x02, 49}, + {56, 0x03, 49}, + }, + /* 5 */ + { + {3, 0x02, 50}, + {6, 0x02, 50}, + {10, 0x02, 50}, + {15, 0x02, 50}, + {24, 0x02, 50}, + {31, 0x02, 50}, + {41, 0x02, 50}, + {56, 0x03, 50}, + {3, 0x02, 97}, + {6, 0x02, 97}, + {10, 0x02, 97}, + {15, 0x02, 97}, + {24, 0x02, 97}, + {31, 0x02, 97}, + {41, 0x02, 97}, + {56, 0x03, 97}, + }, + /* 6 */ + { + {2, 0x02, 99}, + {9, 0x02, 99}, + {23, 0x02, 99}, + {40, 0x03, 99}, + {2, 0x02, 101}, + {9, 0x02, 101}, + {23, 0x02, 101}, + {40, 0x03, 101}, + {2, 0x02, 105}, + {9, 0x02, 105}, + {23, 0x02, 105}, + {40, 0x03, 105}, + {2, 0x02, 111}, + {9, 0x02, 111}, + {23, 0x02, 111}, + {40, 0x03, 111}, + }, + /* 7 */ + { + {3, 0x02, 99}, + {6, 0x02, 99}, + {10, 0x02, 99}, + {15, 0x02, 99}, + {24, 0x02, 99}, + {31, 0x02, 99}, + {41, 0x02, 99}, + {56, 0x03, 99}, + {3, 0x02, 101}, + {6, 0x02, 101}, + {10, 0x02, 101}, + {15, 0x02, 101}, + {24, 0x02, 101}, + {31, 0x02, 101}, + {41, 0x02, 101}, + {56, 0x03, 101}, + }, + /* 8 */ + { + {3, 0x02, 105}, + {6, 0x02, 105}, + {10, 0x02, 105}, + {15, 0x02, 105}, + {24, 0x02, 105}, + {31, 0x02, 105}, + {41, 0x02, 105}, + {56, 0x03, 105}, + {3, 0x02, 111}, + {6, 0x02, 111}, + {10, 0x02, 111}, + {15, 0x02, 111}, + {24, 0x02, 111}, + {31, 0x02, 111}, + {41, 0x02, 111}, + {56, 0x03, 111}, + }, + /* 9 */ + { + {1, 0x02, 115}, + {22, 0x03, 115}, + {1, 0x02, 116}, + {22, 0x03, 116}, + {0, 0x0b, 32}, + {0, 0x03, 37}, + {0, 0x03, 45}, + {0, 0x03, 46}, + {0, 0x0b, 47}, + {0, 0x03, 51}, + {0, 0x03, 52}, + {0, 0x03, 53}, + {0, 0x03, 54}, + {0, 0x03, 55}, + {0, 0x03, 56}, + {0, 0x03, 57}, + }, + /* 10 */ + { + {2, 0x02, 115}, + {9, 0x02, 115}, + {23, 0x02, 115}, + {40, 0x03, 115}, + {2, 0x02, 116}, + {9, 0x02, 116}, + {23, 0x02, 116}, + {40, 0x03, 116}, + {1, 0x0a, 32}, + {22, 0x0b, 32}, + {1, 0x02, 37}, + {22, 0x03, 37}, + {1, 0x02, 45}, + {22, 0x03, 45}, + {1, 0x02, 46}, + {22, 0x03, 46}, + }, + /* 11 */ + { + {3, 0x02, 115}, + {6, 0x02, 115}, + {10, 0x02, 115}, + {15, 0x02, 115}, + {24, 0x02, 115}, + {31, 0x02, 115}, + {41, 0x02, 115}, + {56, 0x03, 115}, + {3, 0x02, 116}, + {6, 0x02, 116}, + {10, 0x02, 116}, + {15, 0x02, 116}, + {24, 0x02, 116}, + {31, 0x02, 116}, + {41, 0x02, 116}, + {56, 0x03, 116}, + }, + /* 12 */ + { + {2, 0x0a, 32}, + {9, 0x0a, 32}, + {23, 0x0a, 32}, + {40, 0x0b, 32}, + {2, 0x02, 37}, + {9, 0x02, 37}, + {23, 0x02, 37}, + {40, 0x03, 37}, + {2, 0x02, 45}, + {9, 0x02, 45}, + {23, 0x02, 45}, + {40, 0x03, 45}, + {2, 0x02, 46}, + {9, 0x02, 46}, + {23, 0x02, 46}, + {40, 0x03, 46}, + }, + /* 13 */ + { + {3, 0x0a, 32}, + {6, 0x0a, 32}, + {10, 0x0a, 32}, + {15, 0x0a, 32}, + {24, 0x0a, 32}, + {31, 0x0a, 32}, + {41, 0x0a, 32}, + {56, 0x0b, 32}, + {3, 0x02, 37}, + {6, 0x02, 37}, + {10, 0x02, 37}, + {15, 0x02, 37}, + {24, 0x02, 37}, + {31, 0x02, 37}, + {41, 0x02, 37}, + {56, 0x03, 37}, + }, + /* 14 */ + { + {3, 0x02, 45}, + {6, 0x02, 45}, + {10, 0x02, 45}, + {15, 0x02, 45}, + {24, 0x02, 45}, + {31, 0x02, 45}, + {41, 0x02, 45}, + {56, 0x03, 45}, + {3, 0x02, 46}, + {6, 0x02, 46}, + {10, 0x02, 46}, + {15, 0x02, 46}, + {24, 0x02, 46}, + {31, 0x02, 46}, + {41, 0x02, 46}, + {56, 0x03, 46}, + }, + /* 15 */ + { + {1, 0x0a, 47}, + {22, 0x0b, 47}, + {1, 0x02, 51}, + {22, 0x03, 51}, + {1, 0x02, 52}, + {22, 0x03, 52}, + {1, 0x02, 53}, + {22, 0x03, 53}, + {1, 0x02, 54}, + {22, 0x03, 54}, + {1, 0x02, 55}, + {22, 0x03, 55}, + {1, 0x02, 56}, + {22, 0x03, 56}, + {1, 0x02, 57}, + {22, 0x03, 57}, + }, + /* 16 */ + { + {2, 0x0a, 47}, + {9, 0x0a, 47}, + {23, 0x0a, 47}, + {40, 0x0b, 47}, + {2, 0x02, 51}, + {9, 0x02, 51}, + {23, 0x02, 51}, + {40, 0x03, 51}, + {2, 0x02, 52}, + {9, 0x02, 52}, + {23, 0x02, 52}, + {40, 0x03, 52}, + {2, 0x02, 53}, + {9, 0x02, 53}, + {23, 0x02, 53}, + {40, 0x03, 53}, + }, + /* 17 */ + { + {3, 0x0a, 47}, + {6, 0x0a, 47}, + {10, 0x0a, 47}, + {15, 0x0a, 47}, + {24, 0x0a, 47}, + {31, 0x0a, 47}, + {41, 0x0a, 47}, + {56, 0x0b, 47}, + {3, 0x02, 51}, + {6, 0x02, 51}, + {10, 0x02, 51}, + {15, 0x02, 51}, + {24, 0x02, 51}, + {31, 0x02, 51}, + {41, 0x02, 51}, + {56, 0x03, 51}, + }, + /* 18 */ + { + {3, 0x02, 52}, + {6, 0x02, 52}, + {10, 0x02, 52}, + {15, 0x02, 52}, + {24, 0x02, 52}, + {31, 0x02, 52}, + {41, 0x02, 52}, + {56, 0x03, 52}, + {3, 0x02, 53}, + {6, 0x02, 53}, + {10, 0x02, 53}, + {15, 0x02, 53}, + {24, 0x02, 53}, + {31, 0x02, 53}, + {41, 0x02, 53}, + {56, 0x03, 53}, + }, + /* 19 */ + { + {2, 0x02, 54}, + {9, 0x02, 54}, + {23, 0x02, 54}, + {40, 0x03, 54}, + {2, 0x02, 55}, + {9, 0x02, 55}, + {23, 0x02, 55}, + {40, 0x03, 55}, + {2, 0x02, 56}, + {9, 0x02, 56}, + {23, 0x02, 56}, + {40, 0x03, 56}, + {2, 0x02, 57}, + {9, 0x02, 57}, + {23, 0x02, 57}, + {40, 0x03, 57}, + }, + /* 20 */ + { + {3, 0x02, 54}, + {6, 0x02, 54}, + {10, 0x02, 54}, + {15, 0x02, 54}, + {24, 0x02, 54}, + {31, 0x02, 54}, + {41, 0x02, 54}, + {56, 0x03, 54}, + {3, 0x02, 55}, + {6, 0x02, 55}, + {10, 0x02, 55}, + {15, 0x02, 55}, + {24, 0x02, 55}, + {31, 0x02, 55}, + {41, 0x02, 55}, + {56, 0x03, 55}, + }, + /* 21 */ + { + {3, 0x02, 56}, + {6, 0x02, 56}, + {10, 0x02, 56}, + {15, 0x02, 56}, + {24, 0x02, 56}, + {31, 0x02, 56}, + {41, 0x02, 56}, + {56, 0x03, 56}, + {3, 0x02, 57}, + {6, 0x02, 57}, + {10, 0x02, 57}, + {15, 0x02, 57}, + {24, 0x02, 57}, + {31, 0x02, 57}, + {41, 0x02, 57}, + {56, 0x03, 57}, + }, + /* 22 */ + { + {26, 0x00, 0}, + {27, 0x00, 0}, + {29, 0x00, 0}, + {30, 0x00, 0}, + {33, 0x00, 0}, + {34, 0x00, 0}, + {36, 0x00, 0}, + {37, 0x00, 0}, + {43, 0x00, 0}, + {46, 0x00, 0}, + {50, 0x00, 0}, + {53, 0x00, 0}, + {58, 0x00, 0}, + {61, 0x00, 0}, + {65, 0x00, 0}, + {68, 0x01, 0}, + }, + /* 23 */ + { + {0, 0x0b, 61}, + {0, 0x2b, 65}, + {0, 0x03, 95}, + {0, 0x03, 98}, + {0, 0x03, 100}, + {0, 0x03, 102}, + {0, 0x03, 103}, + {0, 0x03, 104}, + {0, 0x03, 108}, + {0, 0x03, 109}, + {0, 0x03, 110}, + {0, 0x03, 112}, + {0, 0x03, 114}, + {0, 0x03, 117}, + {38, 0x00, 0}, + {39, 0x00, 0}, + }, + /* 24 */ + { + {1, 0x0a, 61}, + {22, 0x0b, 61}, + {1, 0x2a, 65}, + {22, 0x2b, 65}, + {1, 0x02, 95}, + {22, 0x03, 95}, + {1, 0x02, 98}, + {22, 0x03, 98}, + {1, 0x02, 100}, + {22, 0x03, 100}, + {1, 0x02, 102}, + {22, 0x03, 102}, + {1, 0x02, 103}, + {22, 0x03, 103}, + {1, 0x02, 104}, + {22, 0x03, 104}, + }, + /* 25 */ + { + {2, 0x0a, 61}, + {9, 0x0a, 61}, + {23, 0x0a, 61}, + {40, 0x0b, 61}, + {2, 0x2a, 65}, + {9, 0x2a, 65}, + {23, 0x2a, 65}, + {40, 0x2b, 65}, + {2, 0x02, 95}, + {9, 0x02, 95}, + {23, 0x02, 95}, + {40, 0x03, 95}, + {2, 0x02, 98}, + {9, 0x02, 98}, + {23, 0x02, 98}, + {40, 0x03, 98}, + }, + /* 26 */ + { + {3, 0x0a, 61}, + {6, 0x0a, 61}, + {10, 0x0a, 61}, + {15, 0x0a, 61}, + {24, 0x0a, 61}, + {31, 0x0a, 61}, + {41, 0x0a, 61}, + {56, 0x0b, 61}, + {3, 0x2a, 65}, + {6, 0x2a, 65}, + {10, 0x2a, 65}, + {15, 0x2a, 65}, + {24, 0x2a, 65}, + {31, 0x2a, 65}, + {41, 0x2a, 65}, + {56, 0x2b, 65}, + }, + /* 27 */ + { + {3, 0x02, 95}, + {6, 0x02, 95}, + {10, 0x02, 95}, + {15, 0x02, 95}, + {24, 0x02, 95}, + {31, 0x02, 95}, + {41, 0x02, 95}, + {56, 0x03, 95}, + {3, 0x02, 98}, + {6, 0x02, 98}, + {10, 0x02, 98}, + {15, 0x02, 98}, + {24, 0x02, 98}, + {31, 0x02, 98}, + {41, 0x02, 98}, + {56, 0x03, 98}, + }, + /* 28 */ + { + {2, 0x02, 100}, + {9, 0x02, 100}, + {23, 0x02, 100}, + {40, 0x03, 100}, + {2, 0x02, 102}, + {9, 0x02, 102}, + {23, 0x02, 102}, + {40, 0x03, 102}, + {2, 0x02, 103}, + {9, 0x02, 103}, + {23, 0x02, 103}, + {40, 0x03, 103}, + {2, 0x02, 104}, + {9, 0x02, 104}, + {23, 0x02, 104}, + {40, 0x03, 104}, + }, + /* 29 */ + { + {3, 0x02, 100}, + {6, 0x02, 100}, + {10, 0x02, 100}, + {15, 0x02, 100}, + {24, 0x02, 100}, + {31, 0x02, 100}, + {41, 0x02, 100}, + {56, 0x03, 100}, + {3, 0x02, 102}, + {6, 0x02, 102}, + {10, 0x02, 102}, + {15, 0x02, 102}, + {24, 0x02, 102}, + {31, 0x02, 102}, + {41, 0x02, 102}, + {56, 0x03, 102}, + }, + /* 30 */ + { + {3, 0x02, 103}, + {6, 0x02, 103}, + {10, 0x02, 103}, + {15, 0x02, 103}, + {24, 0x02, 103}, + {31, 0x02, 103}, + {41, 0x02, 103}, + {56, 0x03, 103}, + {3, 0x02, 104}, + {6, 0x02, 104}, + {10, 0x02, 104}, + {15, 0x02, 104}, + {24, 0x02, 104}, + {31, 0x02, 104}, + {41, 0x02, 104}, + {56, 0x03, 104}, + }, + /* 31 */ + { + {1, 0x02, 108}, + {22, 0x03, 108}, + {1, 0x02, 109}, + {22, 0x03, 109}, + {1, 0x02, 110}, + {22, 0x03, 110}, + {1, 0x02, 112}, + {22, 0x03, 112}, + {1, 0x02, 114}, + {22, 0x03, 114}, + {1, 0x02, 117}, + {22, 0x03, 117}, + {0, 0x0b, 58}, + {0, 0x2b, 66}, + {0, 0x2b, 67}, + {0, 0x2b, 68}, + }, + /* 32 */ + { + {2, 0x02, 108}, + {9, 0x02, 108}, + {23, 0x02, 108}, + {40, 0x03, 108}, + {2, 0x02, 109}, + {9, 0x02, 109}, + {23, 0x02, 109}, + {40, 0x03, 109}, + {2, 0x02, 110}, + {9, 0x02, 110}, + {23, 0x02, 110}, + {40, 0x03, 110}, + {2, 0x02, 112}, + {9, 0x02, 112}, + {23, 0x02, 112}, + {40, 0x03, 112}, + }, + /* 33 */ + { + {3, 0x02, 108}, + {6, 0x02, 108}, + {10, 0x02, 108}, + {15, 0x02, 108}, + {24, 0x02, 108}, + {31, 0x02, 108}, + {41, 0x02, 108}, + {56, 0x03, 108}, + {3, 0x02, 109}, + {6, 0x02, 109}, + {10, 0x02, 109}, + {15, 0x02, 109}, + {24, 0x02, 109}, + {31, 0x02, 109}, + {41, 0x02, 109}, + {56, 0x03, 109}, + }, + /* 34 */ + { + {3, 0x02, 110}, + {6, 0x02, 110}, + {10, 0x02, 110}, + {15, 0x02, 110}, + {24, 0x02, 110}, + {31, 0x02, 110}, + {41, 0x02, 110}, + {56, 0x03, 110}, + {3, 0x02, 112}, + {6, 0x02, 112}, + {10, 0x02, 112}, + {15, 0x02, 112}, + {24, 0x02, 112}, + {31, 0x02, 112}, + {41, 0x02, 112}, + {56, 0x03, 112}, + }, + /* 35 */ + { + {2, 0x02, 114}, + {9, 0x02, 114}, + {23, 0x02, 114}, + {40, 0x03, 114}, + {2, 0x02, 117}, + {9, 0x02, 117}, + {23, 0x02, 117}, + {40, 0x03, 117}, + {1, 0x0a, 58}, + {22, 0x0b, 58}, + {1, 0x2a, 66}, + {22, 0x2b, 66}, + {1, 0x2a, 67}, + {22, 0x2b, 67}, + {1, 0x2a, 68}, + {22, 0x2b, 68}, + }, + /* 36 */ + { + {3, 0x02, 114}, + {6, 0x02, 114}, + {10, 0x02, 114}, + {15, 0x02, 114}, + {24, 0x02, 114}, + {31, 0x02, 114}, + {41, 0x02, 114}, + {56, 0x03, 114}, + {3, 0x02, 117}, + {6, 0x02, 117}, + {10, 0x02, 117}, + {15, 0x02, 117}, + {24, 0x02, 117}, + {31, 0x02, 117}, + {41, 0x02, 117}, + {56, 0x03, 117}, + }, + /* 37 */ + { + {2, 0x0a, 58}, + {9, 0x0a, 58}, + {23, 0x0a, 58}, + {40, 0x0b, 58}, + {2, 0x2a, 66}, + {9, 0x2a, 66}, + {23, 0x2a, 66}, + {40, 0x2b, 66}, + {2, 0x2a, 67}, + {9, 0x2a, 67}, + {23, 0x2a, 67}, + {40, 0x2b, 67}, + {2, 0x2a, 68}, + {9, 0x2a, 68}, + {23, 0x2a, 68}, + {40, 0x2b, 68}, + }, + /* 38 */ + { + {3, 0x0a, 58}, + {6, 0x0a, 58}, + {10, 0x0a, 58}, + {15, 0x0a, 58}, + {24, 0x0a, 58}, + {31, 0x0a, 58}, + {41, 0x0a, 58}, + {56, 0x0b, 58}, + {3, 0x2a, 66}, + {6, 0x2a, 66}, + {10, 0x2a, 66}, + {15, 0x2a, 66}, + {24, 0x2a, 66}, + {31, 0x2a, 66}, + {41, 0x2a, 66}, + {56, 0x2b, 66}, + }, + /* 39 */ + { + {3, 0x2a, 67}, + {6, 0x2a, 67}, + {10, 0x2a, 67}, + {15, 0x2a, 67}, + {24, 0x2a, 67}, + {31, 0x2a, 67}, + {41, 0x2a, 67}, + {56, 0x2b, 67}, + {3, 0x2a, 68}, + {6, 0x2a, 68}, + {10, 0x2a, 68}, + {15, 0x2a, 68}, + {24, 0x2a, 68}, + {31, 0x2a, 68}, + {41, 0x2a, 68}, + {56, 0x2b, 68}, + }, + /* 40 */ + { + {44, 0x00, 0}, + {45, 0x00, 0}, + {47, 0x00, 0}, + {48, 0x00, 0}, + {51, 0x00, 0}, + {52, 0x00, 0}, + {54, 0x00, 0}, + {55, 0x00, 0}, + {59, 0x00, 0}, + {60, 0x00, 0}, + {62, 0x00, 0}, + {63, 0x00, 0}, + {66, 0x00, 0}, + {67, 0x00, 0}, + {69, 0x00, 0}, + {72, 0x01, 0}, + }, + /* 41 */ + { + {0, 0x2b, 69}, + {0, 0x2b, 70}, + {0, 0x2b, 71}, + {0, 0x2b, 72}, + {0, 0x2b, 73}, + {0, 0x2b, 74}, + {0, 0x2b, 75}, + {0, 0x2b, 76}, + {0, 0x2b, 77}, + {0, 0x2b, 78}, + {0, 0x2b, 79}, + {0, 0x2b, 80}, + {0, 0x2b, 81}, + {0, 0x2b, 82}, + {0, 0x2b, 83}, + {0, 0x2b, 84}, + }, + /* 42 */ + { + {1, 0x2a, 69}, + {22, 0x2b, 69}, + {1, 0x2a, 70}, + {22, 0x2b, 70}, + {1, 0x2a, 71}, + {22, 0x2b, 71}, + {1, 0x2a, 72}, + {22, 0x2b, 72}, + {1, 0x2a, 73}, + {22, 0x2b, 73}, + {1, 0x2a, 74}, + {22, 0x2b, 74}, + {1, 0x2a, 75}, + {22, 0x2b, 75}, + {1, 0x2a, 76}, + {22, 0x2b, 76}, + }, + /* 43 */ + { + {2, 0x2a, 69}, + {9, 0x2a, 69}, + {23, 0x2a, 69}, + {40, 0x2b, 69}, + {2, 0x2a, 70}, + {9, 0x2a, 70}, + {23, 0x2a, 70}, + {40, 0x2b, 70}, + {2, 0x2a, 71}, + {9, 0x2a, 71}, + {23, 0x2a, 71}, + {40, 0x2b, 71}, + {2, 0x2a, 72}, + {9, 0x2a, 72}, + {23, 0x2a, 72}, + {40, 0x2b, 72}, + }, + /* 44 */ + { + {3, 0x2a, 69}, + {6, 0x2a, 69}, + {10, 0x2a, 69}, + {15, 0x2a, 69}, + {24, 0x2a, 69}, + {31, 0x2a, 69}, + {41, 0x2a, 69}, + {56, 0x2b, 69}, + {3, 0x2a, 70}, + {6, 0x2a, 70}, + {10, 0x2a, 70}, + {15, 0x2a, 70}, + {24, 0x2a, 70}, + {31, 0x2a, 70}, + {41, 0x2a, 70}, + {56, 0x2b, 70}, + }, + /* 45 */ + { + {3, 0x2a, 71}, + {6, 0x2a, 71}, + {10, 0x2a, 71}, + {15, 0x2a, 71}, + {24, 0x2a, 71}, + {31, 0x2a, 71}, + {41, 0x2a, 71}, + {56, 0x2b, 71}, + {3, 0x2a, 72}, + {6, 0x2a, 72}, + {10, 0x2a, 72}, + {15, 0x2a, 72}, + {24, 0x2a, 72}, + {31, 0x2a, 72}, + {41, 0x2a, 72}, + {56, 0x2b, 72}, + }, + /* 46 */ + { + {2, 0x2a, 73}, + {9, 0x2a, 73}, + {23, 0x2a, 73}, + {40, 0x2b, 73}, + {2, 0x2a, 74}, + {9, 0x2a, 74}, + {23, 0x2a, 74}, + {40, 0x2b, 74}, + {2, 0x2a, 75}, + {9, 0x2a, 75}, + {23, 0x2a, 75}, + {40, 0x2b, 75}, + {2, 0x2a, 76}, + {9, 0x2a, 76}, + {23, 0x2a, 76}, + {40, 0x2b, 76}, + }, + /* 47 */ + { + {3, 0x2a, 73}, + {6, 0x2a, 73}, + {10, 0x2a, 73}, + {15, 0x2a, 73}, + {24, 0x2a, 73}, + {31, 0x2a, 73}, + {41, 0x2a, 73}, + {56, 0x2b, 73}, + {3, 0x2a, 74}, + {6, 0x2a, 74}, + {10, 0x2a, 74}, + {15, 0x2a, 74}, + {24, 0x2a, 74}, + {31, 0x2a, 74}, + {41, 0x2a, 74}, + {56, 0x2b, 74}, + }, + /* 48 */ + { + {3, 0x2a, 75}, + {6, 0x2a, 75}, + {10, 0x2a, 75}, + {15, 0x2a, 75}, + {24, 0x2a, 75}, + {31, 0x2a, 75}, + {41, 0x2a, 75}, + {56, 0x2b, 75}, + {3, 0x2a, 76}, + {6, 0x2a, 76}, + {10, 0x2a, 76}, + {15, 0x2a, 76}, + {24, 0x2a, 76}, + {31, 0x2a, 76}, + {41, 0x2a, 76}, + {56, 0x2b, 76}, + }, + /* 49 */ + { + {1, 0x2a, 77}, + {22, 0x2b, 77}, + {1, 0x2a, 78}, + {22, 0x2b, 78}, + {1, 0x2a, 79}, + {22, 0x2b, 79}, + {1, 0x2a, 80}, + {22, 0x2b, 80}, + {1, 0x2a, 81}, + {22, 0x2b, 81}, + {1, 0x2a, 82}, + {22, 0x2b, 82}, + {1, 0x2a, 83}, + {22, 0x2b, 83}, + {1, 0x2a, 84}, + {22, 0x2b, 84}, + }, + /* 50 */ + { + {2, 0x2a, 77}, + {9, 0x2a, 77}, + {23, 0x2a, 77}, + {40, 0x2b, 77}, + {2, 0x2a, 78}, + {9, 0x2a, 78}, + {23, 0x2a, 78}, + {40, 0x2b, 78}, + {2, 0x2a, 79}, + {9, 0x2a, 79}, + {23, 0x2a, 79}, + {40, 0x2b, 79}, + {2, 0x2a, 80}, + {9, 0x2a, 80}, + {23, 0x2a, 80}, + {40, 0x2b, 80}, + }, + /* 51 */ + { + {3, 0x2a, 77}, + {6, 0x2a, 77}, + {10, 0x2a, 77}, + {15, 0x2a, 77}, + {24, 0x2a, 77}, + {31, 0x2a, 77}, + {41, 0x2a, 77}, + {56, 0x2b, 77}, + {3, 0x2a, 78}, + {6, 0x2a, 78}, + {10, 0x2a, 78}, + {15, 0x2a, 78}, + {24, 0x2a, 78}, + {31, 0x2a, 78}, + {41, 0x2a, 78}, + {56, 0x2b, 78}, + }, + /* 52 */ + { + {3, 0x2a, 79}, + {6, 0x2a, 79}, + {10, 0x2a, 79}, + {15, 0x2a, 79}, + {24, 0x2a, 79}, + {31, 0x2a, 79}, + {41, 0x2a, 79}, + {56, 0x2b, 79}, + {3, 0x2a, 80}, + {6, 0x2a, 80}, + {10, 0x2a, 80}, + {15, 0x2a, 80}, + {24, 0x2a, 80}, + {31, 0x2a, 80}, + {41, 0x2a, 80}, + {56, 0x2b, 80}, + }, + /* 53 */ + { + {2, 0x2a, 81}, + {9, 0x2a, 81}, + {23, 0x2a, 81}, + {40, 0x2b, 81}, + {2, 0x2a, 82}, + {9, 0x2a, 82}, + {23, 0x2a, 82}, + {40, 0x2b, 82}, + {2, 0x2a, 83}, + {9, 0x2a, 83}, + {23, 0x2a, 83}, + {40, 0x2b, 83}, + {2, 0x2a, 84}, + {9, 0x2a, 84}, + {23, 0x2a, 84}, + {40, 0x2b, 84}, + }, + /* 54 */ + { + {3, 0x2a, 81}, + {6, 0x2a, 81}, + {10, 0x2a, 81}, + {15, 0x2a, 81}, + {24, 0x2a, 81}, + {31, 0x2a, 81}, + {41, 0x2a, 81}, + {56, 0x2b, 81}, + {3, 0x2a, 82}, + {6, 0x2a, 82}, + {10, 0x2a, 82}, + {15, 0x2a, 82}, + {24, 0x2a, 82}, + {31, 0x2a, 82}, + {41, 0x2a, 82}, + {56, 0x2b, 82}, + }, + /* 55 */ + { + {3, 0x2a, 83}, + {6, 0x2a, 83}, + {10, 0x2a, 83}, + {15, 0x2a, 83}, + {24, 0x2a, 83}, + {31, 0x2a, 83}, + {41, 0x2a, 83}, + {56, 0x2b, 83}, + {3, 0x2a, 84}, + {6, 0x2a, 84}, + {10, 0x2a, 84}, + {15, 0x2a, 84}, + {24, 0x2a, 84}, + {31, 0x2a, 84}, + {41, 0x2a, 84}, + {56, 0x2b, 84}, + }, + /* 56 */ + { + {0, 0x2b, 85}, + {0, 0x2b, 86}, + {0, 0x2b, 87}, + {0, 0x2b, 89}, + {0, 0x03, 106}, + {0, 0x03, 107}, + {0, 0x03, 113}, + {0, 0x03, 118}, + {0, 0x03, 119}, + {0, 0x03, 120}, + {0, 0x03, 121}, + {0, 0x03, 122}, + {70, 0x00, 0}, + {71, 0x00, 0}, + {73, 0x00, 0}, + {74, 0x01, 0}, + }, + /* 57 */ + { + {1, 0x2a, 85}, + {22, 0x2b, 85}, + {1, 0x2a, 86}, + {22, 0x2b, 86}, + {1, 0x2a, 87}, + {22, 0x2b, 87}, + {1, 0x2a, 89}, + {22, 0x2b, 89}, + {1, 0x02, 106}, + {22, 0x03, 106}, + {1, 0x02, 107}, + {22, 0x03, 107}, + {1, 0x02, 113}, + {22, 0x03, 113}, + {1, 0x02, 118}, + {22, 0x03, 118}, + }, + /* 58 */ + { + {2, 0x2a, 85}, + {9, 0x2a, 85}, + {23, 0x2a, 85}, + {40, 0x2b, 85}, + {2, 0x2a, 86}, + {9, 0x2a, 86}, + {23, 0x2a, 86}, + {40, 0x2b, 86}, + {2, 0x2a, 87}, + {9, 0x2a, 87}, + {23, 0x2a, 87}, + {40, 0x2b, 87}, + {2, 0x2a, 89}, + {9, 0x2a, 89}, + {23, 0x2a, 89}, + {40, 0x2b, 89}, + }, + /* 59 */ + { + {3, 0x2a, 85}, + {6, 0x2a, 85}, + {10, 0x2a, 85}, + {15, 0x2a, 85}, + {24, 0x2a, 85}, + {31, 0x2a, 85}, + {41, 0x2a, 85}, + {56, 0x2b, 85}, + {3, 0x2a, 86}, + {6, 0x2a, 86}, + {10, 0x2a, 86}, + {15, 0x2a, 86}, + {24, 0x2a, 86}, + {31, 0x2a, 86}, + {41, 0x2a, 86}, + {56, 0x2b, 86}, + }, + /* 60 */ + { + {3, 0x2a, 87}, + {6, 0x2a, 87}, + {10, 0x2a, 87}, + {15, 0x2a, 87}, + {24, 0x2a, 87}, + {31, 0x2a, 87}, + {41, 0x2a, 87}, + {56, 0x2b, 87}, + {3, 0x2a, 89}, + {6, 0x2a, 89}, + {10, 0x2a, 89}, + {15, 0x2a, 89}, + {24, 0x2a, 89}, + {31, 0x2a, 89}, + {41, 0x2a, 89}, + {56, 0x2b, 89}, + }, + /* 61 */ + { + {2, 0x02, 106}, + {9, 0x02, 106}, + {23, 0x02, 106}, + {40, 0x03, 106}, + {2, 0x02, 107}, + {9, 0x02, 107}, + {23, 0x02, 107}, + {40, 0x03, 107}, + {2, 0x02, 113}, + {9, 0x02, 113}, + {23, 0x02, 113}, + {40, 0x03, 113}, + {2, 0x02, 118}, + {9, 0x02, 118}, + {23, 0x02, 118}, + {40, 0x03, 118}, + }, + /* 62 */ + { + {3, 0x02, 106}, + {6, 0x02, 106}, + {10, 0x02, 106}, + {15, 0x02, 106}, + {24, 0x02, 106}, + {31, 0x02, 106}, + {41, 0x02, 106}, + {56, 0x03, 106}, + {3, 0x02, 107}, + {6, 0x02, 107}, + {10, 0x02, 107}, + {15, 0x02, 107}, + {24, 0x02, 107}, + {31, 0x02, 107}, + {41, 0x02, 107}, + {56, 0x03, 107}, + }, + /* 63 */ + { + {3, 0x02, 113}, + {6, 0x02, 113}, + {10, 0x02, 113}, + {15, 0x02, 113}, + {24, 0x02, 113}, + {31, 0x02, 113}, + {41, 0x02, 113}, + {56, 0x03, 113}, + {3, 0x02, 118}, + {6, 0x02, 118}, + {10, 0x02, 118}, + {15, 0x02, 118}, + {24, 0x02, 118}, + {31, 0x02, 118}, + {41, 0x02, 118}, + {56, 0x03, 118}, + }, + /* 64 */ + { + {1, 0x02, 119}, + {22, 0x03, 119}, + {1, 0x02, 120}, + {22, 0x03, 120}, + {1, 0x02, 121}, + {22, 0x03, 121}, + {1, 0x02, 122}, + {22, 0x03, 122}, + {0, 0x03, 38}, + {0, 0x03, 42}, + {0, 0x0b, 44}, + {0, 0x0b, 59}, + {0, 0x2b, 88}, + {0, 0x2b, 90}, + {75, 0x00, 0}, + {78, 0x00, 0}, + }, + /* 65 */ + { + {2, 0x02, 119}, + {9, 0x02, 119}, + {23, 0x02, 119}, + {40, 0x03, 119}, + {2, 0x02, 120}, + {9, 0x02, 120}, + {23, 0x02, 120}, + {40, 0x03, 120}, + {2, 0x02, 121}, + {9, 0x02, 121}, + {23, 0x02, 121}, + {40, 0x03, 121}, + {2, 0x02, 122}, + {9, 0x02, 122}, + {23, 0x02, 122}, + {40, 0x03, 122}, + }, + /* 66 */ + { + {3, 0x02, 119}, + {6, 0x02, 119}, + {10, 0x02, 119}, + {15, 0x02, 119}, + {24, 0x02, 119}, + {31, 0x02, 119}, + {41, 0x02, 119}, + {56, 0x03, 119}, + {3, 0x02, 120}, + {6, 0x02, 120}, + {10, 0x02, 120}, + {15, 0x02, 120}, + {24, 0x02, 120}, + {31, 0x02, 120}, + {41, 0x02, 120}, + {56, 0x03, 120}, + }, + /* 67 */ + { + {3, 0x02, 121}, + {6, 0x02, 121}, + {10, 0x02, 121}, + {15, 0x02, 121}, + {24, 0x02, 121}, + {31, 0x02, 121}, + {41, 0x02, 121}, + {56, 0x03, 121}, + {3, 0x02, 122}, + {6, 0x02, 122}, + {10, 0x02, 122}, + {15, 0x02, 122}, + {24, 0x02, 122}, + {31, 0x02, 122}, + {41, 0x02, 122}, + {56, 0x03, 122}, + }, + /* 68 */ + { + {1, 0x02, 38}, + {22, 0x03, 38}, + {1, 0x02, 42}, + {22, 0x03, 42}, + {1, 0x0a, 44}, + {22, 0x0b, 44}, + {1, 0x0a, 59}, + {22, 0x0b, 59}, + {1, 0x2a, 88}, + {22, 0x2b, 88}, + {1, 0x2a, 90}, + {22, 0x2b, 90}, + {76, 0x00, 0}, + {77, 0x00, 0}, + {79, 0x00, 0}, + {81, 0x00, 0}, + }, + /* 69 */ + { + {2, 0x02, 38}, + {9, 0x02, 38}, + {23, 0x02, 38}, + {40, 0x03, 38}, + {2, 0x02, 42}, + {9, 0x02, 42}, + {23, 0x02, 42}, + {40, 0x03, 42}, + {2, 0x0a, 44}, + {9, 0x0a, 44}, + {23, 0x0a, 44}, + {40, 0x0b, 44}, + {2, 0x0a, 59}, + {9, 0x0a, 59}, + {23, 0x0a, 59}, + {40, 0x0b, 59}, + }, + /* 70 */ + { + {3, 0x02, 38}, + {6, 0x02, 38}, + {10, 0x02, 38}, + {15, 0x02, 38}, + {24, 0x02, 38}, + {31, 0x02, 38}, + {41, 0x02, 38}, + {56, 0x03, 38}, + {3, 0x02, 42}, + {6, 0x02, 42}, + {10, 0x02, 42}, + {15, 0x02, 42}, + {24, 0x02, 42}, + {31, 0x02, 42}, + {41, 0x02, 42}, + {56, 0x03, 42}, + }, + /* 71 */ + { + {3, 0x0a, 44}, + {6, 0x0a, 44}, + {10, 0x0a, 44}, + {15, 0x0a, 44}, + {24, 0x0a, 44}, + {31, 0x0a, 44}, + {41, 0x0a, 44}, + {56, 0x0b, 44}, + {3, 0x0a, 59}, + {6, 0x0a, 59}, + {10, 0x0a, 59}, + {15, 0x0a, 59}, + {24, 0x0a, 59}, + {31, 0x0a, 59}, + {41, 0x0a, 59}, + {56, 0x0b, 59}, + }, + /* 72 */ + { + {2, 0x2a, 88}, + {9, 0x2a, 88}, + {23, 0x2a, 88}, + {40, 0x2b, 88}, + {2, 0x2a, 90}, + {9, 0x2a, 90}, + {23, 0x2a, 90}, + {40, 0x2b, 90}, + {0, 0x03, 33}, + {0, 0x0b, 34}, + {0, 0x0b, 40}, + {0, 0x0b, 41}, + {0, 0x0b, 63}, + {80, 0x00, 0}, + {82, 0x00, 0}, + {84, 0x00, 0}, + }, + /* 73 */ + { + {3, 0x2a, 88}, + {6, 0x2a, 88}, + {10, 0x2a, 88}, + {15, 0x2a, 88}, + {24, 0x2a, 88}, + {31, 0x2a, 88}, + {41, 0x2a, 88}, + {56, 0x2b, 88}, + {3, 0x2a, 90}, + {6, 0x2a, 90}, + {10, 0x2a, 90}, + {15, 0x2a, 90}, + {24, 0x2a, 90}, + {31, 0x2a, 90}, + {41, 0x2a, 90}, + {56, 0x2b, 90}, + }, + /* 74 */ + { + {1, 0x02, 33}, + {22, 0x03, 33}, + {1, 0x0a, 34}, + {22, 0x0b, 34}, + {1, 0x0a, 40}, + {22, 0x0b, 40}, + {1, 0x0a, 41}, + {22, 0x0b, 41}, + {1, 0x0a, 63}, + {22, 0x0b, 63}, + {0, 0x03, 39}, + {0, 0x03, 43}, + {0, 0x03, 124}, + {83, 0x00, 0}, + {85, 0x00, 0}, + {88, 0x00, 0}, + }, + /* 75 */ + { + {2, 0x02, 33}, + {9, 0x02, 33}, + {23, 0x02, 33}, + {40, 0x03, 33}, + {2, 0x0a, 34}, + {9, 0x0a, 34}, + {23, 0x0a, 34}, + {40, 0x0b, 34}, + {2, 0x0a, 40}, + {9, 0x0a, 40}, + {23, 0x0a, 40}, + {40, 0x0b, 40}, + {2, 0x0a, 41}, + {9, 0x0a, 41}, + {23, 0x0a, 41}, + {40, 0x0b, 41}, + }, + /* 76 */ + { + {3, 0x02, 33}, + {6, 0x02, 33}, + {10, 0x02, 33}, + {15, 0x02, 33}, + {24, 0x02, 33}, + {31, 0x02, 33}, + {41, 0x02, 33}, + {56, 0x03, 33}, + {3, 0x0a, 34}, + {6, 0x0a, 34}, + {10, 0x0a, 34}, + {15, 0x0a, 34}, + {24, 0x0a, 34}, + {31, 0x0a, 34}, + {41, 0x0a, 34}, + {56, 0x0b, 34}, + }, + /* 77 */ + { + {3, 0x0a, 40}, + {6, 0x0a, 40}, + {10, 0x0a, 40}, + {15, 0x0a, 40}, + {24, 0x0a, 40}, + {31, 0x0a, 40}, + {41, 0x0a, 40}, + {56, 0x0b, 40}, + {3, 0x0a, 41}, + {6, 0x0a, 41}, + {10, 0x0a, 41}, + {15, 0x0a, 41}, + {24, 0x0a, 41}, + {31, 0x0a, 41}, + {41, 0x0a, 41}, + {56, 0x0b, 41}, + }, + /* 78 */ + { + {2, 0x0a, 63}, + {9, 0x0a, 63}, + {23, 0x0a, 63}, + {40, 0x0b, 63}, + {1, 0x02, 39}, + {22, 0x03, 39}, + {1, 0x02, 43}, + {22, 0x03, 43}, + {1, 0x02, 124}, + {22, 0x03, 124}, + {0, 0x03, 35}, + {0, 0x0b, 62}, + {86, 0x00, 0}, + {87, 0x00, 0}, + {89, 0x00, 0}, + {90, 0x00, 0}, + }, + /* 79 */ + { + {3, 0x0a, 63}, + {6, 0x0a, 63}, + {10, 0x0a, 63}, + {15, 0x0a, 63}, + {24, 0x0a, 63}, + {31, 0x0a, 63}, + {41, 0x0a, 63}, + {56, 0x0b, 63}, + {2, 0x02, 39}, + {9, 0x02, 39}, + {23, 0x02, 39}, + {40, 0x03, 39}, + {2, 0x02, 43}, + {9, 0x02, 43}, + {23, 0x02, 43}, + {40, 0x03, 43}, + }, + /* 80 */ + { + {3, 0x02, 39}, + {6, 0x02, 39}, + {10, 0x02, 39}, + {15, 0x02, 39}, + {24, 0x02, 39}, + {31, 0x02, 39}, + {41, 0x02, 39}, + {56, 0x03, 39}, + {3, 0x02, 43}, + {6, 0x02, 43}, + {10, 0x02, 43}, + {15, 0x02, 43}, + {24, 0x02, 43}, + {31, 0x02, 43}, + {41, 0x02, 43}, + {56, 0x03, 43}, + }, + /* 81 */ + { + {2, 0x02, 124}, + {9, 0x02, 124}, + {23, 0x02, 124}, + {40, 0x03, 124}, + {1, 0x02, 35}, + {22, 0x03, 35}, + {1, 0x0a, 62}, + {22, 0x0b, 62}, + {0, 0x1b, 0}, + {0, 0x03, 36}, + {0, 0x0b, 64}, + {0, 0x0b, 91}, + {0, 0x0b, 93}, + {0, 0x03, 126}, + {91, 0x00, 0}, + {92, 0x00, 0}, + }, + /* 82 */ + { + {3, 0x02, 124}, + {6, 0x02, 124}, + {10, 0x02, 124}, + {15, 0x02, 124}, + {24, 0x02, 124}, + {31, 0x02, 124}, + {41, 0x02, 124}, + {56, 0x03, 124}, + {2, 0x02, 35}, + {9, 0x02, 35}, + {23, 0x02, 35}, + {40, 0x03, 35}, + {2, 0x0a, 62}, + {9, 0x0a, 62}, + {23, 0x0a, 62}, + {40, 0x0b, 62}, + }, + /* 83 */ + { + {3, 0x02, 35}, + {6, 0x02, 35}, + {10, 0x02, 35}, + {15, 0x02, 35}, + {24, 0x02, 35}, + {31, 0x02, 35}, + {41, 0x02, 35}, + {56, 0x03, 35}, + {3, 0x0a, 62}, + {6, 0x0a, 62}, + {10, 0x0a, 62}, + {15, 0x0a, 62}, + {24, 0x0a, 62}, + {31, 0x0a, 62}, + {41, 0x0a, 62}, + {56, 0x0b, 62}, + }, + /* 84 */ + { + {1, 0x1a, 0}, + {22, 0x1b, 0}, + {1, 0x02, 36}, + {22, 0x03, 36}, + {1, 0x0a, 64}, + {22, 0x0b, 64}, + {1, 0x0a, 91}, + {22, 0x0b, 91}, + {1, 0x0a, 93}, + {22, 0x0b, 93}, + {1, 0x02, 126}, + {22, 0x03, 126}, + {0, 0x03, 94}, + {0, 0x0b, 125}, + {93, 0x00, 0}, + {94, 0x00, 0}, + }, + /* 85 */ + { + {2, 0x1a, 0}, + {9, 0x1a, 0}, + {23, 0x1a, 0}, + {40, 0x1b, 0}, + {2, 0x02, 36}, + {9, 0x02, 36}, + {23, 0x02, 36}, + {40, 0x03, 36}, + {2, 0x0a, 64}, + {9, 0x0a, 64}, + {23, 0x0a, 64}, + {40, 0x0b, 64}, + {2, 0x0a, 91}, + {9, 0x0a, 91}, + {23, 0x0a, 91}, + {40, 0x0b, 91}, + }, + /* 86 */ + { + {3, 0x1a, 0}, + {6, 0x1a, 0}, + {10, 0x1a, 0}, + {15, 0x1a, 0}, + {24, 0x1a, 0}, + {31, 0x1a, 0}, + {41, 0x1a, 0}, + {56, 0x1b, 0}, + {3, 0x02, 36}, + {6, 0x02, 36}, + {10, 0x02, 36}, + {15, 0x02, 36}, + {24, 0x02, 36}, + {31, 0x02, 36}, + {41, 0x02, 36}, + {56, 0x03, 36}, + }, + /* 87 */ + { + {3, 0x0a, 64}, + {6, 0x0a, 64}, + {10, 0x0a, 64}, + {15, 0x0a, 64}, + {24, 0x0a, 64}, + {31, 0x0a, 64}, + {41, 0x0a, 64}, + {56, 0x0b, 64}, + {3, 0x0a, 91}, + {6, 0x0a, 91}, + {10, 0x0a, 91}, + {15, 0x0a, 91}, + {24, 0x0a, 91}, + {31, 0x0a, 91}, + {41, 0x0a, 91}, + {56, 0x0b, 91}, + }, + /* 88 */ + { + {2, 0x0a, 93}, + {9, 0x0a, 93}, + {23, 0x0a, 93}, + {40, 0x0b, 93}, + {2, 0x02, 126}, + {9, 0x02, 126}, + {23, 0x02, 126}, + {40, 0x03, 126}, + {1, 0x02, 94}, + {22, 0x03, 94}, + {1, 0x0a, 125}, + {22, 0x0b, 125}, + {0, 0x0b, 60}, + {0, 0x03, 96}, + {0, 0x0b, 123}, + {95, 0x00, 0}, + }, + /* 89 */ + { + {3, 0x0a, 93}, + {6, 0x0a, 93}, + {10, 0x0a, 93}, + {15, 0x0a, 93}, + {24, 0x0a, 93}, + {31, 0x0a, 93}, + {41, 0x0a, 93}, + {56, 0x0b, 93}, + {3, 0x02, 126}, + {6, 0x02, 126}, + {10, 0x02, 126}, + {15, 0x02, 126}, + {24, 0x02, 126}, + {31, 0x02, 126}, + {41, 0x02, 126}, + {56, 0x03, 126}, + }, + /* 90 */ + { + {2, 0x02, 94}, + {9, 0x02, 94}, + {23, 0x02, 94}, + {40, 0x03, 94}, + {2, 0x0a, 125}, + {9, 0x0a, 125}, + {23, 0x0a, 125}, + {40, 0x0b, 125}, + {1, 0x0a, 60}, + {22, 0x0b, 60}, + {1, 0x02, 96}, + {22, 0x03, 96}, + {1, 0x0a, 123}, + {22, 0x0b, 123}, + {96, 0x00, 0}, + {110, 0x00, 0}, + }, + /* 91 */ + { + {3, 0x02, 94}, + {6, 0x02, 94}, + {10, 0x02, 94}, + {15, 0x02, 94}, + {24, 0x02, 94}, + {31, 0x02, 94}, + {41, 0x02, 94}, + {56, 0x03, 94}, + {3, 0x0a, 125}, + {6, 0x0a, 125}, + {10, 0x0a, 125}, + {15, 0x0a, 125}, + {24, 0x0a, 125}, + {31, 0x0a, 125}, + {41, 0x0a, 125}, + {56, 0x0b, 125}, + }, + /* 92 */ + { + {2, 0x0a, 60}, + {9, 0x0a, 60}, + {23, 0x0a, 60}, + {40, 0x0b, 60}, + {2, 0x02, 96}, + {9, 0x02, 96}, + {23, 0x02, 96}, + {40, 0x03, 96}, + {2, 0x0a, 123}, + {9, 0x0a, 123}, + {23, 0x0a, 123}, + {40, 0x0b, 123}, + {97, 0x00, 0}, + {101, 0x00, 0}, + {111, 0x00, 0}, + {133, 0x00, 0}, + }, + /* 93 */ + { + {3, 0x0a, 60}, + {6, 0x0a, 60}, + {10, 0x0a, 60}, + {15, 0x0a, 60}, + {24, 0x0a, 60}, + {31, 0x0a, 60}, + {41, 0x0a, 60}, + {56, 0x0b, 60}, + {3, 0x02, 96}, + {6, 0x02, 96}, + {10, 0x02, 96}, + {15, 0x02, 96}, + {24, 0x02, 96}, + {31, 0x02, 96}, + {41, 0x02, 96}, + {56, 0x03, 96}, + }, + /* 94 */ + { + {3, 0x0a, 123}, + {6, 0x0a, 123}, + {10, 0x0a, 123}, + {15, 0x0a, 123}, + {24, 0x0a, 123}, + {31, 0x0a, 123}, + {41, 0x0a, 123}, + {56, 0x0b, 123}, + {98, 0x00, 0}, + {99, 0x00, 0}, + {102, 0x00, 0}, + {105, 0x00, 0}, + {112, 0x00, 0}, + {119, 0x00, 0}, + {134, 0x00, 0}, + {153, 0x00, 0}, + }, + /* 95 */ + { + {0, 0x0b, 92}, + {0, 0x0b, 195}, + {0, 0x0b, 208}, + {100, 0x00, 0}, + {103, 0x00, 0}, + {104, 0x00, 0}, + {106, 0x00, 0}, + {107, 0x00, 0}, + {113, 0x00, 0}, + {116, 0x00, 0}, + {120, 0x00, 0}, + {126, 0x00, 0}, + {135, 0x00, 0}, + {142, 0x00, 0}, + {154, 0x00, 0}, + {169, 0x00, 0}, + }, + /* 96 */ + { + {1, 0x0a, 92}, + {22, 0x0b, 92}, + {1, 0x0a, 195}, + {22, 0x0b, 195}, + {1, 0x0a, 208}, + {22, 0x0b, 208}, + {0, 0x0b, 128}, + {0, 0x0b, 130}, + {0, 0x0b, 131}, + {0, 0x0b, 162}, + {0, 0x0b, 184}, + {0, 0x0b, 194}, + {0, 0x0b, 224}, + {0, 0x0b, 226}, + {108, 0x00, 0}, + {109, 0x00, 0}, + }, + /* 97 */ + { + {2, 0x0a, 92}, + {9, 0x0a, 92}, + {23, 0x0a, 92}, + {40, 0x0b, 92}, + {2, 0x0a, 195}, + {9, 0x0a, 195}, + {23, 0x0a, 195}, + {40, 0x0b, 195}, + {2, 0x0a, 208}, + {9, 0x0a, 208}, + {23, 0x0a, 208}, + {40, 0x0b, 208}, + {1, 0x0a, 128}, + {22, 0x0b, 128}, + {1, 0x0a, 130}, + {22, 0x0b, 130}, + }, + /* 98 */ + { + {3, 0x0a, 92}, + {6, 0x0a, 92}, + {10, 0x0a, 92}, + {15, 0x0a, 92}, + {24, 0x0a, 92}, + {31, 0x0a, 92}, + {41, 0x0a, 92}, + {56, 0x0b, 92}, + {3, 0x0a, 195}, + {6, 0x0a, 195}, + {10, 0x0a, 195}, + {15, 0x0a, 195}, + {24, 0x0a, 195}, + {31, 0x0a, 195}, + {41, 0x0a, 195}, + {56, 0x0b, 195}, + }, + /* 99 */ + { + {3, 0x0a, 208}, + {6, 0x0a, 208}, + {10, 0x0a, 208}, + {15, 0x0a, 208}, + {24, 0x0a, 208}, + {31, 0x0a, 208}, + {41, 0x0a, 208}, + {56, 0x0b, 208}, + {2, 0x0a, 128}, + {9, 0x0a, 128}, + {23, 0x0a, 128}, + {40, 0x0b, 128}, + {2, 0x0a, 130}, + {9, 0x0a, 130}, + {23, 0x0a, 130}, + {40, 0x0b, 130}, + }, + /* 100 */ + { + {3, 0x0a, 128}, + {6, 0x0a, 128}, + {10, 0x0a, 128}, + {15, 0x0a, 128}, + {24, 0x0a, 128}, + {31, 0x0a, 128}, + {41, 0x0a, 128}, + {56, 0x0b, 128}, + {3, 0x0a, 130}, + {6, 0x0a, 130}, + {10, 0x0a, 130}, + {15, 0x0a, 130}, + {24, 0x0a, 130}, + {31, 0x0a, 130}, + {41, 0x0a, 130}, + {56, 0x0b, 130}, + }, + /* 101 */ + { + {1, 0x0a, 131}, + {22, 0x0b, 131}, + {1, 0x0a, 162}, + {22, 0x0b, 162}, + {1, 0x0a, 184}, + {22, 0x0b, 184}, + {1, 0x0a, 194}, + {22, 0x0b, 194}, + {1, 0x0a, 224}, + {22, 0x0b, 224}, + {1, 0x0a, 226}, + {22, 0x0b, 226}, + {0, 0x0b, 153}, + {0, 0x0b, 161}, + {0, 0x0b, 167}, + {0, 0x0b, 172}, + }, + /* 102 */ + { + {2, 0x0a, 131}, + {9, 0x0a, 131}, + {23, 0x0a, 131}, + {40, 0x0b, 131}, + {2, 0x0a, 162}, + {9, 0x0a, 162}, + {23, 0x0a, 162}, + {40, 0x0b, 162}, + {2, 0x0a, 184}, + {9, 0x0a, 184}, + {23, 0x0a, 184}, + {40, 0x0b, 184}, + {2, 0x0a, 194}, + {9, 0x0a, 194}, + {23, 0x0a, 194}, + {40, 0x0b, 194}, + }, + /* 103 */ + { + {3, 0x0a, 131}, + {6, 0x0a, 131}, + {10, 0x0a, 131}, + {15, 0x0a, 131}, + {24, 0x0a, 131}, + {31, 0x0a, 131}, + {41, 0x0a, 131}, + {56, 0x0b, 131}, + {3, 0x0a, 162}, + {6, 0x0a, 162}, + {10, 0x0a, 162}, + {15, 0x0a, 162}, + {24, 0x0a, 162}, + {31, 0x0a, 162}, + {41, 0x0a, 162}, + {56, 0x0b, 162}, + }, + /* 104 */ + { + {3, 0x0a, 184}, + {6, 0x0a, 184}, + {10, 0x0a, 184}, + {15, 0x0a, 184}, + {24, 0x0a, 184}, + {31, 0x0a, 184}, + {41, 0x0a, 184}, + {56, 0x0b, 184}, + {3, 0x0a, 194}, + {6, 0x0a, 194}, + {10, 0x0a, 194}, + {15, 0x0a, 194}, + {24, 0x0a, 194}, + {31, 0x0a, 194}, + {41, 0x0a, 194}, + {56, 0x0b, 194}, + }, + /* 105 */ + { + {2, 0x0a, 224}, + {9, 0x0a, 224}, + {23, 0x0a, 224}, + {40, 0x0b, 224}, + {2, 0x0a, 226}, + {9, 0x0a, 226}, + {23, 0x0a, 226}, + {40, 0x0b, 226}, + {1, 0x0a, 153}, + {22, 0x0b, 153}, + {1, 0x0a, 161}, + {22, 0x0b, 161}, + {1, 0x0a, 167}, + {22, 0x0b, 167}, + {1, 0x0a, 172}, + {22, 0x0b, 172}, + }, + /* 106 */ + { + {3, 0x0a, 224}, + {6, 0x0a, 224}, + {10, 0x0a, 224}, + {15, 0x0a, 224}, + {24, 0x0a, 224}, + {31, 0x0a, 224}, + {41, 0x0a, 224}, + {56, 0x0b, 224}, + {3, 0x0a, 226}, + {6, 0x0a, 226}, + {10, 0x0a, 226}, + {15, 0x0a, 226}, + {24, 0x0a, 226}, + {31, 0x0a, 226}, + {41, 0x0a, 226}, + {56, 0x0b, 226}, + }, + /* 107 */ + { + {2, 0x0a, 153}, + {9, 0x0a, 153}, + {23, 0x0a, 153}, + {40, 0x0b, 153}, + {2, 0x0a, 161}, + {9, 0x0a, 161}, + {23, 0x0a, 161}, + {40, 0x0b, 161}, + {2, 0x0a, 167}, + {9, 0x0a, 167}, + {23, 0x0a, 167}, + {40, 0x0b, 167}, + {2, 0x0a, 172}, + {9, 0x0a, 172}, + {23, 0x0a, 172}, + {40, 0x0b, 172}, + }, + /* 108 */ + { + {3, 0x0a, 153}, + {6, 0x0a, 153}, + {10, 0x0a, 153}, + {15, 0x0a, 153}, + {24, 0x0a, 153}, + {31, 0x0a, 153}, + {41, 0x0a, 153}, + {56, 0x0b, 153}, + {3, 0x0a, 161}, + {6, 0x0a, 161}, + {10, 0x0a, 161}, + {15, 0x0a, 161}, + {24, 0x0a, 161}, + {31, 0x0a, 161}, + {41, 0x0a, 161}, + {56, 0x0b, 161}, + }, + /* 109 */ + { + {3, 0x0a, 167}, + {6, 0x0a, 167}, + {10, 0x0a, 167}, + {15, 0x0a, 167}, + {24, 0x0a, 167}, + {31, 0x0a, 167}, + {41, 0x0a, 167}, + {56, 0x0b, 167}, + {3, 0x0a, 172}, + {6, 0x0a, 172}, + {10, 0x0a, 172}, + {15, 0x0a, 172}, + {24, 0x0a, 172}, + {31, 0x0a, 172}, + {41, 0x0a, 172}, + {56, 0x0b, 172}, + }, + /* 110 */ + { + {114, 0x00, 0}, + {115, 0x00, 0}, + {117, 0x00, 0}, + {118, 0x00, 0}, + {121, 0x00, 0}, + {123, 0x00, 0}, + {127, 0x00, 0}, + {130, 0x00, 0}, + {136, 0x00, 0}, + {139, 0x00, 0}, + {143, 0x00, 0}, + {146, 0x00, 0}, + {155, 0x00, 0}, + {162, 0x00, 0}, + {170, 0x00, 0}, + {180, 0x00, 0}, + }, + /* 111 */ + { + {0, 0x0b, 176}, + {0, 0x0b, 177}, + {0, 0x0b, 179}, + {0, 0x0b, 209}, + {0, 0x0b, 216}, + {0, 0x0b, 217}, + {0, 0x0b, 227}, + {0, 0x0b, 229}, + {0, 0x0b, 230}, + {122, 0x00, 0}, + {124, 0x00, 0}, + {125, 0x00, 0}, + {128, 0x00, 0}, + {129, 0x00, 0}, + {131, 0x00, 0}, + {132, 0x00, 0}, + }, + /* 112 */ + { + {1, 0x0a, 176}, + {22, 0x0b, 176}, + {1, 0x0a, 177}, + {22, 0x0b, 177}, + {1, 0x0a, 179}, + {22, 0x0b, 179}, + {1, 0x0a, 209}, + {22, 0x0b, 209}, + {1, 0x0a, 216}, + {22, 0x0b, 216}, + {1, 0x0a, 217}, + {22, 0x0b, 217}, + {1, 0x0a, 227}, + {22, 0x0b, 227}, + {1, 0x0a, 229}, + {22, 0x0b, 229}, + }, + /* 113 */ + { + {2, 0x0a, 176}, + {9, 0x0a, 176}, + {23, 0x0a, 176}, + {40, 0x0b, 176}, + {2, 0x0a, 177}, + {9, 0x0a, 177}, + {23, 0x0a, 177}, + {40, 0x0b, 177}, + {2, 0x0a, 179}, + {9, 0x0a, 179}, + {23, 0x0a, 179}, + {40, 0x0b, 179}, + {2, 0x0a, 209}, + {9, 0x0a, 209}, + {23, 0x0a, 209}, + {40, 0x0b, 209}, + }, + /* 114 */ + { + {3, 0x0a, 176}, + {6, 0x0a, 176}, + {10, 0x0a, 176}, + {15, 0x0a, 176}, + {24, 0x0a, 176}, + {31, 0x0a, 176}, + {41, 0x0a, 176}, + {56, 0x0b, 176}, + {3, 0x0a, 177}, + {6, 0x0a, 177}, + {10, 0x0a, 177}, + {15, 0x0a, 177}, + {24, 0x0a, 177}, + {31, 0x0a, 177}, + {41, 0x0a, 177}, + {56, 0x0b, 177}, + }, + /* 115 */ + { + {3, 0x0a, 179}, + {6, 0x0a, 179}, + {10, 0x0a, 179}, + {15, 0x0a, 179}, + {24, 0x0a, 179}, + {31, 0x0a, 179}, + {41, 0x0a, 179}, + {56, 0x0b, 179}, + {3, 0x0a, 209}, + {6, 0x0a, 209}, + {10, 0x0a, 209}, + {15, 0x0a, 209}, + {24, 0x0a, 209}, + {31, 0x0a, 209}, + {41, 0x0a, 209}, + {56, 0x0b, 209}, + }, + /* 116 */ + { + {2, 0x0a, 216}, + {9, 0x0a, 216}, + {23, 0x0a, 216}, + {40, 0x0b, 216}, + {2, 0x0a, 217}, + {9, 0x0a, 217}, + {23, 0x0a, 217}, + {40, 0x0b, 217}, + {2, 0x0a, 227}, + {9, 0x0a, 227}, + {23, 0x0a, 227}, + {40, 0x0b, 227}, + {2, 0x0a, 229}, + {9, 0x0a, 229}, + {23, 0x0a, 229}, + {40, 0x0b, 229}, + }, + /* 117 */ + { + {3, 0x0a, 216}, + {6, 0x0a, 216}, + {10, 0x0a, 216}, + {15, 0x0a, 216}, + {24, 0x0a, 216}, + {31, 0x0a, 216}, + {41, 0x0a, 216}, + {56, 0x0b, 216}, + {3, 0x0a, 217}, + {6, 0x0a, 217}, + {10, 0x0a, 217}, + {15, 0x0a, 217}, + {24, 0x0a, 217}, + {31, 0x0a, 217}, + {41, 0x0a, 217}, + {56, 0x0b, 217}, + }, + /* 118 */ + { + {3, 0x0a, 227}, + {6, 0x0a, 227}, + {10, 0x0a, 227}, + {15, 0x0a, 227}, + {24, 0x0a, 227}, + {31, 0x0a, 227}, + {41, 0x0a, 227}, + {56, 0x0b, 227}, + {3, 0x0a, 229}, + {6, 0x0a, 229}, + {10, 0x0a, 229}, + {15, 0x0a, 229}, + {24, 0x0a, 229}, + {31, 0x0a, 229}, + {41, 0x0a, 229}, + {56, 0x0b, 229}, + }, + /* 119 */ + { + {1, 0x0a, 230}, + {22, 0x0b, 230}, + {0, 0x0b, 129}, + {0, 0x0b, 132}, + {0, 0x0b, 133}, + {0, 0x0b, 134}, + {0, 0x0b, 136}, + {0, 0x0b, 146}, + {0, 0x0b, 154}, + {0, 0x0b, 156}, + {0, 0x0b, 160}, + {0, 0x0b, 163}, + {0, 0x0b, 164}, + {0, 0x0b, 169}, + {0, 0x0b, 170}, + {0, 0x0b, 173}, + }, + /* 120 */ + { + {2, 0x0a, 230}, + {9, 0x0a, 230}, + {23, 0x0a, 230}, + {40, 0x0b, 230}, + {1, 0x0a, 129}, + {22, 0x0b, 129}, + {1, 0x0a, 132}, + {22, 0x0b, 132}, + {1, 0x0a, 133}, + {22, 0x0b, 133}, + {1, 0x0a, 134}, + {22, 0x0b, 134}, + {1, 0x0a, 136}, + {22, 0x0b, 136}, + {1, 0x0a, 146}, + {22, 0x0b, 146}, + }, + /* 121 */ + { + {3, 0x0a, 230}, + {6, 0x0a, 230}, + {10, 0x0a, 230}, + {15, 0x0a, 230}, + {24, 0x0a, 230}, + {31, 0x0a, 230}, + {41, 0x0a, 230}, + {56, 0x0b, 230}, + {2, 0x0a, 129}, + {9, 0x0a, 129}, + {23, 0x0a, 129}, + {40, 0x0b, 129}, + {2, 0x0a, 132}, + {9, 0x0a, 132}, + {23, 0x0a, 132}, + {40, 0x0b, 132}, + }, + /* 122 */ + { + {3, 0x0a, 129}, + {6, 0x0a, 129}, + {10, 0x0a, 129}, + {15, 0x0a, 129}, + {24, 0x0a, 129}, + {31, 0x0a, 129}, + {41, 0x0a, 129}, + {56, 0x0b, 129}, + {3, 0x0a, 132}, + {6, 0x0a, 132}, + {10, 0x0a, 132}, + {15, 0x0a, 132}, + {24, 0x0a, 132}, + {31, 0x0a, 132}, + {41, 0x0a, 132}, + {56, 0x0b, 132}, + }, + /* 123 */ + { + {2, 0x0a, 133}, + {9, 0x0a, 133}, + {23, 0x0a, 133}, + {40, 0x0b, 133}, + {2, 0x0a, 134}, + {9, 0x0a, 134}, + {23, 0x0a, 134}, + {40, 0x0b, 134}, + {2, 0x0a, 136}, + {9, 0x0a, 136}, + {23, 0x0a, 136}, + {40, 0x0b, 136}, + {2, 0x0a, 146}, + {9, 0x0a, 146}, + {23, 0x0a, 146}, + {40, 0x0b, 146}, + }, + /* 124 */ + { + {3, 0x0a, 133}, + {6, 0x0a, 133}, + {10, 0x0a, 133}, + {15, 0x0a, 133}, + {24, 0x0a, 133}, + {31, 0x0a, 133}, + {41, 0x0a, 133}, + {56, 0x0b, 133}, + {3, 0x0a, 134}, + {6, 0x0a, 134}, + {10, 0x0a, 134}, + {15, 0x0a, 134}, + {24, 0x0a, 134}, + {31, 0x0a, 134}, + {41, 0x0a, 134}, + {56, 0x0b, 134}, + }, + /* 125 */ + { + {3, 0x0a, 136}, + {6, 0x0a, 136}, + {10, 0x0a, 136}, + {15, 0x0a, 136}, + {24, 0x0a, 136}, + {31, 0x0a, 136}, + {41, 0x0a, 136}, + {56, 0x0b, 136}, + {3, 0x0a, 146}, + {6, 0x0a, 146}, + {10, 0x0a, 146}, + {15, 0x0a, 146}, + {24, 0x0a, 146}, + {31, 0x0a, 146}, + {41, 0x0a, 146}, + {56, 0x0b, 146}, + }, + /* 126 */ + { + {1, 0x0a, 154}, + {22, 0x0b, 154}, + {1, 0x0a, 156}, + {22, 0x0b, 156}, + {1, 0x0a, 160}, + {22, 0x0b, 160}, + {1, 0x0a, 163}, + {22, 0x0b, 163}, + {1, 0x0a, 164}, + {22, 0x0b, 164}, + {1, 0x0a, 169}, + {22, 0x0b, 169}, + {1, 0x0a, 170}, + {22, 0x0b, 170}, + {1, 0x0a, 173}, + {22, 0x0b, 173}, + }, + /* 127 */ + { + {2, 0x0a, 154}, + {9, 0x0a, 154}, + {23, 0x0a, 154}, + {40, 0x0b, 154}, + {2, 0x0a, 156}, + {9, 0x0a, 156}, + {23, 0x0a, 156}, + {40, 0x0b, 156}, + {2, 0x0a, 160}, + {9, 0x0a, 160}, + {23, 0x0a, 160}, + {40, 0x0b, 160}, + {2, 0x0a, 163}, + {9, 0x0a, 163}, + {23, 0x0a, 163}, + {40, 0x0b, 163}, + }, + /* 128 */ + { + {3, 0x0a, 154}, + {6, 0x0a, 154}, + {10, 0x0a, 154}, + {15, 0x0a, 154}, + {24, 0x0a, 154}, + {31, 0x0a, 154}, + {41, 0x0a, 154}, + {56, 0x0b, 154}, + {3, 0x0a, 156}, + {6, 0x0a, 156}, + {10, 0x0a, 156}, + {15, 0x0a, 156}, + {24, 0x0a, 156}, + {31, 0x0a, 156}, + {41, 0x0a, 156}, + {56, 0x0b, 156}, + }, + /* 129 */ + { + {3, 0x0a, 160}, + {6, 0x0a, 160}, + {10, 0x0a, 160}, + {15, 0x0a, 160}, + {24, 0x0a, 160}, + {31, 0x0a, 160}, + {41, 0x0a, 160}, + {56, 0x0b, 160}, + {3, 0x0a, 163}, + {6, 0x0a, 163}, + {10, 0x0a, 163}, + {15, 0x0a, 163}, + {24, 0x0a, 163}, + {31, 0x0a, 163}, + {41, 0x0a, 163}, + {56, 0x0b, 163}, + }, + /* 130 */ + { + {2, 0x0a, 164}, + {9, 0x0a, 164}, + {23, 0x0a, 164}, + {40, 0x0b, 164}, + {2, 0x0a, 169}, + {9, 0x0a, 169}, + {23, 0x0a, 169}, + {40, 0x0b, 169}, + {2, 0x0a, 170}, + {9, 0x0a, 170}, + {23, 0x0a, 170}, + {40, 0x0b, 170}, + {2, 0x0a, 173}, + {9, 0x0a, 173}, + {23, 0x0a, 173}, + {40, 0x0b, 173}, + }, + /* 131 */ + { + {3, 0x0a, 164}, + {6, 0x0a, 164}, + {10, 0x0a, 164}, + {15, 0x0a, 164}, + {24, 0x0a, 164}, + {31, 0x0a, 164}, + {41, 0x0a, 164}, + {56, 0x0b, 164}, + {3, 0x0a, 169}, + {6, 0x0a, 169}, + {10, 0x0a, 169}, + {15, 0x0a, 169}, + {24, 0x0a, 169}, + {31, 0x0a, 169}, + {41, 0x0a, 169}, + {56, 0x0b, 169}, + }, + /* 132 */ + { + {3, 0x0a, 170}, + {6, 0x0a, 170}, + {10, 0x0a, 170}, + {15, 0x0a, 170}, + {24, 0x0a, 170}, + {31, 0x0a, 170}, + {41, 0x0a, 170}, + {56, 0x0b, 170}, + {3, 0x0a, 173}, + {6, 0x0a, 173}, + {10, 0x0a, 173}, + {15, 0x0a, 173}, + {24, 0x0a, 173}, + {31, 0x0a, 173}, + {41, 0x0a, 173}, + {56, 0x0b, 173}, + }, + /* 133 */ + { + {137, 0x00, 0}, + {138, 0x00, 0}, + {140, 0x00, 0}, + {141, 0x00, 0}, + {144, 0x00, 0}, + {145, 0x00, 0}, + {147, 0x00, 0}, + {150, 0x00, 0}, + {156, 0x00, 0}, + {159, 0x00, 0}, + {163, 0x00, 0}, + {166, 0x00, 0}, + {171, 0x00, 0}, + {174, 0x00, 0}, + {181, 0x00, 0}, + {190, 0x00, 0}, + }, + /* 134 */ + { + {0, 0x0b, 178}, + {0, 0x0b, 181}, + {0, 0x0b, 185}, + {0, 0x0b, 186}, + {0, 0x0b, 187}, + {0, 0x0b, 189}, + {0, 0x0b, 190}, + {0, 0x0b, 196}, + {0, 0x0b, 198}, + {0, 0x0b, 228}, + {0, 0x0b, 232}, + {0, 0x0b, 233}, + {148, 0x00, 0}, + {149, 0x00, 0}, + {151, 0x00, 0}, + {152, 0x00, 0}, + }, + /* 135 */ + { + {1, 0x0a, 178}, + {22, 0x0b, 178}, + {1, 0x0a, 181}, + {22, 0x0b, 181}, + {1, 0x0a, 185}, + {22, 0x0b, 185}, + {1, 0x0a, 186}, + {22, 0x0b, 186}, + {1, 0x0a, 187}, + {22, 0x0b, 187}, + {1, 0x0a, 189}, + {22, 0x0b, 189}, + {1, 0x0a, 190}, + {22, 0x0b, 190}, + {1, 0x0a, 196}, + {22, 0x0b, 196}, + }, + /* 136 */ + { + {2, 0x0a, 178}, + {9, 0x0a, 178}, + {23, 0x0a, 178}, + {40, 0x0b, 178}, + {2, 0x0a, 181}, + {9, 0x0a, 181}, + {23, 0x0a, 181}, + {40, 0x0b, 181}, + {2, 0x0a, 185}, + {9, 0x0a, 185}, + {23, 0x0a, 185}, + {40, 0x0b, 185}, + {2, 0x0a, 186}, + {9, 0x0a, 186}, + {23, 0x0a, 186}, + {40, 0x0b, 186}, + }, + /* 137 */ + { + {3, 0x0a, 178}, + {6, 0x0a, 178}, + {10, 0x0a, 178}, + {15, 0x0a, 178}, + {24, 0x0a, 178}, + {31, 0x0a, 178}, + {41, 0x0a, 178}, + {56, 0x0b, 178}, + {3, 0x0a, 181}, + {6, 0x0a, 181}, + {10, 0x0a, 181}, + {15, 0x0a, 181}, + {24, 0x0a, 181}, + {31, 0x0a, 181}, + {41, 0x0a, 181}, + {56, 0x0b, 181}, + }, + /* 138 */ + { + {3, 0x0a, 185}, + {6, 0x0a, 185}, + {10, 0x0a, 185}, + {15, 0x0a, 185}, + {24, 0x0a, 185}, + {31, 0x0a, 185}, + {41, 0x0a, 185}, + {56, 0x0b, 185}, + {3, 0x0a, 186}, + {6, 0x0a, 186}, + {10, 0x0a, 186}, + {15, 0x0a, 186}, + {24, 0x0a, 186}, + {31, 0x0a, 186}, + {41, 0x0a, 186}, + {56, 0x0b, 186}, + }, + /* 139 */ + { + {2, 0x0a, 187}, + {9, 0x0a, 187}, + {23, 0x0a, 187}, + {40, 0x0b, 187}, + {2, 0x0a, 189}, + {9, 0x0a, 189}, + {23, 0x0a, 189}, + {40, 0x0b, 189}, + {2, 0x0a, 190}, + {9, 0x0a, 190}, + {23, 0x0a, 190}, + {40, 0x0b, 190}, + {2, 0x0a, 196}, + {9, 0x0a, 196}, + {23, 0x0a, 196}, + {40, 0x0b, 196}, + }, + /* 140 */ + { + {3, 0x0a, 187}, + {6, 0x0a, 187}, + {10, 0x0a, 187}, + {15, 0x0a, 187}, + {24, 0x0a, 187}, + {31, 0x0a, 187}, + {41, 0x0a, 187}, + {56, 0x0b, 187}, + {3, 0x0a, 189}, + {6, 0x0a, 189}, + {10, 0x0a, 189}, + {15, 0x0a, 189}, + {24, 0x0a, 189}, + {31, 0x0a, 189}, + {41, 0x0a, 189}, + {56, 0x0b, 189}, + }, + /* 141 */ + { + {3, 0x0a, 190}, + {6, 0x0a, 190}, + {10, 0x0a, 190}, + {15, 0x0a, 190}, + {24, 0x0a, 190}, + {31, 0x0a, 190}, + {41, 0x0a, 190}, + {56, 0x0b, 190}, + {3, 0x0a, 196}, + {6, 0x0a, 196}, + {10, 0x0a, 196}, + {15, 0x0a, 196}, + {24, 0x0a, 196}, + {31, 0x0a, 196}, + {41, 0x0a, 196}, + {56, 0x0b, 196}, + }, + /* 142 */ + { + {1, 0x0a, 198}, + {22, 0x0b, 198}, + {1, 0x0a, 228}, + {22, 0x0b, 228}, + {1, 0x0a, 232}, + {22, 0x0b, 232}, + {1, 0x0a, 233}, + {22, 0x0b, 233}, + {0, 0x1b, 1}, + {0, 0x0b, 135}, + {0, 0x0b, 137}, + {0, 0x0b, 138}, + {0, 0x0b, 139}, + {0, 0x0b, 140}, + {0, 0x0b, 141}, + {0, 0x0b, 143}, + }, + /* 143 */ + { + {2, 0x0a, 198}, + {9, 0x0a, 198}, + {23, 0x0a, 198}, + {40, 0x0b, 198}, + {2, 0x0a, 228}, + {9, 0x0a, 228}, + {23, 0x0a, 228}, + {40, 0x0b, 228}, + {2, 0x0a, 232}, + {9, 0x0a, 232}, + {23, 0x0a, 232}, + {40, 0x0b, 232}, + {2, 0x0a, 233}, + {9, 0x0a, 233}, + {23, 0x0a, 233}, + {40, 0x0b, 233}, + }, + /* 144 */ + { + {3, 0x0a, 198}, + {6, 0x0a, 198}, + {10, 0x0a, 198}, + {15, 0x0a, 198}, + {24, 0x0a, 198}, + {31, 0x0a, 198}, + {41, 0x0a, 198}, + {56, 0x0b, 198}, + {3, 0x0a, 228}, + {6, 0x0a, 228}, + {10, 0x0a, 228}, + {15, 0x0a, 228}, + {24, 0x0a, 228}, + {31, 0x0a, 228}, + {41, 0x0a, 228}, + {56, 0x0b, 228}, + }, + /* 145 */ + { + {3, 0x0a, 232}, + {6, 0x0a, 232}, + {10, 0x0a, 232}, + {15, 0x0a, 232}, + {24, 0x0a, 232}, + {31, 0x0a, 232}, + {41, 0x0a, 232}, + {56, 0x0b, 232}, + {3, 0x0a, 233}, + {6, 0x0a, 233}, + {10, 0x0a, 233}, + {15, 0x0a, 233}, + {24, 0x0a, 233}, + {31, 0x0a, 233}, + {41, 0x0a, 233}, + {56, 0x0b, 233}, + }, + /* 146 */ + { + {1, 0x1a, 1}, + {22, 0x1b, 1}, + {1, 0x0a, 135}, + {22, 0x0b, 135}, + {1, 0x0a, 137}, + {22, 0x0b, 137}, + {1, 0x0a, 138}, + {22, 0x0b, 138}, + {1, 0x0a, 139}, + {22, 0x0b, 139}, + {1, 0x0a, 140}, + {22, 0x0b, 140}, + {1, 0x0a, 141}, + {22, 0x0b, 141}, + {1, 0x0a, 143}, + {22, 0x0b, 143}, + }, + /* 147 */ + { + {2, 0x1a, 1}, + {9, 0x1a, 1}, + {23, 0x1a, 1}, + {40, 0x1b, 1}, + {2, 0x0a, 135}, + {9, 0x0a, 135}, + {23, 0x0a, 135}, + {40, 0x0b, 135}, + {2, 0x0a, 137}, + {9, 0x0a, 137}, + {23, 0x0a, 137}, + {40, 0x0b, 137}, + {2, 0x0a, 138}, + {9, 0x0a, 138}, + {23, 0x0a, 138}, + {40, 0x0b, 138}, + }, + /* 148 */ + { + {3, 0x1a, 1}, + {6, 0x1a, 1}, + {10, 0x1a, 1}, + {15, 0x1a, 1}, + {24, 0x1a, 1}, + {31, 0x1a, 1}, + {41, 0x1a, 1}, + {56, 0x1b, 1}, + {3, 0x0a, 135}, + {6, 0x0a, 135}, + {10, 0x0a, 135}, + {15, 0x0a, 135}, + {24, 0x0a, 135}, + {31, 0x0a, 135}, + {41, 0x0a, 135}, + {56, 0x0b, 135}, + }, + /* 149 */ + { + {3, 0x0a, 137}, + {6, 0x0a, 137}, + {10, 0x0a, 137}, + {15, 0x0a, 137}, + {24, 0x0a, 137}, + {31, 0x0a, 137}, + {41, 0x0a, 137}, + {56, 0x0b, 137}, + {3, 0x0a, 138}, + {6, 0x0a, 138}, + {10, 0x0a, 138}, + {15, 0x0a, 138}, + {24, 0x0a, 138}, + {31, 0x0a, 138}, + {41, 0x0a, 138}, + {56, 0x0b, 138}, + }, + /* 150 */ + { + {2, 0x0a, 139}, + {9, 0x0a, 139}, + {23, 0x0a, 139}, + {40, 0x0b, 139}, + {2, 0x0a, 140}, + {9, 0x0a, 140}, + {23, 0x0a, 140}, + {40, 0x0b, 140}, + {2, 0x0a, 141}, + {9, 0x0a, 141}, + {23, 0x0a, 141}, + {40, 0x0b, 141}, + {2, 0x0a, 143}, + {9, 0x0a, 143}, + {23, 0x0a, 143}, + {40, 0x0b, 143}, + }, + /* 151 */ + { + {3, 0x0a, 139}, + {6, 0x0a, 139}, + {10, 0x0a, 139}, + {15, 0x0a, 139}, + {24, 0x0a, 139}, + {31, 0x0a, 139}, + {41, 0x0a, 139}, + {56, 0x0b, 139}, + {3, 0x0a, 140}, + {6, 0x0a, 140}, + {10, 0x0a, 140}, + {15, 0x0a, 140}, + {24, 0x0a, 140}, + {31, 0x0a, 140}, + {41, 0x0a, 140}, + {56, 0x0b, 140}, + }, + /* 152 */ + { + {3, 0x0a, 141}, + {6, 0x0a, 141}, + {10, 0x0a, 141}, + {15, 0x0a, 141}, + {24, 0x0a, 141}, + {31, 0x0a, 141}, + {41, 0x0a, 141}, + {56, 0x0b, 141}, + {3, 0x0a, 143}, + {6, 0x0a, 143}, + {10, 0x0a, 143}, + {15, 0x0a, 143}, + {24, 0x0a, 143}, + {31, 0x0a, 143}, + {41, 0x0a, 143}, + {56, 0x0b, 143}, + }, + /* 153 */ + { + {157, 0x00, 0}, + {158, 0x00, 0}, + {160, 0x00, 0}, + {161, 0x00, 0}, + {164, 0x00, 0}, + {165, 0x00, 0}, + {167, 0x00, 0}, + {168, 0x00, 0}, + {172, 0x00, 0}, + {173, 0x00, 0}, + {175, 0x00, 0}, + {177, 0x00, 0}, + {182, 0x00, 0}, + {185, 0x00, 0}, + {191, 0x00, 0}, + {207, 0x00, 0}, + }, + /* 154 */ + { + {0, 0x0b, 147}, + {0, 0x0b, 149}, + {0, 0x0b, 150}, + {0, 0x0b, 151}, + {0, 0x0b, 152}, + {0, 0x0b, 155}, + {0, 0x0b, 157}, + {0, 0x0b, 158}, + {0, 0x0b, 165}, + {0, 0x0b, 166}, + {0, 0x0b, 168}, + {0, 0x0b, 174}, + {0, 0x0b, 175}, + {0, 0x0b, 180}, + {0, 0x0b, 182}, + {0, 0x0b, 183}, + }, + /* 155 */ + { + {1, 0x0a, 147}, + {22, 0x0b, 147}, + {1, 0x0a, 149}, + {22, 0x0b, 149}, + {1, 0x0a, 150}, + {22, 0x0b, 150}, + {1, 0x0a, 151}, + {22, 0x0b, 151}, + {1, 0x0a, 152}, + {22, 0x0b, 152}, + {1, 0x0a, 155}, + {22, 0x0b, 155}, + {1, 0x0a, 157}, + {22, 0x0b, 157}, + {1, 0x0a, 158}, + {22, 0x0b, 158}, + }, + /* 156 */ + { + {2, 0x0a, 147}, + {9, 0x0a, 147}, + {23, 0x0a, 147}, + {40, 0x0b, 147}, + {2, 0x0a, 149}, + {9, 0x0a, 149}, + {23, 0x0a, 149}, + {40, 0x0b, 149}, + {2, 0x0a, 150}, + {9, 0x0a, 150}, + {23, 0x0a, 150}, + {40, 0x0b, 150}, + {2, 0x0a, 151}, + {9, 0x0a, 151}, + {23, 0x0a, 151}, + {40, 0x0b, 151}, + }, + /* 157 */ + { + {3, 0x0a, 147}, + {6, 0x0a, 147}, + {10, 0x0a, 147}, + {15, 0x0a, 147}, + {24, 0x0a, 147}, + {31, 0x0a, 147}, + {41, 0x0a, 147}, + {56, 0x0b, 147}, + {3, 0x0a, 149}, + {6, 0x0a, 149}, + {10, 0x0a, 149}, + {15, 0x0a, 149}, + {24, 0x0a, 149}, + {31, 0x0a, 149}, + {41, 0x0a, 149}, + {56, 0x0b, 149}, + }, + /* 158 */ + { + {3, 0x0a, 150}, + {6, 0x0a, 150}, + {10, 0x0a, 150}, + {15, 0x0a, 150}, + {24, 0x0a, 150}, + {31, 0x0a, 150}, + {41, 0x0a, 150}, + {56, 0x0b, 150}, + {3, 0x0a, 151}, + {6, 0x0a, 151}, + {10, 0x0a, 151}, + {15, 0x0a, 151}, + {24, 0x0a, 151}, + {31, 0x0a, 151}, + {41, 0x0a, 151}, + {56, 0x0b, 151}, + }, + /* 159 */ + { + {2, 0x0a, 152}, + {9, 0x0a, 152}, + {23, 0x0a, 152}, + {40, 0x0b, 152}, + {2, 0x0a, 155}, + {9, 0x0a, 155}, + {23, 0x0a, 155}, + {40, 0x0b, 155}, + {2, 0x0a, 157}, + {9, 0x0a, 157}, + {23, 0x0a, 157}, + {40, 0x0b, 157}, + {2, 0x0a, 158}, + {9, 0x0a, 158}, + {23, 0x0a, 158}, + {40, 0x0b, 158}, + }, + /* 160 */ + { + {3, 0x0a, 152}, + {6, 0x0a, 152}, + {10, 0x0a, 152}, + {15, 0x0a, 152}, + {24, 0x0a, 152}, + {31, 0x0a, 152}, + {41, 0x0a, 152}, + {56, 0x0b, 152}, + {3, 0x0a, 155}, + {6, 0x0a, 155}, + {10, 0x0a, 155}, + {15, 0x0a, 155}, + {24, 0x0a, 155}, + {31, 0x0a, 155}, + {41, 0x0a, 155}, + {56, 0x0b, 155}, + }, + /* 161 */ + { + {3, 0x0a, 157}, + {6, 0x0a, 157}, + {10, 0x0a, 157}, + {15, 0x0a, 157}, + {24, 0x0a, 157}, + {31, 0x0a, 157}, + {41, 0x0a, 157}, + {56, 0x0b, 157}, + {3, 0x0a, 158}, + {6, 0x0a, 158}, + {10, 0x0a, 158}, + {15, 0x0a, 158}, + {24, 0x0a, 158}, + {31, 0x0a, 158}, + {41, 0x0a, 158}, + {56, 0x0b, 158}, + }, + /* 162 */ + { + {1, 0x0a, 165}, + {22, 0x0b, 165}, + {1, 0x0a, 166}, + {22, 0x0b, 166}, + {1, 0x0a, 168}, + {22, 0x0b, 168}, + {1, 0x0a, 174}, + {22, 0x0b, 174}, + {1, 0x0a, 175}, + {22, 0x0b, 175}, + {1, 0x0a, 180}, + {22, 0x0b, 180}, + {1, 0x0a, 182}, + {22, 0x0b, 182}, + {1, 0x0a, 183}, + {22, 0x0b, 183}, + }, + /* 163 */ + { + {2, 0x0a, 165}, + {9, 0x0a, 165}, + {23, 0x0a, 165}, + {40, 0x0b, 165}, + {2, 0x0a, 166}, + {9, 0x0a, 166}, + {23, 0x0a, 166}, + {40, 0x0b, 166}, + {2, 0x0a, 168}, + {9, 0x0a, 168}, + {23, 0x0a, 168}, + {40, 0x0b, 168}, + {2, 0x0a, 174}, + {9, 0x0a, 174}, + {23, 0x0a, 174}, + {40, 0x0b, 174}, + }, + /* 164 */ + { + {3, 0x0a, 165}, + {6, 0x0a, 165}, + {10, 0x0a, 165}, + {15, 0x0a, 165}, + {24, 0x0a, 165}, + {31, 0x0a, 165}, + {41, 0x0a, 165}, + {56, 0x0b, 165}, + {3, 0x0a, 166}, + {6, 0x0a, 166}, + {10, 0x0a, 166}, + {15, 0x0a, 166}, + {24, 0x0a, 166}, + {31, 0x0a, 166}, + {41, 0x0a, 166}, + {56, 0x0b, 166}, + }, + /* 165 */ + { + {3, 0x0a, 168}, + {6, 0x0a, 168}, + {10, 0x0a, 168}, + {15, 0x0a, 168}, + {24, 0x0a, 168}, + {31, 0x0a, 168}, + {41, 0x0a, 168}, + {56, 0x0b, 168}, + {3, 0x0a, 174}, + {6, 0x0a, 174}, + {10, 0x0a, 174}, + {15, 0x0a, 174}, + {24, 0x0a, 174}, + {31, 0x0a, 174}, + {41, 0x0a, 174}, + {56, 0x0b, 174}, + }, + /* 166 */ + { + {2, 0x0a, 175}, + {9, 0x0a, 175}, + {23, 0x0a, 175}, + {40, 0x0b, 175}, + {2, 0x0a, 180}, + {9, 0x0a, 180}, + {23, 0x0a, 180}, + {40, 0x0b, 180}, + {2, 0x0a, 182}, + {9, 0x0a, 182}, + {23, 0x0a, 182}, + {40, 0x0b, 182}, + {2, 0x0a, 183}, + {9, 0x0a, 183}, + {23, 0x0a, 183}, + {40, 0x0b, 183}, + }, + /* 167 */ + { + {3, 0x0a, 175}, + {6, 0x0a, 175}, + {10, 0x0a, 175}, + {15, 0x0a, 175}, + {24, 0x0a, 175}, + {31, 0x0a, 175}, + {41, 0x0a, 175}, + {56, 0x0b, 175}, + {3, 0x0a, 180}, + {6, 0x0a, 180}, + {10, 0x0a, 180}, + {15, 0x0a, 180}, + {24, 0x0a, 180}, + {31, 0x0a, 180}, + {41, 0x0a, 180}, + {56, 0x0b, 180}, + }, + /* 168 */ + { + {3, 0x0a, 182}, + {6, 0x0a, 182}, + {10, 0x0a, 182}, + {15, 0x0a, 182}, + {24, 0x0a, 182}, + {31, 0x0a, 182}, + {41, 0x0a, 182}, + {56, 0x0b, 182}, + {3, 0x0a, 183}, + {6, 0x0a, 183}, + {10, 0x0a, 183}, + {15, 0x0a, 183}, + {24, 0x0a, 183}, + {31, 0x0a, 183}, + {41, 0x0a, 183}, + {56, 0x0b, 183}, + }, + /* 169 */ + { + {0, 0x0b, 188}, + {0, 0x0b, 191}, + {0, 0x0b, 197}, + {0, 0x0b, 231}, + {0, 0x0b, 239}, + {176, 0x00, 0}, + {178, 0x00, 0}, + {179, 0x00, 0}, + {183, 0x00, 0}, + {184, 0x00, 0}, + {186, 0x00, 0}, + {187, 0x00, 0}, + {192, 0x00, 0}, + {199, 0x00, 0}, + {208, 0x00, 0}, + {223, 0x00, 0}, + }, + /* 170 */ + { + {1, 0x0a, 188}, + {22, 0x0b, 188}, + {1, 0x0a, 191}, + {22, 0x0b, 191}, + {1, 0x0a, 197}, + {22, 0x0b, 197}, + {1, 0x0a, 231}, + {22, 0x0b, 231}, + {1, 0x0a, 239}, + {22, 0x0b, 239}, + {0, 0x0b, 9}, + {0, 0x0b, 142}, + {0, 0x0b, 144}, + {0, 0x0b, 145}, + {0, 0x0b, 148}, + {0, 0x0b, 159}, + }, + /* 171 */ + { + {2, 0x0a, 188}, + {9, 0x0a, 188}, + {23, 0x0a, 188}, + {40, 0x0b, 188}, + {2, 0x0a, 191}, + {9, 0x0a, 191}, + {23, 0x0a, 191}, + {40, 0x0b, 191}, + {2, 0x0a, 197}, + {9, 0x0a, 197}, + {23, 0x0a, 197}, + {40, 0x0b, 197}, + {2, 0x0a, 231}, + {9, 0x0a, 231}, + {23, 0x0a, 231}, + {40, 0x0b, 231}, + }, + /* 172 */ + { + {3, 0x0a, 188}, + {6, 0x0a, 188}, + {10, 0x0a, 188}, + {15, 0x0a, 188}, + {24, 0x0a, 188}, + {31, 0x0a, 188}, + {41, 0x0a, 188}, + {56, 0x0b, 188}, + {3, 0x0a, 191}, + {6, 0x0a, 191}, + {10, 0x0a, 191}, + {15, 0x0a, 191}, + {24, 0x0a, 191}, + {31, 0x0a, 191}, + {41, 0x0a, 191}, + {56, 0x0b, 191}, + }, + /* 173 */ + { + {3, 0x0a, 197}, + {6, 0x0a, 197}, + {10, 0x0a, 197}, + {15, 0x0a, 197}, + {24, 0x0a, 197}, + {31, 0x0a, 197}, + {41, 0x0a, 197}, + {56, 0x0b, 197}, + {3, 0x0a, 231}, + {6, 0x0a, 231}, + {10, 0x0a, 231}, + {15, 0x0a, 231}, + {24, 0x0a, 231}, + {31, 0x0a, 231}, + {41, 0x0a, 231}, + {56, 0x0b, 231}, + }, + /* 174 */ + { + {2, 0x0a, 239}, + {9, 0x0a, 239}, + {23, 0x0a, 239}, + {40, 0x0b, 239}, + {1, 0x0a, 9}, + {22, 0x0b, 9}, + {1, 0x0a, 142}, + {22, 0x0b, 142}, + {1, 0x0a, 144}, + {22, 0x0b, 144}, + {1, 0x0a, 145}, + {22, 0x0b, 145}, + {1, 0x0a, 148}, + {22, 0x0b, 148}, + {1, 0x0a, 159}, + {22, 0x0b, 159}, + }, + /* 175 */ + { + {3, 0x0a, 239}, + {6, 0x0a, 239}, + {10, 0x0a, 239}, + {15, 0x0a, 239}, + {24, 0x0a, 239}, + {31, 0x0a, 239}, + {41, 0x0a, 239}, + {56, 0x0b, 239}, + {2, 0x0a, 9}, + {9, 0x0a, 9}, + {23, 0x0a, 9}, + {40, 0x0b, 9}, + {2, 0x0a, 142}, + {9, 0x0a, 142}, + {23, 0x0a, 142}, + {40, 0x0b, 142}, + }, + /* 176 */ + { + {3, 0x0a, 9}, + {6, 0x0a, 9}, + {10, 0x0a, 9}, + {15, 0x0a, 9}, + {24, 0x0a, 9}, + {31, 0x0a, 9}, + {41, 0x0a, 9}, + {56, 0x0b, 9}, + {3, 0x0a, 142}, + {6, 0x0a, 142}, + {10, 0x0a, 142}, + {15, 0x0a, 142}, + {24, 0x0a, 142}, + {31, 0x0a, 142}, + {41, 0x0a, 142}, + {56, 0x0b, 142}, + }, + /* 177 */ + { + {2, 0x0a, 144}, + {9, 0x0a, 144}, + {23, 0x0a, 144}, + {40, 0x0b, 144}, + {2, 0x0a, 145}, + {9, 0x0a, 145}, + {23, 0x0a, 145}, + {40, 0x0b, 145}, + {2, 0x0a, 148}, + {9, 0x0a, 148}, + {23, 0x0a, 148}, + {40, 0x0b, 148}, + {2, 0x0a, 159}, + {9, 0x0a, 159}, + {23, 0x0a, 159}, + {40, 0x0b, 159}, + }, + /* 178 */ + { + {3, 0x0a, 144}, + {6, 0x0a, 144}, + {10, 0x0a, 144}, + {15, 0x0a, 144}, + {24, 0x0a, 144}, + {31, 0x0a, 144}, + {41, 0x0a, 144}, + {56, 0x0b, 144}, + {3, 0x0a, 145}, + {6, 0x0a, 145}, + {10, 0x0a, 145}, + {15, 0x0a, 145}, + {24, 0x0a, 145}, + {31, 0x0a, 145}, + {41, 0x0a, 145}, + {56, 0x0b, 145}, + }, + /* 179 */ + { + {3, 0x0a, 148}, + {6, 0x0a, 148}, + {10, 0x0a, 148}, + {15, 0x0a, 148}, + {24, 0x0a, 148}, + {31, 0x0a, 148}, + {41, 0x0a, 148}, + {56, 0x0b, 148}, + {3, 0x0a, 159}, + {6, 0x0a, 159}, + {10, 0x0a, 159}, + {15, 0x0a, 159}, + {24, 0x0a, 159}, + {31, 0x0a, 159}, + {41, 0x0a, 159}, + {56, 0x0b, 159}, + }, + /* 180 */ + { + {0, 0x0b, 171}, + {0, 0x0b, 206}, + {0, 0x0b, 215}, + {0, 0x0b, 225}, + {0, 0x0b, 236}, + {0, 0x0b, 237}, + {188, 0x00, 0}, + {189, 0x00, 0}, + {193, 0x00, 0}, + {196, 0x00, 0}, + {200, 0x00, 0}, + {203, 0x00, 0}, + {209, 0x00, 0}, + {216, 0x00, 0}, + {224, 0x00, 0}, + {238, 0x00, 0}, + }, + /* 181 */ + { + {1, 0x0a, 171}, + {22, 0x0b, 171}, + {1, 0x0a, 206}, + {22, 0x0b, 206}, + {1, 0x0a, 215}, + {22, 0x0b, 215}, + {1, 0x0a, 225}, + {22, 0x0b, 225}, + {1, 0x0a, 236}, + {22, 0x0b, 236}, + {1, 0x0a, 237}, + {22, 0x0b, 237}, + {0, 0x0b, 199}, + {0, 0x0b, 207}, + {0, 0x0b, 234}, + {0, 0x0b, 235}, + }, + /* 182 */ + { + {2, 0x0a, 171}, + {9, 0x0a, 171}, + {23, 0x0a, 171}, + {40, 0x0b, 171}, + {2, 0x0a, 206}, + {9, 0x0a, 206}, + {23, 0x0a, 206}, + {40, 0x0b, 206}, + {2, 0x0a, 215}, + {9, 0x0a, 215}, + {23, 0x0a, 215}, + {40, 0x0b, 215}, + {2, 0x0a, 225}, + {9, 0x0a, 225}, + {23, 0x0a, 225}, + {40, 0x0b, 225}, + }, + /* 183 */ + { + {3, 0x0a, 171}, + {6, 0x0a, 171}, + {10, 0x0a, 171}, + {15, 0x0a, 171}, + {24, 0x0a, 171}, + {31, 0x0a, 171}, + {41, 0x0a, 171}, + {56, 0x0b, 171}, + {3, 0x0a, 206}, + {6, 0x0a, 206}, + {10, 0x0a, 206}, + {15, 0x0a, 206}, + {24, 0x0a, 206}, + {31, 0x0a, 206}, + {41, 0x0a, 206}, + {56, 0x0b, 206}, + }, + /* 184 */ + { + {3, 0x0a, 215}, + {6, 0x0a, 215}, + {10, 0x0a, 215}, + {15, 0x0a, 215}, + {24, 0x0a, 215}, + {31, 0x0a, 215}, + {41, 0x0a, 215}, + {56, 0x0b, 215}, + {3, 0x0a, 225}, + {6, 0x0a, 225}, + {10, 0x0a, 225}, + {15, 0x0a, 225}, + {24, 0x0a, 225}, + {31, 0x0a, 225}, + {41, 0x0a, 225}, + {56, 0x0b, 225}, + }, + /* 185 */ + { + {2, 0x0a, 236}, + {9, 0x0a, 236}, + {23, 0x0a, 236}, + {40, 0x0b, 236}, + {2, 0x0a, 237}, + {9, 0x0a, 237}, + {23, 0x0a, 237}, + {40, 0x0b, 237}, + {1, 0x0a, 199}, + {22, 0x0b, 199}, + {1, 0x0a, 207}, + {22, 0x0b, 207}, + {1, 0x0a, 234}, + {22, 0x0b, 234}, + {1, 0x0a, 235}, + {22, 0x0b, 235}, + }, + /* 186 */ + { + {3, 0x0a, 236}, + {6, 0x0a, 236}, + {10, 0x0a, 236}, + {15, 0x0a, 236}, + {24, 0x0a, 236}, + {31, 0x0a, 236}, + {41, 0x0a, 236}, + {56, 0x0b, 236}, + {3, 0x0a, 237}, + {6, 0x0a, 237}, + {10, 0x0a, 237}, + {15, 0x0a, 237}, + {24, 0x0a, 237}, + {31, 0x0a, 237}, + {41, 0x0a, 237}, + {56, 0x0b, 237}, + }, + /* 187 */ + { + {2, 0x0a, 199}, + {9, 0x0a, 199}, + {23, 0x0a, 199}, + {40, 0x0b, 199}, + {2, 0x0a, 207}, + {9, 0x0a, 207}, + {23, 0x0a, 207}, + {40, 0x0b, 207}, + {2, 0x0a, 234}, + {9, 0x0a, 234}, + {23, 0x0a, 234}, + {40, 0x0b, 234}, + {2, 0x0a, 235}, + {9, 0x0a, 235}, + {23, 0x0a, 235}, + {40, 0x0b, 235}, + }, + /* 188 */ + { + {3, 0x0a, 199}, + {6, 0x0a, 199}, + {10, 0x0a, 199}, + {15, 0x0a, 199}, + {24, 0x0a, 199}, + {31, 0x0a, 199}, + {41, 0x0a, 199}, + {56, 0x0b, 199}, + {3, 0x0a, 207}, + {6, 0x0a, 207}, + {10, 0x0a, 207}, + {15, 0x0a, 207}, + {24, 0x0a, 207}, + {31, 0x0a, 207}, + {41, 0x0a, 207}, + {56, 0x0b, 207}, + }, + /* 189 */ + { + {3, 0x0a, 234}, + {6, 0x0a, 234}, + {10, 0x0a, 234}, + {15, 0x0a, 234}, + {24, 0x0a, 234}, + {31, 0x0a, 234}, + {41, 0x0a, 234}, + {56, 0x0b, 234}, + {3, 0x0a, 235}, + {6, 0x0a, 235}, + {10, 0x0a, 235}, + {15, 0x0a, 235}, + {24, 0x0a, 235}, + {31, 0x0a, 235}, + {41, 0x0a, 235}, + {56, 0x0b, 235}, + }, + /* 190 */ + { + {194, 0x00, 0}, + {195, 0x00, 0}, + {197, 0x00, 0}, + {198, 0x00, 0}, + {201, 0x00, 0}, + {202, 0x00, 0}, + {204, 0x00, 0}, + {205, 0x00, 0}, + {210, 0x00, 0}, + {213, 0x00, 0}, + {217, 0x00, 0}, + {220, 0x00, 0}, + {225, 0x00, 0}, + {231, 0x00, 0}, + {239, 0x00, 0}, + {246, 0x00, 0}, + }, + /* 191 */ + { + {0, 0x0b, 192}, + {0, 0x0b, 193}, + {0, 0x0b, 200}, + {0, 0x0b, 201}, + {0, 0x0b, 202}, + {0, 0x0b, 205}, + {0, 0x0b, 210}, + {0, 0x0b, 213}, + {0, 0x0b, 218}, + {0, 0x0b, 219}, + {0, 0x0b, 238}, + {0, 0x0b, 240}, + {0, 0x0b, 242}, + {0, 0x0b, 243}, + {0, 0x0b, 255}, + {206, 0x00, 0}, + }, + /* 192 */ + { + {1, 0x0a, 192}, + {22, 0x0b, 192}, + {1, 0x0a, 193}, + {22, 0x0b, 193}, + {1, 0x0a, 200}, + {22, 0x0b, 200}, + {1, 0x0a, 201}, + {22, 0x0b, 201}, + {1, 0x0a, 202}, + {22, 0x0b, 202}, + {1, 0x0a, 205}, + {22, 0x0b, 205}, + {1, 0x0a, 210}, + {22, 0x0b, 210}, + {1, 0x0a, 213}, + {22, 0x0b, 213}, + }, + /* 193 */ + { + {2, 0x0a, 192}, + {9, 0x0a, 192}, + {23, 0x0a, 192}, + {40, 0x0b, 192}, + {2, 0x0a, 193}, + {9, 0x0a, 193}, + {23, 0x0a, 193}, + {40, 0x0b, 193}, + {2, 0x0a, 200}, + {9, 0x0a, 200}, + {23, 0x0a, 200}, + {40, 0x0b, 200}, + {2, 0x0a, 201}, + {9, 0x0a, 201}, + {23, 0x0a, 201}, + {40, 0x0b, 201}, + }, + /* 194 */ + { + {3, 0x0a, 192}, + {6, 0x0a, 192}, + {10, 0x0a, 192}, + {15, 0x0a, 192}, + {24, 0x0a, 192}, + {31, 0x0a, 192}, + {41, 0x0a, 192}, + {56, 0x0b, 192}, + {3, 0x0a, 193}, + {6, 0x0a, 193}, + {10, 0x0a, 193}, + {15, 0x0a, 193}, + {24, 0x0a, 193}, + {31, 0x0a, 193}, + {41, 0x0a, 193}, + {56, 0x0b, 193}, + }, + /* 195 */ + { + {3, 0x0a, 200}, + {6, 0x0a, 200}, + {10, 0x0a, 200}, + {15, 0x0a, 200}, + {24, 0x0a, 200}, + {31, 0x0a, 200}, + {41, 0x0a, 200}, + {56, 0x0b, 200}, + {3, 0x0a, 201}, + {6, 0x0a, 201}, + {10, 0x0a, 201}, + {15, 0x0a, 201}, + {24, 0x0a, 201}, + {31, 0x0a, 201}, + {41, 0x0a, 201}, + {56, 0x0b, 201}, + }, + /* 196 */ + { + {2, 0x0a, 202}, + {9, 0x0a, 202}, + {23, 0x0a, 202}, + {40, 0x0b, 202}, + {2, 0x0a, 205}, + {9, 0x0a, 205}, + {23, 0x0a, 205}, + {40, 0x0b, 205}, + {2, 0x0a, 210}, + {9, 0x0a, 210}, + {23, 0x0a, 210}, + {40, 0x0b, 210}, + {2, 0x0a, 213}, + {9, 0x0a, 213}, + {23, 0x0a, 213}, + {40, 0x0b, 213}, + }, + /* 197 */ + { + {3, 0x0a, 202}, + {6, 0x0a, 202}, + {10, 0x0a, 202}, + {15, 0x0a, 202}, + {24, 0x0a, 202}, + {31, 0x0a, 202}, + {41, 0x0a, 202}, + {56, 0x0b, 202}, + {3, 0x0a, 205}, + {6, 0x0a, 205}, + {10, 0x0a, 205}, + {15, 0x0a, 205}, + {24, 0x0a, 205}, + {31, 0x0a, 205}, + {41, 0x0a, 205}, + {56, 0x0b, 205}, + }, + /* 198 */ + { + {3, 0x0a, 210}, + {6, 0x0a, 210}, + {10, 0x0a, 210}, + {15, 0x0a, 210}, + {24, 0x0a, 210}, + {31, 0x0a, 210}, + {41, 0x0a, 210}, + {56, 0x0b, 210}, + {3, 0x0a, 213}, + {6, 0x0a, 213}, + {10, 0x0a, 213}, + {15, 0x0a, 213}, + {24, 0x0a, 213}, + {31, 0x0a, 213}, + {41, 0x0a, 213}, + {56, 0x0b, 213}, + }, + /* 199 */ + { + {1, 0x0a, 218}, + {22, 0x0b, 218}, + {1, 0x0a, 219}, + {22, 0x0b, 219}, + {1, 0x0a, 238}, + {22, 0x0b, 238}, + {1, 0x0a, 240}, + {22, 0x0b, 240}, + {1, 0x0a, 242}, + {22, 0x0b, 242}, + {1, 0x0a, 243}, + {22, 0x0b, 243}, + {1, 0x0a, 255}, + {22, 0x0b, 255}, + {0, 0x0b, 203}, + {0, 0x0b, 204}, + }, + /* 200 */ + { + {2, 0x0a, 218}, + {9, 0x0a, 218}, + {23, 0x0a, 218}, + {40, 0x0b, 218}, + {2, 0x0a, 219}, + {9, 0x0a, 219}, + {23, 0x0a, 219}, + {40, 0x0b, 219}, + {2, 0x0a, 238}, + {9, 0x0a, 238}, + {23, 0x0a, 238}, + {40, 0x0b, 238}, + {2, 0x0a, 240}, + {9, 0x0a, 240}, + {23, 0x0a, 240}, + {40, 0x0b, 240}, + }, + /* 201 */ + { + {3, 0x0a, 218}, + {6, 0x0a, 218}, + {10, 0x0a, 218}, + {15, 0x0a, 218}, + {24, 0x0a, 218}, + {31, 0x0a, 218}, + {41, 0x0a, 218}, + {56, 0x0b, 218}, + {3, 0x0a, 219}, + {6, 0x0a, 219}, + {10, 0x0a, 219}, + {15, 0x0a, 219}, + {24, 0x0a, 219}, + {31, 0x0a, 219}, + {41, 0x0a, 219}, + {56, 0x0b, 219}, + }, + /* 202 */ + { + {3, 0x0a, 238}, + {6, 0x0a, 238}, + {10, 0x0a, 238}, + {15, 0x0a, 238}, + {24, 0x0a, 238}, + {31, 0x0a, 238}, + {41, 0x0a, 238}, + {56, 0x0b, 238}, + {3, 0x0a, 240}, + {6, 0x0a, 240}, + {10, 0x0a, 240}, + {15, 0x0a, 240}, + {24, 0x0a, 240}, + {31, 0x0a, 240}, + {41, 0x0a, 240}, + {56, 0x0b, 240}, + }, + /* 203 */ + { + {2, 0x0a, 242}, + {9, 0x0a, 242}, + {23, 0x0a, 242}, + {40, 0x0b, 242}, + {2, 0x0a, 243}, + {9, 0x0a, 243}, + {23, 0x0a, 243}, + {40, 0x0b, 243}, + {2, 0x0a, 255}, + {9, 0x0a, 255}, + {23, 0x0a, 255}, + {40, 0x0b, 255}, + {1, 0x0a, 203}, + {22, 0x0b, 203}, + {1, 0x0a, 204}, + {22, 0x0b, 204}, + }, + /* 204 */ + { + {3, 0x0a, 242}, + {6, 0x0a, 242}, + {10, 0x0a, 242}, + {15, 0x0a, 242}, + {24, 0x0a, 242}, + {31, 0x0a, 242}, + {41, 0x0a, 242}, + {56, 0x0b, 242}, + {3, 0x0a, 243}, + {6, 0x0a, 243}, + {10, 0x0a, 243}, + {15, 0x0a, 243}, + {24, 0x0a, 243}, + {31, 0x0a, 243}, + {41, 0x0a, 243}, + {56, 0x0b, 243}, + }, + /* 205 */ + { + {3, 0x0a, 255}, + {6, 0x0a, 255}, + {10, 0x0a, 255}, + {15, 0x0a, 255}, + {24, 0x0a, 255}, + {31, 0x0a, 255}, + {41, 0x0a, 255}, + {56, 0x0b, 255}, + {2, 0x0a, 203}, + {9, 0x0a, 203}, + {23, 0x0a, 203}, + {40, 0x0b, 203}, + {2, 0x0a, 204}, + {9, 0x0a, 204}, + {23, 0x0a, 204}, + {40, 0x0b, 204}, + }, + /* 206 */ + { + {3, 0x0a, 203}, + {6, 0x0a, 203}, + {10, 0x0a, 203}, + {15, 0x0a, 203}, + {24, 0x0a, 203}, + {31, 0x0a, 203}, + {41, 0x0a, 203}, + {56, 0x0b, 203}, + {3, 0x0a, 204}, + {6, 0x0a, 204}, + {10, 0x0a, 204}, + {15, 0x0a, 204}, + {24, 0x0a, 204}, + {31, 0x0a, 204}, + {41, 0x0a, 204}, + {56, 0x0b, 204}, + }, + /* 207 */ + { + {211, 0x00, 0}, + {212, 0x00, 0}, + {214, 0x00, 0}, + {215, 0x00, 0}, + {218, 0x00, 0}, + {219, 0x00, 0}, + {221, 0x00, 0}, + {222, 0x00, 0}, + {226, 0x00, 0}, + {228, 0x00, 0}, + {232, 0x00, 0}, + {235, 0x00, 0}, + {240, 0x00, 0}, + {243, 0x00, 0}, + {247, 0x00, 0}, + {250, 0x00, 0}, + }, + /* 208 */ + { + {0, 0x0b, 211}, + {0, 0x0b, 212}, + {0, 0x0b, 214}, + {0, 0x0b, 221}, + {0, 0x0b, 222}, + {0, 0x0b, 223}, + {0, 0x0b, 241}, + {0, 0x0b, 244}, + {0, 0x0b, 245}, + {0, 0x0b, 246}, + {0, 0x0b, 247}, + {0, 0x0b, 248}, + {0, 0x0b, 250}, + {0, 0x0b, 251}, + {0, 0x0b, 252}, + {0, 0x0b, 253}, + }, + /* 209 */ + { + {1, 0x0a, 211}, + {22, 0x0b, 211}, + {1, 0x0a, 212}, + {22, 0x0b, 212}, + {1, 0x0a, 214}, + {22, 0x0b, 214}, + {1, 0x0a, 221}, + {22, 0x0b, 221}, + {1, 0x0a, 222}, + {22, 0x0b, 222}, + {1, 0x0a, 223}, + {22, 0x0b, 223}, + {1, 0x0a, 241}, + {22, 0x0b, 241}, + {1, 0x0a, 244}, + {22, 0x0b, 244}, + }, + /* 210 */ + { + {2, 0x0a, 211}, + {9, 0x0a, 211}, + {23, 0x0a, 211}, + {40, 0x0b, 211}, + {2, 0x0a, 212}, + {9, 0x0a, 212}, + {23, 0x0a, 212}, + {40, 0x0b, 212}, + {2, 0x0a, 214}, + {9, 0x0a, 214}, + {23, 0x0a, 214}, + {40, 0x0b, 214}, + {2, 0x0a, 221}, + {9, 0x0a, 221}, + {23, 0x0a, 221}, + {40, 0x0b, 221}, + }, + /* 211 */ + { + {3, 0x0a, 211}, + {6, 0x0a, 211}, + {10, 0x0a, 211}, + {15, 0x0a, 211}, + {24, 0x0a, 211}, + {31, 0x0a, 211}, + {41, 0x0a, 211}, + {56, 0x0b, 211}, + {3, 0x0a, 212}, + {6, 0x0a, 212}, + {10, 0x0a, 212}, + {15, 0x0a, 212}, + {24, 0x0a, 212}, + {31, 0x0a, 212}, + {41, 0x0a, 212}, + {56, 0x0b, 212}, + }, + /* 212 */ + { + {3, 0x0a, 214}, + {6, 0x0a, 214}, + {10, 0x0a, 214}, + {15, 0x0a, 214}, + {24, 0x0a, 214}, + {31, 0x0a, 214}, + {41, 0x0a, 214}, + {56, 0x0b, 214}, + {3, 0x0a, 221}, + {6, 0x0a, 221}, + {10, 0x0a, 221}, + {15, 0x0a, 221}, + {24, 0x0a, 221}, + {31, 0x0a, 221}, + {41, 0x0a, 221}, + {56, 0x0b, 221}, + }, + /* 213 */ + { + {2, 0x0a, 222}, + {9, 0x0a, 222}, + {23, 0x0a, 222}, + {40, 0x0b, 222}, + {2, 0x0a, 223}, + {9, 0x0a, 223}, + {23, 0x0a, 223}, + {40, 0x0b, 223}, + {2, 0x0a, 241}, + {9, 0x0a, 241}, + {23, 0x0a, 241}, + {40, 0x0b, 241}, + {2, 0x0a, 244}, + {9, 0x0a, 244}, + {23, 0x0a, 244}, + {40, 0x0b, 244}, + }, + /* 214 */ + { + {3, 0x0a, 222}, + {6, 0x0a, 222}, + {10, 0x0a, 222}, + {15, 0x0a, 222}, + {24, 0x0a, 222}, + {31, 0x0a, 222}, + {41, 0x0a, 222}, + {56, 0x0b, 222}, + {3, 0x0a, 223}, + {6, 0x0a, 223}, + {10, 0x0a, 223}, + {15, 0x0a, 223}, + {24, 0x0a, 223}, + {31, 0x0a, 223}, + {41, 0x0a, 223}, + {56, 0x0b, 223}, + }, + /* 215 */ + { + {3, 0x0a, 241}, + {6, 0x0a, 241}, + {10, 0x0a, 241}, + {15, 0x0a, 241}, + {24, 0x0a, 241}, + {31, 0x0a, 241}, + {41, 0x0a, 241}, + {56, 0x0b, 241}, + {3, 0x0a, 244}, + {6, 0x0a, 244}, + {10, 0x0a, 244}, + {15, 0x0a, 244}, + {24, 0x0a, 244}, + {31, 0x0a, 244}, + {41, 0x0a, 244}, + {56, 0x0b, 244}, + }, + /* 216 */ + { + {1, 0x0a, 245}, + {22, 0x0b, 245}, + {1, 0x0a, 246}, + {22, 0x0b, 246}, + {1, 0x0a, 247}, + {22, 0x0b, 247}, + {1, 0x0a, 248}, + {22, 0x0b, 248}, + {1, 0x0a, 250}, + {22, 0x0b, 250}, + {1, 0x0a, 251}, + {22, 0x0b, 251}, + {1, 0x0a, 252}, + {22, 0x0b, 252}, + {1, 0x0a, 253}, + {22, 0x0b, 253}, + }, + /* 217 */ + { + {2, 0x0a, 245}, + {9, 0x0a, 245}, + {23, 0x0a, 245}, + {40, 0x0b, 245}, + {2, 0x0a, 246}, + {9, 0x0a, 246}, + {23, 0x0a, 246}, + {40, 0x0b, 246}, + {2, 0x0a, 247}, + {9, 0x0a, 247}, + {23, 0x0a, 247}, + {40, 0x0b, 247}, + {2, 0x0a, 248}, + {9, 0x0a, 248}, + {23, 0x0a, 248}, + {40, 0x0b, 248}, + }, + /* 218 */ + { + {3, 0x0a, 245}, + {6, 0x0a, 245}, + {10, 0x0a, 245}, + {15, 0x0a, 245}, + {24, 0x0a, 245}, + {31, 0x0a, 245}, + {41, 0x0a, 245}, + {56, 0x0b, 245}, + {3, 0x0a, 246}, + {6, 0x0a, 246}, + {10, 0x0a, 246}, + {15, 0x0a, 246}, + {24, 0x0a, 246}, + {31, 0x0a, 246}, + {41, 0x0a, 246}, + {56, 0x0b, 246}, + }, + /* 219 */ + { + {3, 0x0a, 247}, + {6, 0x0a, 247}, + {10, 0x0a, 247}, + {15, 0x0a, 247}, + {24, 0x0a, 247}, + {31, 0x0a, 247}, + {41, 0x0a, 247}, + {56, 0x0b, 247}, + {3, 0x0a, 248}, + {6, 0x0a, 248}, + {10, 0x0a, 248}, + {15, 0x0a, 248}, + {24, 0x0a, 248}, + {31, 0x0a, 248}, + {41, 0x0a, 248}, + {56, 0x0b, 248}, + }, + /* 220 */ + { + {2, 0x0a, 250}, + {9, 0x0a, 250}, + {23, 0x0a, 250}, + {40, 0x0b, 250}, + {2, 0x0a, 251}, + {9, 0x0a, 251}, + {23, 0x0a, 251}, + {40, 0x0b, 251}, + {2, 0x0a, 252}, + {9, 0x0a, 252}, + {23, 0x0a, 252}, + {40, 0x0b, 252}, + {2, 0x0a, 253}, + {9, 0x0a, 253}, + {23, 0x0a, 253}, + {40, 0x0b, 253}, + }, + /* 221 */ + { + {3, 0x0a, 250}, + {6, 0x0a, 250}, + {10, 0x0a, 250}, + {15, 0x0a, 250}, + {24, 0x0a, 250}, + {31, 0x0a, 250}, + {41, 0x0a, 250}, + {56, 0x0b, 250}, + {3, 0x0a, 251}, + {6, 0x0a, 251}, + {10, 0x0a, 251}, + {15, 0x0a, 251}, + {24, 0x0a, 251}, + {31, 0x0a, 251}, + {41, 0x0a, 251}, + {56, 0x0b, 251}, + }, + /* 222 */ + { + {3, 0x0a, 252}, + {6, 0x0a, 252}, + {10, 0x0a, 252}, + {15, 0x0a, 252}, + {24, 0x0a, 252}, + {31, 0x0a, 252}, + {41, 0x0a, 252}, + {56, 0x0b, 252}, + {3, 0x0a, 253}, + {6, 0x0a, 253}, + {10, 0x0a, 253}, + {15, 0x0a, 253}, + {24, 0x0a, 253}, + {31, 0x0a, 253}, + {41, 0x0a, 253}, + {56, 0x0b, 253}, + }, + /* 223 */ + { + {0, 0x0b, 254}, + {227, 0x00, 0}, + {229, 0x00, 0}, + {230, 0x00, 0}, + {233, 0x00, 0}, + {234, 0x00, 0}, + {236, 0x00, 0}, + {237, 0x00, 0}, + {241, 0x00, 0}, + {242, 0x00, 0}, + {244, 0x00, 0}, + {245, 0x00, 0}, + {248, 0x00, 0}, + {249, 0x00, 0}, + {251, 0x00, 0}, + {252, 0x00, 0}, + }, + /* 224 */ + { + {1, 0x0a, 254}, + {22, 0x0b, 254}, + {0, 0x1b, 2}, + {0, 0x1b, 3}, + {0, 0x1b, 4}, + {0, 0x1b, 5}, + {0, 0x1b, 6}, + {0, 0x1b, 7}, + {0, 0x1b, 8}, + {0, 0x1b, 11}, + {0, 0x1b, 12}, + {0, 0x1b, 14}, + {0, 0x1b, 15}, + {0, 0x1b, 16}, + {0, 0x1b, 17}, + {0, 0x1b, 18}, + }, + /* 225 */ + { + {2, 0x0a, 254}, + {9, 0x0a, 254}, + {23, 0x0a, 254}, + {40, 0x0b, 254}, + {1, 0x1a, 2}, + {22, 0x1b, 2}, + {1, 0x1a, 3}, + {22, 0x1b, 3}, + {1, 0x1a, 4}, + {22, 0x1b, 4}, + {1, 0x1a, 5}, + {22, 0x1b, 5}, + {1, 0x1a, 6}, + {22, 0x1b, 6}, + {1, 0x1a, 7}, + {22, 0x1b, 7}, + }, + /* 226 */ + { + {3, 0x0a, 254}, + {6, 0x0a, 254}, + {10, 0x0a, 254}, + {15, 0x0a, 254}, + {24, 0x0a, 254}, + {31, 0x0a, 254}, + {41, 0x0a, 254}, + {56, 0x0b, 254}, + {2, 0x1a, 2}, + {9, 0x1a, 2}, + {23, 0x1a, 2}, + {40, 0x1b, 2}, + {2, 0x1a, 3}, + {9, 0x1a, 3}, + {23, 0x1a, 3}, + {40, 0x1b, 3}, + }, + /* 227 */ + { + {3, 0x1a, 2}, + {6, 0x1a, 2}, + {10, 0x1a, 2}, + {15, 0x1a, 2}, + {24, 0x1a, 2}, + {31, 0x1a, 2}, + {41, 0x1a, 2}, + {56, 0x1b, 2}, + {3, 0x1a, 3}, + {6, 0x1a, 3}, + {10, 0x1a, 3}, + {15, 0x1a, 3}, + {24, 0x1a, 3}, + {31, 0x1a, 3}, + {41, 0x1a, 3}, + {56, 0x1b, 3}, + }, + /* 228 */ + { + {2, 0x1a, 4}, + {9, 0x1a, 4}, + {23, 0x1a, 4}, + {40, 0x1b, 4}, + {2, 0x1a, 5}, + {9, 0x1a, 5}, + {23, 0x1a, 5}, + {40, 0x1b, 5}, + {2, 0x1a, 6}, + {9, 0x1a, 6}, + {23, 0x1a, 6}, + {40, 0x1b, 6}, + {2, 0x1a, 7}, + {9, 0x1a, 7}, + {23, 0x1a, 7}, + {40, 0x1b, 7}, + }, + /* 229 */ + { + {3, 0x1a, 4}, + {6, 0x1a, 4}, + {10, 0x1a, 4}, + {15, 0x1a, 4}, + {24, 0x1a, 4}, + {31, 0x1a, 4}, + {41, 0x1a, 4}, + {56, 0x1b, 4}, + {3, 0x1a, 5}, + {6, 0x1a, 5}, + {10, 0x1a, 5}, + {15, 0x1a, 5}, + {24, 0x1a, 5}, + {31, 0x1a, 5}, + {41, 0x1a, 5}, + {56, 0x1b, 5}, + }, + /* 230 */ + { + {3, 0x1a, 6}, + {6, 0x1a, 6}, + {10, 0x1a, 6}, + {15, 0x1a, 6}, + {24, 0x1a, 6}, + {31, 0x1a, 6}, + {41, 0x1a, 6}, + {56, 0x1b, 6}, + {3, 0x1a, 7}, + {6, 0x1a, 7}, + {10, 0x1a, 7}, + {15, 0x1a, 7}, + {24, 0x1a, 7}, + {31, 0x1a, 7}, + {41, 0x1a, 7}, + {56, 0x1b, 7}, + }, + /* 231 */ + { + {1, 0x1a, 8}, + {22, 0x1b, 8}, + {1, 0x1a, 11}, + {22, 0x1b, 11}, + {1, 0x1a, 12}, + {22, 0x1b, 12}, + {1, 0x1a, 14}, + {22, 0x1b, 14}, + {1, 0x1a, 15}, + {22, 0x1b, 15}, + {1, 0x1a, 16}, + {22, 0x1b, 16}, + {1, 0x1a, 17}, + {22, 0x1b, 17}, + {1, 0x1a, 18}, + {22, 0x1b, 18}, + }, + /* 232 */ + { + {2, 0x1a, 8}, + {9, 0x1a, 8}, + {23, 0x1a, 8}, + {40, 0x1b, 8}, + {2, 0x1a, 11}, + {9, 0x1a, 11}, + {23, 0x1a, 11}, + {40, 0x1b, 11}, + {2, 0x1a, 12}, + {9, 0x1a, 12}, + {23, 0x1a, 12}, + {40, 0x1b, 12}, + {2, 0x1a, 14}, + {9, 0x1a, 14}, + {23, 0x1a, 14}, + {40, 0x1b, 14}, + }, + /* 233 */ + { + {3, 0x1a, 8}, + {6, 0x1a, 8}, + {10, 0x1a, 8}, + {15, 0x1a, 8}, + {24, 0x1a, 8}, + {31, 0x1a, 8}, + {41, 0x1a, 8}, + {56, 0x1b, 8}, + {3, 0x1a, 11}, + {6, 0x1a, 11}, + {10, 0x1a, 11}, + {15, 0x1a, 11}, + {24, 0x1a, 11}, + {31, 0x1a, 11}, + {41, 0x1a, 11}, + {56, 0x1b, 11}, + }, + /* 234 */ + { + {3, 0x1a, 12}, + {6, 0x1a, 12}, + {10, 0x1a, 12}, + {15, 0x1a, 12}, + {24, 0x1a, 12}, + {31, 0x1a, 12}, + {41, 0x1a, 12}, + {56, 0x1b, 12}, + {3, 0x1a, 14}, + {6, 0x1a, 14}, + {10, 0x1a, 14}, + {15, 0x1a, 14}, + {24, 0x1a, 14}, + {31, 0x1a, 14}, + {41, 0x1a, 14}, + {56, 0x1b, 14}, + }, + /* 235 */ + { + {2, 0x1a, 15}, + {9, 0x1a, 15}, + {23, 0x1a, 15}, + {40, 0x1b, 15}, + {2, 0x1a, 16}, + {9, 0x1a, 16}, + {23, 0x1a, 16}, + {40, 0x1b, 16}, + {2, 0x1a, 17}, + {9, 0x1a, 17}, + {23, 0x1a, 17}, + {40, 0x1b, 17}, + {2, 0x1a, 18}, + {9, 0x1a, 18}, + {23, 0x1a, 18}, + {40, 0x1b, 18}, + }, + /* 236 */ + { + {3, 0x1a, 15}, + {6, 0x1a, 15}, + {10, 0x1a, 15}, + {15, 0x1a, 15}, + {24, 0x1a, 15}, + {31, 0x1a, 15}, + {41, 0x1a, 15}, + {56, 0x1b, 15}, + {3, 0x1a, 16}, + {6, 0x1a, 16}, + {10, 0x1a, 16}, + {15, 0x1a, 16}, + {24, 0x1a, 16}, + {31, 0x1a, 16}, + {41, 0x1a, 16}, + {56, 0x1b, 16}, + }, + /* 237 */ + { + {3, 0x1a, 17}, + {6, 0x1a, 17}, + {10, 0x1a, 17}, + {15, 0x1a, 17}, + {24, 0x1a, 17}, + {31, 0x1a, 17}, + {41, 0x1a, 17}, + {56, 0x1b, 17}, + {3, 0x1a, 18}, + {6, 0x1a, 18}, + {10, 0x1a, 18}, + {15, 0x1a, 18}, + {24, 0x1a, 18}, + {31, 0x1a, 18}, + {41, 0x1a, 18}, + {56, 0x1b, 18}, + }, + /* 238 */ + { + {0, 0x1b, 19}, + {0, 0x1b, 20}, + {0, 0x1b, 21}, + {0, 0x1b, 23}, + {0, 0x1b, 24}, + {0, 0x1b, 25}, + {0, 0x1b, 26}, + {0, 0x1b, 27}, + {0, 0x1b, 28}, + {0, 0x1b, 29}, + {0, 0x1b, 30}, + {0, 0x1b, 31}, + {0, 0x1b, 127}, + {0, 0x0b, 220}, + {0, 0x0b, 249}, + {253, 0x00, 0}, + }, + /* 239 */ + { + {1, 0x1a, 19}, + {22, 0x1b, 19}, + {1, 0x1a, 20}, + {22, 0x1b, 20}, + {1, 0x1a, 21}, + {22, 0x1b, 21}, + {1, 0x1a, 23}, + {22, 0x1b, 23}, + {1, 0x1a, 24}, + {22, 0x1b, 24}, + {1, 0x1a, 25}, + {22, 0x1b, 25}, + {1, 0x1a, 26}, + {22, 0x1b, 26}, + {1, 0x1a, 27}, + {22, 0x1b, 27}, + }, + /* 240 */ + { + {2, 0x1a, 19}, + {9, 0x1a, 19}, + {23, 0x1a, 19}, + {40, 0x1b, 19}, + {2, 0x1a, 20}, + {9, 0x1a, 20}, + {23, 0x1a, 20}, + {40, 0x1b, 20}, + {2, 0x1a, 21}, + {9, 0x1a, 21}, + {23, 0x1a, 21}, + {40, 0x1b, 21}, + {2, 0x1a, 23}, + {9, 0x1a, 23}, + {23, 0x1a, 23}, + {40, 0x1b, 23}, + }, + /* 241 */ + { + {3, 0x1a, 19}, + {6, 0x1a, 19}, + {10, 0x1a, 19}, + {15, 0x1a, 19}, + {24, 0x1a, 19}, + {31, 0x1a, 19}, + {41, 0x1a, 19}, + {56, 0x1b, 19}, + {3, 0x1a, 20}, + {6, 0x1a, 20}, + {10, 0x1a, 20}, + {15, 0x1a, 20}, + {24, 0x1a, 20}, + {31, 0x1a, 20}, + {41, 0x1a, 20}, + {56, 0x1b, 20}, + }, + /* 242 */ + { + {3, 0x1a, 21}, + {6, 0x1a, 21}, + {10, 0x1a, 21}, + {15, 0x1a, 21}, + {24, 0x1a, 21}, + {31, 0x1a, 21}, + {41, 0x1a, 21}, + {56, 0x1b, 21}, + {3, 0x1a, 23}, + {6, 0x1a, 23}, + {10, 0x1a, 23}, + {15, 0x1a, 23}, + {24, 0x1a, 23}, + {31, 0x1a, 23}, + {41, 0x1a, 23}, + {56, 0x1b, 23}, + }, + /* 243 */ + { + {2, 0x1a, 24}, + {9, 0x1a, 24}, + {23, 0x1a, 24}, + {40, 0x1b, 24}, + {2, 0x1a, 25}, + {9, 0x1a, 25}, + {23, 0x1a, 25}, + {40, 0x1b, 25}, + {2, 0x1a, 26}, + {9, 0x1a, 26}, + {23, 0x1a, 26}, + {40, 0x1b, 26}, + {2, 0x1a, 27}, + {9, 0x1a, 27}, + {23, 0x1a, 27}, + {40, 0x1b, 27}, + }, + /* 244 */ + { + {3, 0x1a, 24}, + {6, 0x1a, 24}, + {10, 0x1a, 24}, + {15, 0x1a, 24}, + {24, 0x1a, 24}, + {31, 0x1a, 24}, + {41, 0x1a, 24}, + {56, 0x1b, 24}, + {3, 0x1a, 25}, + {6, 0x1a, 25}, + {10, 0x1a, 25}, + {15, 0x1a, 25}, + {24, 0x1a, 25}, + {31, 0x1a, 25}, + {41, 0x1a, 25}, + {56, 0x1b, 25}, + }, + /* 245 */ + { + {3, 0x1a, 26}, + {6, 0x1a, 26}, + {10, 0x1a, 26}, + {15, 0x1a, 26}, + {24, 0x1a, 26}, + {31, 0x1a, 26}, + {41, 0x1a, 26}, + {56, 0x1b, 26}, + {3, 0x1a, 27}, + {6, 0x1a, 27}, + {10, 0x1a, 27}, + {15, 0x1a, 27}, + {24, 0x1a, 27}, + {31, 0x1a, 27}, + {41, 0x1a, 27}, + {56, 0x1b, 27}, + }, + /* 246 */ + { + {1, 0x1a, 28}, + {22, 0x1b, 28}, + {1, 0x1a, 29}, + {22, 0x1b, 29}, + {1, 0x1a, 30}, + {22, 0x1b, 30}, + {1, 0x1a, 31}, + {22, 0x1b, 31}, + {1, 0x1a, 127}, + {22, 0x1b, 127}, + {1, 0x0a, 220}, + {22, 0x0b, 220}, + {1, 0x0a, 249}, + {22, 0x0b, 249}, + {254, 0x00, 0}, + {255, 0x00, 0}, + }, + /* 247 */ + { + {2, 0x1a, 28}, + {9, 0x1a, 28}, + {23, 0x1a, 28}, + {40, 0x1b, 28}, + {2, 0x1a, 29}, + {9, 0x1a, 29}, + {23, 0x1a, 29}, + {40, 0x1b, 29}, + {2, 0x1a, 30}, + {9, 0x1a, 30}, + {23, 0x1a, 30}, + {40, 0x1b, 30}, + {2, 0x1a, 31}, + {9, 0x1a, 31}, + {23, 0x1a, 31}, + {40, 0x1b, 31}, + }, + /* 248 */ + { + {3, 0x1a, 28}, + {6, 0x1a, 28}, + {10, 0x1a, 28}, + {15, 0x1a, 28}, + {24, 0x1a, 28}, + {31, 0x1a, 28}, + {41, 0x1a, 28}, + {56, 0x1b, 28}, + {3, 0x1a, 29}, + {6, 0x1a, 29}, + {10, 0x1a, 29}, + {15, 0x1a, 29}, + {24, 0x1a, 29}, + {31, 0x1a, 29}, + {41, 0x1a, 29}, + {56, 0x1b, 29}, + }, + /* 249 */ + { + {3, 0x1a, 30}, + {6, 0x1a, 30}, + {10, 0x1a, 30}, + {15, 0x1a, 30}, + {24, 0x1a, 30}, + {31, 0x1a, 30}, + {41, 0x1a, 30}, + {56, 0x1b, 30}, + {3, 0x1a, 31}, + {6, 0x1a, 31}, + {10, 0x1a, 31}, + {15, 0x1a, 31}, + {24, 0x1a, 31}, + {31, 0x1a, 31}, + {41, 0x1a, 31}, + {56, 0x1b, 31}, + }, + /* 250 */ + { + {2, 0x1a, 127}, + {9, 0x1a, 127}, + {23, 0x1a, 127}, + {40, 0x1b, 127}, + {2, 0x0a, 220}, + {9, 0x0a, 220}, + {23, 0x0a, 220}, + {40, 0x0b, 220}, + {2, 0x0a, 249}, + {9, 0x0a, 249}, + {23, 0x0a, 249}, + {40, 0x0b, 249}, + {0, 0x1b, 10}, + {0, 0x1b, 13}, + {0, 0x1b, 22}, + {0, 0x04, 0}, + }, + /* 251 */ + { + {3, 0x1a, 127}, + {6, 0x1a, 127}, + {10, 0x1a, 127}, + {15, 0x1a, 127}, + {24, 0x1a, 127}, + {31, 0x1a, 127}, + {41, 0x1a, 127}, + {56, 0x1b, 127}, + {3, 0x0a, 220}, + {6, 0x0a, 220}, + {10, 0x0a, 220}, + {15, 0x0a, 220}, + {24, 0x0a, 220}, + {31, 0x0a, 220}, + {41, 0x0a, 220}, + {56, 0x0b, 220}, + }, + /* 252 */ + { + {3, 0x0a, 249}, + {6, 0x0a, 249}, + {10, 0x0a, 249}, + {15, 0x0a, 249}, + {24, 0x0a, 249}, + {31, 0x0a, 249}, + {41, 0x0a, 249}, + {56, 0x0b, 249}, + {1, 0x1a, 10}, + {22, 0x1b, 10}, + {1, 0x1a, 13}, + {22, 0x1b, 13}, + {1, 0x1a, 22}, + {22, 0x1b, 22}, + {0, 0x04, 0}, + {0, 0x04, 0}, + }, + /* 253 */ + { + {2, 0x1a, 10}, + {9, 0x1a, 10}, + {23, 0x1a, 10}, + {40, 0x1b, 10}, + {2, 0x1a, 13}, + {9, 0x1a, 13}, + {23, 0x1a, 13}, + {40, 0x1b, 13}, + {2, 0x1a, 22}, + {9, 0x1a, 22}, + {23, 0x1a, 22}, + {40, 0x1b, 22}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + }, + /* 254 */ + { + {3, 0x1a, 10}, + {6, 0x1a, 10}, + {10, 0x1a, 10}, + {15, 0x1a, 10}, + {24, 0x1a, 10}, + {31, 0x1a, 10}, + {41, 0x1a, 10}, + {56, 0x1b, 10}, + {3, 0x1a, 13}, + {6, 0x1a, 13}, + {10, 0x1a, 13}, + {15, 0x1a, 13}, + {24, 0x1a, 13}, + {31, 0x1a, 13}, + {41, 0x1a, 13}, + {56, 0x1b, 13}, + }, + /* 255 */ + { + {3, 0x1a, 22}, + {6, 0x1a, 22}, + {10, 0x1a, 22}, + {15, 0x1a, 22}, + {24, 0x1a, 22}, + {31, 0x1a, 22}, + {41, 0x1a, 22}, + {56, 0x1b, 22}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + {0, 0x04, 0}, + }, +}; diff --git a/web/server/h2o/libh2o/lib/http2/hpack_static_table.h b/web/server/h2o/libh2o/lib/http2/hpack_static_table.h new file mode 100644 index 000000000..4c1243103 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/hpack_static_table.h @@ -0,0 +1,87 @@ +/* + * 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. + */ + +/* automatically generated by tokens.pl */ + +static const struct st_h2o_hpack_static_table_entry_t h2o_hpack_static_table[61] = { + { H2O_TOKEN_AUTHORITY, { H2O_STRLIT("") } }, + { H2O_TOKEN_METHOD, { H2O_STRLIT("GET") } }, + { H2O_TOKEN_METHOD, { H2O_STRLIT("POST") } }, + { H2O_TOKEN_PATH, { H2O_STRLIT("/") } }, + { H2O_TOKEN_PATH, { H2O_STRLIT("/index.html") } }, + { H2O_TOKEN_SCHEME, { H2O_STRLIT("http") } }, + { H2O_TOKEN_SCHEME, { H2O_STRLIT("https") } }, + { H2O_TOKEN_STATUS, { H2O_STRLIT("200") } }, + { H2O_TOKEN_STATUS, { H2O_STRLIT("204") } }, + { H2O_TOKEN_STATUS, { H2O_STRLIT("206") } }, + { H2O_TOKEN_STATUS, { H2O_STRLIT("304") } }, + { H2O_TOKEN_STATUS, { H2O_STRLIT("400") } }, + { H2O_TOKEN_STATUS, { H2O_STRLIT("404") } }, + { H2O_TOKEN_STATUS, { H2O_STRLIT("500") } }, + { H2O_TOKEN_ACCEPT_CHARSET, { H2O_STRLIT("") } }, + { H2O_TOKEN_ACCEPT_ENCODING, { H2O_STRLIT("gzip, deflate") } }, + { H2O_TOKEN_ACCEPT_LANGUAGE, { H2O_STRLIT("") } }, + { H2O_TOKEN_ACCEPT_RANGES, { H2O_STRLIT("") } }, + { H2O_TOKEN_ACCEPT, { H2O_STRLIT("") } }, + { H2O_TOKEN_ACCESS_CONTROL_ALLOW_ORIGIN, { H2O_STRLIT("") } }, + { H2O_TOKEN_AGE, { H2O_STRLIT("") } }, + { H2O_TOKEN_ALLOW, { H2O_STRLIT("") } }, + { H2O_TOKEN_AUTHORIZATION, { H2O_STRLIT("") } }, + { H2O_TOKEN_CACHE_CONTROL, { H2O_STRLIT("") } }, + { H2O_TOKEN_CONTENT_DISPOSITION, { H2O_STRLIT("") } }, + { H2O_TOKEN_CONTENT_ENCODING, { H2O_STRLIT("") } }, + { H2O_TOKEN_CONTENT_LANGUAGE, { H2O_STRLIT("") } }, + { H2O_TOKEN_CONTENT_LENGTH, { H2O_STRLIT("") } }, + { H2O_TOKEN_CONTENT_LOCATION, { H2O_STRLIT("") } }, + { H2O_TOKEN_CONTENT_RANGE, { H2O_STRLIT("") } }, + { H2O_TOKEN_CONTENT_TYPE, { H2O_STRLIT("") } }, + { H2O_TOKEN_COOKIE, { H2O_STRLIT("") } }, + { H2O_TOKEN_DATE, { H2O_STRLIT("") } }, + { H2O_TOKEN_ETAG, { H2O_STRLIT("") } }, + { H2O_TOKEN_EXPECT, { H2O_STRLIT("") } }, + { H2O_TOKEN_EXPIRES, { H2O_STRLIT("") } }, + { H2O_TOKEN_FROM, { H2O_STRLIT("") } }, + { H2O_TOKEN_HOST, { H2O_STRLIT("") } }, + { H2O_TOKEN_IF_MATCH, { H2O_STRLIT("") } }, + { H2O_TOKEN_IF_MODIFIED_SINCE, { H2O_STRLIT("") } }, + { H2O_TOKEN_IF_NONE_MATCH, { H2O_STRLIT("") } }, + { H2O_TOKEN_IF_RANGE, { H2O_STRLIT("") } }, + { H2O_TOKEN_IF_UNMODIFIED_SINCE, { H2O_STRLIT("") } }, + { H2O_TOKEN_LAST_MODIFIED, { H2O_STRLIT("") } }, + { H2O_TOKEN_LINK, { H2O_STRLIT("") } }, + { H2O_TOKEN_LOCATION, { H2O_STRLIT("") } }, + { H2O_TOKEN_MAX_FORWARDS, { H2O_STRLIT("") } }, + { H2O_TOKEN_PROXY_AUTHENTICATE, { H2O_STRLIT("") } }, + { H2O_TOKEN_PROXY_AUTHORIZATION, { H2O_STRLIT("") } }, + { H2O_TOKEN_RANGE, { H2O_STRLIT("") } }, + { H2O_TOKEN_REFERER, { H2O_STRLIT("") } }, + { H2O_TOKEN_REFRESH, { H2O_STRLIT("") } }, + { H2O_TOKEN_RETRY_AFTER, { H2O_STRLIT("") } }, + { H2O_TOKEN_SERVER, { H2O_STRLIT("") } }, + { H2O_TOKEN_SET_COOKIE, { H2O_STRLIT("") } }, + { H2O_TOKEN_STRICT_TRANSPORT_SECURITY, { H2O_STRLIT("") } }, + { H2O_TOKEN_TRANSFER_ENCODING, { H2O_STRLIT("") } }, + { H2O_TOKEN_USER_AGENT, { H2O_STRLIT("") } }, + { H2O_TOKEN_VARY, { H2O_STRLIT("") } }, + { H2O_TOKEN_VIA, { H2O_STRLIT("") } }, + { H2O_TOKEN_WWW_AUTHENTICATE, { H2O_STRLIT("") } } +}; diff --git a/web/server/h2o/libh2o/lib/http2/http2_debug_state.c b/web/server/h2o/libh2o/lib/http2/http2_debug_state.c new file mode 100644 index 000000000..3ef8de37f --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/http2_debug_state.c @@ -0,0 +1,194 @@ +/* + * Copyright (c) 2016 DeNA Co., Ltd., Ichito Nagata + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ +#include <inttypes.h> +#include "h2o.h" +#include "h2o/http2.h" +#include "h2o/http2_internal.h" + +static const char *debug_state_string_open = "OPEN"; +static const char *debug_state_string_half_closed_remote = "HALF_CLOSED_REMOTE"; +static const char *debug_state_string_reserved_local = "RESERVED_LOCAL"; + +static const char *get_debug_state_string(h2o_http2_stream_t *stream) +{ + if (h2o_http2_stream_is_push(stream->stream_id)) { + switch (stream->state) { + case H2O_HTTP2_STREAM_STATE_RECV_HEADERS: + case H2O_HTTP2_STREAM_STATE_RECV_BODY: + case H2O_HTTP2_STREAM_STATE_REQ_PENDING: + return debug_state_string_reserved_local; + case H2O_HTTP2_STREAM_STATE_SEND_HEADERS: + case H2O_HTTP2_STREAM_STATE_SEND_BODY: + case H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL: + return debug_state_string_half_closed_remote; + case H2O_HTTP2_STREAM_STATE_IDLE: + case H2O_HTTP2_STREAM_STATE_END_STREAM: + return NULL; + } + } else { + switch (stream->state) { + case H2O_HTTP2_STREAM_STATE_RECV_HEADERS: + case H2O_HTTP2_STREAM_STATE_RECV_BODY: + return debug_state_string_open; + case H2O_HTTP2_STREAM_STATE_REQ_PENDING: + case H2O_HTTP2_STREAM_STATE_SEND_HEADERS: + case H2O_HTTP2_STREAM_STATE_SEND_BODY: + case H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL: + return debug_state_string_half_closed_remote; + case H2O_HTTP2_STREAM_STATE_IDLE: + case H2O_HTTP2_STREAM_STATE_END_STREAM: + return NULL; + } + } + return NULL; +} + +__attribute__((format(printf, 3, 4))) static void append_chunk(h2o_mem_pool_t *pool, h2o_iovec_vector_t *chunks, const char *fmt, + ...) +{ + va_list args; + + va_start(args, fmt); + int size = vsnprintf(NULL, 0, fmt, args); + va_end(args); + + assert(size > 0); + + h2o_iovec_t v; + v.base = h2o_mem_alloc_pool(pool, size + 1); + + va_start(args, fmt); + v.len = vsnprintf(v.base, size + 1, fmt, args); + va_end(args); + + h2o_vector_reserve(pool, chunks, chunks->size + 1); + chunks->entries[chunks->size++] = v; +} + +static void append_header_table_chunks(h2o_mem_pool_t *pool, h2o_iovec_vector_t *chunks, h2o_hpack_header_table_t *header_table) +{ + int i; + for (i = 0; i < header_table->num_entries; i++) { + h2o_hpack_header_table_entry_t *entry = h2o_hpack_header_table_get(header_table, i); + append_chunk(pool, chunks, "\n" + " [ \"%.*s\", \"%.*s\" ],", + (int)entry->name->len, entry->name->base, (int)entry->value->len, entry->value->base); + } + + if (i > 0) { + // remove the last commna + --chunks->entries[chunks->size - 1].len; + } +} + +h2o_http2_debug_state_t *h2o_http2_get_debug_state(h2o_req_t *req, int hpack_enabled) +{ + h2o_http2_conn_t *conn = (h2o_http2_conn_t *)req->conn; + h2o_http2_debug_state_t *state = h2o_mem_alloc_pool(&req->pool, sizeof(*state)); + *state = (h2o_http2_debug_state_t){{NULL}}; + + state->conn_flow_in = conn->_write.window._avail; + state->conn_flow_out = conn->_write.window._avail; + + append_chunk(&req->pool, &state->json, "{\n" + " \"version\": \"draft-01\",\n" + " \"settings\": {\n" + " \"SETTINGS_HEADER_TABLE_SIZE\": %" PRIu32 ",\n" + " \"SETTINGS_ENABLE_PUSH\": %" PRIu32 ",\n" + " \"SETTINGS_MAX_CONCURRENT_STREAMS\": %" PRIu32 ",\n" + " \"SETTINGS_INITIAL_WINDOW_SIZE\": %" PRIu32 ",\n" + " \"SETTINGS_MAX_FRAME_SIZE\": %" PRIu32 "\n" + " },\n" + " \"peerSettings\": {\n" + " \"SETTINGS_HEADER_TABLE_SIZE\": %" PRIu32 ",\n" + " \"SETTINGS_ENABLE_PUSH\": %" PRIu32 ",\n" + " \"SETTINGS_MAX_CONCURRENT_STREAMS\": %" PRIu32 ",\n" + " \"SETTINGS_INITIAL_WINDOW_SIZE\": %" PRIu32 ",\n" + " \"SETTINGS_MAX_FRAME_SIZE\": %" PRIu32 "\n" + " },\n" + " \"connFlowIn\": %zd,\n" + " \"connFlowOut\": %zd,\n" + " \"streams\": {", + H2O_HTTP2_SETTINGS_HOST.header_table_size, H2O_HTTP2_SETTINGS_HOST.enable_push, + H2O_HTTP2_SETTINGS_HOST.max_concurrent_streams, H2O_HTTP2_SETTINGS_HOST.initial_window_size, + H2O_HTTP2_SETTINGS_HOST.max_frame_size, conn->peer_settings.header_table_size, conn->peer_settings.enable_push, + conn->peer_settings.max_concurrent_streams, conn->peer_settings.initial_window_size, + conn->peer_settings.max_frame_size, conn->_input_window._avail, conn->_write.window._avail); + + /* encode streams */ + { + h2o_http2_stream_t *stream; + kh_foreach_value(conn->streams, stream, { + const char *state_string = get_debug_state_string(stream); + if (state_string == NULL) + continue; + + append_chunk(&req->pool, &state->json, "\n" + " \"%" PRIu32 "\": {\n" + " \"state\": \"%s\",\n" + " \"flowIn\": %zd,\n" + " \"flowOut\": %zd,\n" + " \"dataIn\": %zu,\n" + " \"dataOut\": %zu,\n" + " \"created\": %" PRIu64 "\n" + " },", + stream->stream_id, state_string, stream->input_window._avail, stream->output_window._avail, + (stream->_req_body == NULL ? 0 : stream->_req_body->size), stream->req.bytes_sent, + (uint64_t)stream->req.timestamps.request_begin_at.tv_sec); + }); + + if (conn->streams->size > 0) { + // remove the last commna + --state->json.entries[state->json.size - 1].len; + } + } + + append_chunk(&req->pool, &state->json, "\n" + " }"); + + if (hpack_enabled) { + /* encode inbound header table */ + append_chunk(&req->pool, &state->json, ",\n" + " \"hpack\": {\n" + " \"inboundTableSize\": %zd,\n" + " \"inboundDynamicHeaderTable\": [", + conn->_input_header_table.num_entries); + append_header_table_chunks(&req->pool, &state->json, &conn->_input_header_table); + + /* encode outbound header table */ + append_chunk(&req->pool, &state->json, "\n" + " ],\n" + " \"outboundTableSize\": %zd,\n" + " \"outboundDynamicHeaderTable\": [", + conn->_output_header_table.num_entries); + append_header_table_chunks(&req->pool, &state->json, &conn->_output_header_table); + + append_chunk(&req->pool, &state->json, "\n" + " ]\n" + " }"); + } + + append_chunk(&req->pool, &state->json, "\n" + "}\n"); + + return state; +} diff --git a/web/server/h2o/libh2o/lib/http2/scheduler.c b/web/server/h2o/libh2o/lib/http2/scheduler.c new file mode 100644 index 000000000..0ea7e4591 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/scheduler.c @@ -0,0 +1,365 @@ +/* + * 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 "h2o.h" +#include "h2o/http2_scheduler.h" + +struct st_h2o_http2_scheduler_queue_t { + uint64_t bits; + size_t offset; + h2o_linklist_t anchors[64]; + h2o_linklist_t anchor257; +}; + +static void queue_init(h2o_http2_scheduler_queue_t *queue) +{ + size_t i; + queue->bits = 0; + queue->offset = 0; + for (i = 0; i != sizeof(queue->anchors) / sizeof(queue->anchors[0]); ++i) + h2o_linklist_init_anchor(queue->anchors + i); + h2o_linklist_init_anchor(&queue->anchor257); +} + +static int queue_is_empty(h2o_http2_scheduler_queue_t *queue) +{ + return queue->bits == 0 && h2o_linklist_is_empty(&queue->anchor257); +} + +static void queue_set(h2o_http2_scheduler_queue_t *queue, h2o_http2_scheduler_queue_node_t *node, uint16_t weight) +{ + /* holds 257 entries of offsets (multiplied by 65536) where nodes with weights between 1..257 should go into + * each entry (expect for weight=256) is calculated as: round(N / weight), where N is adjusted so that the + * value would become 63*65536 for weight=0. + * weight=257 is used internally to send data before any of the streams being pulled, and therefore has the offset set to zero. + */ + static const unsigned OFFSET_TABLE[] = { + 4128768, 2064384, 1376256, 1032192, 825754, 688128, 589824, 516096, 458752, 412877, 375343, 344064, 317598, 294912, 275251, + 258048, 242869, 229376, 217304, 206438, 196608, 187671, 179512, 172032, 165151, 158799, 152917, 147456, 142371, 137626, + 133186, 129024, 125114, 121434, 117965, 114688, 111588, 108652, 105866, 103219, 100702, 98304, 96018, 93836, 91750, + 89756, 87846, 86016, 84261, 82575, 80956, 79399, 77901, 76459, 75069, 73728, 72435, 71186, 69979, 68813, + 67685, 66593, 65536, 64512, 63520, 62557, 61623, 60717, 59837, 58982, 58152, 57344, 56558, 55794, 55050, + 54326, 53620, 52933, 52263, 51610, 50972, 50351, 49744, 49152, 48574, 48009, 47457, 46918, 46391, 45875, + 45371, 44878, 44395, 43923, 43461, 43008, 42565, 42130, 41705, 41288, 40879, 40478, 40085, 39700, 39322, + 38951, 38587, 38229, 37879, 37534, 37196, 36864, 36538, 36217, 35902, 35593, 35289, 34990, 34696, 34406, + 34122, 33842, 33567, 33297, 33030, 32768, 32510, 32256, 32006, 31760, 31517, 31279, 31043, 30812, 30583, + 30359, 30137, 29919, 29703, 29491, 29282, 29076, 28873, 28672, 28474, 28279, 28087, 27897, 27710, 27525, + 27343, 27163, 26985, 26810, 26637, 26466, 26298, 26131, 25967, 25805, 25645, 25486, 25330, 25175, 25023, + 24872, 24723, 24576, 24431, 24287, 24145, 24004, 23866, 23729, 23593, 23459, 23326, 23195, 23066, 22938, + 22811, 22686, 22562, 22439, 22318, 22198, 22079, 21962, 21845, 21730, 21617, 21504, 21393, 21282, 21173, + 21065, 20958, 20852, 20748, 20644, 20541, 20439, 20339, 20239, 20140, 20043, 19946, 19850, 19755, 19661, + 19568, 19475, 19384, 19293, 19204, 19115, 19027, 18939, 18853, 18767, 18682, 18598, 18515, 18432, 18350, + 18269, 18188, 18109, 18030, 17951, 17873, 17796, 17720, 17644, 17569, 17495, 17421, 17348, 17275, 17203, + 17132, 17061, 16991, 16921, 16852, 16784, 16716, 16648, 16581, 16515, 16449, 16384, 16319, 16255, 16191, + 16128, 0}; + + assert(!h2o_linklist_is_linked(&node->_link)); + + if (weight > 256) { + + h2o_linklist_insert(&queue->anchor257, &node->_link); + + } else { + + assert(1 <= weight); + + size_t offset = OFFSET_TABLE[weight - 1] + node->_deficit; + node->_deficit = offset % 65536; + offset = offset / 65536; + + queue->bits |= 1ULL << (sizeof(queue->bits) * 8 - 1 - offset); + h2o_linklist_insert(queue->anchors + (queue->offset + offset) % (sizeof(queue->anchors) / sizeof(queue->anchors[0])), + &node->_link); + } +} + +static void queue_unset(h2o_http2_scheduler_queue_node_t *node) +{ + assert(h2o_linklist_is_linked(&node->_link)); + h2o_linklist_unlink(&node->_link); +} + +static h2o_http2_scheduler_queue_node_t *queue_pop(h2o_http2_scheduler_queue_t *queue) +{ + if (!h2o_linklist_is_empty(&queue->anchor257)) { + h2o_http2_scheduler_queue_node_t *node = + H2O_STRUCT_FROM_MEMBER(h2o_http2_scheduler_queue_node_t, _link, queue->anchor257.next); + h2o_linklist_unlink(&node->_link); + return node; + } + + while (queue->bits != 0) { + int zeroes = __builtin_clzll(queue->bits); + queue->bits <<= zeroes; + queue->offset = (queue->offset + zeroes) % (sizeof(queue->anchors) / sizeof(queue->anchors[0])); + if (!h2o_linklist_is_empty(queue->anchors + queue->offset)) { + h2o_http2_scheduler_queue_node_t *node = + H2O_STRUCT_FROM_MEMBER(h2o_http2_scheduler_queue_node_t, _link, queue->anchors[queue->offset].next); + h2o_linklist_unlink(&node->_link); + if (h2o_linklist_is_empty(queue->anchors + queue->offset)) + queue->bits &= (1ULL << (sizeof(queue->bits) * 8 - 1)) - 1; + return node; + } + queue->bits &= (1ULL << (sizeof(queue->bits) * 8 - 1)) - 1; + } + return NULL; +} + +static void init_node(h2o_http2_scheduler_node_t *node, h2o_http2_scheduler_node_t *parent) +{ + *node = (h2o_http2_scheduler_node_t){parent}; + h2o_linklist_init_anchor(&node->_all_refs); +} + +static h2o_http2_scheduler_queue_t *get_queue(h2o_http2_scheduler_node_t *node) +{ + if (node->_queue == NULL) { + node->_queue = h2o_mem_alloc(sizeof(*node->_queue)); + queue_init(node->_queue); + } + return node->_queue; +} + +static void incr_active_cnt(h2o_http2_scheduler_node_t *node) +{ + h2o_http2_scheduler_openref_t *ref; + + /* do nothing if node is the root */ + if (node->_parent == NULL) + return; + + ref = (h2o_http2_scheduler_openref_t *)node; + if (++ref->_active_cnt != 1) + return; + /* just changed to active */ + queue_set(get_queue(ref->node._parent), &ref->_queue_node, ref->weight); + /* delegate the change towards root */ + incr_active_cnt(ref->node._parent); +} + +static void decr_active_cnt(h2o_http2_scheduler_node_t *node) +{ + h2o_http2_scheduler_openref_t *ref; + + /* do notnig if node is the root */ + if (node->_parent == NULL) + return; + + ref = (h2o_http2_scheduler_openref_t *)node; + if (--ref->_active_cnt != 0) + return; + /* just changed to inactive */ + queue_unset(&ref->_queue_node); + /* delegate the change towards root */ + decr_active_cnt(ref->node._parent); +} + +static void convert_to_exclusive(h2o_http2_scheduler_node_t *parent, h2o_http2_scheduler_openref_t *added) +{ + while (!h2o_linklist_is_empty(&parent->_all_refs)) { + h2o_http2_scheduler_openref_t *child_ref = + H2O_STRUCT_FROM_MEMBER(h2o_http2_scheduler_openref_t, _all_link, parent->_all_refs.next); + if (child_ref == added) { + /* precond: the added node should exist as the last item within parent */ + assert(parent->_all_refs.prev == &added->_all_link); + break; + } + h2o_http2_scheduler_rebind(child_ref, &added->node, h2o_http2_scheduler_get_weight(child_ref), 0); + } +} + +void h2o_http2_scheduler_open(h2o_http2_scheduler_openref_t *ref, h2o_http2_scheduler_node_t *parent, uint16_t weight, + int exclusive) +{ + init_node(&ref->node, parent); + ref->weight = weight; + ref->_all_link = (h2o_linklist_t){NULL}; + ref->_active_cnt = 0; + ref->_self_is_active = 0; + ref->_queue_node = (h2o_http2_scheduler_queue_node_t){{NULL}}; + + h2o_linklist_insert(&parent->_all_refs, &ref->_all_link); + + if (exclusive) + convert_to_exclusive(parent, ref); +} + +void h2o_http2_scheduler_close(h2o_http2_scheduler_openref_t *ref) +{ + assert(h2o_http2_scheduler_is_open(ref)); + + /* move dependents to parent */ + if (!h2o_linklist_is_empty(&ref->node._all_refs)) { + /* proportionally distribute the weight to the children (draft-16 5.3.4) */ + uint32_t total_weight = 0, factor; + h2o_linklist_t *link; + for (link = ref->node._all_refs.next; link != &ref->node._all_refs; link = link->next) { + h2o_http2_scheduler_openref_t *child_ref = H2O_STRUCT_FROM_MEMBER(h2o_http2_scheduler_openref_t, _all_link, link); + total_weight += child_ref->weight; + } + assert(total_weight != 0); + factor = ((uint32_t)ref->weight * 65536 + total_weight / 2) / total_weight; + do { + h2o_http2_scheduler_openref_t *child_ref = + H2O_STRUCT_FROM_MEMBER(h2o_http2_scheduler_openref_t, _all_link, ref->node._all_refs.next); + uint16_t weight = (child_ref->weight * factor / 32768 + 1) / 2; + if (weight < 1) + weight = 1; + else if (weight > 256) + weight = 256; + h2o_http2_scheduler_rebind(child_ref, ref->node._parent, weight, 0); + } while (!h2o_linklist_is_empty(&ref->node._all_refs)); + } + + free(ref->node._queue); + ref->node._queue = NULL; + + /* detach self */ + h2o_linklist_unlink(&ref->_all_link); + if (ref->_self_is_active) { + assert(ref->_active_cnt == 1); + queue_unset(&ref->_queue_node); + decr_active_cnt(ref->node._parent); + } else { + assert(ref->_active_cnt == 0); + } +} + +static void do_rebind(h2o_http2_scheduler_openref_t *ref, h2o_http2_scheduler_node_t *new_parent, int exclusive) +{ + /* rebind _all_link */ + h2o_linklist_unlink(&ref->_all_link); + h2o_linklist_insert(&new_parent->_all_refs, &ref->_all_link); + /* rebind to WRR (as well as adjust active_cnt) */ + if (ref->_active_cnt != 0) { + queue_unset(&ref->_queue_node); + queue_set(get_queue(new_parent), &ref->_queue_node, ref->weight); + decr_active_cnt(ref->node._parent); + incr_active_cnt(new_parent); + } + /* update the backlinks */ + ref->node._parent = new_parent; + + if (exclusive) + convert_to_exclusive(new_parent, ref); +} + +void h2o_http2_scheduler_rebind(h2o_http2_scheduler_openref_t *ref, h2o_http2_scheduler_node_t *new_parent, uint16_t weight, + int exclusive) +{ + assert(h2o_http2_scheduler_is_open(ref)); + assert(&ref->node != new_parent); + assert(1 <= weight); + assert(weight <= 257); + + /* do nothing if there'd be no change at all */ + if (ref->node._parent == new_parent && ref->weight == weight && !exclusive) + return; + + ref->weight = weight; + + { /* if new_parent is dependent to ref, make new_parent a sibling of ref before applying the final transition (see draft-16 + 5.3.3) */ + h2o_http2_scheduler_node_t *t; + for (t = new_parent; t->_parent != NULL; t = t->_parent) { + if (t->_parent == &ref->node) { + /* quoting the spec: "The moved dependency retains its weight." */ + h2o_http2_scheduler_openref_t *new_parent_ref = (void *)new_parent; + do_rebind(new_parent_ref, ref->node._parent, 0); + break; + } + } + } + + do_rebind(ref, new_parent, exclusive); +} + +void h2o_http2_scheduler_init(h2o_http2_scheduler_node_t *root) +{ + init_node(root, NULL); +} + +void h2o_http2_scheduler_dispose(h2o_http2_scheduler_node_t *root) +{ + free(root->_queue); + root->_queue = NULL; +} + +void h2o_http2_scheduler_activate(h2o_http2_scheduler_openref_t *ref) +{ + if (ref->_self_is_active) + return; + ref->_self_is_active = 1; + incr_active_cnt(&ref->node); +} + +static int proceed(h2o_http2_scheduler_node_t *node, h2o_http2_scheduler_run_cb cb, void *cb_arg) +{ +Redo: + if (node->_queue == NULL) + return 0; + + h2o_http2_scheduler_queue_node_t *drr_node = queue_pop(node->_queue); + if (drr_node == NULL) + return 0; + + h2o_http2_scheduler_openref_t *ref = H2O_STRUCT_FROM_MEMBER(h2o_http2_scheduler_openref_t, _queue_node, drr_node); + + if (!ref->_self_is_active) { + /* run the children (manually-unrolled tail recursion) */ + queue_set(node->_queue, &ref->_queue_node, ref->weight); + node = &ref->node; + goto Redo; + } + assert(ref->_active_cnt != 0); + + /* call the callbacks */ + int still_is_active, bail_out = cb(ref, &still_is_active, cb_arg); + if (still_is_active) { + queue_set(node->_queue, &ref->_queue_node, ref->weight); + } else { + ref->_self_is_active = 0; + if (--ref->_active_cnt != 0) { + queue_set(node->_queue, &ref->_queue_node, ref->weight); + } else if (ref->node._parent != NULL) { + decr_active_cnt(ref->node._parent); + } + } + + return bail_out; +} + +int h2o_http2_scheduler_run(h2o_http2_scheduler_node_t *root, h2o_http2_scheduler_run_cb cb, void *cb_arg) +{ + if (root->_queue != NULL) { + while (!queue_is_empty(root->_queue)) { + int bail_out = proceed(root, cb, cb_arg); + if (bail_out) + return bail_out; + } + } + return 0; +} + +int h2o_http2_scheduler_is_active(h2o_http2_scheduler_node_t *root) +{ + return root->_queue != NULL && !queue_is_empty(root->_queue); +} diff --git a/web/server/h2o/libh2o/lib/http2/stream.c b/web/server/h2o/libh2o/lib/http2/stream.c new file mode 100644 index 000000000..1dfe2c3a3 --- /dev/null +++ b/web/server/h2o/libh2o/lib/http2/stream.c @@ -0,0 +1,410 @@ +/* + * 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.h" +#include "h2o/http2.h" +#include "h2o/http2_internal.h" + +static void finalostream_start_pull(h2o_ostream_t *self, h2o_ostream_pull_cb cb); +static void finalostream_send(h2o_ostream_t *self, h2o_req_t *req, h2o_iovec_t *bufs, size_t bufcnt, h2o_send_state_t state); + +static size_t sz_min(size_t x, size_t y) +{ + return x < y ? x : y; +} + +h2o_http2_stream_t *h2o_http2_stream_open(h2o_http2_conn_t *conn, uint32_t stream_id, h2o_req_t *src_req, + const h2o_http2_priority_t *received_priority) +{ + h2o_http2_stream_t *stream = h2o_mem_alloc(sizeof(*stream)); + + /* init properties (other than req) */ + memset(stream, 0, offsetof(h2o_http2_stream_t, req)); + stream->stream_id = stream_id; + stream->_ostr_final.do_send = finalostream_send; + stream->_ostr_final.start_pull = finalostream_start_pull; + stream->state = H2O_HTTP2_STREAM_STATE_IDLE; + h2o_http2_window_init(&stream->output_window, &conn->peer_settings); + h2o_http2_window_init(&stream->input_window, &H2O_HTTP2_SETTINGS_HOST); + stream->received_priority = *received_priority; + stream->_expected_content_length = SIZE_MAX; + + /* init request */ + h2o_init_request(&stream->req, &conn->super, src_req); + stream->req.version = 0x200; + if (src_req != NULL) + memset(&stream->req.upgrade, 0, sizeof(stream->req.upgrade)); + stream->req._ostr_top = &stream->_ostr_final; + + h2o_http2_conn_register_stream(conn, stream); + + ++conn->num_streams.priority.open; + stream->_num_streams_slot = &conn->num_streams.priority; + + return stream; +} + +void h2o_http2_stream_close(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + h2o_http2_conn_unregister_stream(conn, stream); + if (stream->_req_body != NULL) + h2o_buffer_dispose(&stream->_req_body); + if (stream->cache_digests != NULL) + h2o_cache_digests_destroy(stream->cache_digests); + h2o_dispose_request(&stream->req); + if (stream->stream_id == 1 && conn->_http1_req_input != NULL) + h2o_buffer_dispose(&conn->_http1_req_input); + free(stream); +} + +void h2o_http2_stream_reset(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + switch (stream->state) { + case H2O_HTTP2_STREAM_STATE_IDLE: + case H2O_HTTP2_STREAM_STATE_RECV_HEADERS: + case H2O_HTTP2_STREAM_STATE_RECV_BODY: + case H2O_HTTP2_STREAM_STATE_REQ_PENDING: + h2o_http2_stream_close(conn, stream); + break; + case H2O_HTTP2_STREAM_STATE_SEND_HEADERS: + case H2O_HTTP2_STREAM_STATE_SEND_BODY: + case H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL: + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_END_STREAM); + /* continues */ + case H2O_HTTP2_STREAM_STATE_END_STREAM: + /* clear all the queued bufs, and close the connection in the callback */ + stream->_data.size = 0; + if (h2o_linklist_is_linked(&stream->_refs.link)) { + /* will be closed in the callback */ + } else { + h2o_http2_stream_close(conn, stream); + } + break; + } +} + +static size_t calc_max_payload_size(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + ssize_t conn_max, stream_max; + + if ((conn_max = h2o_http2_conn_get_buffer_window(conn)) <= 0) + return 0; + if ((stream_max = h2o_http2_window_get_window(&stream->output_window)) <= 0) + return 0; + return sz_min(sz_min(conn_max, stream_max), conn->peer_settings.max_frame_size); +} + +static void commit_data_header(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream, h2o_buffer_t **outbuf, size_t length, + h2o_send_state_t send_state) +{ + assert(outbuf != NULL); + /* send a DATA frame if there's data or the END_STREAM flag to send */ + if (length || send_state == H2O_SEND_STATE_FINAL) { + h2o_http2_encode_frame_header((void *)((*outbuf)->bytes + (*outbuf)->size), length, H2O_HTTP2_FRAME_TYPE_DATA, + send_state == H2O_SEND_STATE_FINAL ? H2O_HTTP2_FRAME_FLAG_END_STREAM : 0, stream->stream_id); + h2o_http2_window_consume_window(&conn->_write.window, length); + h2o_http2_window_consume_window(&stream->output_window, length); + (*outbuf)->size += length + H2O_HTTP2_FRAME_HEADER_SIZE; + stream->req.bytes_sent += length; + } + /* send a RST_STREAM if there's an error */ + if (send_state == H2O_SEND_STATE_ERROR) { + h2o_http2_encode_rst_stream_frame(outbuf, stream->stream_id, -H2O_HTTP2_ERROR_PROTOCOL); + } +} + +static h2o_send_state_t send_data_pull(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + size_t max_payload_size; + h2o_iovec_t cbuf; + h2o_send_state_t send_state = H2O_SEND_STATE_IN_PROGRESS; + + if ((max_payload_size = calc_max_payload_size(conn, stream)) == 0) + goto Exit; + /* reserve buffer */ + h2o_buffer_reserve(&conn->_write.buf, H2O_HTTP2_FRAME_HEADER_SIZE + max_payload_size); + /* obtain content */ + cbuf.base = conn->_write.buf->bytes + conn->_write.buf->size + H2O_HTTP2_FRAME_HEADER_SIZE; + cbuf.len = max_payload_size; + send_state = h2o_pull(&stream->req, stream->_pull_cb, &cbuf); + /* write the header */ + commit_data_header(conn, stream, &conn->_write.buf, cbuf.len, send_state); + +Exit: + return send_state; +} + +static h2o_iovec_t *send_data_push(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream, h2o_iovec_t *bufs, size_t bufcnt, + h2o_send_state_t send_state) +{ + h2o_iovec_t dst; + size_t max_payload_size; + + if ((max_payload_size = calc_max_payload_size(conn, stream)) == 0) + goto Exit; + + /* reserve buffer and point dst to the payload */ + dst.base = + h2o_buffer_reserve(&conn->_write.buf, H2O_HTTP2_FRAME_HEADER_SIZE + max_payload_size).base + H2O_HTTP2_FRAME_HEADER_SIZE; + dst.len = max_payload_size; + + /* emit data */ + while (bufcnt != 0) { + if (bufs->len != 0) + break; + ++bufs; + --bufcnt; + } + while (bufcnt != 0) { + size_t fill_size = sz_min(dst.len, bufs->len); + memcpy(dst.base, bufs->base, fill_size); + dst.base += fill_size; + dst.len -= fill_size; + bufs->base += fill_size; + bufs->len -= fill_size; + while (bufs->len == 0) { + ++bufs; + --bufcnt; + if (bufcnt == 0) + break; + } + if (dst.len == 0) + break; + } + + /* commit the DATA frame if we have actually emitted payload */ + if (dst.len != max_payload_size || !h2o_send_state_is_in_progress(send_state)) { + size_t payload_len = max_payload_size - dst.len; + if (bufcnt != 0) { + send_state = H2O_SEND_STATE_IN_PROGRESS; + } + commit_data_header(conn, stream, &conn->_write.buf, payload_len, send_state); + } + +Exit: + return bufs; +} + +static int is_blocking_asset(h2o_req_t *req) +{ + if (req->res.mime_attr == NULL) + h2o_req_fill_mime_attributes(req); + return req->res.mime_attr->priority == H2O_MIME_ATTRIBUTE_PRIORITY_HIGHEST; +} + +static int send_headers(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + h2o_timestamp_t ts; + + h2o_get_timestamp(conn->super.ctx, &stream->req.pool, &ts); + + /* cancel push with an error response */ + if (h2o_http2_stream_is_push(stream->stream_id)) { + if (400 <= stream->req.res.status) + goto CancelPush; + if (stream->cache_digests != NULL) { + ssize_t etag_index = h2o_find_header(&stream->req.headers, H2O_TOKEN_ETAG, -1); + if (etag_index != -1) { + h2o_iovec_t url = h2o_concat(&stream->req.pool, stream->req.input.scheme->name, h2o_iovec_init(H2O_STRLIT("://")), + stream->req.input.authority, stream->req.input.path); + h2o_iovec_t *etag = &stream->req.headers.entries[etag_index].value; + if (h2o_cache_digests_lookup_by_url_and_etag(stream->cache_digests, url.base, url.len, etag->base, etag->len) == + H2O_CACHE_DIGESTS_STATE_FRESH) + goto CancelPush; + } + } + } + + /* reset casper cookie in case cache-digests exist */ + if (stream->cache_digests != NULL && stream->req.hostconf->http2.casper.capacity_bits != 0) { + h2o_add_header(&stream->req.pool, &stream->req.res.headers, H2O_TOKEN_SET_COOKIE, NULL, + H2O_STRLIT("h2o_casper=; Path=/; Expires=Sat, 01 Jan 2000 00:00:00 GMT")); + } + + /* CASPER */ + if (conn->casper != NULL) { + /* update casper if necessary */ + if (stream->req.hostconf->http2.casper.track_all_types || is_blocking_asset(&stream->req)) { + if (h2o_http2_casper_lookup(conn->casper, stream->req.path.base, stream->req.path.len, 1)) { + /* cancel if the pushed resource is already marked as cached */ + if (h2o_http2_stream_is_push(stream->stream_id)) + goto CancelPush; + } + } + if (stream->cache_digests != NULL) + goto SkipCookie; + /* browsers might ignore push responses, or they may process the responses in a different order than they were pushed. + * Therefore H2O tries to include casper cookie only in the last stream that may be received by the client, or when the + * value become stable; see also: https://github.com/h2o/h2o/issues/421 + */ + if (h2o_http2_stream_is_push(stream->stream_id)) { + if (!(conn->num_streams.pull.open == 0 && (conn->num_streams.push.half_closed - conn->num_streams.push.send_body) == 1)) + goto SkipCookie; + } else { + if (conn->num_streams.push.half_closed - conn->num_streams.push.send_body != 0) + goto SkipCookie; + } + h2o_iovec_t cookie = h2o_http2_casper_get_cookie(conn->casper); + h2o_add_header(&stream->req.pool, &stream->req.res.headers, H2O_TOKEN_SET_COOKIE, NULL, cookie.base, cookie.len); + SkipCookie:; + } + + if (h2o_http2_stream_is_push(stream->stream_id)) { + /* for push, send the push promise */ + if (!stream->push.promise_sent) + h2o_http2_stream_send_push_promise(conn, stream); + /* send ASAP if it is a blocking asset (even in case of Firefox we can't wait 1RTT for it to reprioritize the asset) */ + if (is_blocking_asset(&stream->req)) + h2o_http2_scheduler_rebind(&stream->_refs.scheduler, &conn->scheduler, 257, 0); + } else { + /* raise the priority of asset files that block rendering to highest if the user-agent is _not_ using dependency-based + * prioritization (e.g. that of Firefox) + */ + if (conn->num_streams.priority.open == 0 && stream->req.hostconf->http2.reprioritize_blocking_assets && + h2o_http2_scheduler_get_parent(&stream->_refs.scheduler) == &conn->scheduler && is_blocking_asset(&stream->req)) + h2o_http2_scheduler_rebind(&stream->_refs.scheduler, &conn->scheduler, 257, 0); + } + + /* send HEADERS, as well as start sending body */ + if (h2o_http2_stream_is_push(stream->stream_id)) + h2o_add_header_by_str(&stream->req.pool, &stream->req.res.headers, H2O_STRLIT("x-http2-push"), 0, NULL, + H2O_STRLIT("pushed")); + h2o_hpack_flatten_response(&conn->_write.buf, &conn->_output_header_table, stream->stream_id, + conn->peer_settings.max_frame_size, &stream->req.res, &ts, &conn->super.ctx->globalconf->server_name, + stream->req.res.content_length); + h2o_http2_conn_request_write(conn); + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_SEND_BODY); + + return 0; + +CancelPush: + h2o_add_header_by_str(&stream->req.pool, &stream->req.res.headers, H2O_STRLIT("x-http2-push"), 0, NULL, + H2O_STRLIT("cancelled")); + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_END_STREAM); + h2o_linklist_insert(&conn->_write.streams_to_proceed, &stream->_refs.link); + if (stream->push.promise_sent) { + h2o_http2_encode_rst_stream_frame(&conn->_write.buf, stream->stream_id, -H2O_HTTP2_ERROR_INTERNAL); + h2o_http2_conn_request_write(conn); + } + return -1; +} + +void finalostream_start_pull(h2o_ostream_t *self, h2o_ostream_pull_cb cb) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, _ostr_final, self); + h2o_http2_conn_t *conn = (void *)stream->req.conn; + + assert(stream->req._ostr_top == &stream->_ostr_final); + assert(stream->state == H2O_HTTP2_STREAM_STATE_SEND_HEADERS); + + /* register the pull callback */ + stream->_pull_cb = cb; + + /* send headers */ + if (send_headers(conn, stream) != 0) + return; + + /* set dummy data in the send buffer */ + h2o_vector_reserve(&stream->req.pool, &stream->_data, 1); + stream->_data.entries[0].base = "<pull interface>"; + stream->_data.entries[0].len = 1; + stream->_data.size = 1; + + h2o_http2_conn_register_for_proceed_callback(conn, stream); +} + +void finalostream_send(h2o_ostream_t *self, h2o_req_t *req, h2o_iovec_t *bufs, size_t bufcnt, h2o_send_state_t state) +{ + h2o_http2_stream_t *stream = H2O_STRUCT_FROM_MEMBER(h2o_http2_stream_t, _ostr_final, self); + h2o_http2_conn_t *conn = (h2o_http2_conn_t *)req->conn; + + assert(stream->_data.size == 0); + + stream->send_state = state; + + /* send headers */ + switch (stream->state) { + case H2O_HTTP2_STREAM_STATE_SEND_HEADERS: + if (send_headers(conn, stream) != 0) + return; + /* fallthru */ + case H2O_HTTP2_STREAM_STATE_SEND_BODY: + if (state != H2O_SEND_STATE_IN_PROGRESS) { + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL); + } + break; + case H2O_HTTP2_STREAM_STATE_END_STREAM: + /* might get set by h2o_http2_stream_reset */ + return; + default: + assert(!"cannot be in a receiving state"); + } + + /* save the contents in queue */ + if (bufcnt != 0) { + h2o_vector_reserve(&req->pool, &stream->_data, bufcnt); + memcpy(stream->_data.entries, bufs, sizeof(h2o_iovec_t) * bufcnt); + stream->_data.size = bufcnt; + } + + h2o_http2_conn_register_for_proceed_callback(conn, stream); +} + +void h2o_http2_stream_send_pending_data(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + if (h2o_http2_window_get_window(&stream->output_window) <= 0) + return; + + if (stream->_pull_cb != NULL) { + h2o_send_state_t send_state; + /* pull mode */ + assert(stream->state != H2O_HTTP2_STREAM_STATE_END_STREAM); + send_state = send_data_pull(conn, stream); + if (send_state != H2O_SEND_STATE_IN_PROGRESS) { + /* sent all data */ + stream->_data.size = 0; + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_END_STREAM); + } + } else { + /* push mode */ + h2o_iovec_t *nextbuf = send_data_push(conn, stream, stream->_data.entries, stream->_data.size, stream->send_state); + if (nextbuf == stream->_data.entries + stream->_data.size) { + /* sent all data */ + stream->_data.size = 0; + if (stream->state == H2O_HTTP2_STREAM_STATE_SEND_BODY_IS_FINAL) + h2o_http2_stream_set_state(conn, stream, H2O_HTTP2_STREAM_STATE_END_STREAM); + } else if (nextbuf != stream->_data.entries) { + /* adjust the buffer */ + size_t newsize = stream->_data.size - (nextbuf - stream->_data.entries); + memmove(stream->_data.entries, nextbuf, sizeof(h2o_iovec_t) * newsize); + stream->_data.size = newsize; + } + } +} + +void h2o_http2_stream_proceed(h2o_http2_conn_t *conn, h2o_http2_stream_t *stream) +{ + if (stream->state == H2O_HTTP2_STREAM_STATE_END_STREAM) { + h2o_http2_stream_close(conn, stream); + } else { + h2o_proceed_response(&stream->req); + } +} diff --git a/web/server/h2o/libh2o/lib/tunnel.c b/web/server/h2o/libh2o/lib/tunnel.c new file mode 100644 index 000000000..aa86aaf4d --- /dev/null +++ b/web/server/h2o/libh2o/lib/tunnel.c @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2015 Justin Zhu, 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 <stdlib.h> +#include "h2o.h" +#include "h2o/http1.h" +#include "h2o/tunnel.h" + +struct st_h2o_tunnel_t { + h2o_context_t *ctx; + h2o_timeout_entry_t timeout_entry; + h2o_timeout_t *timeout; + h2o_socket_t *sock[2]; +}; + +static void on_write_complete(h2o_socket_t *sock, const char *err); + +static void close_connection(struct st_h2o_tunnel_t *tunnel) +{ + h2o_timeout_unlink(&tunnel->timeout_entry); + + h2o_socket_close(tunnel->sock[0]); + h2o_socket_close(tunnel->sock[1]); + + free(tunnel); +} + +static void on_timeout(h2o_timeout_entry_t *entry) +{ + struct st_h2o_tunnel_t *tunnel = H2O_STRUCT_FROM_MEMBER(struct st_h2o_tunnel_t, timeout_entry, entry); + close_connection(tunnel); +} + +static inline void reset_timeout(struct st_h2o_tunnel_t *tunnel) +{ + h2o_timeout_unlink(&tunnel->timeout_entry); + h2o_timeout_link(tunnel->ctx->loop, tunnel->timeout, &tunnel->timeout_entry); +} + +static inline void on_read(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_tunnel_t *tunnel = sock->data; + h2o_socket_t *dst; + assert(tunnel != NULL); + assert(tunnel->sock[0] == sock || tunnel->sock[1] == sock); + + if (err != NULL) { + close_connection(tunnel); + return; + } + + if (sock->bytes_read == 0) + return; + + h2o_socket_read_stop(sock); + reset_timeout(tunnel); + + if (tunnel->sock[0] == sock) + dst = tunnel->sock[1]; + else + dst = tunnel->sock[0]; + + h2o_iovec_t buf; + buf.base = sock->input->bytes; + buf.len = sock->input->size; + h2o_socket_write(dst, &buf, 1, on_write_complete); +} + +static void on_write_complete(h2o_socket_t *sock, const char *err) +{ + struct st_h2o_tunnel_t *tunnel = sock->data; + h2o_socket_t *peer; + assert(tunnel != NULL); + assert(tunnel->sock[0] == sock || tunnel->sock[1] == sock); + + if (err != NULL) { + close_connection(tunnel); + return; + } + + reset_timeout(tunnel); + + if (tunnel->sock[0] == sock) + peer = tunnel->sock[1]; + else + peer = tunnel->sock[0]; + + h2o_buffer_consume(&peer->input, peer->input->size); + h2o_socket_read_start(peer, on_read); +} + +h2o_tunnel_t *h2o_tunnel_establish(h2o_context_t *ctx, h2o_socket_t *sock1, h2o_socket_t *sock2, h2o_timeout_t *timeout) +{ + h2o_tunnel_t *tunnel = h2o_mem_alloc(sizeof(*tunnel)); + tunnel->ctx = ctx; + tunnel->timeout = timeout; + tunnel->timeout_entry = (h2o_timeout_entry_t){0}; + tunnel->timeout_entry.cb = on_timeout; + tunnel->sock[0] = sock1; + tunnel->sock[1] = sock2; + sock1->data = tunnel; + sock2->data = tunnel; + h2o_timeout_link(tunnel->ctx->loop, tunnel->timeout, &tunnel->timeout_entry); + + /* Bring up the tunnel. Note. Upstream always ready first. */ + if (sock2->input->size) + on_read(sock2, NULL); + if (sock1->input->size) + on_read(sock1, NULL); + h2o_socket_read_start(sock2, on_read); + h2o_socket_read_start(sock1, on_read); + + return tunnel; +} + +void h2o_tunnel_break(h2o_tunnel_t *tunnel) +{ + close_connection(tunnel); +} diff --git a/web/server/h2o/libh2o/lib/websocket.c b/web/server/h2o/libh2o/lib/websocket.c new file mode 100644 index 000000000..2886acda6 --- /dev/null +++ b/web/server/h2o/libh2o/lib/websocket.c @@ -0,0 +1,238 @@ +/* + * 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 <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <openssl/sha.h> +#include "h2o/websocket.h" + +#define WS_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" + +static void create_accept_key(char *dst, const char *client_key) +{ + uint8_t sha1buf[20], key_src[60]; + + memcpy(key_src, client_key, 24); + memcpy(key_src + 24, WS_GUID, 36); + SHA1(key_src, sizeof(key_src), sha1buf); + h2o_base64_encode(dst, sha1buf, sizeof(sha1buf), 0); + dst[28] = '\0'; +} + +static void on_close(h2o_websocket_conn_t *conn) +{ + (*conn->cb)(conn, NULL); +} + +static void on_recv(h2o_socket_t *sock, const char *err) +{ + h2o_websocket_conn_t *conn = sock->data; + + if (err != NULL) { + on_close(conn); + return; + } + h2o_websocket_proceed(conn); +} + +static void on_write_complete(h2o_socket_t *sock, const char *err) +{ + h2o_websocket_conn_t *conn = sock->data; + + if (err != NULL) { + on_close(conn); + return; + } + h2o_websocket_proceed(conn); +} + +static ssize_t recv_callback(wslay_event_context_ptr ctx, uint8_t *buf, size_t len, int flags, void *_conn) +{ + h2o_websocket_conn_t *conn = _conn; + + /* return WOULDBLOCK if no data */ + if (conn->sock->input->size == 0) { + wslay_event_set_error(conn->ws_ctx, WSLAY_ERR_WOULDBLOCK); + return -1; + } + + if (conn->sock->input->size < len) + len = conn->sock->input->size; + memcpy(buf, conn->sock->input->bytes, len); + h2o_buffer_consume(&conn->sock->input, len); + return len; +} + +static ssize_t send_callback(wslay_event_context_ptr ctx, const uint8_t *data, size_t len, int flags, void *_conn) +{ + h2o_websocket_conn_t *conn = _conn; + h2o_iovec_t buf; + + /* return WOULDBLOCK if pending (TODO: queue fixed number of chunks, instead of only one) */ + if (h2o_socket_is_writing(conn->sock)) { + wslay_event_set_error(conn->ws_ctx, WSLAY_ERR_WOULDBLOCK); + return -1; + } + + /* copy data */ + conn->_write_buf = h2o_mem_realloc(conn->_write_buf, len); + memcpy(conn->_write_buf, data, len); + + /* write */ + buf.base = conn->_write_buf; + buf.len = len; + h2o_socket_write(conn->sock, &buf, 1, on_write_complete); + + return len; +} + +static void on_msg_callback(wslay_event_context_ptr ctx, const struct wslay_event_on_msg_recv_arg *arg, void *_conn) +{ + h2o_websocket_conn_t *conn = _conn; + (*conn->cb)(conn, arg); +} + +static void on_complete(void *user_data, h2o_socket_t *sock, size_t reqsize) +{ + h2o_websocket_conn_t *conn = user_data; + + /* close the connection on error */ + if (sock == NULL) { + (*conn->cb)(conn, NULL); + return; + } + + conn->sock = sock; + sock->data = conn; + h2o_buffer_consume(&sock->input, reqsize); + h2o_websocket_proceed(conn); +} + +h2o_websocket_conn_t *h2o_upgrade_to_websocket(h2o_req_t *req, const char *client_key, void *data, h2o_websocket_msg_callback cb) +{ + h2o_websocket_conn_t *conn = h2o_mem_alloc(sizeof(*conn)); + char accept_key[29]; + + /* only for http1 connection */ + assert(req->version < 0x200); + + /* setup the context */ + memset(conn, 0, sizeof(*conn)); + // conn->sock = sock; set by on_complete + conn->ws_callbacks.recv_callback = recv_callback; + conn->ws_callbacks.send_callback = send_callback; + conn->ws_callbacks.on_msg_recv_callback = on_msg_callback; + conn->data = data; + conn->cb = cb; + + wslay_event_context_server_init(&conn->ws_ctx, &conn->ws_callbacks, conn); + + /* build response */ + create_accept_key(accept_key, client_key); + req->res.status = 101; + req->res.reason = "Switching Protocols"; + h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_UPGRADE, NULL, H2O_STRLIT("websocket")); + h2o_add_header_by_str(&req->pool, &req->res.headers, H2O_STRLIT("sec-websocket-accept"), 0, NULL, accept_key, + strlen(accept_key)); + + /* send */ + h2o_http1_upgrade(req, NULL, 0, on_complete, conn); + + return conn; +} + +int h2o_is_websocket_handshake(h2o_req_t *req, const char **ws_client_key) +{ + ssize_t key_header_index; + + *ws_client_key = NULL; + + /* method */ + if (h2o_memis(req->input.method.base, req->input.method.len, H2O_STRLIT("GET"))) { + /* ok */ + } else { + return 0; + } + + /* upgrade header */ + if (req->upgrade.base != NULL && h2o_lcstris(req->upgrade.base, req->upgrade.len, H2O_STRLIT("websocket"))) { + /* ok */ + } else { + return 0; + } + /* sec-websocket-key header */ + if ((key_header_index = h2o_find_header_by_str(&req->headers, H2O_STRLIT("sec-websocket-key"), -1)) != -1) { + if (req->headers.entries[key_header_index].value.len != 24) { + return -1; + } + } else { + return 0; + } + + *ws_client_key = req->headers.entries[key_header_index].value.base; + return 0; +} + +void h2o_websocket_close(h2o_websocket_conn_t *conn) +{ + if (conn->sock != NULL) + h2o_socket_close(conn->sock); + free(conn->_write_buf); + wslay_event_context_free(conn->ws_ctx); + free(conn); +} + +void h2o_websocket_proceed(h2o_websocket_conn_t *conn) +{ + int handled; + + /* run the loop until getting to a point where no more progress can be achieved */ + do { + handled = 0; + if (!h2o_socket_is_writing(conn->sock) && wslay_event_want_write(conn->ws_ctx)) { + if (wslay_event_send(conn->ws_ctx) != 0) { + goto Close; + } + handled = 1; + } + if (conn->sock->input->size != 0 && wslay_event_want_read(conn->ws_ctx)) { + if (wslay_event_recv(conn->ws_ctx) != 0) { + goto Close; + } + handled = 1; + } + } while (handled); + + if (wslay_event_want_read(conn->ws_ctx)) { + h2o_socket_read_start(conn->sock, on_recv); + } else if (h2o_socket_is_writing(conn->sock) || wslay_event_want_write(conn->ws_ctx)) { + h2o_socket_read_stop(conn->sock); + } else { + /* nothing is going on... close the socket */ + goto Close; + } + + return; + +Close: + on_close(conn); +} diff --git a/web/server/h2o/libh2o/libh2o-evloop.pc.in b/web/server/h2o/libh2o/libh2o-evloop.pc.in new file mode 100644 index 000000000..4853951b3 --- /dev/null +++ b/web/server/h2o/libh2o/libh2o-evloop.pc.in @@ -0,0 +1,11 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=${prefix} +includedir=${prefix}/include +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ + +Name: libh2o-evloop +Description: An optimized HTTP/1.x & HTTP/2 library +URL: https://h2o.examp1e.net/ +Version: @LIBRARY_VERSION_MAJOR@.@LIBRARY_VERSION_MINOR@.@LIBRARY_VERSION_PATCH@ +Libs: -L${libdir} -lh2o-evloop +Cflags: -I${includedir} diff --git a/web/server/h2o/libh2o/libh2o.pc.in b/web/server/h2o/libh2o/libh2o.pc.in new file mode 100644 index 000000000..cbda928fe --- /dev/null +++ b/web/server/h2o/libh2o/libh2o.pc.in @@ -0,0 +1,12 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=${prefix} +includedir=${prefix}/include +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ + +Name: libh2o +Description: An optimized HTTP/1.x & HTTP/2 library +URL: https://h2o.examp1e.net/ +Version: @LIBRARY_VERSION_MAJOR@.@LIBRARY_VERSION_MINOR@.@LIBRARY_VERSION_PATCH@ +Requires.private: libuv >= 1.0.0 +Libs: -L${libdir} -lh2o +Cflags: -I${includedir} |