int main(int argc, char **argv)
{
uv_loop_t *loop = uv_default_loop();
uv_tcp_t listener;
struct sockaddr_in sockaddr;
h2o_handler_t ws_handler;
int r;
if ((r = uv_tcp_init(loop, &listener)) != 0) {
fprintf(stderr, "uv_tcp_init:%s\n", uv_strerror(r));
goto Error;
}
uv_ip4_addr("127.0.0.1", 7890, &sockaddr);
if ((r = uv_tcp_bind(&listener, (struct sockaddr*)&sockaddr, sizeof(sockaddr))) != 0) {
fprintf(stderr, "uv_tcp_bind:%s\n", uv_strerror(r));
goto Error;
}
if ((r = uv_listen((uv_stream_t*)&listener, 128, on_connect)) != 0) {
fprintf(stderr, "uv_listen:%s\n", uv_strerror(r));
goto Error;
}
h2o_config_init(&config);
memset(&ws_handler, 0, sizeof(ws_handler));
ws_handler.on_req = on_req;
h2o_linklist_insert(&config.default_host.handlers, &ws_handler._link);
h2o_context_init(&ctx, loop, &config);
//ssl_ctx = h2o_ssl_new_server_context("server.crt", "server.key", NULL);
return uv_run(loop, UV_RUN_DEFAULT);
Error:
return 1;
}
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);
}
int main(int argc, char **argv)
{
h2o_hostconf_t *hostconf;
signal(SIGPIPE, SIG_IGN);
h2o_config_init(&config);
hostconf = h2o_config_register_host(&config, "default");
register_handler(hostconf, "/post-test", post_test);
register_handler(hostconf, "/chunked-test", chunked_test);
h2o_file_register(h2o_config_register_path(hostconf, "/"), "examples/doc_root", NULL, NULL, 0);
#if 0 /* reproxy is not yet implemented */
register_handler(hostconf, "/reproxy-test", reproxy_test);
h2o_reproxy_register(hostconf);
#endif
#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)
;
#endif
Error:
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);
}
void test_lib__handler__fastcgi_c()
{
h2o_globalconf_t globalconf;
h2o_hostconf_t *hostconf;
h2o_pathconf_t *pathconf;
h2o_config_init(&globalconf);
globalconf.server_name = h2o_iovec_init(H2O_STRLIT("h2o/1.2.1-alpha1"));
hostconf = h2o_config_register_host(&globalconf, h2o_iovec_init(H2O_STRLIT("default")), 65535);
pathconf = h2o_config_register_path(hostconf, "/");
h2o_context_init(&ctx, test_loop, &globalconf);
subtest("build-request", test_build_request);
h2o_context_dispose(&ctx);
h2o_config_dispose(&globalconf);
}
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)
;
#endif
Error:
return 1;
}
int main(int argc, char **argv)
{
uv_loop_t *loop = uv_default_loop();
uv_tcp_t listener;
struct sockaddr_in sockaddr;
h2o_hostconf_t *hostconf;
h2o_pathconf_t *pathconf;
int r;
if ((r = uv_tcp_init(loop, &listener)) != 0) {
fprintf(stderr, "uv_tcp_init:%s\n", uv_strerror(r));
goto Error;
}
uv_ip4_addr("127.0.0.1", 7890, &sockaddr);
if ((r = uv_tcp_bind(&listener, (struct sockaddr *)&sockaddr, sizeof(sockaddr))) != 0) {
fprintf(stderr, "uv_tcp_bind:%s\n", uv_strerror(r));
goto Error;
}
if ((r = uv_listen((uv_stream_t *)&listener, 128, on_connect)) != 0) {
fprintf(stderr, "uv_listen:%s\n", uv_strerror(r));
goto Error;
}
h2o_config_init(&config);
hostconf = h2o_config_register_host(&config, "default");
pathconf = h2o_config_register_path(hostconf, "/");
h2o_create_handler(pathconf, sizeof(h2o_handler_t))->on_req = on_req;
h2o_context_init(&ctx, loop, &config);
/* disabled by default: uncomment the block below to use HTTPS instead of HTTP */
/*
if (setup_ssl("server.crt", "server.key") != 0)
goto Error;
*/
return uv_run(loop, UV_RUN_DEFAULT);
Error:
return 1;
}
int main(int argc, char **argv)
{
signal(SIGPIPE, SIG_IGN);
h2o_config_init(&config);
register_handler(&config.default_host, post_test);
register_handler(&config.default_host, chunked_test);
register_handler(&config.default_host, reproxy_test);
h2o_register_file_handler(&config.default_host, "/", "htdocs", "index.html");
h2o_define_mimetype(&config.default_host.mimemap, "html", "text/html");
h2o_register_reproxy_filter(&config.default_host);
#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
//ssl_ctx = h2o_ssl_new_server_context("server.crt", "server.key", h2o_http2_tls_identifiers);
//h2o_register_access_logger(&ctx, "/dev/stdout");
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)
;
#endif
Error:
return 1;
}
int main(int argc, char **argv)
{
static struct option longopts[] = {
{ "conf", required_argument, NULL, 'c' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
static struct config_t config = {
{}, /* global_config */
NULL, /* listeners */
0, /* num_listeners */
1024, /* max_connections */
1, /* num_threads */
NULL, /* thread_ids */
{}, /* state */
};
const char *config_file = "h2o.conf";
int opt_ch;
yoml_t *config_yoml;
h2o_config_init(&config.global_config);
config.global_config.close_cb = on_close;
{
h2o_configurator_t *c = h2o_config_create_configurator(&config.global_config, sizeof(*c));
c->exit = on_config_listen_exit;
h2o_config_define_command(
c, "listen", H2O_CONFIGURATOR_FLAG_GLOBAL,
on_config_listen,
"port at which the server should listen for incoming requests (mandatory)",
" - if the value is a scalar, it is treated as the port number (or as the",
" service name)",
" - if the value is a mapping, following properties are recognized:",
" port: incoming port number or service name (mandatory)",
" host: incoming address (default: any address)",
" ssl: if using SSL (default: none)",
" certificate-file: path of the certificate file",
" key-file: path of the key file");
h2o_config_define_command(
c, "max-connections", H2O_CONFIGURATOR_FLAG_GLOBAL,
on_config_max_connections,
"max connections (default: 1024)");
h2o_config_define_command(
c, "num-threads", H2O_CONFIGURATOR_FLAG_GLOBAL,
on_config_num_threads,
"number of worker threads (default: 1)");
}
h2o_access_log_register_configurator(&config.global_config);
h2o_file_register_configurator(&config.global_config);
h2o_proxy_register_configurator(&config.global_config);
/* parse options */
while ((opt_ch = getopt_long(argc, argv, "c:h", longopts, NULL)) != -1) {
switch (opt_ch) {
case 'c':
config_file = optarg;
break;
case 'h':
usage(&config.global_config);
exit(0);
break;
default:
assert(0);
break;
}
}
argc -= optind;
argv += optind;
/* configure */
if ((config_yoml = load_config(config_file)) == NULL)
exit(EX_CONFIG);
if (h2o_config_configure(&config.global_config, config_file, config_yoml) != 0)
exit(EX_CONFIG);
yoml_free(config_yoml);
setup_signal_handlers();
if (config.num_threads <= 1) {
run_loop(&config);
} else {
config.thread_ids = alloca(sizeof(pthread_t) * config.num_threads);
unsigned i;
for (i = 0; i != config.num_threads; ++i) {
pthread_create(config.thread_ids + i, NULL, run_loop, &config);
}
for (i = 0; i < config.num_threads; ++i) {
pthread_join(config.thread_ids[i], NULL);
}
}
return 0;
}
void test_lib__file_c()
{
h2o_globalconf_t globalconf;
h2o_hostconf_t *hostconf;
h2o_context_t ctx;
h2o_config_init(&globalconf);
hostconf = h2o_config_register_host(&globalconf, "default");
h2o_file_register(hostconf, "/", "t/00unit/file", NULL, NULL);
h2o_context_init(&ctx, test_loop, &globalconf);
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx);
conn->req.method = h2o_buf_init(H2O_STRLIT("GET"));
conn->req.path = h2o_buf_init(H2O_STRLIT("/"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 200);
ok(check_header(&conn->req.res, H2O_TOKEN_CONTENT_TYPE, "text/html"));
ok(h2o_memis(conn->body->bytes, conn->body->size, H2O_STRLIT("hello html\n")));
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx);
conn->req.method = h2o_buf_init(H2O_STRLIT("GET"));
conn->req.path = h2o_buf_init(H2O_STRLIT("/index.html"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 200);
ok(check_header(&conn->req.res, H2O_TOKEN_CONTENT_TYPE, "text/html"));
ok(h2o_memis(conn->body->bytes, conn->body->size, H2O_STRLIT("hello html\n")));
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx);
conn->req.method = h2o_buf_init(H2O_STRLIT("GET"));
conn->req.path = h2o_buf_init(H2O_STRLIT("/1000.txt"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 200);
ok(check_header(&conn->req.res, H2O_TOKEN_CONTENT_TYPE, "text/plain"));
ok(conn->body->size == 1000);
ok(strcmp(sha1sum(conn->body->bytes, conn->body->size), "dfd3ae1f5c475555fad62efe42e07309fa45f2ed") == 0);
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx);
conn->req.method = h2o_buf_init(H2O_STRLIT("GET"));
conn->req.path = h2o_buf_init(H2O_STRLIT("/1000000.txt"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 200);
ok(check_header(&conn->req.res, H2O_TOKEN_CONTENT_TYPE, "text/plain"));
ok(conn->body->size == 1000000);
ok(strcmp(sha1sum(conn->body->bytes, conn->body->size), "00c8ab71d0914dce6a1ec2eaa0fda0df7044b2a2") == 0);
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx);
conn->req.method = h2o_buf_init(H2O_STRLIT("GET"));
conn->req.path = h2o_buf_init(H2O_STRLIT("/index_txt/"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 200);
ok(check_header(&conn->req.res, H2O_TOKEN_CONTENT_TYPE, "text/plain"));
ok(h2o_memis(conn->body->bytes, conn->body->size, H2O_STRLIT("hello text\n")));
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx);
conn->req.method = h2o_buf_init(H2O_STRLIT("GET"));
conn->req.path = h2o_buf_init(H2O_STRLIT("/index_txt"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 301);
ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "http://default/index_txt/"));
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx);
conn->req.method = h2o_buf_init(H2O_STRLIT("GET"));
conn->req.path = h2o_buf_init(H2O_STRLIT("/index_txt_as_dir/"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 301);
ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "http://default/index_txt_as_dir/index.txt/"));
h2o_loopback_destroy(conn);
}
h2o_context_dispose(&ctx);
h2o_config_dispose(&globalconf);
}
int main(int argc, char **argv)
{
static struct option longopts[] = {
{ "conf", required_argument, NULL, 'c' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
static struct port_configurator_t port_configurator = {
{ {}, "port", NULL, on_config_port, on_config_port_complete, on_config_port_context_create },
0
};
static struct num_threads_configurator_t num_threads_configurator = {
{ {}, "num-threads", NULL, on_config_num_threads, NULL, NULL },
1 /* default number of threads is 1 */
};
const char *config_file = "h2o.conf";
int opt_ch;
yoml_t *config_yoml;
h2o_global_configuration_t config;
/* parse options */
while ((opt_ch = getopt_long(argc, argv, "c:h", longopts, NULL)) != -1) {
switch (opt_ch) {
case 'c':
config_file = optarg;
break;
case 'h':
usage();
exit(0);
break;
default:
assert(0);
break;
}
}
argc -= optind;
argv += optind;
/* configure */
h2o_config_init(&config);
h2o_linklist_insert(&config.global_configurators, &port_configurator.super._link);
h2o_linklist_insert(&config.global_configurators, &num_threads_configurator.super._link);
if ((config_yoml = load_config(config_file)) == NULL)
exit(EX_CONFIG);
if (h2o_config_configure(&config, config_file, config_yoml) != 0)
exit(EX_CONFIG);
yoml_free(config_yoml);
if (num_threads_configurator.num_threads <= 1) {
run_loop(&config);
} else {
pthread_t *tids = alloca(sizeof(pthread_t) * num_threads_configurator.num_threads);
unsigned i;
for (i = 0; i != num_threads_configurator.num_threads; ++i) {
pthread_create(tids + i, NULL, run_loop, &config);
}
for (i = 0; i < num_threads_configurator.num_threads; ++i) {
pthread_join(tids[i], NULL);
}
}
return 0;
}
