void wr_draw_transfers(wi_boolean_t force) {
static wi_time_interval_t update;
wi_enumerator_t *enumerator;
wi_mutable_string_t *string;
wi_string_t *status;
wr_transfer_t *transfer;
wi_time_interval_t interval;
wi_uinteger_t i = 0;
interval = wi_time_interval();
if(!force && interval - update < 1.0)
return;
update = interval;
wi_terminal_set_scroll(wr_terminal, wi_make_range(1 + wi_array_count(wr_transfers),
wi_terminal_size(wr_terminal).height - 4));
enumerator = wi_array_data_enumerator(wr_transfers);
while((transfer = wi_enumerator_next_data(enumerator))) {
wi_terminal_move(wr_terminal, wi_make_point(0, i + 1));
wi_terminal_clear_line(wr_terminal);
if(transfer->state == WR_TRANSFER_RUNNING && interval - transfer->start_time > 0.0) {
transfer->speed = ((double) transfer->total_transferred - transfer->total_offset) / (interval - transfer->start_time);
status = wi_string_with_format(WI_STR("%@/%@, %@/s"),
wr_files_string_for_size(transfer->total_transferred),
wr_files_string_for_size(transfer->total_size),
wr_files_string_for_size(transfer->speed));
}
else if(transfer->state == WR_TRANSFER_QUEUED) {
status = wi_string_with_format(WI_STR("queued at %u"),
transfer->queue);
}
else {
status = wi_string_with_cstring("waiting");
}
string = wi_mutable_string_with_format(WI_STR("%u %3.0f%% %@"),
transfer->tid,
transfer->total_size > 0
? 100 * ((double) transfer->total_transferred / (double) transfer->total_size)
: 0,
transfer->name);
wi_terminal_adjust_string_to_fit_width(wr_terminal, string);
wi_mutable_string_delete_characters_from_index(string, wi_string_length(string) - wi_string_length(status));
wi_mutable_string_append_string(string, status);
wi_terminal_printf(wr_terminal, WI_STR("%@"), string);
i++;
}
wr_terminal_reset_location();
}
wi_url_t * wi_url_init_with_string(wi_url_t *url, wi_string_t *string) {
wi_string_t *userpassword;
wi_range_t range;
range = wi_string_range_of_string(string, WI_STR("://"), 0);
if(range.location != WI_NOT_FOUND) {
url->scheme = wi_retain(wi_string_substring_to_index(string, range.location));
if(range.location + range.length >= wi_string_length(string))
goto end;
else
string = wi_string_substring_from_index(string, range.location + 3);
}
range = wi_string_range_of_string(string, WI_STR("/"), 0);
if(range.location != WI_NOT_FOUND) {
url->path = wi_retain(wi_string_substring_from_index(string, range.location));
string = wi_string_substring_to_index(string, range.location);
}
range = wi_string_range_of_string(string, WI_STR("@"), 0);
if(range.location != WI_NOT_FOUND) {
userpassword = wi_string_substring_to_index(string, range.location);
string = wi_string_substring_from_index(string, range.location + 1);
range = wi_string_range_of_string(userpassword, WI_STR(":"), 0);
if(range.location != WI_NOT_FOUND && range.location != wi_string_length(userpassword) - 1) {
url->user = wi_retain(wi_string_substring_to_index(userpassword, range.location));
url->password = wi_retain(wi_string_substring_from_index(userpassword, range.location + 1));
} else {
url->user = wi_retain(userpassword);
}
}
range = wi_string_range_of_string(string, WI_STR(":"), 0);
if(range.location == WI_NOT_FOUND ||
range.location + range.length >= wi_string_length(string) ||
wi_string_contains_string(wi_string_substring_from_index(string, range.location + 1), WI_STR(":"), 0)) {
url->host = wi_copy(string);
} else {
url->host = wi_retain(wi_string_substring_to_index(string, range.location));
url->port = wi_string_uint32(wi_string_substring_from_index(string, range.location + 1));
}
end:
_wi_url_regenerate_string(url);
return url;
}
void wr_draw_transfers(wi_boolean_t force) {
static wi_time_interval_t update;
wi_list_node_t *node;
wi_string_t *string, *status;
wr_transfer_t *transfer;
wi_time_interval_t interval;
unsigned int i = 0;
interval = wi_time_interval();
if(!force && interval - update < 1.0)
return;
update = interval;
wi_terminal_set_scroll(wr_terminal, wi_make_range(1 + wi_list_count(wr_transfers),
wi_terminal_size(wr_terminal).height - 3));
WI_LIST_FOREACH(wr_transfers, node, transfer) {
wi_terminal_move(wr_terminal, wi_make_point(0, i + 1));
wi_terminal_clear_line(wr_terminal);
if(transfer->state == WR_TRANSFER_RUNNING && interval - transfer->start_time > 0.0) {
transfer->speed = ((double) transfer->transferred - transfer->offset) / (interval - transfer->start_time);
status = wi_string_with_format(WI_STR("%@/%@, %@/s"),
wr_files_string_for_size(transfer->transferred),
wr_files_string_for_size(transfer->size),
wr_files_string_for_size(transfer->speed));
}
else if(transfer->state == WR_TRANSFER_QUEUED) {
status = wi_string_with_format(WI_STR("queued at %u"),
transfer->queue);
}
else {
status = wi_string_with_cstring("waiting");
}
string = wi_string_with_format(WI_STR("%u %3.0f%% %@"),
transfer->tid,
transfer->size > 0
? 100 * ((double) transfer->transferred / (double) transfer->size)
: 0,
transfer->name);
wi_terminal_adjust_string_to_fit_width(wr_terminal, string);
wi_string_delete_characters_from_index(string, wi_string_length(string) - wi_string_length(status));
wi_string_append_string(string, status);
wi_terminal_printf(wr_terminal, WI_STR("%@"), string);
i++;
}
static void wr_command_save(wi_array_t *arguments) {
wi_file_t *file;
wi_string_t *path, *login, *password, *port;
path = wi_user_home();
path = wi_string_by_appending_path_component(path, WI_STR(WB_WIREBOT_USER_PATH));
path = wi_string_by_appending_path_component(path, WI_ARRAY(arguments, 0));
file = wi_file_for_writing(path);
if(!file) {
wr_printf_prefix(WI_STR("save: %@: %m"), path);
return;
}
wi_file_write_format(file, WI_STR("charset %@\n"), wi_string_encoding_charset(wr_client_string_encoding));
wi_file_write_format(file, WI_STR("timestamp %@\n"), wr_timestamp_format);
wi_file_write_format(file, WI_STR("nick %@\n"), wr_nick);
if(wi_string_length(wr_status) > 0)
wi_file_write_format(file, WI_STR("status %@\n"), wr_status);
if(wr_icon_path)
wi_file_write_format(file, WI_STR("icon %@\n"), wr_icon_path);
if(wr_connected) {
if(wi_string_length(wi_p7_socket_user_name(wr_p7_socket)) > 0)
login = wi_string_with_format(WI_STR("-l %@"), wi_p7_socket_user_name(wr_p7_socket));
else
login = NULL;
if(wi_string_length(wr_password) > 0)
password = wi_string_with_format(WI_STR("-p %@"), wr_password);
else
password = NULL;
if(wi_address_port(wi_socket_address(wr_socket)) != WR_PORT)
port = wi_string_with_format(WI_STR("-P %u"), wi_address_port(wi_socket_address(wr_socket)));
else
port = NULL;
wi_file_write_format(file, WI_STR("open %#@ %#@ %#@ %@\n"),
login, password, port, wi_address_string(wi_socket_address(wr_socket)));
}
wr_printf_prefix(WI_STR("save: \"%@\" saved"), path);
}
void wr_wprint_me(wr_window_t *window, wi_string_t *nick, wi_string_t *chat) {
wi_string_t *prefix;
const char *color;
wi_uinteger_t length;
length = wi_string_length(wr_nick);
if(length > 4)
length = 4;
prefix = wi_string_substring_to_index(wr_nick, length);
if(wi_string_has_prefix(chat, prefix)) {
color = WR_HIGHLIGHT_COLOR;
if(window->status < WR_WINDOW_STATUS_HIGHLIGHT)
window->status = WR_WINDOW_STATUS_HIGHLIGHT;
} else {
color = NULL;
if(window->status < WR_WINDOW_STATUS_CHAT)
window->status = WR_WINDOW_STATUS_CHAT;
}
wr_wprintf(window, WI_STR("%s*%s %s%@%s %@"),
WR_ME_COLOR,
WR_TERMINATE_COLOR,
color ? color : "",
nick,
color ? WR_TERMINATE_COLOR : "",
chat);
}
static void wr_msg_307(wi_array_t *arguments) {
wi_string_t *message;
wr_user_t *killer, *victim;
wr_uid_t killer_uid, victim_uid;
victim_uid = wi_string_uint32(WI_ARRAY(arguments, 0));
killer_uid = wi_string_uint32(WI_ARRAY(arguments, 1));
message = WI_ARRAY(arguments, 2);
victim = wr_chat_user_with_uid(wr_public_chat, victim_uid);
killer = wr_chat_user_with_uid(wr_public_chat, killer_uid);
if(killer && victim) {
if(wi_string_length(message) > 0) {
wr_wprintf_prefix(wr_console_window, WI_STR("%@ was banned by %@: %@"),
wr_user_nick(victim), wr_user_nick(killer), message);
} else {
wr_wprintf_prefix(wr_console_window, WI_STR("%@ was banned by %@"),
wr_user_nick(victim), wr_user_nick(killer));
}
}
if(victim) {
wr_chat_remove_user(wr_public_chat, victim);
wr_draw_divider();
}
}
void wr_print_user(wr_user_t *user, wi_uinteger_t max_length) {
const char *color;
switch(wr_user_color(user)) {
case WR_USER_COLOR_BLACK:
default:
color = wr_user_is_idle(user) ? WR_WHITE_COLOR : WR_BRIGHT_WHITE_COLOR;
break;
case WR_USER_COLOR_RED:
case WR_USER_COLOR_ORANGE:
color = wr_user_is_idle(user) ? WR_RED_COLOR : WR_BRIGHT_RED_COLOR;
break;
case WR_USER_COLOR_GREEN:
color = wr_user_is_idle(user) ? WR_GREEN_COLOR : WR_BRIGHT_GREEN_COLOR;
break;
case WR_USER_COLOR_BLUE:
color = wr_user_is_idle(user) ? WR_BLUE_COLOR : WR_BRIGHT_BLUE_COLOR;
break;
case WR_USER_COLOR_PURPLE:
color = wr_user_is_idle(user) ? WR_MAGENTA_COLOR : WR_BRIGHT_MAGENTA_COLOR;
break;
}
wr_printf_block(WI_STR("%s%@%s%*s%@"),
color,
wr_user_nick(user),
WR_TERMINATE_COLOR,
max_length - wi_string_length(wr_user_nick(user)) + 4,
" ",
wr_user_status(user));
}
static wi_p7_message_t * _wi_p7_socket_read_xml_message(wi_p7_socket_t *p7_socket, wi_time_interval_t timeout, wi_string_t *prefix) {
wi_string_t *string;
wi_p7_message_t *p7_message;
p7_message = wi_autorelease(wi_p7_message_init(wi_p7_message_alloc(), p7_socket));
while(true) {
string = wi_socket_read_to_string(p7_socket->socket, timeout, WI_STR(">"));
if(!string || wi_string_length(string) == 0)
return NULL;
wi_string_delete_surrounding_whitespace(string);
if(!p7_message->xml_string)
p7_message->xml_string = wi_copy(string);
else
wi_string_append_string(p7_message->xml_string, string);
if(wi_string_has_suffix(string, WI_STR("</p7:message>")) ||
(wi_string_has_suffix(string, WI_STR("/>")) &&
wi_string_has_prefix(string, WI_STR("<p7:message")))) {
break;
}
}
wi_retain(p7_message->xml_string);
if(prefix)
wi_string_insert_string_at_index(p7_message->xml_string, prefix, 0);
wi_string_delete_surrounding_whitespace(p7_message->xml_string);
return p7_message;
}
wi_boolean_t wi_settings_read_file(wi_settings_t *settings, wi_boolean_t chroot) {
wi_file_t *file;
wi_string_t *path, *string;
wi_boolean_t result = true;
path = wi_full_path(wi_settings_config_path);
file = wi_file_for_reading(path);
if(!file) {
wi_log_err(WI_STR("Could not open %@: %s"),
path, strerror(errno));
return false;
}
wi_log_info(WI_STR("Reading %@"), path);
_wi_settings_clear(settings);
settings->file = path;
settings->line = 0;
settings->chroot = chroot;
while((string = wi_file_read_line(file))) {
settings->line++;
if(wi_string_length(string) > 0 && !wi_string_has_prefix(string, WI_STR("#"))) {
if(!_wi_settings_parse_setting(settings, string))
result = false;
}
}
settings->file = NULL;
return result;
}
void wr_wprint_say(wr_window_t *window, wi_string_t *nick, wi_string_t *chat) {
wi_string_t *prefix;
const char *color;
unsigned int length;
length = wi_string_length(wr_nick);
if(length > 4)
length = 4;
prefix = wi_string_substring_to_index(wr_nick, length);
if(wi_string_has_prefix(chat, prefix)) {
color = WR_HIGHLIGHT_COLOR;
if(window->status < WR_WINDOW_STATUS_HIGHLIGHT)
window->status = WR_WINDOW_STATUS_HIGHLIGHT;
} else {
color = WR_NICK_COLOR;
if(window->status < WR_WINDOW_STATUS_CHAT)
window->status = WR_WINDOW_STATUS_CHAT;
}
wr_wprintf(window, WI_STR("%s<%s%s%@%s%s>%s %@"),
WR_SAY_COLOR,
WR_END_COLOR,
color,
nick,
WR_END_COLOR,
WR_SAY_COLOR,
WR_END_COLOR,
chat);
}
void wi_error_set_libwired_error_with_string(int code, wi_string_t *string) {
wi_string_t *errorstring;
errorstring = wi_string_init_with_cstring(wi_mutable_string_alloc(), _wi_error_strings[code]);
if(wi_string_length(string) > 0) {
if(wi_string_length(errorstring) > 0)
wi_mutable_string_append_string(errorstring, WI_STR(": "));
wi_mutable_string_append_string(errorstring, string);
}
wi_error_set_error_with_string(WI_ERROR_DOMAIN_LIBWIRED, code, errorstring);
wi_release(errorstring);
}
wi_sqlite3_statement_t * wi_sqlite3_prepare_statement(wi_sqlite3_database_t *database, wi_string_t *query, ...) {
wi_sqlite3_statement_t *statement;
va_list ap;
statement = wi_autorelease(wi_runtime_create_instance(_wi_sqlite3_statement_runtime_id, sizeof(wi_sqlite3_statement_t)));
statement->query = wi_retain(query);
wi_recursive_lock_lock(database->lock);
if(
#ifdef HAVE_SQLITE3_PREPARE_V2
sqlite3_prepare_v2
#else
sqlite3_prepare
#endif
(database->database, wi_string_cstring(query), wi_string_length(query), &statement->statement, NULL) == SQLITE_OK) {
va_start(ap, query);
_wi_sqlite3_bind_statement(statement, ap);
va_end(ap);
} else {
wi_error_set_sqlite3_error_with_description(database->database, wi_description(statement));
statement = NULL;
}
wi_recursive_lock_unlock(database->lock);
return statement;
}
wi_boolean_t wt_category_is_valid(wi_string_t *category) {
wi_file_t *file;
wi_string_t *string;
wi_boolean_t result = false;
if(wi_string_length(category) == 0)
return true;
file = wi_file_for_reading(wt_settings.categories);
if(!file) {
wi_log_err(WI_STR("Could not open %@: %m"), wt_settings.categories);
return true;
}
while((string = wi_file_read_config_line(file))) {
if(wi_is_equal(category, string)) {
result = true;
break;
}
}
return result;
}
wi_string_t * wi_file_read_to_string(wi_file_t *file, wi_string_t *separator) {
wi_string_t *string, *totalstring = NULL;
wi_uinteger_t index, length;
_WI_FILE_ASSERT_OPEN(file);
while((string = wi_file_read(file, WI_FILE_BUFFER_SIZE))) {
if(!totalstring)
totalstring = wi_string_init(wi_string_alloc());
index = wi_string_index_of_string(string, separator, 0);
if(index == WI_NOT_FOUND) {
wi_string_append_string(totalstring, string);
} else {
length = wi_string_length(string);
wi_string_delete_characters_from_index(string, index);
wi_string_append_string(totalstring, string);
wi_file_seek(file, wi_file_offset(file) - length + index + 1);
break;
}
}
return wi_autorelease(totalstring);
}
static wi_mutable_array_t * _wi_terminal_buffer_lines_for_string(wi_terminal_buffer_t *buffer, wi_string_t *string) {
wi_enumerator_t *enumerator;
wi_mutable_array_t *array;
wi_mutable_string_t *newstring;
wi_string_t *line, *subline;
wi_size_t size;
wi_uinteger_t index;
array = wi_array_init(wi_mutable_array_alloc());
size = wi_terminal_size(buffer->terminal);
enumerator = wi_array_data_enumerator(wi_string_components_separated_by_string(string, WI_STR("\n")));
while((line = wi_enumerator_next_data(enumerator))) {
if(wi_terminal_width_of_string(buffer->terminal, line) < size.width) {
wi_mutable_array_add_data(array, line);
} else {
newstring = wi_mutable_copy(line);
do {
index = wi_terminal_index_of_string_for_width(buffer->terminal, newstring, size.width);
subline = wi_string_substring_to_index(newstring, index);
wi_mutable_array_add_data(array, subline);
wi_mutable_string_delete_characters_to_index(newstring, wi_string_length(subline));
} while(wi_terminal_width_of_string(buffer->terminal, newstring) >= size.width);
wi_mutable_array_add_data(array, newstring);
wi_release(newstring);
}
}
return wi_autorelease(array);
}
static wi_array_t * _wi_terminal_buffer_lines_for_string(wi_terminal_buffer_t *buffer, wi_string_t *string) {
wi_array_t *array, *linearray;
wi_string_t *string_copy, *line, *subline;
wi_size_t size;
uint32_t i, count, index;
array = wi_array_init(wi_array_alloc());
size = wi_terminal_size(buffer->terminal);
linearray = wi_string_components_separated_by_string(string, WI_STR("\n"));
count = wi_array_count(linearray);
for(i = 0; i < count; i++) {
line = WI_ARRAY(linearray, i);
if(wi_terminal_width_of_string(buffer->terminal, line) < size.width) {
wi_array_add_data(array, line);
} else {
string_copy = wi_copy(line);
do {
index = wi_terminal_index_of_string_for_width(buffer->terminal, string_copy, size.width);
subline = wi_string_substring_to_index(string_copy, index);
wi_array_add_data(array, subline);
wi_string_delete_characters_to_index(string_copy, wi_string_length(subline));
} while(wi_terminal_width_of_string(buffer->terminal, string_copy) >= size.width);
wi_array_add_data(array, string_copy);
wi_release(string_copy);
}
}
return array;
}
wi_boolean_t wi_settings_read_file(wi_settings_t *settings) {
wi_file_t *file;
wi_string_t *string;
file = wi_file_for_reading(wi_settings_config_path);
if(!file) {
wi_log_err(WI_STR("Could not open %@: %s"),
wi_settings_config_path, strerror(errno));
return false;
}
wi_log_info(WI_STR("Reading %@"), wi_settings_config_path);
_wi_settings_clear(settings);
settings->file = wi_settings_config_path;
settings->line = 0;
while((string = wi_file_read_line(file))) {
settings->line++;
if(wi_string_length(string) > 0 && !wi_string_has_prefix(string, WI_STR("#")))
_wi_settings_parse_setting(settings, string);
}
settings->file = NULL;
return true;
}
static void wd_cmd_say(wi_array_t *arguments) {
wd_client_t *client = wd_client();
wi_array_t *array;
wi_string_t *string;
wd_chat_t *chat;
wd_cid_t cid;
unsigned int i, count;
cid = wi_string_uint32(WI_ARRAY(arguments, 0));
chat = wd_chat_with_cid(cid);
if(!chat)
return;
if(!wd_chat_contains_client(chat, client))
return;
array = wi_string_components_separated_by_string(WI_ARRAY(arguments, 1), WI_STR("\n\r"));
count = wi_array_count(array);
wd_broadcast_lock();
for(i = 0; i < count; i++) {
string = WI_ARRAY(array, i);
if(wi_string_length(string) > 0) {
wd_broadcast(cid, 300, WI_STR("%u%c%u%c%#@"),
cid, WD_FIELD_SEPARATOR,
client->uid, WD_FIELD_SEPARATOR,
string);
}
}
wd_broadcast_unlock();
}
wi_boolean_t wi_p7_message_set_date_for_name(wi_p7_message_t *p7_message, wi_date_t *date, wi_string_t *field_name) {
wi_string_t *string;
unsigned char *binary;
uint32_t field_id, field_size;
if(!date)
date = wi_date();
string = wi_date_iso8601_string(date);
if(p7_message->serialization == WI_P7_BINARY) {
field_size = wi_string_length(string) + 1;
if(!_wi_p7_message_get_binary_buffer_for_writing_for_name(p7_message, field_name, 0, &binary, &field_id))
return false;
wi_write_swap_host_to_big_int32(binary, 0, field_id);
memcpy(binary + 4, wi_string_cstring(string), field_size);
} else {
_wi_p7_message_set_xml_field(p7_message, WI_P7_DATE, field_name, string);
}
return true;
}
wi_socket_state_t wi_socket_wait(wi_socket_t *socket, wi_time_interval_t timeout) {
if(wi_string_length(socket->buffer) > 0)
return WI_SOCKET_READY;
return wi_socket_wait_descriptor(socket->sd,
timeout,
(socket->direction & WI_SOCKET_READ),
(socket->direction & WI_SOCKET_WRITE));
}
wi_boolean_t wi_process_set_hostname(wi_process_t *process, wi_string_t *hostname) {
if(sethostname((char *) wi_string_cstring(hostname), (int)wi_string_length(hostname))) {
wi_error_set_errno(errno);
return false;
}
return true;
}
static void wd_transfer_accept_thread(wi_runtime_instance_t *argument) {
wi_pool_t *pool;
wi_socket_t *socket = argument;
wi_array_t *arguments;
wi_string_t *ip, *string, *command;
wd_transfer_t *transfer;
pool = wi_pool_init(wi_pool_alloc());
ip = wi_address_string(wi_socket_address(socket));
if(!wi_socket_accept_tls(socket, wd_transfer_socket_tls, 30.0)) {
wi_log_err(WI_STR("Could not accept a connection for %@: %m"), ip);
goto end;
}
if(!wi_socket_set_timeout(socket, 30.0))
wi_log_warn(WI_STR("Could not set timeout for %@: %m"), ip);
string = wi_socket_read_to_string(socket, 5.0, WI_STR(WD_MESSAGE_SEPARATOR_STR));
if(!string || wi_string_length(string) == 0) {
if(!string)
wi_log_warn(WI_STR("Could not read from %@: %m"), ip);
goto end;
}
wi_parse_wired_command(string, &command, &arguments);
if(wi_is_equal(command, WI_STR("TRANSFER")) && wi_array_count(arguments) >= 1) {
transfer = wd_transfers_transfer_with_hash(WI_ARRAY(arguments, 0));
if(!transfer)
goto end;
if(!wi_is_equal(ip, wd_user_ip(transfer->user)))
goto end;
wi_lock_lock(transfer->socket_lock);
if(!transfer->socket) {
transfer->socket = wi_retain(socket);
wi_lock_unlock(transfer->socket_lock);
wd_transfer_loop(transfer);
} else {
wi_lock_unlock(transfer->socket_lock);
}
}
end:
wi_socket_close(socket);
wi_release(pool);
}
void wi_error_set_libwired_error_with_string(int code, wi_string_t *string) {
wi_error_t *error;
error = _wi_get_error();
error->domain = WI_ERROR_DOMAIN_LIBWIRED;
error->code = code;
wi_release(error->string);
error->string = wi_string_init_with_cstring(wi_string_alloc(), _wi_error_strings[error->code]);
if(wi_string_length(string) > 0) {
if(wi_string_length(error->string) > 0)
wi_string_append_string(error->string, WI_STR(": "));
wi_string_append_string(error->string, string);
}
}
static wi_boolean_t wd_users_get_human_readable_version(wi_string_t *version, wi_string_t **application_name, wi_string_t **application_version, wi_string_t **os_name, wi_string_t **os_version, wi_string_t **arch) {
wi_range_t range;
wi_uinteger_t index;
range = wi_make_range(0, wi_string_length(version));
index = wi_string_index_of_string_in_range(version, WI_STR("/"), 0, range);
if(index == WI_NOT_FOUND || index == range.length - 1)
return false;
*application_name = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));
range.location = index + 1;
range.length -= index + 1;
index = wi_string_index_of_string_in_range(version, WI_STR(" ("), 0, range);
if(index == WI_NOT_FOUND || index == range.length - 2)
return false;
*application_version = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));
range.location = index + 2;
range.length -= index + 2;
index = wi_string_index_of_string_in_range(version, WI_STR("; "), 0, range);
if(index == WI_NOT_FOUND || index == range.length - 2)
return false;
*os_name = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));
range.location = index + 2;
range.length -= index + 2;
index = wi_string_index_of_string_in_range(version, WI_STR("; "), 0, range);
if(index == WI_NOT_FOUND || index == range.length - 2)
return false;
*os_version = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));
range.location = index + 2;
range.length -= index + 2;
index = wi_string_index_of_string_in_range(version, WI_STR(")"), 0, range);
if(index == WI_NOT_FOUND || index == range.length - 1)
return false;
*arch = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));
return true;
}
wi_array_t * wi_array_init_with_string(wi_array_t *array, wi_string_t *string, wi_string_t *separator) {
if(wi_string_length(string) == 0) {
array = wi_array_init_with_data(array, WI_STR(""), (void *) NULL);
} else {
wi_release(array);
array = wi_retain(wi_string_components_separated_by_string(string, separator));
}
return array;
}
void wt_control_thread(wi_runtime_instance_t *argument) {
wi_pool_t *pool;
wt_client_t *client = argument;
wi_string_t *string;
wi_socket_state_t state;
wi_uinteger_t i = 0;
pool = wi_pool_init(wi_pool_alloc());
wt_client_set(client);
while(client->state <= WT_CLIENT_STATE_SAID_HELLO) {
do {
state = wi_socket_wait(client->socket, 0.1);
} while(state == WI_SOCKET_TIMEOUT && client->state <= WT_CLIENT_STATE_SAID_HELLO);
if(client->state > WT_CLIENT_STATE_SAID_HELLO) {
/* invalid state */
break;
}
if(state == WI_SOCKET_ERROR) {
if(wi_error_code() == EINTR) {
/* got a signal */
continue;
} else {
/* error in TCP communication */
wi_log_err(WI_STR("Could not read from %@: %m"), client->ip);
break;
}
}
string = wi_socket_read_to_string(client->socket, 0.0, WI_STR(WT_MESSAGE_SEPARATOR_STR));
if(!string || wi_string_length(string) == 0) {
if(!string)
wi_log_info(WI_STR("Could not read from %@: %m"), client->ip);
break;
}
wt_parse_command(string);
if(++i % 10 == 0)
wi_pool_drain(pool);
}
wi_log_info(WI_STR("Disconnect from %@ after %.2fs"),
client->ip,
wi_time_interval() - client->connect_time);
wi_release(pool);
}
static wi_boolean_t _wi_file_copy_directory(wi_string_t *frompath, wi_string_t *topath) {
WI_FTS *fts;
WI_FTSENT *p;
wi_string_t *path, *newpath;
char *paths[2];
uint32_t pathlength;
wi_boolean_t result = true;
paths[0] = (char *) wi_string_cstring(frompath);;
paths[1] = NULL;
fts = wi_fts_open(paths, WI_FTS_LOGICAL | WI_FTS_NOSTAT, NULL);
if(!fts)
return false;
pathlength = wi_string_length(frompath);
while((p = wi_fts_read(fts))) {
path = wi_string_init_with_cstring(wi_string_alloc(), p->fts_path);
newpath = wi_string_init_with_cstring(wi_string_alloc(), p->fts_path + pathlength);
wi_string_insert_string_at_index(newpath, topath, 0);
switch(p->fts_info) {
case WI_FTS_NS:
case WI_FTS_ERR:
case WI_FTS_DNR:
errno = p->fts_errno;
result = false;
break;
case WI_FTS_DC:
case WI_FTS_DP:
break;
case WI_FTS_D:
if(!wi_file_create_directory(newpath, 0777))
result = false;
break;
default:
if(!_wi_file_copy_file(path, newpath))
result = false;
break;
}
wi_release(newpath);
wi_release(path);
}
wi_fts_close(fts);
return result;
}
wi_string_t * wi_file_read_config_line(wi_file_t *file) {
wi_string_t *string;
while((string = wi_file_read_line(file))) {
if(wi_string_length(string) == 0 || wi_string_has_prefix(string, WI_STR("#")))
continue;
return string;
}
return NULL;
}
void wr_print_users(void) {
wi_list_node_t *node;
wr_user_t *user;
unsigned int max_length = 0;
WI_LIST_FOREACH(wr_users, node, user)
max_length = WI_MAX(max_length, wi_string_length(user->nick));
wr_printf_prefix(WI_STR("Users currently online:"));
WI_LIST_FOREACH(wr_users, node, user)
wr_print_user(user, max_length);
}
void wi_test_system(void) {
wi_array_t *backtrace;
WI_TEST_ASSERT_TRUE(wi_user_id() >= 0, "");
WI_TEST_ASSERT_TRUE(wi_string_length(wi_user_name()) > 0, "");
WI_TEST_ASSERT_TRUE(wi_string_length(wi_user_home()) > 0, "");
WI_TEST_ASSERT_TRUE(wi_group_id() >= 0, "");
WI_TEST_ASSERT_TRUE(wi_string_length(wi_group_name()) > 0, "");
WI_TEST_ASSERT_TRUE(wi_page_size() > 0, "");
backtrace = wi_backtrace();
if(backtrace) {
WI_TEST_ASSERT_TRUE(wi_array_count(backtrace) > 0, "");
WI_TEST_ASSERT_NOT_EQUALS(wi_string_index_of_string(wi_array_components_joined_by_string(backtrace, WI_STR("\n")),
WI_STR("test"), 0),
WI_NOT_FOUND, "");
}
WI_TEST_ASSERT_TRUE(wi_string_length(wi_getenv(WI_STR("HOME"))) > 0, "");
}
