自学教程：C++ H2O_STRLIT函数代码示例

void h2o_send_error(h2o_req_t *req, int status, const char *reason, const char *body, int flags){    bind_conf(req);    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);    memset(&req->res.headers, 0, sizeof(req->res.headers));    h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, H2O_STRLIT("text/plain; charset=utf-8"));    h2o_send_inline(req, body, SIZE_MAX);}

static void register_authority(h2o_globalconf_t *globalconf, h2o_iovec_t host, uint16_t port){    static h2o_iovec_t x_authority = {H2O_STRLIT("x-authority")};    h2o_hostconf_t *hostconf = h2o_config_register_host(globalconf, host, port);    h2o_pathconf_t *pathconf = h2o_config_register_path(hostconf, "/");    h2o_file_register(pathconf, "t/00unit/assets", NULL, NULL, 0);    char *authority = h2o_mem_alloc(host.len + sizeof(":65535"));    sprintf(authority, "%.*s:%" PRIu16, (int)host.len, host.base, port);    h2o_headers_command_t *cmds = h2o_mem_alloc(sizeof(*cmds) * 2);    cmds[0] = (h2o_headers_command_t){H2O_HEADERS_CMD_ADD, &x_authority, {authority, strlen(authority)}};    cmds[1] = (h2o_headers_command_t){H2O_HEADERS_CMD_NULL};    h2o_headers_register(pathconf, cmds);}

static h2o_iovec_t rewrite_location(h2o_mem_pool_t *pool, const char *location, size_t location_len, h2o_proxy_location_t *upstream, h2o_iovec_t req_scheme, h2o_iovec_t req_authority, h2o_iovec_t req_basepath){    h2o_iovec_t loc_scheme, loc_host, loc_path;    uint16_t loc_port;    if (h2o_parse_url(location, location_len, &loc_scheme, &loc_host, &loc_port, &loc_path) != 0        || ! test_location_match(upstream, loc_scheme, loc_host, loc_port, loc_path))        return h2o_iovec_init(location, location_len);    return h2o_concat(pool,        req_scheme,        h2o_iovec_init(H2O_STRLIT("://")),        req_authority,        req_basepath,        h2o_iovec_init(loc_path.base + upstream->path.len, loc_path.len - upstream->path.len));}

static void test_decode_base64(void){    h2o_mem_pool_t pool;    char buf[256];    h2o_mem_init_pool(&pool);    h2o_iovec_t src = {H2O_STRLIT("The quick brown fox jumps over the lazy dog.")}, decoded;    h2o_base64_encode(buf, (const uint8_t *)src.base, src.len, 1);    ok(strcmp(buf, "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4") == 0);    decoded = h2o_decode_base64url(&pool, buf, strlen(buf));    ok(src.len == decoded.len);    ok(strcmp(decoded.base, src.base) == 0);    h2o_mem_clear_pool(&pool);}

static struct rp_generator_t *proxy_send_prepare(h2o_req_t *req, h2o_proxy_location_t *upstream, int keepalive){    struct rp_generator_t *self = h2o_mem_alloc_shared(&req->pool, sizeof(*self), on_generator_dispose);    self->super.proceed = do_proceed;    self->super.stop = do_close;    self->upstream = upstream;    self->src_req = req;    self->up_req.bufs[0] = build_request(req, upstream, keepalive);    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_buffer_init(&self->buf_sending, &h2o_socket_buffer_prototype);    return self;}

