void slave_initialize(void)
{
if (slave_running)
return;
thread_rwlock_create (&slaves_lock);
slave_running = 1;
streamlister = 0;
streamlist_check = 0;
update_settings = 0;
update_all_sources = 0;
restart_connection_thread = 0;
redirectors = NULL;
workers = NULL;
worker_count = 0;
relays_connecting = 0;
thread_spin_create (&relay_start_lock);
thread_rwlock_create (&workers_lock);
inactivity_timeout = 0;
inactivity_timer = 0;
#ifndef HAVE_CURL
ERROR0 ("streamlist request disabled, rebuild with libcurl if required");
#endif
_slave_thread ();
yp_stop ();
workers_adjust(0);
}
void fserve_initialize(void)
{
if (fserve_running) return;
ice_config_t *config = config_get_config();
mimetypes = NULL;
thread_spin_create (&pending_lock);
#ifndef HAVE_PREAD
thread_mutex_create (&seekread_lock);
#endif
fh_cache = avl_tree_new (_compare_fh, NULL);
fserve_recheck_mime_types (config);
config_release_config();
stats_event_flags (NULL, "file_connections", "0", STATS_COUNTERS);
fserve_running = 1;
memset (&no_file, 0, sizeof (no_file));
thread_mutex_create (&no_file.lock);
no_file.clients = avl_tree_new (client_compare, NULL);
no_file.refcount = 1;
no_file.expire = (time_t)-1;
no_file.f = -1;
avl_insert (fh_cache, &no_file);
INFO0("file serving started");
}
void connection_initialize(void)
{
if (_initialized) return;
thread_spin_create (&_connection_lock);
thread_mutex_create(&move_clients_mutex);
thread_rwlock_create(&_source_shutdown_rwlock);
thread_cond_init(&global.shutdown_cond);
_con_queue = NULL;
_con_queue_tail = &_con_queue;
banned_ip.contents = NULL;
banned_ip.file_mtime = 0;
allowed_ip.contents = NULL;
allowed_ip.file_mtime = 0;
_connection_running = 1;
/* (XXX)xaiki: need a way to make it go away on shutdown, ok for now */
_connection_thread_id = thread_create ("Connection Thread", _connection_thread,
NULL, THREAD_DETACHED);
_connection_cond = thread_cond_create ();
_initialized = 1;
}
static void worker_start (void)
{
worker_t *handler = calloc (1, sizeof(worker_t));
worker_control_create (&handler->wakeup_fd[0]);
handler->pending_clients_tail = &handler->pending_clients;
thread_spin_create (&handler->lock);
handler->last_p = &handler->clients;
thread_rwlock_wlock (&workers_lock);
if (worker_incoming == NULL)
{
worker_incoming = handler;
handler->thread = thread_create ("worker", worker, handler, THREAD_ATTACHED);
thread_rwlock_unlock (&workers_lock);
INFO0 ("starting incoming worker thread");
worker_start(); // single level recursion, just get a special worker thread set up
return;
}
handler->next = workers;
workers = handler;
worker_count++;
worker_least_used = worker_balance_to_check = workers;
thread_rwlock_unlock (&workers_lock);
handler->thread = thread_create ("worker", worker, handler, THREAD_ATTACHED);
}
void xslt_initialize(void)
{
memset (&cache[0], 0, sizeof cache);
thread_rwlock_create (&xslt_lock);
thread_spin_create (&update_lock);
xsl_updating = 0;
xmlInitParser();
LIBXML_TEST_VERSION
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
}
void xslt_initialize(void)
{
memset(cache, 0, sizeof(stylesheet_cache_t)*CACHESIZE);
thread_mutex_create(&xsltlock);
thread_rwlock_create (&xslt_lock);
thread_spin_create (&update_lock);
xsl_updating = 0;
xmlInitParser();
LIBXML_TEST_VERSION
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
}
void connection_initialize(void)
{
thread_spin_create (&_connection_lock);
memset (&banned_ip, 0, sizeof (banned_ip));
memset (&allowed_ip, 0, sizeof (allowed_ip));
memset (&useragents, 0, sizeof (useragents));
conn_tid = NULL;
connection_running = 0;
#ifdef HAVE_OPENSSL
SSL_load_error_strings(); /* readable error messages */
SSL_library_init(); /* initialize library */
#endif
}
void fserve_initialize(void)
{
ice_config_t *config = config_get_config();
mimetypes = NULL;
active_list = NULL;
pending_list = NULL;
thread_spin_create (&pending_lock);
fserve_recheck_mime_types (config);
config_release_config();
stats_event (NULL, "file_connections", "0");
INFO0("file serving started");
}
void global_initialize(void)
{
global.server_sockets = 0;
global.relays = NULL;
global.master_relays = NULL;
global.running = 0;
global.clients = 0;
global.sources = 0;
global.source_tree = avl_tree_new(source_compare_sources, NULL);
#ifdef MY_ALLOC
global.alloc_tree = avl_tree_new(compare_allocs, NULL);
#endif
thread_mutex_create(&_global_mutex);
thread_spin_create (&global.spinlock);
global.out_bitrate = rate_setup (20000, 1000);
}
static void worker_start (void)
{
worker_t *handler = calloc (1, sizeof(worker_t));
worker_control_create (handler);
handler->pending_clients_tail = &handler->pending_clients;
thread_spin_create (&handler->lock);
thread_rwlock_wlock (&workers_lock);
handler->last_p = &handler->clients;
handler->next = workers;
workers = handler;
worker_count++;
worker_least_used = worker_balance_to_check = workers;
handler->thread = thread_create ("worker", worker, handler, THREAD_ATTACHED);
thread_rwlock_unlock (&workers_lock);
}
void connection_initialize(void)
{
if (_initialized) return;
thread_spin_create (&_connection_lock);
thread_mutex_create(&move_clients_mutex);
thread_rwlock_create(&_source_shutdown_rwlock);
thread_cond_create(&global.shutdown_cond);
_req_queue = NULL;
_req_queue_tail = &_req_queue;
_con_queue = NULL;
_con_queue_tail = &_con_queue;
banned_ip.contents = NULL;
banned_ip.file_mtime = 0;
allowed_ip.contents = NULL;
allowed_ip.file_mtime = 0;
_initialized = 1;
}
