void wr_client_disconnect(void) {
if(wr_connected) {
wr_wprintf_prefix(wr_console_window, WI_STR("Connection to %@ closed"),
wi_address_string(wi_socket_address(wr_socket)));
wr_connected = false;
}
wr_runloop_remove_socket(wr_socket);
wi_socket_close(wr_socket);
wi_release(wr_p7_socket);
wi_release(wr_socket);
wi_release(wr_server);
wi_release(wr_password);
wr_windows_clear();
wr_chats_clear();
wr_users_clear();
wr_draw_header();
wr_draw_divider();
}
void wd_reply(uint32_t n, wi_string_t *fmt, ...) {
wd_user_t *user = wd_users_user_for_thread();
wi_string_t *string;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
wd_user_lock_socket(user);
wi_socket_write(wd_user_socket(user), 0.0, WI_STR("%u %@%c"), n, string, WD_MESSAGE_SEPARATOR);
wd_user_unlock_socket(user);
wi_release(string);
}
wi_dictionary_t * wi_dictionary_init_with_plist_file(wi_dictionary_t *dictionary, wi_string_t *path) {
wi_runtime_instance_t *instance;
wi_release(dictionary);
instance = wi_plist_read_instance_from_file(path);
if(!instance)
return NULL;
if(wi_runtime_id(instance) != wi_dictionary_runtime_id())
return NULL;
return wi_retain(instance);
}
int32_t wi_socket_sendto(wi_socket_t *socket, wi_socket_context_t *context, wi_string_t *fmt, ...) {
wi_string_t *string;
int bytes;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
bytes = wi_socket_sendto_buffer(socket, context, wi_string_cstring(string), wi_string_length(string));
wi_release(string);
return bytes;
}
wi_terminal_t * wi_terminal_init(wi_terminal_t *terminal) {
wi_string_t *type;
const char *term;
term = getenv("TERM");
if(!term)
term = "vt100";
type = wi_string_init_with_cstring(wi_string_alloc(), term);
terminal = wi_terminal_init_with_type(terminal, type);
wi_release(type);
return terminal;
}
void wr_client_reload_icon(void) {
wi_data_t *data;
wi_string_t *icon_path;
if(wr_icon)
wi_release(wr_icon), wr_icon = NULL;
if(wr_icon_path)
wi_release(wr_icon_path), wr_icon_path = NULL;
icon_path = wi_config_path_for_name(wd_config, WI_STR("icon path"));
if(!wi_string_has_prefix(icon_path, WI_STR("/")))
wr_icon_path = wi_retain(wi_string_by_appending_path_component(wi_string_by_appending_path_component(wi_user_home(), WI_STR(".wirebot")), icon_path));
else {
wr_icon_path = wi_retain(icon_path);
}
if(wi_fs_path_exists(wr_icon_path, false)) {
wr_icon = wi_data_init_with_contents_of_file(wi_data_alloc(), wr_icon_path);
} else {
wr_icon = wi_data_init_with_base64(wi_data_alloc(), wi_string_with_cstring(wr_default_icon));
}
}
static void _wi_list_dealloc(wi_runtime_instance_t *instance) {
wi_list_t *list = instance;
uint32_t i;
wi_list_remove_all_data(list);
if(list->node_chunks) {
for(i = 0; i < list->node_chunks_count; i++)
wi_free(list->node_chunks[i]);
wi_free(list->node_chunks);
}
wi_release(list->lock);
}
wi_socket_t * wi_socket_init_with_address(wi_socket_t *_socket, wi_address_t *address, wi_socket_type_t type) {
_socket->address = wi_copy(address);
_socket->close = true;
_socket->buffer = wi_string_init_with_capacity(wi_string_alloc(), WI_SOCKET_BUFFER_SIZE);
_socket->type = type;
_socket->sd = socket(wi_address_family(_socket->address), _socket->type, 0);
if(_socket->sd < 0) {
wi_error_set_errno(errno);
wi_release(_socket);
return NULL;
}
if(!_wi_socket_set_option(_socket, SOL_SOCKET, SO_REUSEADDR, 1)) {
wi_release(_socket);
return NULL;
}
return _socket;
}
wi_file_t * wi_file_init_temporary_file(wi_file_t *file) {
FILE *fp;
fp = wi_tmpfile();
if(!fp) {
wi_error_set_errno(errno);
wi_release(file);
return NULL;
}
return wi_file_init_with_file_descriptor(file, fileno(fp));
}
int32_t wi_socket_write(wi_socket_t *socket, wi_time_interval_t timeout, wi_string_t *fmt, ...) {
wi_string_t *string;
int bytes;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
bytes = wi_socket_write_buffer(socket, timeout, wi_string_cstring(string), wi_string_length(string));
wi_release(string);
return bytes;
}
void wi_error_set_libxml2_error(void) {
wi_error_t *error;
xmlErrorPtr xml_error;
xml_error = xmlGetLastError();
error = _wi_get_error();
error->domain = WI_ERROR_DOMAIN_REGEX;
error->code = xml_error->code;
wi_release(error->string);
error->string = wi_string_init_with_cstring(wi_string_alloc(), xml_error->message);
wi_string_delete_surrounding_whitespace(error->string);
}
static void wt_server_dealloc(wi_runtime_instance_t *instance) {
wt_server_t *server = instance;
wi_release(server->key);
wi_release(server->ip);
wi_release(server->category);
wi_release(server->url);
wi_release(server->name);
wi_release(server->description);
}
static void wr_msg_400(wi_array_t *arguments) {
wi_address_t *address;
wr_transfer_t *transfer;
transfer = wr_transfers_transfer_with_path(WI_ARRAY(arguments, 0));
if(!transfer)
return;
address = wi_copy(wr_address);
wi_address_set_port(address, wi_address_port(address) + 1);
transfer->state = WR_TRANSFER_RUNNING;
transfer->offset = wi_string_uint64(WI_ARRAY(arguments, 1));
transfer->transferred = transfer->offset;
transfer->key = wi_retain(WI_ARRAY(arguments, 2));
transfer->start_time = wi_time_interval();
transfer->socket = wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP);
wi_socket_set_interactive(transfer->socket, false);
if(!wi_socket_connect(transfer->socket, wr_socket_context, 15.0)) {
wr_printf_prefix(WI_STR("Could not connect to %@: %m"), wi_address_string(address));
wr_transfer_stop(transfer);
goto end;
}
wi_file_seek(transfer->file, transfer->offset);
if(transfer->type == WR_TRANSFER_DOWNLOAD) {
wi_socket_set_direction(transfer->socket, WI_SOCKET_READ);
wr_runloop_add_socket(transfer->socket, wr_runloop_download_callback);
} else {
wi_socket_set_direction(transfer->socket, WI_SOCKET_WRITE);
wr_runloop_add_socket(transfer->socket, wr_runloop_upload_callback);
}
wr_send_command_on_socket(transfer->socket, WI_STR("TRANSFER %#@"), transfer->key);
wr_printf_prefix(WI_STR("Starting transfer of \"%@\""), transfer->name);
wr_draw_transfers(true);
end:
wi_release(address);
}
static void wd_client_info_dealloc(wi_runtime_instance_t *instance) {
wd_client_info_t *client_info = instance;
wi_release(client_info->application_name);
wi_release(client_info->application_version);
wi_release(client_info->application_build);
wi_release(client_info->os_name);
wi_release(client_info->os_version);
wi_release(client_info->arch);
}
void wi_error_set_libxml2_error(void) {
wi_error_t *error;
wi_string_t *string;
xmlErrorPtr xml_error;
xml_error = xmlGetLastError();
error = _wi_error_get_error();
error->domain = WI_ERROR_DOMAIN_REGEX;
error->code = xml_error->code;
string = wi_string_by_deleting_surrounding_whitespace(wi_string_with_cstring(xml_error->message));
wi_release(error->string);
error->string = wi_retain(string);
}
void wr_wprintf_block(wr_window_t *window, wi_string_t *fmt, ...) {
wi_enumerator_t *enumerator;
wi_string_t *string, *line;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
enumerator = wi_array_data_enumerator(wi_string_components_separated_by_string(string, WI_STR("\n")));
while((line = wi_enumerator_next_data(enumerator)))
wr_wprintf(window, WI_STR(" %@"), line);
wi_release(string);
}
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;
}
wi_string_t * wi_string_init_with_contents_of_file(wi_string_t *string, wi_string_t *path) {
wi_file_t *file;
wi_release(string);
file = wi_file_for_reading(path);
if(!file)
return NULL;
string = wi_file_read_to_end_of_file(file);
wi_file_close(file);
return wi_retain(string);
}
wi_cipher_t * wi_cipher_init_with_random_key(wi_cipher_t *cipher, wi_cipher_type_t type) {
wi_data_t *key, *iv;
if(!_wi_cipher_set_type(cipher, type)) {
wi_error_set_libwired_error(WI_ERROR_CIPHER_CIPHERNOTSUPP);
wi_release(cipher);
return NULL;
}
key = wi_data_with_random_bytes(wi_cipher_bits(cipher) / 8);
iv = wi_data_with_random_bytes(wi_cipher_block_size(cipher));
return _wi_cipher_init_with_key(cipher, key, iv);
}
static void _wi_tests_assert_handler(const char *file, unsigned int line, wi_string_t *fmt, ...) {
wi_string_t *string;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
wi_log_warn(WI_STR("%@:%u: %@"), wi_string_last_path_component(wi_string_with_cstring(file)), line, string);
wi_release(string);
_wi_tests_current_test->passed = false;
longjmp(_wi_tests_jmp_buf, 1);
}
void wi_test_runtime_info(void) {
_wi_runtimetest_t *runtimetest;
WI_TEST_ASSERT_EQUALS(wi_runtime_class_with_name(WI_STR("_wi_runtimetest_t")), &_wi_runtimetest_runtime_class, "");
WI_TEST_ASSERT_EQUALS(wi_runtime_class_with_id(_wi_runtimetest_runtime_id), &_wi_runtimetest_runtime_class, "");
WI_TEST_ASSERT_EQUALS(wi_runtime_id_for_class(&_wi_runtimetest_runtime_class), _wi_runtimetest_runtime_id, "");
runtimetest = _wi_runtimetest_init_with_value(_wi_runtimetest_alloc(), 42);
WI_TEST_ASSERT_EQUALS(wi_runtime_class(runtimetest), &_wi_runtimetest_runtime_class, "");
WI_TEST_ASSERT_EQUAL_INSTANCES(wi_runtime_class_name(runtimetest), wi_string_with_utf8_string(_wi_runtimetest_runtime_class.name), "");
WI_TEST_ASSERT_EQUALS(wi_runtime_id(runtimetest), _wi_runtimetest_runtime_id, "");
WI_TEST_ASSERT_EQUALS(wi_runtime_options(runtimetest), WI_RUNTIME_OPTION_IMMUTABLE, "");
wi_release(runtimetest);
}
static void wr_msg_302(wi_array_t *arguments) {
wr_chat_t *chat;
wr_user_t *user;
wr_cid_t cid;
cid = wi_string_uint32(WI_ARRAY(arguments, 0));
chat = wr_chats_chat_with_cid(cid);
user = wr_user_init_with_arguments(wr_user_alloc(), arguments);
wr_chat_add_user(chat, user);
wi_release(user);
wr_draw_divider();
wr_wprintf_prefix(wr_windows_window_with_chat(chat), WI_STR("%@ has joined"),
wr_user_nick(user));
}
void wr_wprintf_prefix(wr_window_t *window, wi_string_t *fmt, ...) {
wi_string_t *string;
va_list ap;
va_start(ap, fmt);
string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);
va_end(ap);
wr_wprintf(window, WI_STR("%s%s%s%@"),
WR_PREFIX_COLOR,
WR_PREFIX,
WR_TERMINATE_COLOR,
string);
wi_release(string);
}
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);
}
static void _wi_process_dealloc(wi_runtime_instance_t *instance) {
wi_process_t *process = instance;
wi_release(process->name);
wi_release(process->path);
wi_release(process->arguments);
wi_release(process->os_name);
wi_release(process->os_release);
wi_release(process->arch);
}
static void _wi_url_dealloc(wi_runtime_instance_t *instance) {
wi_url_t *url = instance;
wi_release(url->scheme);
wi_release(url->host);
wi_release(url->path);
wi_release(url->user);
wi_release(url->password);
wi_release(url->string);
}
static void wd_transfer_expire_timer(wi_timer_t *timer) {
wd_transfer_t *transfer;
transfer = wi_timer_data(timer);
wi_lock_lock(wd_transfers_update_queue_lock);
wi_array_wrlock(wd_transfers);
wi_mutable_array_remove_data(wd_transfers, transfer);
wi_array_unlock(wd_transfers);
wd_transfers_update_queue();
wi_lock_unlock(wd_transfers_update_queue_lock);
wi_release(transfer);
}
wi_boolean_t _wi_settings_set_path(wi_settings_t *settings, uint32_t index, wi_string_t *name, wi_string_t *value) {
wi_string_t **string = (wi_string_t **) settings->spec[index].setting;
if(*string)
wi_release(*string);
if(wi_string_has_prefix(value, WI_STR("/")))
*string = wi_retain(value);
else if(settings->chroot)
*string = wi_string_init_with_format(wi_string_alloc(), WI_STR("/%@"), value);
else
*string = wi_string_init_with_format(wi_string_alloc(), WI_STR("%@/%@"), wi_root_path, value);
wi_string_normalize_path(*string);
return true;
}
wi_date_t * wi_date_init_with_iso8601_string(wi_date_t *date, wi_string_t *string) {
if(wi_string_length(string) < _WI_DATE_ISO8601_STRING_SIZE) {
wi_release(date);
return NULL;
}
#ifdef HAVE_GLIBC
string = wi_string_by_deleting_characters_in_range(string, wi_make_range(19, 6));
return wi_date_init_with_string(date, string, WI_STR("%Y-%m-%dT%H:%M:%S"));
#else
string = wi_string_by_deleting_characters_in_range(string, wi_make_range(22, 1));
return wi_date_init_with_string(date, string, WI_STR("%Y-%m-%dT%H:%M:%S%z"));
#endif
}
static void _wi_set_dealloc(wi_runtime_instance_t *instance) {
wi_set_t *set = instance;
wi_uinteger_t i;
_wi_set_remove_all_data(set);
if(set->bucket_chunks) {
for(i = 0; i < set->bucket_chunks_count; i++)
wi_free(set->bucket_chunks[i]);
wi_free(set->bucket_chunks);
}
wi_free(set->buckets);
wi_release(set->lock);
}