void h2o_socketpool_unregister_loop(h2o_socketpool_t *pool, h2o_loop_t *loop)
{
if (pool->_interval_cb.loop != loop)
return;
h2o_timeout_unlink(&pool->_interval_cb.entry);
h2o_timeout_dispose(loop, &pool->_interval_cb.timeout);
pool->_interval_cb.loop = NULL;
}
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);
}
void h2o_context_dispose(h2o_context_t *ctx)
{
h2o_globalconf_t *config = ctx->global_config;
size_t i;
for (i = 0; i != config->hosts.size; ++i) {
h2o_hostconf_t *hostconf = config->hosts.entries + i;
on_context_dispose(ctx, hostconf);
}
free(ctx->_module_configs);
h2o_timeout_dispose(ctx->loop, &ctx->zero_timeout);
h2o_timeout_dispose(ctx->loop, &ctx->req_timeout);
#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_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);
}
if (pool->peer.is_named)
free(pool->peer.named.host.base);
}
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_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->proxy.io_timeout);
/* what should we do here? assert(!h2o_linklist_is_empty(&ctx->http2._conns); */
h2o_filecache_destroy(ctx->filecache);
ctx->filecache = NULL;
/* 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 H2O_USE_LIBUV
/* make sure the handles released by h2o_timeout_dispose get freed */
uv_run(ctx->loop, UV_RUN_NOWAIT);
#endif
}