h2o_compress_context_t *h2o_compress_gzip_open(h2o_mem_pool_t *pool, int quality){    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.compress = do_compress;    self->zs.zalloc = alloc_cb;    self->zs.zfree = free_cb;    self->zs.opaque = NULL;    /* 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);    self->zs_is_open = 1;    self->bufs = (iovec_vector_t){};    expand_buf(&self->bufs);    return &self->super;}

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"));#ifndef _MSC_VER        req->entity = (h2o_iovec_t){NULL};#else		req->entity = (h2o_iovec_t) { 0 };#endif        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);}

int main(int argc, char **argv){    h2o_hostconf_t *hostconf;    signal(SIGPIPE, SIG_IGN);    h2o_config_init(&config);    hostconf = h2o_config_register_host(&config, h2o_iovec_init(H2O_STRLIT("default")), 65535);    register_handler(hostconf, "/post-test", post_test);    register_handler(hostconf, "/chunked-test", chunked_test);    h2o_reproxy_register(register_handler(hostconf, "/reproxy-test", reproxy_test));    h2o_file_register(h2o_config_register_path(hostconf, "/"), "examples/doc_root", NULL, NULL, 0);#if H2O_USE_LIBUV    uv_loop_t loop;    uv_loop_init(&loop);    h2o_context_init(&ctx, &loop, &config);#else    h2o_context_init(&ctx, h2o_evloop_create(), &config);#endif    /* disabled by default: uncomment the block below to use HTTPS instead of HTTP */    /*    if (setup_ssl("server.crt", "server.key") != 0)        goto Error;    */    /* disabled by default: uncomment the line below to enable access logging */    /* h2o_access_log_register(&config.default_host, "/dev/stdout", NULL); */    if (create_listener() != 0) {        fprintf(stderr, "failed to listen to 127.0.0.1:7890:%s/n", strerror(errno));        goto Error;    }#if H2O_USE_LIBUV    uv_run(ctx.loop, UV_RUN_DEFAULT);#else    while (h2o_evloop_run(ctx.loop) == 0)        ;#endifError:    return 1;}

void test_lib__handler__redirect_c(){    h2o_globalconf_t globalconf;    h2o_hostconf_t *hostconf;    h2o_pathconf_t *pathconf;    h2o_config_init(&globalconf);    hostconf = h2o_config_register_host(&globalconf, h2o_iovec_init(H2O_STRLIT("default")), 65535);    pathconf = h2o_config_register_path(hostconf, "/", 0);    h2o_redirect_register(pathconf, 0, 301, "https://example.com/bar/");    h2o_context_init(&ctx, test_loop, &globalconf);    {        h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx, ctx.globalconf->hosts);        conn->req.input.method = h2o_iovec_init(H2O_STRLIT("GET"));        conn->req.input.path = h2o_iovec_init(H2O_STRLIT("/"));        h2o_loopback_run_loop(conn);        ok(conn->req.res.status == 301);        ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "https://example.com/bar/"));        ok(conn->body->size != 0);        h2o_loopback_destroy(conn);    }    {        h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx, ctx.globalconf->hosts);        conn->req.input.method = h2o_iovec_init(H2O_STRLIT("GET"));        conn->req.input.path = h2o_iovec_init(H2O_STRLIT("/abc"));        h2o_loopback_run_loop(conn);        ok(conn->req.res.status == 301);        ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "https://example.com/bar/abc"));        ok(conn->body->size != 0);        h2o_loopback_destroy(conn);    }    {        h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx, ctx.globalconf->hosts);        conn->req.input.method = h2o_iovec_init(H2O_STRLIT("HEAD"));        conn->req.input.path = h2o_iovec_init(H2O_STRLIT("/"));        h2o_loopback_run_loop(conn);        ok(conn->req.res.status == 301);        ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "https://example.com/bar/"));        ok(conn->body->size == 0);        h2o_loopback_destroy(conn);    }    h2o_context_dispose(&ctx);    h2o_config_dispose(&globalconf);}

