wi_boolean_t wd_banlist_delete_ban(wi_string_t *ip, wi_date_t *expiration_date, wd_user_t *user, wi_p7_message_t *message) {
wi_dictionary_t *results;
results = wi_sqlite3_execute_statement(wd_database, WI_STR("SELECT ip FROM banlist WHERE ip = ?"),
ip,
NULL);
if(!results) {
wi_log_error(WI_STR("Could not execute database statement: %m"));
wd_user_reply_internal_error(user, wi_error_string(), message);
return false;
}
if(wi_dictionary_count(results) == 0) {
wd_user_reply_error(user, WI_STR("wired.error.ban_not_found"), message);
return false;
}
if(!wi_sqlite3_execute_statement(wd_database, WI_STR("DELETE FROM banlist WHERE ip = ?"),
ip,
NULL)) {
wi_log_error(WI_STR("Could not execute database statement: %m"));
wd_user_reply_internal_error(user, wi_error_string(), message);
return false;
}
return true;
}
wi_boolean_t wd_banlist_add_ban(wi_string_t *ip, wi_date_t *expiration_date, wd_user_t *user, wi_p7_message_t *message) {
wi_dictionary_t *results;
wi_string_t *string;
// check for negative expiration date
if(expiration_date && wi_date_time_interval(expiration_date) - wi_time_interval() < 1.0) {
wi_log_error(WI_STR("Could not add ban for \"%@\" expiring at %@: Negative expiration date"),
ip, wi_date_string_with_format(expiration_date, WI_STR("%Y-%m-%d %H:%M:%S")));
wd_user_reply_internal_error(user, WI_STR("Ban has negative expiration date"), message);
return false;
}
// check if an entry already exists for this IP address in the database
results = wi_sqlite3_execute_statement(wd_database, WI_STR("SELECT ip FROM banlist WHERE ip = ?"),
ip,
NULL);
// prevents for database statement error
if(!results) {
wi_log_error(WI_STR("Could not execute database statement: %m"));
wd_user_reply_internal_error(user, wi_error_string(), message);
return false;
}
// if an entry already exists, replay ban_exists error message and stop
if(wi_dictionary_count(results) > 0) {
wd_user_reply_error(user, WI_STR("wired.error.ban_exists"), message);
return false;
}
// check if the ban is limited in time or not
string = expiration_date ? wi_date_sqlite3_string(expiration_date) : NULL;
// finally add the new ban entry to the database
if(!wi_sqlite3_execute_statement(wd_database, WI_STR("INSERT INTO banlist "
"(ip, expiration_date) "
"VALUES "
"(?, ?)"),
ip,
string,
NULL)) {
wi_log_error(WI_STR("Could not execute database statement: %m"));
wd_user_reply_internal_error(user, wi_error_string(), message);
return false;
}
return true;
}
void wd_banlist_reply_bans(wd_user_t *user, wi_p7_message_t *message) {
wi_sqlite3_statement_t *statement;
wi_p7_message_t *reply;
wi_dictionary_t *results;
wi_runtime_instance_t *instance;
statement = wi_sqlite3_prepare_statement(wd_database, WI_STR("SELECT ip, expiration_date FROM banlist"), NULL);
if(!statement) {
wi_log_error(WI_STR("Could not execute database statement: %m"));
wd_user_reply_internal_error(user, wi_error_string(), message);
return;
}
while((results = wi_sqlite3_fetch_statement_results(wd_database, statement)) && wi_dictionary_count(results) > 0) {
reply = wi_p7_message_with_name(WI_STR("wired.banlist.list"), wd_p7_spec);
wi_p7_message_set_string_for_name(reply, wi_dictionary_data_for_key(results, WI_STR("ip")), WI_STR("wired.banlist.ip"));
instance = wi_dictionary_data_for_key(results, WI_STR("expiration_date"));
if(instance != wi_null())
wi_p7_message_set_date_for_name(reply, wi_date_with_sqlite3_string(instance), WI_STR("wired.banlist.expiration_date"));
wd_user_reply_message(user, reply, message);
}
if(!results) {
wi_log_error(WI_STR("Could not execute database statement: %m"));
wd_user_reply_internal_error(user, wi_error_string(), message);
return;
}
reply = wi_p7_message_with_name(WI_STR("wired.banlist.list.done"), wd_p7_spec);
wd_user_reply_message(user, reply, message);
}
void wi_test_error(void) {
wi_string_t *string;
wi_boolean_t result;
result = wi_filesystem_file_exists_at_path(WI_STR("/non/existing/path"), NULL);
WI_TEST_ASSERT_FALSE(result, "");
WI_TEST_ASSERT_EQUALS(wi_error_domain(), WI_ERROR_DOMAIN_ERRNO, "");
WI_TEST_ASSERT_EQUALS(wi_error_code(), ENOENT, "");
WI_TEST_ASSERT_EQUAL_INSTANCES(wi_error_string(), WI_STR("No such file or directory"), "");
string = wi_string_with_format(WI_STR("%m"));
WI_TEST_ASSERT_EQUAL_INSTANCES(string, WI_STR("No such file or directory"), "");
}
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;
}
