h2o_file_handler_t *h2o_file_register(h2o_hostconf_t *host_config, const char *virtual_path, const char *real_path, const char **index_files, h2o_mimemap_t *mimemap)
{
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(host_config, offsetof(h2o_file_handler_t, index_files[0]) + sizeof(self->index_files[0]) * (i + 1));
/* setup callbacks */
self->super.dispose = on_dispose;
self->super.on_req = on_req;
/* setup attributes */
self->virtual_path = append_slash_and_dup(virtual_path);
self->real_path = append_slash_and_dup(real_path);
if (mimemap != NULL) {
h2o_mempool_addref_shared(mimemap);
self->mimemap = mimemap;
} else {
self->mimemap = h2o_mimemap_create();
}
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;
}
void h2o_proxy_register_reverse_proxy(h2o_pathconf_t *pathconf, h2o_url_t *upstream, h2o_proxy_config_vars_t *config)
{
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;
if (config->keepalive_timeout != 0) {
self->sockpool = h2o_mem_alloc(sizeof(*self->sockpool));
struct sockaddr_un sa;
const char *to_sa_err;
int is_ssl = upstream->scheme == &H2O_URL_SCHEME_HTTPS;
if ((to_sa_err = h2o_url_host_to_sun(upstream->host, &sa)) == 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);
h2o_strtolower(self->upstream.host.base, self->upstream.host.len);
self->config = *config;
if (self->config.ssl_ctx != NULL)
CRYPTO_add(&self->config.ssl_ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
}
static h2o_pathconf_t *register_handler(h2o_hostconf_t *hostconf, const char *path, int (*on_req)(h2o_handler_t *, h2o_req_t *))
{
h2o_pathconf_t *pathconf = h2o_config_register_path(hostconf, path);
h2o_handler_t *handler = h2o_create_handler(pathconf, sizeof(*handler));
handler->on_req = on_req;
return pathconf;
}
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;
}
void h2o_proxy_register_reverse_proxy(h2o_pathconf_t *pathconf, h2o_proxy_config_vars_t *config, h2o_socketpool_t *sockpool)
{
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;
self->super.supports_request_streaming = 1;
self->config = *config;
self->sockpool = sockpool;
}
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;
}
void h2o_proxy_register_reverse_proxy(h2o_pathconf_t *pathconf, const char *host, uint16_t port, const char *real_path, h2o_proxy_config_vars_t *config)
{
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;
self->upstream.host = h2o_strdup(NULL, host, SIZE_MAX);
self->upstream.port = port;
self->upstream.path = h2o_strdup(NULL, real_path, SIZE_MAX);
if (config->use_keepalive) {
self->sockpool = h2o_mem_alloc(sizeof(*self->sockpool));
h2o_socketpool_init(self->sockpool, host, port, SIZE_MAX /* FIXME */);
}
self->config = *config;
}
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;
}
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;
}
static void register_handler(h2o_hostconf_t *host_config, int (*on_req)(h2o_handler_t *, h2o_req_t *))
{
h2o_handler_t *handler = h2o_create_handler(host_config, sizeof(*handler));
handler->on_req = on_req;
}
