void wd_broadcast(wd_chat_t *chat, uint32_t n, wi_string_t *fmt, ...) {
wi_enumerator_t *enumerator;
wi_string_t *string;
wi_array_t *users;
wd_user_t *user;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
users = wd_chat_users(chat);
wi_array_rdlock(users);
enumerator = wi_array_data_enumerator(users);
while((user = wi_enumerator_next_data(enumerator))) {
if(wd_user_state(user) == WD_USER_LOGGED_IN) {
wd_user_lock_socket(user);
wi_socket_write_format(wd_user_socket(user), 0.0, WI_STR("%u %@%c"), n, string, WD_MESSAGE_SEPARATOR);
wd_user_unlock_socket(user);
}
}
wi_array_unlock(users);
wi_release(string);
}
static wi_boolean_t wd_transfers_wait_until_ready(wd_transfer_t *transfer, wd_user_t *user, wi_p7_message_t *message) {
wi_p7_message_t *reply;
wi_uinteger_t queue;
wi_p7_uint32_t transaction;
while(true) {
if(wi_condition_lock_lock_when_condition(transfer->queue_lock, 1, 1.0)) {
queue = transfer->queue;
wi_condition_lock_unlock_with_condition(transfer->queue_lock, 0);
if(queue > 0) {
reply = wi_p7_message_with_name(WI_STR("wired.transfer.queue"), wd_p7_spec);
wi_p7_message_set_string_for_name(reply, transfer->path, WI_STR("wired.file.path"));
wi_p7_message_set_uint32_for_name(reply, queue, WI_STR("wired.transfer.queue_position"));
if(wi_p7_message_get_uint32_for_name(message, &transaction, WI_STR("wired.transaction")))
wi_p7_message_set_uint32_for_name(reply, transaction, WI_STR("wired.transaction"));
if(!wd_user_write_message(user, 30.0, reply)) {
wi_log_error(WI_STR("Could not write message \"%@\" to %@: %m"),
wi_p7_message_name(reply), wd_user_identifier(user));
return false;
}
}
if(queue == 0 || wd_user_state(user) != WD_USER_LOGGED_IN)
return true;
}
}
}
void wd_chat_reply_user_list(wd_chat_t *chat) {
wi_enumerator_t *enumerator;
wd_user_t *user;
wi_array_rdlock(chat->users);
enumerator = wi_array_data_enumerator(chat->users);
while((user = wi_enumerator_next_data(enumerator))) {
if(wd_user_state(user) == WD_USER_LOGGED_IN) {
wd_reply(310, WI_STR("%u%c%u%c%u%c%u%c%u%c%#@%c%#@%c%#@%c%#@%c%#@%c%#@"),
chat->cid, WD_FIELD_SEPARATOR,
wd_user_uid(user), WD_FIELD_SEPARATOR,
wd_user_is_idle(user), WD_FIELD_SEPARATOR,
wd_user_is_admin(user), WD_FIELD_SEPARATOR,
wd_user_icon(user), WD_FIELD_SEPARATOR,
wd_user_nick(user), WD_FIELD_SEPARATOR,
wd_user_login(user), WD_FIELD_SEPARATOR,
wd_user_ip(user), WD_FIELD_SEPARATOR,
wd_user_host(user), WD_FIELD_SEPARATOR,
wd_user_status(user), WD_FIELD_SEPARATOR,
wd_user_image(user));
}
}
wi_array_unlock(chat->users);
wd_reply(311, WI_STR("%u"), chat->cid);
}
static wi_boolean_t wd_transfer_download(wd_transfer_t *transfer) {
wi_pool_t *pool;
wi_socket_t *socket;
wi_p7_socket_t *p7_socket;
wd_account_t *account;
char buffer[WD_TRANSFER_BUFFER_SIZE];
wi_socket_state_t state;
wi_time_interval_t timeout, interval, speedinterval, statusinterval, accountinterval;
wi_file_offset_t sendbytes, speedbytes, statsbytes;
wi_uinteger_t i, transfers;
ssize_t readbytes;
int sd;
wi_boolean_t data, result;
wd_user_state_t user_state;
interval = wi_time_interval();
speedinterval = interval;
statusinterval = interval;
accountinterval = interval;
speedbytes = 0;
statsbytes = 0;
i = 0;
socket = wd_user_socket(transfer->user);
sd = wi_socket_descriptor(socket);
p7_socket = wd_user_p7_socket(transfer->user);
account = wd_user_account(transfer->user);
data = true;
result = true;
wd_transfers_note_statistics(WD_TRANSFER_DOWNLOAD, WD_TRANSFER_STATISTICS_ADD, 0);
wi_dictionary_rdlock(wd_transfers_user_downloads);
transfers = (wi_integer_t) wi_dictionary_data_for_key(wd_transfers_user_downloads, transfer->key);
wi_dictionary_unlock(wd_transfers_user_downloads);
pool = wi_pool_init(wi_pool_alloc());
wd_user_lock_socket(transfer->user);
while(wd_user_state(transfer->user) == WD_USER_LOGGED_IN) {
if(data && transfer->remainingdatasize == 0)
data = false;
if(!data && transfer->remainingrsrcsize == 0)
break;
readbytes = read(data ? transfer->datafd : transfer->rsrcfd, buffer, sizeof(buffer));
if(readbytes <= 0) {
if(readbytes < 0) {
wi_log_error(WI_STR("Could not read download from \"%@\": %m"),
data ? transfer->realdatapath : transfer->realrsrcpath, strerror(errno));
}
result = false;
break;
}
timeout = wi_time_interval();
do {
user_state = wd_user_state(transfer->user);
state = wi_socket_wait_descriptor(sd, 0.1, false, true);
if(state == WI_SOCKET_TIMEOUT) {
if(wi_time_interval() - timeout >= 30.0)
break;
}
} while(state == WI_SOCKET_TIMEOUT && user_state == WD_USER_LOGGED_IN);
if(state == WI_SOCKET_ERROR || wi_time_interval() - timeout >= 30.0) {
wi_log_error(WI_STR("Could not wait for download to %@: %@"),
wd_user_identifier(transfer->user),
(state == WI_SOCKET_ERROR) ? wi_error_string() : WI_STR("Timed out"));
result = false;
break;
}
if(user_state != WD_USER_LOGGED_IN) {
result = false;
break;
}
if(data) {
sendbytes = (transfer->remainingdatasize < (wi_file_offset_t) readbytes)
? transfer->remainingdatasize
: (wi_file_offset_t) readbytes;
} else {
sendbytes = (transfer->remainingrsrcsize < (wi_file_offset_t) readbytes)
? transfer->remainingrsrcsize
: (wi_file_offset_t) readbytes;
}
if(!wi_p7_socket_write_oobdata(p7_socket, 30.0, buffer, sendbytes)) {
wi_log_error(WI_STR("Could not write download to %@: %m"),
wd_user_identifier(transfer->user));
result = false;
break;
}
if(data)
transfer->remainingdatasize -= sendbytes;
else
transfer->remainingrsrcsize -= sendbytes;
interval = wi_time_interval();
transfer->transferred += sendbytes;
transfer->actualtransferred += sendbytes;
speedbytes += sendbytes;
statsbytes += sendbytes;
transfer->speed = speedbytes / (interval - speedinterval);
wd_transfer_limit_speed(transfer,
wd_transfers_total_download_speed,
wd_account_transfer_download_speed_limit(account),
wd_current_downloads,
transfers,
speedbytes,
interval,
speedinterval);
if(interval - speedinterval > 30.0) {
speedbytes = 0;
speedinterval = interval;
}
if(interval - statusinterval > wd_current_downloads) {
wd_transfers_note_statistics(WD_TRANSFER_DOWNLOAD, WD_TRANSFER_STATISTICS_DATA, statsbytes);
statsbytes = 0;
statusinterval = interval;
}
if(interval - accountinterval > 15.0) {
account = wd_user_account(transfer->user);
accountinterval = interval;
wi_dictionary_rdlock(wd_transfers_user_downloads);
transfers = (wi_integer_t) wi_dictionary_data_for_key(wd_transfers_user_downloads, transfer->key);
wi_dictionary_unlock(wd_transfers_user_downloads);
}
if(++i % 1000 == 0)
wi_pool_drain(pool);
}
wd_user_unlock_socket(transfer->user);
wi_release(pool);
wd_transfers_note_statistics(WD_TRANSFER_DOWNLOAD, WD_TRANSFER_STATISTICS_REMOVE, statsbytes);
return result;
}
void wd_transfers_remove_user(wd_user_t *user, wi_boolean_t removingallusers) {
wi_enumerator_t *enumerator;
wi_string_t *key;
wd_user_t *each_user;
wd_transfer_t *transfer;
wi_uinteger_t i, count;
wi_boolean_t update = false, present = false;
key = wd_transfers_transfer_key_for_user(user);
if(!key)
return;
if(!removingallusers) {
wi_dictionary_rdlock(wd_users);
enumerator = wi_dictionary_data_enumerator(wd_users);
while((each_user = wi_enumerator_next_data(enumerator))) {
if(wd_user_state(each_user) == WD_USER_LOGGED_IN && wi_is_equal(wd_transfers_transfer_key_for_user(each_user), key)) {
present = true;
break;
}
}
wi_dictionary_unlock(wd_users);
}
if(!present) {
wi_array_wrlock(wd_transfers);
count = wi_array_count(wd_transfers);
for(i = 0; i < count; i++) {
transfer = WI_ARRAY(wd_transfers, i);
if(wi_is_equal(key, transfer->key)) {
wd_user_set_state(transfer->user, WD_USER_DISCONNECTED);
if(transfer->state == WD_TRANSFER_RUNNING) {
if(wi_condition_lock_lock_when_condition(transfer->finished_lock, 1, 1.0))
wi_condition_lock_unlock(transfer->finished_lock);
} else {
wi_mutable_array_remove_data_at_index(wd_transfers, i);
i--;
count--;
update = true;
}
}
}
if(update) {
wi_condition_lock_lock(wd_transfers_queue_lock);
wi_condition_lock_unlock_with_condition(wd_transfers_queue_lock, 1);
}
wi_array_unlock(wd_transfers);
}
}
