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, ""); }