void wr_chats_init(void) {
wr_chat_runtime_id = wi_runtime_register_class(&wr_chat_runtime_class);
wr_chats = wi_dictionary_init(wi_mutable_dictionary_alloc());
wr_public_chat = wr_chat_init_public_chat(wr_chat_alloc());
wr_chats_add_chat(wr_public_chat);
}
void wi_dictionary_initialize(void) {
_wi_dictionary_buckets_per_page = wi_page_size() / sizeof(_wi_dictionary_bucket_t);
#ifndef _WI_DICTIONARY_USE_QSORT_R
_wi_dictionary_sort_lock = wi_lock_init(wi_lock_alloc());
#endif
_wi_dictionary0 = wi_dictionary_init(wi_dictionary_alloc());
}
wi_dictionary_t * wi_thread_dictionary(void) {
#ifdef WI_PTHREADS
wi_dictionary_t *dictionary;
dictionary = pthread_getspecific(_wi_thread_dictionary_key);
if(!dictionary) {
dictionary = wi_dictionary_init(wi_dictionary_alloc());
pthread_setspecific(_wi_thread_dictionary_key, dictionary);
}
return dictionary;
#else
if(!_wi_thread_dictionary)
_wi_thread_dictionary = wi_dictionary_init(wi_dictionary_alloc());
return _wi_thread_dictionary;
#endif
}
void wd_users_init(void) {
wd_user_runtime_id = wi_runtime_register_class(&wd_user_runtime_class);
wd_users = wi_dictionary_init(wi_dictionary_alloc());
wd_users_uid_lock = wi_lock_init(wi_lock_alloc());
wd_users_timer = wi_timer_init_with_function(wi_timer_alloc(),
wd_users_update_idle,
WD_USERS_TIMER_INTERVAL,
true);
}
void wt_servers_init(void) {
wt_server_runtime_id = wi_runtime_register_class(&wt_server_runtime_class);
wt_servers = wi_dictionary_init(wi_dictionary_alloc());
wt_servers_lock = wi_lock_init(wi_lock_alloc());
wt_servers_timer = wi_timer_init_with_function(wi_timer_alloc(),
wt_update_servers,
WT_SERVERS_UPDATE_INTERVAL,
true);
}
wi_mutable_dictionary_t * wi_mutable_dictionary_with_data_and_keys(void *data0, void *key0, ...) {
wi_dictionary_t *dictionary;
void *data, *key;
va_list ap;
dictionary = wi_dictionary_init(wi_mutable_dictionary_alloc());
_wi_dictionary_set_data_for_key(dictionary, data0, key0);
va_start(ap, key0);
while((data = va_arg(ap, void *))) {
key = va_arg(ap, void *);
_wi_dictionary_set_data_for_key(dictionary, data, key);
}
va_end(ap);
return wi_autorelease(dictionary);
}
static wd_user_t * wd_user_init_with_socket(wd_user_t *user, wi_socket_t *socket) {
wi_address_t *address;
user->id = wd_user_next_id();
user->socket = wi_retain(socket);
user->state = WD_USER_CONNECTED;
user->login_time = wi_date_init(wi_date_alloc());
user->idle_time = wi_date_init(wi_date_alloc());
address = wi_socket_address(socket);
user->ip = wi_retain(wi_address_string(address));
user->host = wi_retain(wi_address_hostname(address));
user->user_lock = wi_recursive_lock_init(wi_recursive_lock_alloc());
user->socket_lock = wi_recursive_lock_init(wi_recursive_lock_alloc());
user->subscribed_paths = wi_set_init_with_capacity(wi_mutable_set_alloc(), 0, true);
user->subscribed_virtualpaths = wi_dictionary_init(wi_mutable_dictionary_alloc());
return user;
}
wi_dictionary_t * wi_p7_message_fields(wi_p7_message_t *p7_message) {
wi_p7_spec_field_t *field;
wi_mutable_dictionary_t *fields;
wi_string_t *field_name, *field_value;
unsigned char *buffer, *start;
uint32_t message_size, field_id, field_size;
fields = wi_dictionary_init(wi_mutable_dictionary_alloc());
message_size = p7_message->binary_size - WI_P7_MESSAGE_BINARY_HEADER_SIZE;
buffer = start = p7_message->binary_buffer + WI_P7_MESSAGE_BINARY_HEADER_SIZE;
while((uint32_t) (buffer - start) < message_size) {
field_id = wi_read_swap_big_to_host_int32(buffer, 0);
buffer += sizeof(field_id);
field = wi_p7_spec_field_with_id(p7_message->spec, field_id);
if(!field)
continue;
field_size = wi_p7_spec_field_size(field);
if(field_size == 0) {
field_size = wi_read_swap_big_to_host_int32(buffer, 0);
buffer += sizeof(field_size);
}
field_name = wi_p7_spec_field_name(field);
field_value = _wi_p7_message_field_string_value(p7_message, field);
wi_mutable_dictionary_set_data_for_key(fields, field_value, field_name);
buffer += field_size;
}
return wi_autorelease(fields);
}
wi_mutable_dictionary_t * wi_mutable_dictionary(void) {
return wi_autorelease(wi_dictionary_init(wi_mutable_dictionary_alloc()));
}
static void wd_transfers_queue_thread(wi_runtime_instance_t *argument) {
wi_pool_t *pool;
wi_enumerator_t *enumerator;
wi_mutable_dictionary_t *key_queues;
wi_mutable_array_t *key_queue, *keys;
wi_string_t *key;
wd_transfer_t *transfer;
wd_account_t *account;
wi_uinteger_t user_downloads, user_uploads, user_transfers;
wi_uinteger_t new_position, position, queue, i, count, longest_queue;
pool = wi_pool_init(wi_pool_alloc());
key_queues = wi_dictionary_init(wi_mutable_dictionary_alloc());
while(true) {
wi_mutable_dictionary_remove_all_data(key_queues);
wi_condition_lock_lock_when_condition(wd_transfers_queue_lock, 1, 0.0);
wi_array_rdlock(wd_transfers);
longest_queue = 0;
enumerator = wi_array_data_enumerator(wd_transfers);
while((transfer = wi_enumerator_next_data(enumerator))) {
wi_condition_lock_lock(transfer->queue_lock);
if(transfer->state == WD_TRANSFER_QUEUED && transfer->queue != 0) {
key_queue = wi_dictionary_data_for_key(key_queues, transfer->key);
if(!key_queue) {
key_queue = wi_mutable_array();
wi_mutable_dictionary_set_data_for_key(key_queues, key_queue, transfer->key);
}
wi_mutable_array_add_data(key_queue, transfer);
if(wi_array_count(key_queue) > longest_queue)
longest_queue = wi_array_count(key_queue);
}
wi_condition_lock_unlock(transfer->queue_lock);
}
keys = wi_autorelease(wi_mutable_copy(wi_dictionary_keys_sorted_by_value(key_queues, wd_transfers_queue_compare)));
position = 1;
count = wi_array_count(keys);
while(longest_queue > 0) {
for(i = 0; i < count; i++) {
key = WI_ARRAY(keys, i);
key_queue = wi_dictionary_data_for_key(key_queues, key);
if(wi_array_count(key_queue) > 0) {
transfer = WI_ARRAY(key_queue, 0);
account = wd_user_account(transfer->user);
wi_lock_lock(wd_transfers_status_lock);
if(transfer->type == WD_TRANSFER_DOWNLOAD) {
wi_dictionary_rdlock(wd_transfers_user_downloads);
user_downloads = wd_account_transfer_download_limit(account);
user_transfers = (wi_integer_t) wi_dictionary_data_for_key(wd_transfers_user_downloads, transfer->key);
queue = ((wd_transfers_total_downloads > 0 && wd_transfers_active_downloads >= wd_transfers_total_downloads) ||
(user_downloads > 0 && user_transfers >= user_downloads));
wi_dictionary_unlock(wd_transfers_user_downloads);
} else {
wi_dictionary_rdlock(wd_transfers_user_uploads);
user_uploads = wd_account_transfer_upload_limit(account);
user_transfers = (wi_integer_t) wi_dictionary_data_for_key(wd_transfers_user_uploads, transfer->key);
queue = ((wd_transfers_total_uploads > 0 && wd_transfers_active_uploads >= wd_transfers_total_uploads) ||
(user_uploads > 0 && user_transfers >= user_uploads));
wi_dictionary_unlock(wd_transfers_user_uploads);
}
wi_lock_unlock(wd_transfers_status_lock);
if(queue)
new_position = position++;
else
new_position = 0;
if(new_position != (wi_uinteger_t) transfer->queue) {
if(new_position == 0)
wd_transfers_add_or_remove_transfer(transfer, true);
wi_condition_lock_lock(transfer->queue_lock);
transfer->queue = new_position;
wi_condition_lock_unlock_with_condition(transfer->queue_lock, 1);
}
wi_mutable_array_remove_data_at_index(key_queue, 0);
}
}
longest_queue--;
}
wi_array_unlock(wd_transfers);
wi_condition_lock_unlock_with_condition(wd_transfers_queue_lock, 0);
wi_pool_drain(pool);
}
wi_release(key_queues);
wi_release(pool);
}
static wi_boolean_t _wi_plist_read_node_to_instance(xmlNodePtr content_node, wi_runtime_instance_t *collection) {
xmlNodePtr node;
wi_string_t *name, *key = NULL;
wi_runtime_instance_t *instance = NULL;
wi_boolean_t dictionary;
dictionary = (wi_runtime_id(collection) == wi_dictionary_runtime_id());
for(node = content_node->children; node != NULL; node = node->next) {
if(node->type == XML_ELEMENT_NODE) {
name = wi_xml_node_name(node);
if(wi_is_equal(name, WI_STR("key")))
key = wi_xml_node_content(node);
else if(wi_is_equal(name, WI_STR("string")))
instance = wi_xml_node_content(node);
else if(wi_is_equal(name, WI_STR("integer")))
instance = wi_number_with_integer(wi_string_integer(wi_xml_node_content(node)));
else if(wi_is_equal(name, WI_STR("real")))
instance = wi_number_with_double(wi_string_double(wi_xml_node_content(node)));
else if(wi_is_equal(name, WI_STR("true")))
instance = wi_number_with_bool(true);
else if(wi_is_equal(name, WI_STR("false")))
instance = wi_number_with_bool(false);
else if(wi_is_equal(name, WI_STR("date")))
instance = wi_date_with_rfc3339_string(wi_xml_node_content(node));
else if(wi_is_equal(name, WI_STR("data")))
instance = wi_data_with_base64(wi_xml_node_content(node));
else if(wi_is_equal(name, WI_STR("dict"))) {
instance = wi_autorelease(wi_dictionary_init(wi_dictionary_alloc()));
if(!_wi_plist_read_node_to_instance(node, instance))
return false;
}
else if(wi_is_equal(name, WI_STR("array"))) {
instance = wi_autorelease(wi_array_init(wi_array_alloc()));
if(!_wi_plist_read_node_to_instance(node, instance))
return false;
}
else {
wi_error_set_libwired_error_with_format(WI_ERROR_PLIST_READFAILED,
WI_STR("Unhandled node \"%@\""), name);
return false;
}
}
if(instance) {
if(dictionary)
wi_dictionary_set_data_for_key(collection, instance, key);
else
wi_array_add_data(collection, instance);
instance = NULL;
key = NULL;
}
}
return true;
}
wi_boolean_t wi_config_read_file(wi_config_t *config) {
wi_enumerator_t *enumerator;
wi_runtime_instance_t *instance;
wi_file_t *file;
wi_mutable_array_t *array;
wi_mutable_dictionary_t *previous_values;
wi_string_t *string, *name, *value;
wi_config_type_t type;
file = wi_file_for_reading(config->path);
if(!file) {
wi_log_err(WI_STR("Could not open %@: %m"),
config->path);
return false;
}
wi_log_info(WI_STR("Reading %@"), config->path);
config->line = 0;
wi_lock_lock(config->lock);
previous_values = config->values;
config->values = wi_dictionary_init(wi_mutable_dictionary_alloc());
if(config->defaults) {
enumerator = wi_dictionary_key_enumerator(config->defaults);
while((name = wi_enumerator_next_data(enumerator))) {
// instance = wi_mutable_copy(wi_dictionary_data_for_key(config->defaults, name));
instance = wi_dictionary_data_for_key(config->defaults, name);
if(wi_runtime_id(instance) == wi_array_runtime_id())
instance = wi_autorelease(wi_mutable_copy(instance));
wi_mutable_dictionary_set_data_for_key(config->values, instance, name);
// wi_release(instance);
}
}
while((string = wi_file_read_line(file))) {
config->line++;
if(wi_string_length(string) > 0 && !wi_string_has_prefix(string, WI_STR("#"))) {
if(_wi_config_parse_string(config, string, &name, &value)) {
instance = _wi_config_instance_for_setting(config, name, value, &type);
if(instance) {
wi_log_debug(WI_STR(" %@ = %@"), name, value);
if(type == WI_CONFIG_STRINGLIST) {
array = wi_dictionary_data_for_key(config->values, name);
if(!array) {
array = wi_mutable_array();
wi_mutable_dictionary_set_data_for_key(config->values, array, name);
}
wi_mutable_array_add_data(array, instance);
} else {
wi_mutable_dictionary_set_data_for_key(config->values, instance, name);
}
} else {
_wi_config_log_error(config, name);
}
} else {
wi_error_set_libwired_error(WI_ERROR_SETTINGS_SYNTAXERROR);
_wi_config_log_error(config, string);
}
}
}
enumerator = wi_dictionary_key_enumerator(config->values);
while((name = wi_enumerator_next_data(enumerator))) {
instance = wi_dictionary_data_for_key(config->values, name);
if(!previous_values || !wi_is_equal(instance, wi_dictionary_data_for_key(previous_values, name)))
wi_mutable_set_add_data(config->changes, name);
}
wi_release(previous_values);
wi_lock_unlock(config->lock);
return true;
}
void wd_banlist_init(void) {
wd_tempban_runtime_id = wi_runtime_register_class(&wd_tempban_runtime_class);
wd_tempbans = wi_dictionary_init(wi_mutable_dictionary_alloc());
}
void wr_commands_initialize(void) {
wr_commands_transactions = wi_dictionary_init(wi_mutable_dictionary_alloc());
}
wr_chat_t * wr_chat_init(wr_chat_t *chat) {
chat->users_array = wi_array_init(wi_mutable_array_alloc());
chat->users_dictionary = wi_dictionary_init(wi_mutable_dictionary_alloc());
return chat;
}