static void test_parse_proxy_line(void){    char in[256];    struct sockaddr_storage sa;    socklen_t salen;    ssize_t ret;    strcpy(in, "");    ret = parse_proxy_line(in, strlen(in), (void *)&sa, &salen);    ok(ret == -2);    strcpy(in, "PROXY TCP4 192.168.0.1 192.168.0.11 56324 443/r/nabc");    ret = parse_proxy_line(in, strlen(in), (void *)&sa, &salen);    ok(ret == strlen(in) - 3);    ok(salen == sizeof(struct sockaddr_in));    ok(sa.ss_family == AF_INET);    ok(((struct sockaddr_in *)&sa)->sin_addr.s_addr == htonl(0xc0a80001));    ok(((struct sockaddr_in *)&sa)->sin_port == htons(56324));    strcpy(in, "PROXY TCP4 192.168.0.1 192.168.0.11 56324 443/r");    ret = parse_proxy_line(in, strlen(in), (void *)&sa, &salen);    ok(ret == -2);    strcpy(in, "PROXY TCP5");    ret = parse_proxy_line(in, strlen(in), (void *)&sa, &salen);    ok(ret == -1);    strcpy(in, "PROXY UNKNOWN");    ret = parse_proxy_line(in, strlen(in), (void *)&sa, &salen);    ok(ret == -2);    strcpy(in, "PROXY UNKNOWN/r/nabc");    ret = parse_proxy_line(in, strlen(in), (void *)&sa, &salen);    ok(ret == strlen(in) - 3);    ok(salen == 0);    strcpy(in, "PROXY TCP6 ::1 ::1 56324 443/r/n");    ret = parse_proxy_line(in, strlen(in), (void *)&sa, &salen);    ok(ret == strlen(in));    ok(salen == sizeof(struct sockaddr_in6));    ok(sa.ss_family == AF_INET6);    ok(memcmp(&((struct sockaddr_in6 *)&sa)->sin6_addr, H2O_STRLIT("/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/1")) == 0);    ok(((struct sockaddr_in6 *)&sa)->sin6_port == htons(56324));}

void test_issues293(){    h2o_globalconf_t globalconf;    h2o_config_init(&globalconf);    /* register two hosts, using 80 and 443 */    register_authority(&globalconf, h2o_iovec_init(H2O_STRLIT("default")), 65535);    register_authority(&globalconf, h2o_iovec_init(H2O_STRLIT("host1")), 80);    register_authority(&globalconf, h2o_iovec_init(H2O_STRLIT("host1")), 443);    register_authority(&globalconf, h2o_iovec_init(H2O_STRLIT("host2")), 80);    register_authority(&globalconf, h2o_iovec_init(H2O_STRLIT("host2")), 443);    register_authority(&globalconf, h2o_iovec_init(H2O_STRLIT("host3")), 65535);    h2o_context_init(&ctx, test_loop, &globalconf);    /* run the tests */    check(&H2O_URL_SCHEME_HTTP, "host1", "host1:80");    check(&H2O_URL_SCHEME_HTTPS, "host1", "host1:443");    check(&H2O_URL_SCHEME_HTTP, "host2", "host2:80");    check(&H2O_URL_SCHEME_HTTPS, "host2", "host2:443");    /* supplied port number in the Host header must be preferred */    check(&H2O_URL_SCHEME_HTTP, "host1:80", "host1:80");    check(&H2O_URL_SCHEME_HTTP, "host1:443", "host1:443");    check(&H2O_URL_SCHEME_HTTPS, "host1:80", "host1:80");    check(&H2O_URL_SCHEME_HTTPS, "host1:443", "host1:443");    check(&H2O_URL_SCHEME_HTTP, "host2:80", "host2:80");    check(&H2O_URL_SCHEME_HTTP, "host2:443", "host2:443");    check(&H2O_URL_SCHEME_HTTPS, "host2:80", "host2:80");    check(&H2O_URL_SCHEME_HTTPS, "host2:443", "host2:443");    /* host-level conf without default port */    check(&H2O_URL_SCHEME_HTTP, "host3", "host3:65535");    check(&H2O_URL_SCHEME_HTTPS, "host3", "host3:65535");    check(&H2O_URL_SCHEME_HTTP, "host3", "host3:65535");    check(&H2O_URL_SCHEME_HTTPS, "host3", "host3:65535");    check(&H2O_URL_SCHEME_HTTP, "host3:80", "host3:65535");    check(&H2O_URL_SCHEME_HTTPS, "host3:80", "default:65535");    check(&H2O_URL_SCHEME_HTTP, "host3:443", "default:65535");    check(&H2O_URL_SCHEME_HTTPS, "host3:443", "host3:65535");    /* upper-case */    check(&H2O_URL_SCHEME_HTTP, "HoST1", "host1:80");    check(&H2O_URL_SCHEME_HTTP, "HoST1:80", "host1:80");    check(&H2O_URL_SCHEME_HTTPS, "HoST1", "host1:443");    check(&H2O_URL_SCHEME_HTTPS, "HoST1:443", "host1:443");    h2o_context_dispose(&ctx);    h2o_config_dispose(&globalconf);}

