void fserve_shutdown(void)
{
fserve_running = 0;
if (mimetypes)
avl_tree_free (mimetypes, _delete_mapping);
if (fh_cache)
{
int count = 20;
avl_delete (fh_cache, &no_file, NULL);
while (fh_cache->length > 1 && count)
{
fh_node *fh = fh_cache->root->right->key;
if (fh && fh->refcount == 0)
{
remove_fh_from_cache (fh);
continue;
}
DEBUG1 ("waiting for %u entries to clear", fh_cache->length);
thread_sleep (100000);
count--;
}
avl_tree_free (fh_cache, _delete_fh);
}
thread_spin_destroy (&pending_lock);
#ifndef HAVE_PREAD
thread_mutex_destroy (&seekread_lock);
#endif
INFO0("file serving stopped");
}
void connection_shutdown(void)
{
if (!_initialized) return;
_connection_running = 0;
thread_cond_signal(_connection_cond);
DEBUG0 ("waiting for connection thread");
thread_join(_connection_thread_id);
#ifdef HAVE_OPENSSL
SSL_CTX_free (ssl_ctx);
#endif
if (banned_ip.contents) avl_tree_free (banned_ip.contents, free_filtered_ip);
if (allowed_ip.contents) avl_tree_free (allowed_ip.contents, free_filtered_ip);
thread_cond_destroy (_connection_cond);
free (_connection_cond);
thread_cond_destroy(&global.shutdown_cond);
thread_rwlock_destroy(&_source_shutdown_rwlock);
thread_spin_destroy (&_connection_lock);
thread_mutex_destroy(&move_clients_mutex);
_initialized = 0;
}
static void worker_stop (void)
{
worker_t *handler;
if (workers == NULL)
return;
thread_rwlock_wlock (&workers_lock);
handler = workers;
workers = handler->next;
worker_least_used = worker_balance_to_check = workers;
if (workers)
workers->move_allocations = 100;
worker_count--;
thread_rwlock_unlock (&workers_lock);
handler->running = 0;
worker_wakeup (handler);
thread_join (handler->thread);
thread_spin_destroy (&handler->lock);
sock_close (handler->wakeup_fd[1]);
sock_close (handler->wakeup_fd[0]);
free (handler);
}
void fserve_shutdown(void)
{
if (!__inited)
return;
thread_spin_lock (&pending_lock);
run_fserv = 0;
while (pending_list)
{
fserve_t *to_go = (fserve_t *)pending_list;
pending_list = to_go->next;
fserve_client_destroy (to_go);
}
while (active_list)
{
fserve_t *to_go = active_list;
active_list = to_go->next;
fserve_client_destroy (to_go);
}
if (mimetypes)
avl_tree_free (mimetypes, _delete_mapping);
thread_spin_unlock (&pending_lock);
thread_spin_destroy (&pending_lock);
ICECAST_LOG_INFO("file serving stopped");
}
void slave_shutdown(void)
{
thread_rwlock_destroy (&slaves_lock);
thread_rwlock_destroy (&workers_lock);
thread_spin_destroy (&relay_start_lock);
yp_shutdown();
}
void slave_shutdown(void)
{
if (slave_running == 0)
return;
thread_rwlock_destroy (&slaves_lock);
thread_rwlock_destroy (&workers_lock);
thread_spin_destroy (&relay_start_lock);
yp_shutdown();
slave_running = 0;
}
void global_shutdown(void)
{
thread_mutex_destroy(&_global_mutex);
thread_spin_destroy (&global.spinlock);
avl_tree_free(global.source_tree, NULL);
rate_free (global.out_bitrate);
global.out_bitrate = NULL;
#ifdef MY_ALLOC
avl_tree_free(global.alloc_tree, free_alloc_node);
#endif
}
void xslt_shutdown(void) {
int i;
for(i=0; i < CACHESIZE; i++) {
free(cache[i].filename);
free(cache[i].disposition);
if(cache[i].stylesheet)
xsltFreeStylesheet(cache[i].stylesheet);
}
thread_rwlock_destroy (&xslt_lock);
thread_spin_destroy (&update_lock);
xmlCleanupParser();
xsltCleanupGlobals();
}
static void worker_stop (void)
{
worker_t *handler;
thread_rwlock_wlock (&workers_lock);
do
{
if (worker_count > 0)
{
handler = workers;
workers = handler->next;
worker_least_used = worker_balance_to_check = workers;
if (workers)
workers->move_allocations = 100;
worker_count--;
}
else
{
handler = worker_incoming;
worker_incoming = NULL;
INFO0 ("stopping incoming worker thread");
}
thread_rwlock_unlock (&workers_lock);
if (handler)
{
handler->running = 0;
worker_wakeup (handler);
thread_join (handler->thread);
thread_spin_destroy (&handler->lock);
sock_close (handler->wakeup_fd[1]);
sock_close (handler->wakeup_fd[0]);
free (handler);
}
thread_rwlock_wlock (&workers_lock);
} while (workers == NULL && worker_incoming);
}
void connection_shutdown(void)
{
connection_listen_sockets_close (NULL, 1);
thread_spin_destroy (&_connection_lock);
}
