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
avl_tree_free (avl_tree * tree, avl_free_key_fun_type free_key_fun)
{
if (tree->length && tree->root->right) {
avl_tree_free_helper (tree->root->right, free_key_fun);
}
if (tree->root) {
#ifdef HAVE_AVL_NODE_LOCK
thread_rwlock_destroy(&tree->root->rwlock);
#endif
free (tree->root);
}
thread_rwlock_destroy(&tree->rwlock);
free (tree);
}
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 htpasswd_clear(auth_t *self) {
htpasswd_auth_state *state = self->state;
free(state->filename);
thread_rwlock_destroy(&state->file_rwlock);
free(state);
free(self->type);
free(self);
}
static void htpasswd_clear(auth_t *self) {
htpasswd_auth_state *state = self->state;
free(state->filename);
if (state->users)
avl_tree_free (state->users, _free_user);
thread_rwlock_destroy(&state->file_rwlock);
free(state);
}
int main(void)
{
int rv;
thread_rwlock_t *thread_rwlock = NULL;
rv = thread_rwlock_create(&thread_rwlock);
rv = thread_rwlock_wrlock(thread_rwlock);
rv = thread_rwlock_unlock(thread_rwlock);
thread_rwlock_destroy(thread_rwlock);
return 0;
}
void auth_shutdown (void)
{
if (allow_auth == 0)
return;
allow_auth = 0;
thread_rwlock_wlock (&auth_lock);
thread_rwlock_unlock (&auth_lock);
thread_rwlock_destroy (&auth_lock);
INFO0 ("Auth shutdown complete");
}
void global_shutdown(void)
{
thread_rwlock_destroy(&global.workers_rw);
thread_mutex_destroy(&_global_mutex);
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
}
static void *yp_update_thread(void *arg)
{
if (!kitsune_is_updating()) { /**DSU control */
INFO0("YP update thread started");
yp_running = 1;
}
while (yp_running)
{
kitsune_update("yp_update"); /**DSU updatepoint */
struct yp_server *server;
thread_sleep (200000);
/* do the YP communication */
thread_rwlock_rlock (&yp_lock);
server = (struct yp_server *)active_yps;
while (server)
{
/* DEBUG1 ("trying %s", server->url); */
yp_process_server (server);
server = server->next;
}
thread_rwlock_unlock (&yp_lock);
/* update the local YP structure */
if (yp_update)
{
thread_rwlock_wlock (&yp_lock);
check_servers ();
server = (struct yp_server *)active_yps;
while (server)
{
/* DEBUG1 ("Checking yps %s", server->url); */
add_pending_yp (server);
delete_marked_yp (server);
server = server->next;
}
yp_update = 0;
thread_rwlock_unlock (&yp_lock);
}
}
thread_rwlock_destroy (&yp_lock);
thread_mutex_destroy (&yp_pending_lock);
/* free server and ypdata left */
while (active_yps)
{
struct yp_server *server = (struct yp_server *)active_yps;
active_yps = server->next;
destroy_yp_server (server);
}
return NULL;
}
void connection_shutdown(void)
{
if (!_initialized) return;
thread_cond_destroy(&global.shutdown_cond);
thread_rwlock_destroy(&_source_shutdown_rwlock);
thread_mutex_destroy(&_queue_mutex);
thread_mutex_destroy(&_connection_mutex);
thread_mutex_destroy(&move_clients_mutex);
_initialized = 0;
}
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
avl_tree_free_helper (avl_node * node, avl_free_key_fun_type free_key_fun)
{
if (node->left) {
avl_tree_free_helper (node->left, free_key_fun);
}
if (free_key_fun)
free_key_fun (node->key);
if (node->right) {
avl_tree_free_helper (node->right, free_key_fun);
}
#ifdef HAVE_AVL_NODE_LOCK
thread_rwlock_destroy (&node->rwlock);
#endif
free (node);
}
void connection_shutdown(void)
{
if (!_initialized) return;
#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(&global.shutdown_cond);
thread_rwlock_destroy(&_source_shutdown_rwlock);
thread_mutex_destroy(&_con_queue_mutex);
thread_mutex_destroy(&_req_queue_mutex);
thread_mutex_destroy(&_connection_mutex);
thread_mutex_destroy(&move_clients_mutex);
_initialized = 0;
}
void yp_shutdown (void)
{
DEBUG0 ("releasing directory details");
if (yp_initialised == 0)
return;
thread_rwlock_destroy (&yp_lock);
thread_mutex_destroy (&yp_pending_lock);
/* free server and ypdata left */
while (active_yps)
{
struct yp_server *server = (struct yp_server *)active_yps;
active_yps = server->next;
destroy_yp_server (server);
}
free ((char*)server_version);
server_version = NULL;
active_yps = NULL;
yp_initialised = 0;
INFO0 ("YP cleanup complete");
}
static void release_locks(void) {
thread_mutex_destroy(&_locks.relay_lock);
thread_rwlock_destroy(&_locks.config_lock);
}
int avl_delete(avl_tree *tree, void *key, avl_free_key_fun_type free_key_fun)
{
avl_node *x, *y, *p, *q, *r, *top, *x_child;
int shortened_side, shorter;
x = tree->root->right;
if (!x) {
return -1;
}
while (1) {
int compare_result = tree->compare_fun (tree->compare_arg, key, x->key);
if (compare_result < 0) {
/* move left
* We will be deleting from the left, adjust this node's
* rank accordingly
*/
AVL_SET_RANK (x, (AVL_GET_RANK(x) - 1));
if (x->left) {
x = x->left;
} else {
/* Oops! now we have to undo the rank changes
* all the way up the tree
*/
AVL_SET_RANK(x, (AVL_GET_RANK (x) + 1));
while (x != tree->root->right) {
if (x->parent->left == x) {
AVL_SET_RANK(x->parent, (AVL_GET_RANK (x->parent) + 1));
}
x = x->parent;
}
return -1; /* key not in tree */
}
} else if (compare_result > 0) {
/* move right */
if (x->right) {
x = x->right;
} else {
AVL_SET_RANK(x, (AVL_GET_RANK (x) + 1));
while (x != tree->root->right) {
if (x->parent->left == x) {
AVL_SET_RANK(x->parent, (AVL_GET_RANK (x->parent) + 1));
}
x = x->parent;
}
return -1; /* key not in tree */
}
} else {
break;
}
}
if (x->left && x->right) {
void * temp_key;
/* The complicated case.
* reduce this to the simple case where we are deleting
* a node with at most one child.
*/
/* find the immediate predecessor <y> */
y = x->left;
while (y->right) {
y = y->right;
}
/* swap <x> with <y> */
temp_key = x->key;
x->key = y->key;
y->key = temp_key;
/* we know <x>'s left subtree lost a node because that's
* where we took it from
*/
AVL_SET_RANK (x, (AVL_GET_RANK (x) - 1));
x = y;
}
/* now <x> has at most one child
* scoot this child into the place of <x>
*/
if (x->left) {
x_child = x->left;
x_child->parent = x->parent;
} else if (x->right) {
x_child = x->right;
x_child->parent = x->parent;
} else {
x_child = NULL;
}
/* now tell <x>'s parent that a grandchild became a child */
if (x == x->parent->left) {
x->parent->left = x_child;
shortened_side = -1;
} else {
x->parent->right = x_child;
shortened_side = +1;
}
/*
* the height of the subtree <x>
* has now been shortened. climb back up
* the tree, rotating when necessary to adjust
* for the change.
*/
shorter = 1;
p = x->parent;
/* return the key and node to storage */
if (free_key_fun)
free_key_fun (x->key);
#ifdef HAVE_AVL_NODE_LOCK
thread_rwlock_destroy (&x->rwlock);
#endif
free (x);
while (shorter && p->parent) {
/* case 1: height unchanged */
if (AVL_GET_BALANCE(p) == 0) {
if (shortened_side == -1) {
/* we removed a left child, the tree is now heavier
* on the right
*/
AVL_SET_BALANCE (p, +1);
} else {
/* we removed a right child, the tree is now heavier
* on the left
*/
AVL_SET_BALANCE (p, -1);
}
shorter = 0;
} else if (AVL_GET_BALANCE (p) == shortened_side) {
/* case 2: taller subtree shortened, height reduced */
AVL_SET_BALANCE (p, 0);
} else {
/* case 3: shorter subtree shortened */
top = p->parent;
/* set <q> to the taller of the two subtrees of <p> */
if (shortened_side == 1) {
q = p->left;
} else {
q = p->right;
}
if (AVL_GET_BALANCE (q) == 0) {
/* case 3a: height unchanged */
if (shortened_side == -1) {
/* single rotate left */
q->parent = p->parent;
p->right = q->left;
if (q->left) {
q->left->parent = p;
}
q->left = p;
p->parent = q;
AVL_SET_RANK (q, (AVL_GET_RANK (q) + AVL_GET_RANK (p)));
} else {
/* single rotate right */
q->parent = p->parent;
p->left = q->right;
if (q->right) {
q->right->parent = p;
}
q->right = p;
p->parent = q;
AVL_SET_RANK (p, (AVL_GET_RANK (p) - AVL_GET_RANK (q)));
}
shorter = 0;
AVL_SET_BALANCE (q, shortened_side);
AVL_SET_BALANCE (p, (- shortened_side));
} else if (AVL_GET_BALANCE (q) == AVL_GET_BALANCE (p)) {
/* case 3b: height reduced */
if (shortened_side == -1) {
/* single rotate left */
q->parent = p->parent;
p->right = q->left;
if (q->left) {
q->left->parent = p;
}
q->left = p;
p->parent = q;
AVL_SET_RANK (q, (AVL_GET_RANK (q) + AVL_GET_RANK (p)));
} else {
/* single rotate right */
q->parent = p->parent;
p->left = q->right;
if (q->right) {
q->right->parent = p;
}
q->right = p;
p->parent = q;
AVL_SET_RANK (p, (AVL_GET_RANK (p) - AVL_GET_RANK (q)));
}
shorter = 1;
AVL_SET_BALANCE (q, 0);
AVL_SET_BALANCE (p, 0);
} else {
/* case 3c: height reduced, balance factors opposite */
if (shortened_side == 1) {
/* double rotate right */
/* first, a left rotation around q */
r = q->right;
r->parent = p->parent;
q->right = r->left;
if (r->left) {
r->left->parent = q;
}
r->left = q;
q->parent = r;
/* now, a right rotation around p */
p->left = r->right;
if (r->right) {
r->right->parent = p;
}
r->right = p;
p->parent = r;
AVL_SET_RANK (r, (AVL_GET_RANK (r) + AVL_GET_RANK (q)));
AVL_SET_RANK (p, (AVL_GET_RANK (p) - AVL_GET_RANK (r)));
} else {
/* double rotate left */
/* first, a right rotation around q */
r = q->left;
r->parent = p->parent;
q->left = r->right;
if (r->right) {
r->right->parent = q;
}
r->right = q;
q->parent = r;
/* now a left rotation around p */
p->right = r->left;
if (r->left) {
r->left->parent = p;
}
r->left = p;
p->parent = r;
AVL_SET_RANK (q, (AVL_GET_RANK (q) - AVL_GET_RANK (r)));
AVL_SET_RANK (r, (AVL_GET_RANK (r) + AVL_GET_RANK (p)));
}
if (AVL_GET_BALANCE (r) == shortened_side) {
AVL_SET_BALANCE (q, (- shortened_side));
AVL_SET_BALANCE (p, 0);
} else if (AVL_GET_BALANCE (r) == (- shortened_side)) {
AVL_SET_BALANCE (q, 0);
AVL_SET_BALANCE (p, shortened_side);
} else {
AVL_SET_BALANCE (q, 0);
AVL_SET_BALANCE (p, 0);
}
AVL_SET_BALANCE (r, 0);
q = r;
}
/* a rotation has caused <q> (or <r> in case 3c) to become
* the root. let <p>'s former parent know this.
*/
if (top->left == p) {
top->left = q;
} else {
top->right = q;
}
/* end case 3 */
p = q;
}
x = p;
p = x->parent;
/* shortened_side tells us which side we came up from */
if (x == p->left) {
shortened_side = -1;
} else {
shortened_side = +1;
}
} /* end while(shorter) */
/* when we're all done, we're one shorter */
tree->length = tree->length - 1;
return (0);
}