static int on_req(h2o_handler_t *_self, h2o_req_t *req){    h2o_redirect_handler_t *self = (void *)_self;    /* build the URL */    h2o_iovec_t path =        h2o_iovec_init(req->path_normalized.base + req->pathconf->path.len, req->path_normalized.len - req->pathconf->path.len);    h2o_iovec_t query = req->query_at != SIZE_MAX ? h2o_iovec_init(req->path.base + req->query_at, req->path.len - req->query_at)                                                  : h2o_iovec_init(H2O_STRLIT(""));    h2o_iovec_t dest = h2o_concat(&req->pool, self->prefix, path, query);    if (self->internal) {        redirect_internally(self, req, dest);    } else {        h2o_send_redirect(req, self->status, "Redirected", dest.base, dest.len);    }    return 0;}

int main(int argc, char **argv){    h2o_hostconf_t *hostconf;    h2o_pathconf_t *pathconf;    h2o_config_init(&config);    hostconf = h2o_config_register_host(&config, h2o_iovec_init(H2O_STRLIT("default")), 65535);    pathconf = h2o_config_register_path(hostconf, "/", 0);    h2o_create_handler(pathconf, sizeof(h2o_handler_t))->on_req = on_req;#if H2O_USE_LIBUV    uv_loop_t loop;    uv_loop_init(&loop);    h2o_context_init(&ctx, &loop, &config);#else    h2o_context_init(&ctx, h2o_evloop_create(), &config);#endif    /* disabled by default: uncomment the block below to use HTTPS instead of HTTP */    /*    if (setup_ssl("server.crt", "server.key") != 0)        goto Error;    */    accept_ctx.ctx = &ctx;    accept_ctx.hosts = config.hosts;    if (create_listener() != 0) {        fprintf(stderr, "failed to listen to 127.0.0.1:7890:%s/n", strerror(errno));        goto Error;    }#if H2O_USE_LIBUV    uv_run(ctx.loop, UV_RUN_DEFAULT);#else    while (h2o_evloop_run(ctx.loop, INT32_MAX) == 0)        ;#endifError:    return 1;}

ssize_t 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){    size_t found = -1;    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 -1;            found = i;        }    }    if (found != -1) {        h2o_header_t *dest = headers->entries + found;        dest->value = h2o_concat(pool, dest->value, h2o_iovec_init(H2O_STRLIT(", ")), h2o_iovec_init(value, value_len));        return found;    } else {        return h2o_add_header(pool, headers, token, NULL, value, value_len);    }}

static struct rp_generator_t *proxy_send_prepare(h2o_req_t *req, int keepalive){    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->up_req.bufs[0] = build_request(req, keepalive, self->is_websocket_handshake);    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;}

