static void wd_transfers_add_or_remove_transfer(wd_transfer_t *transfer, wi_boolean_t add) {
wi_mutable_dictionary_t *dictionary;
wi_integer_t number;
wi_lock_lock(wd_transfers_status_lock);
if(transfer->type == WD_TRANSFER_DOWNLOAD)
wd_transfers_active_downloads += add ? 1 : -1;
else
wd_transfers_active_uploads += add ? 1 : -1;
wi_lock_unlock(wd_transfers_status_lock);
if(transfer->type == WD_TRANSFER_DOWNLOAD)
dictionary = wd_transfers_user_downloads;
else
dictionary = wd_transfers_user_uploads;
wi_dictionary_wrlock(dictionary);
number = (wi_integer_t) wi_dictionary_data_for_key(dictionary, transfer->key);
if(add) {
wi_mutable_dictionary_set_data_for_key(dictionary, (void *) (number + 1), transfer->key);
} else {
if(number > 0) {
wi_mutable_dictionary_set_data_for_key(dictionary, (void *) (number - 1), transfer->key);
} else {
wi_mutable_dictionary_remove_data_for_key(dictionary, transfer->key);
}
}
wi_dictionary_unlock(dictionary);
}
static wi_boolean_t _wi_plist_read_node_to_instance(xmlNodePtr content_node, wi_runtime_instance_t *collection) {
xmlNodePtr node;
wi_string_t *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) {
if(strcmp((const char *) node->name, "key") == 0)
key = wi_xml_node_content(node);
else if(strcmp((const char *) node->name, "string") == 0)
instance = wi_xml_node_content(node);
else if(strcmp((const char *) node->name, "integer") == 0)
instance = wi_number_with_integer(wi_string_integer(wi_xml_node_content(node)));
else if(strcmp((const char *) node->name, "real") == 0)
instance = wi_number_with_double(wi_string_double(wi_xml_node_content(node)));
else if(strcmp((const char *) node->name, "true") == 0)
instance = wi_number_with_bool(true);
else if(strcmp((const char *) node->name, "false") == 0)
instance = wi_number_with_bool(false);
else if(strcmp((const char *) node->name, "date") == 0)
instance = wi_date_with_rfc3339_string(wi_xml_node_content(node));
else if(strcmp((const char *) node->name, "data") == 0)
instance = wi_data_with_base64(wi_xml_node_content(node));
else if(strcmp((const char *) node->name, "dict") == 0) {
instance = wi_mutable_dictionary();
if(!_wi_plist_read_node_to_instance(node, instance))
return false;
}
else if(strcmp((const char *) node->name, "array") == 0) {
instance = wi_mutable_array();
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 \"%s\""), node->name);
return false;
}
}
if(instance) {
if(dictionary)
wi_mutable_dictionary_set_data_for_key(collection, instance, key);
else
wi_mutable_array_add_data(collection, instance);
instance = NULL;
key = NULL;
}
}
return true;
}
static void wr_commands_send_message(wi_p7_message_t *message, wi_string_t *command) {
wi_p7_message_set_uint32_for_name(message, wr_commands_transaction, WI_STR("wired.transaction"));
wi_mutable_dictionary_set_data_for_key(wr_commands_transactions, command, WI_INT32(wr_commands_transaction));
wr_client_send_message(message);
wr_commands_transaction++;
}
void wi_error_enter_thread(void) {
wi_error_t *error;
error = _wi_error_init(_wi_error_alloc());
wi_mutable_dictionary_set_data_for_key(wi_thread_dictionary(), error, WI_STR(_WI_ERROR_THREAD_KEY));
wi_release(error);
wi_error_set_error(WI_ERROR_DOMAIN_NONE, WI_ERROR_NONE);
#ifdef WI_LIBXML2
xmlSetGenericErrorFunc(NULL, _wi_error_xml_error_handler);
#endif
}
void wi_config_set_instance_for_name(wi_config_t *config, wi_runtime_instance_t *instance, wi_string_t *name) {
wi_runtime_instance_t *copy;
wi_lock_lock(config->lock);
if(!wi_is_equal(instance, wi_dictionary_data_for_key(config->values, name)))
wi_mutable_set_add_data(config->changes, name);
copy = wi_copy(instance);
wi_mutable_dictionary_set_data_for_key(config->values, copy, name);
wi_release(copy);
wi_lock_unlock(config->lock);
}
wi_string_t * _wi_string_constant_string(const char *cstring) {
wi_string_t *string;
wi_lock_lock(_wi_string_constant_string_lock);
string = wi_dictionary_data_for_key(_wi_string_constant_string_table, (void *) cstring);
if(!string) {
string = wi_string_init_with_cstring(wi_string_alloc(), cstring);
wi_mutable_dictionary_set_data_for_key(_wi_string_constant_string_table, string, (void *) cstring);
wi_release(string);
}
wi_lock_unlock(_wi_string_constant_string_lock);
return string;
}
void wd_banlist_add_temporary_ban_for_ip(wi_string_t *ip) {
wd_tempban_t *tempban;
tempban = wd_tempban_with_ip(ip);
tempban->timer = wi_timer_init_with_function(wi_timer_alloc(),
wd_tempban_expire_timer,
wd_settings.bantime,
false);
wi_timer_set_data(tempban->timer, tempban);
wi_timer_schedule(tempban->timer);
wi_dictionary_wrlock(wd_tempbans);
wi_mutable_dictionary_set_data_for_key(wd_tempbans, tempban, tempban->ip);
wi_dictionary_unlock(wd_tempbans);
}
void wd_user_subscribe_path(wd_user_t *user, wi_string_t *path, wi_string_t *realpath) {
wi_string_t *metapath;
wi_recursive_lock_lock(user->user_lock);
wi_mutable_set_add_data(user->subscribed_paths, realpath);
if(wd_files_fsevents)
wi_fsevents_add_path(wd_files_fsevents, realpath);
metapath = wi_string_by_appending_path_component(realpath, WI_STR(WD_FILES_META_PATH));
wi_mutable_set_add_data(user->subscribed_paths, metapath);
if(wd_files_fsevents)
wi_fsevents_add_path(wd_files_fsevents, metapath);
wi_mutable_dictionary_set_data_for_key(user->subscribed_virtualpaths, path, realpath);
wi_recursive_lock_unlock(user->user_lock);
}
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);
}
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);
}
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_chats_add_chat(wd_chat_t *chat) {
wi_dictionary_wrlock(wd_chats);
wi_mutable_dictionary_set_data_for_key(wd_chats, chat, wi_number_with_int32(chat->cid));
wi_dictionary_unlock(wd_chats);
}
wi_dictionary_t * wi_sqlite3_fetch_statement_results(wi_sqlite3_database_t *database, wi_sqlite3_statement_t *statement) {
wi_mutable_dictionary_t *results;
wi_runtime_instance_t *instance;
int i, count, length, result;
wi_recursive_lock_lock(database->lock);
result = sqlite3_step(statement->statement);
switch(result) {
case SQLITE_DONE:
results = wi_dictionary();
sqlite3_finalize(statement->statement);
statement->statement = NULL;
break;
case SQLITE_ROW:
results = wi_mutable_dictionary();
count = sqlite3_column_count(statement->statement);
for(i = 0; i < count; i++) {
switch(sqlite3_column_type(statement->statement, i)) {
case SQLITE_INTEGER:
instance = wi_number_with_int64(sqlite3_column_int64(statement->statement, i));
break;
case SQLITE_FLOAT:
instance = wi_number_with_double(sqlite3_column_double(statement->statement, i));
break;
case SQLITE_TEXT:
instance = wi_string_with_cstring((const char *) sqlite3_column_text(statement->statement, i));
break;
case SQLITE_BLOB:
length = sqlite3_column_bytes(statement->statement, i);
instance = wi_data_with_bytes(sqlite3_column_blob(statement->statement, i), length);
break;
case SQLITE_NULL:
instance = wi_null();
break;
default:
instance = NULL;
break;
}
if(instance)
wi_mutable_dictionary_set_data_for_key(results, instance, wi_string_with_cstring(sqlite3_column_name(statement->statement, i)));
}
wi_runtime_make_immutable(results);
break;
default:
wi_error_set_sqlite3_error_with_description(database->database, wi_description(statement));
sqlite3_finalize(statement->statement);
statement->statement = NULL;
results = NULL;
break;
}
wi_recursive_lock_unlock(database->lock);
return results;
}
void wd_users_add_user(wd_user_t *user) {
wi_dictionary_wrlock(wd_users);
wi_mutable_dictionary_set_data_for_key(wd_users, user, wi_number_with_int32(wd_user_id(user)));
wi_dictionary_unlock(wd_users);
}
void wr_chats_add_chat(wr_chat_t *chat) {
wi_mutable_dictionary_set_data_for_key(wr_chats, chat, wi_number_with_integer(chat->cid));
}
void wr_chat_add_user(wr_chat_t *chat, wr_user_t *user) {
wi_mutable_array_add_data(chat->users_array, user);
wi_mutable_dictionary_set_data_for_key(chat->users_dictionary, user, wi_number_with_integer(wr_user_id(user)));
}