static void send_chunk(h2o_ostream_t *_self, h2o_req_t *req, h2o_buf_t *inbufs, size_t inbufcnt, int is_final){    struct rproxy_t *self = (void*)_self;    const char *host, *path;    uint16_t port;    /* throw away all data */    if (! is_final) {        h2o_ostream_send_next(&self->super, req, NULL, 0, 0);        return;    }    /* end of the original stream, start retreiving the data from the reproxy-url */    if (! parse_url(&req->pool, self->reproxy_url, &host, &port, &path)) {        host = NULL;        path = NULL;        port = 0;    }    /* NOT IMPLEMENTED!!! */    h2o_buf_t body = h2o_sprintf(        &req->pool,        "reproxy request to URL: %s/n"        "  host: %s/n"        "  port: %u/n"        "  path: %s/n",        self->reproxy_url,        host,        (int)port,        path);    req->res.status = 200;    req->res.reason = "Internal Server Error";    req->res.content_length = SIZE_MAX;    h2o_set_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_TYPE, H2O_STRLIT("text/plain; charset=utf-8"), 1);    h2o_setup_next_ostream(self->filter, req, &self->super.next);    assert(is_final);    h2o_ostream_send_next(&self->super, req, &body, 1, is_final);}

static void test_aton(void){    struct in_addr addr;    memset(&addr, 0x55, sizeof(addr));#ifndef _MSC_VER    ok(h2o_hostinfo_aton((h2o_iovec_t){H2O_STRLIT("127.0.0.1")}, &addr) == 0);#else	ok(h2o_hostinfo_aton((h2o_iovec_t) { H2O_MY_STRLIT("127.0.0.1") }, &addr) == 0);#endif    ok(ntohl(addr.s_addr) == 0x7f000001);    memset(&addr, 0x55, sizeof(addr));#ifndef _MSC_VER    ok(h2o_hostinfo_aton((h2o_iovec_t){"127.0.0.12", sizeof("127.0.0.1") - 1}, &addr) == 0);#else	ok(h2o_hostinfo_aton((h2o_iovec_t) { sizeof("127.0.0.1") - 1 , "127.0.0.12" }, &addr) == 0);#endif    ok(ntohl(addr.s_addr) == 0x7f000001);    memset(&addr, 0x55, sizeof(addr));#ifndef _MSC_VER    ok(h2o_hostinfo_aton((h2o_iovec_t){H2O_STRLIT("255.001.002.128")}, &addr) == 0);#else	ok(h2o_hostinfo_aton((h2o_iovec_t) { H2O_MY_STRLIT("255.001.002.128") }, &addr) == 0);#endif    ok(ntohl(addr.s_addr) == 0xff010280);#ifndef _MSC_VER    ok(h2o_hostinfo_aton((h2o_iovec_t){H2O_STRLIT("127.0.0.z")}, &addr) != 0);    ok(h2o_hostinfo_aton((h2o_iovec_t){H2O_STRLIT("256.0.0.0")}, &addr) != 0);    ok(h2o_hostinfo_aton((h2o_iovec_t){H2O_STRLIT("0001.0.0.0")}, &addr) != 0);    ok(h2o_hostinfo_aton((h2o_iovec_t){H2O_STRLIT("0.0..1")}, &addr) != 0);    ok(h2o_hostinfo_aton((h2o_iovec_t){H2O_STRLIT("1.0.0.0.")}, &addr) != 0);#else	ok(h2o_hostinfo_aton((h2o_iovec_t) { H2O_MY_STRLIT("127.0.0.z") }, &addr) != 0);	ok(h2o_hostinfo_aton((h2o_iovec_t) { H2O_MY_STRLIT("256.0.0.0") }, &addr) != 0);	ok(h2o_hostinfo_aton((h2o_iovec_t) { H2O_MY_STRLIT("0001.0.0.0") }, &addr) != 0);	ok(h2o_hostinfo_aton((h2o_iovec_t) { H2O_MY_STRLIT("0.0..1") }, &addr) != 0);	ok(h2o_hostinfo_aton((h2o_iovec_t) { H2O_MY_STRLIT("1.0.0.0.") }, &addr) != 0);#endif}

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->proxy.io_timeout = H2O_DEFAULT_PROXY_IO_TIMEOUT;    config->http2.max_concurrent_requests_per_connection = H2O_HTTP2_SETTINGS_HOST.max_concurrent_streams;    config->http2.max_streams_for_priority = 16;    config->http2.callbacks = H2O_HTTP2_CALLBACKS;    config->mimemap = h2o_mimemap_create();    h2o_configurator__init_core(config);}

static void test_decode(void){    h2o_cache_digests_t *digests = NULL;    h2o_cache_digests_load_header(&digests, H2O_STRLIT("AeLA"));    ok(digests != NULL);    if (digests == NULL)        return;    ok(digests->fresh.url_only.size == 1);    ok(digests->fresh.url_and_etag.size == 0);    ok(digests->fresh.url_only.entries[0].capacity_bits == 7);    ok(digests->fresh.url_only.entries[0].keys.size == 1);    ok(digests->fresh.url_only.entries[0].keys.entries[0] == 0x0b);    ok(!digests->fresh.complete);    ok(h2o_cache_digests_lookup_by_url(digests, H2O_STRLIT("https://127.0.0.1.xip.io:8081/cache-digests.cgi/hello.js")) ==       H2O_CACHE_DIGESTS_STATE_FRESH);    ok(h2o_cache_digests_lookup_by_url(digests, H2O_STRLIT("https://127.0.0.1.xip.io:8081/notfound.js")) ==       H2O_CACHE_DIGESTS_STATE_UNKNOWN);    h2o_cache_digests_load_header(&digests, H2O_STRLIT("FOO; stale, AcA; validators; complete"));    ok(digests->fresh.url_only.size == 1);    ok(digests->fresh.url_and_etag.size == 1);    ok(digests->fresh.url_and_etag.entries[0].capacity_bits == 7);    ok(digests->fresh.url_and_etag.entries[0].keys.size == 0);    ok(digests->fresh.complete);    ok(h2o_cache_digests_lookup_by_url(digests, H2O_STRLIT("https://127.0.0.1.xip.io:8081/notfound.js")) ==       H2O_CACHE_DIGESTS_STATE_NOT_CACHED);    ok(h2o_cache_digests_lookup_by_url(digests, H2O_STRLIT("https://127.0.0.1.xip.io:8081/cache-digests.cgi/hello.js")) ==       H2O_CACHE_DIGESTS_STATE_FRESH);    h2o_cache_digests_load_header(&digests, H2O_STRLIT("AcA; reset"));    ok(digests->fresh.url_only.size == 1);    ok(digests->fresh.url_and_etag.size == 0);    ok(digests->fresh.url_only.entries[0].capacity_bits == 7);    ok(digests->fresh.url_only.entries[0].keys.size == 0);    ok(!digests->fresh.complete);    h2o_cache_digests_destroy(digests);}

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_lcstris(loc_parsed.host.base, loc_parsed.host.len, match->host.base, match->host.len))        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){};}

static void on_send_request(h2o_socket_t *sock, const char *err){    struct st_h2o_http1client_t *client = sock->data;    h2o_timer_unlink(&client->super._timeout);    if (err != NULL) {        on_error_before_head(client, "I/O error (send request)");        return;    }    if (client->_is_chunked) {        client->_is_chunked = 0;        h2o_iovec_t last = h2o_iovec_init(H2O_STRLIT("0/r/n"));        h2o_socket_write(client->sock, &last, 1, on_send_request);        return;    }    client->super.timings.request_end_at = h2o_gettimeofday(client->super.ctx->loop);    h2o_socket_read_start(client->sock, on_head);    client->super._timeout.cb = on_head_timeout;    h2o_timer_link(client->super.ctx->loop, client->super.ctx->first_byte_timeout, &client->super._timeout);}

static void on_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;    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 */#ifndef _MSC_VER#else#define H2O_USE_BROTLI 0#endif#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 {        goto Next;    }    /* adjust the response headers */    req->res.content_length = SIZE_MAX;    h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_ENCODING, 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, 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);}

static void on_setup_ostream(h2o_filter_t *self, h2o_req_t *req, h2o_ostream_t **slot){    gzip_encoder_t *encoder;    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;    if (req->res.mime_attr == NULL)        h2o_req_fill_mime_attributes(req);    if (!req->res.mime_attr->is_compressible)        goto Next;    /* 100 is a rough estimate */    if (req->res.content_length <= 100)        goto Next;    /* skip if no accept-encoding is set */    if ((i = h2o_find_header(&req->headers, H2O_TOKEN_ACCEPT_ENCODING, -1)) == -1)        goto Next;    if (!h2o_contains_token(req->headers.entries[i].value.base, req->headers.entries[i].value.len, H2O_STRLIT("gzip"), ','))        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;    /* adjust the response headers */    req->res.content_length = SIZE_MAX;    h2o_add_header(&req->pool, &req->res.headers, H2O_TOKEN_CONTENT_ENCODING, H2O_STRLIT("gzip"));    h2o_add_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, H2O_STRLIT("none"));    }    /* setup filter */    encoder = (void *)h2o_add_ostream(req, sizeof(gzip_encoder_t), slot);    encoder->super.do_send = send_gzip;    encoder->super.stop = stop_gzip;    slot = &encoder->super.next;    encoder->bufs.capacity = 0;    encoder->bufs.size = 0;    encoder->zstream.zalloc = gzip_encoder_alloc;    encoder->zstream.zfree = gzip_encoder_free;    encoder->zstream.opaque = encoder;    /* 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);}

    h2o_iovec_t ret = {NULL};#else	h2o_iovec_t ret = { 0 };#endif    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);#ifndef _MSC_VER    pthread_mutex_destroy(&rsc->mutex);#else	uv_mutex_destroy(&rsc->mutex);#endif    free(rsc);    return ret;}#ifndef _MSC_VERh2o_status_handler_t requests_status_handler = {    {H2O_STRLIT("requests")}, requests_status_init, requests_status_per_thread, requests_status_final,};#elseh2o_status_handler_t requests_status_handler = {	{ H2O_MY_STRLIT("requests") }, requests_status_init, requests_status_per_thread, requests_status_final,};#endif

static void test_stripws(void){    h2o_iovec_t t;    t = h2o_str_stripws(H2O_STRLIT(""));    ok(h2o_memis(t.base, t.len, H2O_STRLIT("")));    t = h2o_str_stripws(H2O_STRLIT("hello world"));    ok(h2o_memis(t.base, t.len, H2O_STRLIT("hello world")));    t = h2o_str_stripws(H2O_STRLIT("   hello world"));    ok(h2o_memis(t.base, t.len, H2O_STRLIT("hello world")));    t = h2o_str_stripws(H2O_STRLIT("hello world   "));    ok(h2o_memis(t.base, t.len, H2O_STRLIT("hello world")));    t = h2o_str_stripws(H2O_STRLIT("   hello world   "));    ok(h2o_memis(t.base, t.len, H2O_STRLIT("hello world")));    t = h2o_str_stripws(H2O_STRLIT("     "));    ok(h2o_memis(t.base, t.len, H2O_STRLIT("")));}

static void test_at_position(void){    char buf[160];    int ret;    /* normal cases */    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 1, 1);    ok(ret == 0);    ok(strcmp(buf, "hello/n^/n") == 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 1, 5);    ok(ret == 0);    ok(strcmp(buf, "hello/n    ^/n") == 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 1, 6);    ok(ret == 0);    ok(strcmp(buf, "hello/n     ^/n") == 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 1, 7);    ok(ret == 0);    ok(strcmp(buf, "hello/n     ^/n") == 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 2, 1);    ok(ret == 0);    ok(strcmp(buf, "world/n^/n") == 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 2, 5);    ok(ret == 0);    ok(strcmp(buf, "world/n    ^/n") == 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 1, 7);    ok(ret == 0);    ok(strcmp(buf, "hello/n     ^/n") == 0);    ret = h2o_str_at_position(        buf, H2O_STRLIT("_________1_________2_________3_________4_________5_________6_________7_________/nworld/n"), 1, 5);    ok(ret == 0);    ok(strcmp(buf, "_________1_________2_________3_________4_________5_________6_________7______/n    ^/n") == 0);    ret = h2o_str_at_position(        buf, H2O_STRLIT("_________1_________2_________3_________4_________5_________6_________7_________/nworld/n"), 1, 60);    ok(ret == 0);    ok(strcmp(buf, "_________3_________4_________5_________6_________7_________/n                                       ^/n") == 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello"), 1, 20);    ok(ret == 0);    ok(strcmp(buf, "hello/n     ^/n") == 0);    /* error cases */    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 0, 1);    ok(ret != 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 1, 0);    ok(ret != 0);    ret = h2o_str_at_position(buf, H2O_STRLIT("hello/nworld/n"), 4, 1);    ok(ret != 0);}

static void test_next_token2(void){    h2o_iovec_t iter, value;    const char *name;    size_t name_len;#define NEXT()                                                                                                                     /    if ((name = h2o_next_token(&iter, ',', &name_len, &value)) == NULL) {                                                          /        ok(0);                                                                                                                     /        return;                                                                                                                    /    }    iter = h2o_iovec_init(H2O_STRLIT("public, max-age=86400, must-revalidate"));    NEXT();    ok(h2o_memis(name, name_len, H2O_STRLIT("public")));    ok(value.base == NULL);    ok(value.len == 0);    NEXT();    ok(h2o_memis(name, name_len, H2O_STRLIT("max-age")));    ok(h2o_memis(value.base, value.len, H2O_STRLIT("86400")));    NEXT();    ok(h2o_memis(name, name_len, H2O_STRLIT("must-revalidate")));    ok(value.base == NULL);    ok(value.len == 0);    name = h2o_next_token(&iter, ',', &name_len, &value);    ok(name == NULL);    iter = h2o_iovec_init(H2O_STRLIT("public, max-age = 86400 = c , must-revalidate="));    NEXT();    ok(h2o_memis(name, name_len, H2O_STRLIT("public")));    ok(value.base == NULL);    ok(value.len == 0);    NEXT();    ok(h2o_memis(name, name_len, H2O_STRLIT("max-age")));    ok(h2o_memis(value.base, value.len, H2O_STRLIT("86400 = c")));    NEXT();    ok(h2o_memis(name, name_len, H2O_STRLIT("must-revalidate")));    name = h2o_next_token(&iter, ',', &name_len, &value);    ok(h2o_memis(value.base, value.len, H2O_STRLIT("")));#undef NEXT}

 * 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/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")};/* h2-14 and h2-16 are kept for backwards compatibility, as they are often used */static const h2o_iovec_t alpn_protocols[] = {{H2O_STRLIT("h2")}, {H2O_STRLIT("h2-16")}, {H2O_STRLIT("h2-14")}, {NULL, 0}};const h2o_iovec_t *h2o_http2_alpn_protocols = alpn_protocols;/* npn defs should match the definition of alpn_protocols */const char *h2o_http2_npn_protocols = "/x02"                                      "h2"                                      "/x05"                                      "h2-16"                                      "/x05"                                      "h2-14";const h2o_http2_priority_t h2o_http2_default_priority = {    0, /* exclusive */    0, /* dependency */

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;    /* 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;                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(req, 503, "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(req, 403, "Access Forbidden", "access forbidden", 0);        }    }    return 0;Opened:    return serve_with_generator(generator, req, rpath, rpath_len,                                h2o_mimemap_get_type_by_extension(self->mimemap, h2o_get_filext(rpath, rpath_len)));}

static int serve_with_generator(struct st_h2o_sendfile_generator_t *generator, h2o_req_t *req, 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;    }    /* 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;        }    }    /* obtain mime type */    if (mime_type->type == H2O_MIMEMAP_TYPE_DYNAMIC) {        do_close(&generator->super, req);        return delegate_dynamic_request(req, req->path_normalized.len, rpath, rpath_len, mime_type);    }    assert(mime_type->type == H2O_MIMEMAP_TYPE_MIMETYPE);    /* 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, content_range.base, content_range.len);            h2o_send_error(req, 416, "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++;                }//.........这里部分代码省略.........