diff --git a/src/command_download.cc b/src/command_download.cc index 8c86327a..4053f6c5 100644 --- a/src/command_download.cc +++ b/src/command_download.cc @@ -635,63 +635,43 @@ d_list_remove(core::Download* download, const torrent::Object& rawArgs, const ch std::placeholders::_1, std::placeholders::_2, \ first_key, second_key)); -#define CMD2_DL_VAR_VALUE_U(key, first_key, second_key) \ - CMD2_DL_U(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \ - CMD2_DL_VALUE_P(key ".set", std::bind(&download_set_variable_value, \ - std::placeholders::_1, std::placeholders::_2, first_key, second_key)); - -#define CMD2_DL_VAR_VALUE_PUBLIC_U(key, first_key, second_key) \ - CMD2_DL_U(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \ - CMD2_DL_VALUE_U(key ".set", std::bind(&download_set_variable_value, \ - std::placeholders::_1, std::placeholders::_2, first_key, second_key)); - -#define CMD2_DL_VAR_STRING_U(key, first_key, second_key) \ - CMD2_DL_U(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \ - CMD2_DL_STRING_P(key ".set", std::bind(&download_set_variable_string, \ - std::placeholders::_1, std::placeholders::_2, first_key, second_key)); - -#define CMD2_DL_VAR_STRING_PUBLIC_U(key, first_key, second_key) \ - CMD2_DL_U(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \ - CMD2_DL_STRING_U(key ".set", std::bind(&download_set_variable_string, \ - std::placeholders::_1, std::placeholders::_2, first_key, second_key)); - int64_t cg_d_group(core::Download* download); const std::string& cg_d_group_name(core::Download* download); void cg_d_group_set(core::Download* download, const torrent::Object& arg); void initialize_command_download() { - CMD2_DL_U("d.hash", std::bind(&rak::transform_hex_str, CMD2_ON_INFO(hash))); - CMD2_DL_U("d.local_id", std::bind(&rak::transform_hex_str, CMD2_ON_INFO(local_id))); - CMD2_DL_U("d.local_id_html", std::bind(&rak::copy_escape_html_str, CMD2_ON_INFO(local_id))); - CMD2_DL_U("d.bitfield", std::bind(&retrieve_d_bitfield, std::placeholders::_1)); - CMD2_DL_U("d.base_path", std::bind(&retrieve_d_base_path, std::placeholders::_1)); - CMD2_DL_U("d.base_filename", std::bind(&retrieve_d_base_filename, std::placeholders::_1)); + CMD2_DL("d.hash", std::bind(&rak::transform_hex_str, CMD2_ON_INFO(hash))); + CMD2_DL("d.local_id", std::bind(&rak::transform_hex_str, CMD2_ON_INFO(local_id))); + CMD2_DL("d.local_id_html", std::bind(&rak::copy_escape_html_str, CMD2_ON_INFO(local_id))); + CMD2_DL("d.bitfield", std::bind(&retrieve_d_bitfield, std::placeholders::_1)); + CMD2_DL("d.base_path", std::bind(&retrieve_d_base_path, std::placeholders::_1)); + CMD2_DL("d.base_filename", std::bind(&retrieve_d_base_filename, std::placeholders::_1)); - CMD2_DL_U("d.name", CMD2_ON_INFO(name)); - CMD2_DL_U("d.creation_date", CMD2_ON_INFO(creation_date)); - CMD2_DL_U("d.load_date", CMD2_ON_INFO(load_date)); + CMD2_DL("d.name", CMD2_ON_INFO(name)); + CMD2_DL("d.creation_date", CMD2_ON_INFO(creation_date)); + CMD2_DL("d.load_date", CMD2_ON_INFO(load_date)); // // Network related: // - CMD2_DL_U ("d.up.rate", std::bind(&torrent::Rate::rate, CMD2_ON_INFO(up_rate))); - CMD2_DL_U ("d.up.total", std::bind(&torrent::Rate::total, CMD2_ON_INFO(up_rate))); - CMD2_DL_U ("d.down.rate", std::bind(&torrent::Rate::rate, CMD2_ON_INFO(down_rate))); - CMD2_DL_U ("d.down.total", std::bind(&torrent::Rate::total, CMD2_ON_INFO(down_rate))); - CMD2_DL_U ("d.skip.rate", std::bind(&torrent::Rate::rate, CMD2_ON_INFO(skip_rate))); - CMD2_DL_U ("d.skip.total", std::bind(&torrent::Rate::total, CMD2_ON_INFO(skip_rate))); + CMD2_DL ("d.up.rate", std::bind(&torrent::Rate::rate, CMD2_ON_INFO(up_rate))); + CMD2_DL ("d.up.total", std::bind(&torrent::Rate::total, CMD2_ON_INFO(up_rate))); + CMD2_DL ("d.down.rate", std::bind(&torrent::Rate::rate, CMD2_ON_INFO(down_rate))); + CMD2_DL ("d.down.total", std::bind(&torrent::Rate::total, CMD2_ON_INFO(down_rate))); + CMD2_DL ("d.skip.rate", std::bind(&torrent::Rate::rate, CMD2_ON_INFO(skip_rate))); + CMD2_DL ("d.skip.total", std::bind(&torrent::Rate::total, CMD2_ON_INFO(skip_rate))); - CMD2_DL_U ("d.peer_exchange", CMD2_ON_INFO(is_pex_enabled)); - CMD2_DL_VALUE_V_U("d.peer_exchange.set", std::bind(&torrent::Download::set_pex_enabled, CMD2_BIND_DL, std::placeholders::_2)); + CMD2_DL ("d.peer_exchange", CMD2_ON_INFO(is_pex_enabled)); + CMD2_DL_VALUE_V ("d.peer_exchange.set", std::bind(&torrent::Download::set_pex_enabled, CMD2_BIND_DL, std::placeholders::_2)); - CMD2_DL_LIST_U ("d.create_link", std::bind(&apply_d_change_link, std::placeholders::_1, std::placeholders::_2, 0)); - CMD2_DL_LIST_U ("d.delete_link", std::bind(&apply_d_change_link, std::placeholders::_1, std::placeholders::_2, 1)); - CMD2_DL_U ("d.delete_tied", std::bind(&apply_d_delete_tied, std::placeholders::_1)); + CMD2_DL_LIST ("d.create_link", std::bind(&apply_d_change_link, std::placeholders::_1, std::placeholders::_2, 0)); + CMD2_DL_LIST ("d.delete_link", std::bind(&apply_d_change_link, std::placeholders::_1, std::placeholders::_2, 1)); + CMD2_DL ("d.delete_tied", std::bind(&apply_d_delete_tied, std::placeholders::_1)); - CMD2_FUNC_SINGLE_U("d.start", "d.hashing_failed.set=0 ;view.set_visible=started"); - CMD2_FUNC_SINGLE_U("d.stop", "view.set_visible=stopped"); + CMD2_FUNC_SINGLE("d.start", "d.hashing_failed.set=0 ;view.set_visible=started"); + CMD2_FUNC_SINGLE("d.stop", "view.set_visible=stopped"); CMD2_FUNC_SINGLE("d.try_start", "branch=\"or={d.hashing_failed=,d.ignore_commands=}\",{},{view.set_visible=started}"); CMD2_FUNC_SINGLE("d.try_stop", "branch=d.ignore_commands=, {}, {view.set_visible=stopped}"); CMD2_FUNC_SINGLE("d.try_close", "branch=d.ignore_commands=, {}, {view.set_visible=stopped, d.close=}"); @@ -700,91 +680,91 @@ initialize_command_download() { // Control functinos: // - CMD2_DL_U ("d.is_open", CMD2_ON_INFO(is_open)); - CMD2_DL_U ("d.is_active", CMD2_ON_INFO(is_active)); - CMD2_DL_U ("d.is_hash_checked", std::bind(&torrent::Download::is_hash_checked, CMD2_BIND_DL)); - CMD2_DL_U ("d.is_hash_checking", std::bind(&torrent::Download::is_hash_checking, CMD2_BIND_DL)); - CMD2_DL_U ("d.is_multi_file", std::bind(&torrent::FileList::is_multi_file, CMD2_BIND_FL)); - CMD2_DL_U ("d.is_private", CMD2_ON_INFO(is_private)); - CMD2_DL_U ("d.is_pex_active", CMD2_ON_INFO(is_pex_active)); - CMD2_DL_U ("d.is_partially_done", CMD2_ON_DATA(is_partially_done)); - CMD2_DL_U ("d.is_not_partially_done", CMD2_ON_DATA(is_not_partially_done)); - CMD2_DL_U ("d.is_meta", CMD2_ON_INFO(is_meta_download)); + CMD2_DL ("d.is_open", CMD2_ON_INFO(is_open)); + CMD2_DL ("d.is_active", CMD2_ON_INFO(is_active)); + CMD2_DL ("d.is_hash_checked", std::bind(&torrent::Download::is_hash_checked, CMD2_BIND_DL)); + CMD2_DL ("d.is_hash_checking", std::bind(&torrent::Download::is_hash_checking, CMD2_BIND_DL)); + CMD2_DL ("d.is_multi_file", std::bind(&torrent::FileList::is_multi_file, CMD2_BIND_FL)); + CMD2_DL ("d.is_private", CMD2_ON_INFO(is_private)); + CMD2_DL ("d.is_pex_active", CMD2_ON_INFO(is_pex_active)); + CMD2_DL ("d.is_partially_done", CMD2_ON_DATA(is_partially_done)); + CMD2_DL ("d.is_not_partially_done", CMD2_ON_DATA(is_not_partially_done)); + CMD2_DL ("d.is_meta", CMD2_ON_INFO(is_meta_download)); - CMD2_DL_V_U ("d.resume", std::bind(&core::DownloadList::resume_default, control->core()->download_list(), std::placeholders::_1)); - CMD2_DL_V_U ("d.pause", std::bind(&core::DownloadList::pause_default, control->core()->download_list(), std::placeholders::_1)); - CMD2_DL_V_U ("d.open", std::bind(&core::DownloadList::open_throw, control->core()->download_list(), std::placeholders::_1)); - CMD2_DL_V_U ("d.close", std::bind(&core::DownloadList::close_throw, control->core()->download_list(), std::placeholders::_1)); - CMD2_DL_V_U ("d.close.directly", std::bind(&core::DownloadList::close_directly, control->core()->download_list(), std::placeholders::_1)); - CMD2_DL_V_U ("d.erase", std::bind(&core::DownloadList::erase_ptr, control->core()->download_list(), std::placeholders::_1)); - CMD2_DL_V_U ("d.check_hash", std::bind(&core::DownloadList::check_hash, control->core()->download_list(), std::placeholders::_1)); + CMD2_DL_V ("d.resume", std::bind(&core::DownloadList::resume_default, control->core()->download_list(), std::placeholders::_1)); + CMD2_DL_V ("d.pause", std::bind(&core::DownloadList::pause_default, control->core()->download_list(), std::placeholders::_1)); + CMD2_DL_V ("d.open", std::bind(&core::DownloadList::open_throw, control->core()->download_list(), std::placeholders::_1)); + CMD2_DL_V ("d.close", std::bind(&core::DownloadList::close_throw, control->core()->download_list(), std::placeholders::_1)); + CMD2_DL_V ("d.close.directly", std::bind(&core::DownloadList::close_directly, control->core()->download_list(), std::placeholders::_1)); + CMD2_DL_V ("d.erase", std::bind(&core::DownloadList::erase_ptr, control->core()->download_list(), std::placeholders::_1)); + CMD2_DL_V ("d.check_hash", std::bind(&core::DownloadList::check_hash, control->core()->download_list(), std::placeholders::_1)); - CMD2_DL_V_U ("d.save_resume", [](core::Download* download, auto) { session_thread::manager()->save_resume_download(download); }); - CMD2_DL_V_U ("d.save_full_session", [](core::Download* download, auto) { session_thread::manager()->save_full_download(download); }); + CMD2_DL_V ("d.save_resume", [](core::Download* download, auto) { session_thread::manager()->save_resume_download(download); }); + CMD2_DL_V ("d.save_full_session", [](core::Download* download, auto) { session_thread::manager()->save_full_download(download); }); - CMD2_DL_V_U ("d.update_priorities", CMD2_ON_DL(update_priorities)); + CMD2_DL_V ("d.update_priorities", CMD2_ON_DL(update_priorities)); - CMD2_DL_STRING_V_U("add_peer", std::bind(&apply_d_add_peer, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_STRING_V("add_peer", std::bind(&apply_d_add_peer, std::placeholders::_1, std::placeholders::_2)); // // Custom settings: // - CMD2_DL_STRING_U("d.custom", std::bind(&retrieve_d_custom, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_STRING_U("d.custom_throw", std::bind(&retrieve_d_custom_throw, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_LIST_U ("d.custom.set", std::bind(&apply_d_custom, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_LIST_U ("d.custom.if_z", std::bind(&retrieve_d_custom_if_z, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_LIST_U ("d.custom.keys", std::bind(&retrieve_d_custom_map, std::placeholders::_1, true, std::placeholders::_2)); - CMD2_DL_LIST_U ("d.custom.items", std::bind(&retrieve_d_custom_map, std::placeholders::_1, false, std::placeholders::_2)); + CMD2_DL_STRING("d.custom", std::bind(&retrieve_d_custom, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_STRING("d.custom_throw", std::bind(&retrieve_d_custom_throw, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_LIST ("d.custom.set", std::bind(&apply_d_custom, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_LIST ("d.custom.if_z", std::bind(&retrieve_d_custom_if_z, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_LIST ("d.custom.keys", std::bind(&retrieve_d_custom_map, std::placeholders::_1, true, std::placeholders::_2)); + CMD2_DL_LIST ("d.custom.items", std::bind(&retrieve_d_custom_map, std::placeholders::_1, false, std::placeholders::_2)); - CMD2_DL_VAR_STRING_PUBLIC_U("d.custom1", "rtorrent", "custom1"); - CMD2_DL_VAR_STRING_PUBLIC_U("d.custom2", "rtorrent", "custom2"); - CMD2_DL_VAR_STRING_PUBLIC_U("d.custom3", "rtorrent", "custom3"); - CMD2_DL_VAR_STRING_PUBLIC_U("d.custom4", "rtorrent", "custom4"); - CMD2_DL_VAR_STRING_PUBLIC_U("d.custom5", "rtorrent", "custom5"); + CMD2_DL_VAR_STRING_PUBLIC("d.custom1", "rtorrent", "custom1"); + CMD2_DL_VAR_STRING_PUBLIC("d.custom2", "rtorrent", "custom2"); + CMD2_DL_VAR_STRING_PUBLIC("d.custom3", "rtorrent", "custom3"); + CMD2_DL_VAR_STRING_PUBLIC("d.custom4", "rtorrent", "custom4"); + CMD2_DL_VAR_STRING_PUBLIC("d.custom5", "rtorrent", "custom5"); // 0 - stopped // 1 - started - CMD2_DL_VAR_VALUE_U("d.state", "rtorrent", "state"); - CMD2_DL_VAR_VALUE_U("d.complete", "rtorrent", "complete"); + CMD2_DL_VAR_VALUE("d.state", "rtorrent", "state"); + CMD2_DL_VAR_VALUE("d.complete", "rtorrent", "complete"); - CMD2_FUNC_SINGLE_U("d.incomplete", "not=(d.complete)"); + CMD2_FUNC_SINGLE ("d.incomplete", "not=(d.complete)"); // 0 off // 1 scheduled, being controlled by a download scheduler. Includes a priority. // 3 forced off // 2 forced on - CMD2_DL_VAR_VALUE_U("d.mode", "rtorrent", "mode"); + CMD2_DL_VAR_VALUE("d.mode", "rtorrent", "mode"); // 0 - Not hashing // 1 - Normal hashing // 2 - Download finished, hashing // 3 - Rehashing - CMD2_DL_VAR_VALUE_U("d.hashing", "rtorrent", "hashing"); + CMD2_DL_VAR_VALUE("d.hashing", "rtorrent", "hashing"); // 'tied_to_file' is the file the download is associated with, and // can be changed by the user. // // 'loaded_file' is the file this instance of the torrent was loaded // from, and should not be changed. - CMD2_DL_VAR_STRING_PUBLIC_U("d.tied_to_file", "rtorrent", "tied_to_file"); + CMD2_DL_VAR_STRING_PUBLIC("d.tied_to_file", "rtorrent", "tied_to_file"); CMD2_DL_VAR_STRING("d.loaded_file", "rtorrent", "loaded_file"); // The "state_changed" variable is required to be a valid unix time // value, it indicates the last time the torrent changed its state, // resume/pause. - CMD2_DL_VAR_VALUE_U("d.state_changed", "rtorrent", "state_changed"); - CMD2_DL_VAR_VALUE_U("d.state_counter", "rtorrent", "state_counter"); - CMD2_DL_VAR_VALUE_PUBLIC_U("d.ignore_commands", "rtorrent", "ignore_commands"); + CMD2_DL_VAR_VALUE("d.state_changed", "rtorrent", "state_changed"); + CMD2_DL_VAR_VALUE("d.state_counter", "rtorrent", "state_counter"); + CMD2_DL_VAR_VALUE_PUBLIC("d.ignore_commands", "rtorrent", "ignore_commands"); CMD2_DL_TIMESTAMP("d.timestamp.started", "rtorrent", "timestamp.started"); CMD2_DL_TIMESTAMP("d.timestamp.finished", "rtorrent", "timestamp.finished"); - CMD2_DL_U ("d.connection_current", std::bind(&torrent::option_as_string, torrent::OPTION_CONNECTION_TYPE, CMD2_ON_DL(connection_type))); - CMD2_DL_STRING_U("d.connection_current.set", std::bind(&apply_d_connection_type, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL ("d.connection_current", std::bind(&torrent::option_as_string, torrent::OPTION_CONNECTION_TYPE, CMD2_ON_DL(connection_type))); + CMD2_DL_STRING("d.connection_current.set", std::bind(&apply_d_connection_type, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_VAR_STRING_U("d.connection_leech", "rtorrent", "connection_leech"); - CMD2_DL_VAR_STRING_U("d.connection_seed", "rtorrent", "connection_seed"); + CMD2_DL_VAR_STRING("d.connection_leech", "rtorrent", "connection_leech"); + CMD2_DL_VAR_STRING("d.connection_seed", "rtorrent", "connection_seed"); CMD2_DL ("d.up.choke_heuristics", std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, CMD2_ON_DL(upload_choke_heuristic))); CMD2_DL_STRING("d.up.choke_heuristics.set", std::bind(&apply_d_choke_heuristics, std::placeholders::_1, std::placeholders::_2, false)); @@ -796,39 +776,39 @@ initialize_command_download() { CMD2_DL_VAR_STRING("d.down.choke_heuristics.leech", "rtorrent", "choke_heuristics.down.leech"); CMD2_DL_VAR_STRING("d.down.choke_heuristics.seed", "rtorrent", "choke_heuristics.down.seed"); - CMD2_DL_U ("d.hashing_failed", std::bind(&core::Download::is_hash_failed, std::placeholders::_1)); - CMD2_DL_VALUE_V_U("d.hashing_failed.set", std::bind(&core::Download::set_hash_failed, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL ("d.hashing_failed", std::bind(&core::Download::is_hash_failed, std::placeholders::_1)); + CMD2_DL_VALUE_V ("d.hashing_failed.set", std::bind(&core::Download::set_hash_failed, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_U ("d.views", std::bind(&download_get_variable, std::placeholders::_1, "rtorrent", "views")); + CMD2_DL ("d.views", std::bind(&download_get_variable, std::placeholders::_1, "rtorrent", "views")); CMD2_DL ("d.views.has", std::bind(&d_list_has, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views")); - CMD2_DL_U ("d.views.remove", std::bind(&d_list_remove, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views")); - CMD2_DL_STRING_U("d.views.push_back", std::bind(&d_list_push_back_string, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views")); - CMD2_DL_STRING_U("d.views.push_back_unique", std::bind(&d_list_push_back_unique_string, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views")); + CMD2_DL ("d.views.remove", std::bind(&d_list_remove, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views")); + CMD2_DL_STRING ("d.views.push_back", std::bind(&d_list_push_back_string, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views")); + CMD2_DL_STRING ("d.views.push_back_unique", std::bind(&d_list_push_back_unique_string, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views")); // This command really needs to be improved, so we have proper // logging support. - CMD2_DL_U ("d.message", std::bind(&core::Download::message, std::placeholders::_1)); - CMD2_DL_STRING_V_U("d.message.set", std::bind(&core::Download::set_message, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL ("d.message", std::bind(&core::Download::message, std::placeholders::_1)); + CMD2_DL_STRING_V("d.message.set", std::bind(&core::Download::set_message, std::placeholders::_1, std::placeholders::_2)); CMD2_DL ("d.max_file_size", CMD2_ON_FL(max_file_size)); CMD2_DL_VALUE_V ("d.max_file_size.set", std::bind(&torrent::FileList::set_max_file_size, CMD2_BIND_FL, std::placeholders::_2)); - CMD2_DL_U ("d.peers_min", std::bind(&torrent::ConnectionList::min_size, CMD2_BIND_CL)); - CMD2_DL_VALUE_V_U("d.peers_min.set", std::bind(&torrent::ConnectionList::set_min_size, CMD2_BIND_CL, std::placeholders::_2)); - CMD2_DL_U ("d.peers_max", std::bind(&torrent::ConnectionList::max_size, CMD2_BIND_CL)); - CMD2_DL_VALUE_V_U("d.peers_max.set", std::bind(&torrent::ConnectionList::set_max_size, CMD2_BIND_CL, std::placeholders::_2)); - CMD2_DL_U ("d.uploads_max", std::bind(&torrent::Download::uploads_max, CMD2_BIND_DL)); - CMD2_DL_VALUE_V_U("d.uploads_max.set", std::bind(&torrent::Download::set_uploads_max, CMD2_BIND_DL, std::placeholders::_2)); + CMD2_DL ("d.peers_min", std::bind(&torrent::ConnectionList::min_size, CMD2_BIND_CL)); + CMD2_DL_VALUE_V ("d.peers_min.set", std::bind(&torrent::ConnectionList::set_min_size, CMD2_BIND_CL, std::placeholders::_2)); + CMD2_DL ("d.peers_max", std::bind(&torrent::ConnectionList::max_size, CMD2_BIND_CL)); + CMD2_DL_VALUE_V ("d.peers_max.set", std::bind(&torrent::ConnectionList::set_max_size, CMD2_BIND_CL, std::placeholders::_2)); + CMD2_DL ("d.uploads_max", std::bind(&torrent::Download::uploads_max, CMD2_BIND_DL)); + CMD2_DL_VALUE_V ("d.uploads_max.set", std::bind(&torrent::Download::set_uploads_max, CMD2_BIND_DL, std::placeholders::_2)); CMD2_DL ("d.uploads_min", std::bind(&torrent::Download::uploads_min, CMD2_BIND_DL)); CMD2_DL_VALUE_V ("d.uploads_min.set", std::bind(&torrent::Download::set_uploads_min, CMD2_BIND_DL, std::placeholders::_2)); - CMD2_DL_U ("d.downloads_max", std::bind(&torrent::Download::downloads_max, CMD2_BIND_DL)); - CMD2_DL_VALUE_V_U("d.downloads_max.set", std::bind(&torrent::Download::set_downloads_max, CMD2_BIND_DL, std::placeholders::_2)); + CMD2_DL ("d.downloads_max", std::bind(&torrent::Download::downloads_max, CMD2_BIND_DL)); + CMD2_DL_VALUE_V ("d.downloads_max.set", std::bind(&torrent::Download::set_downloads_max, CMD2_BIND_DL, std::placeholders::_2)); CMD2_DL ("d.downloads_min", std::bind(&torrent::Download::downloads_min, CMD2_BIND_DL)); CMD2_DL_VALUE_V ("d.downloads_min.set", std::bind(&torrent::Download::set_downloads_min, CMD2_BIND_DL, std::placeholders::_2)); - CMD2_DL_U ("d.peers_connected", std::bind(&torrent::ConnectionList::size, CMD2_BIND_CL)); - CMD2_DL_U ("d.peers_not_connected", std::bind(&torrent::PeerList::available_list_size, CMD2_BIND_PL)); + CMD2_DL ("d.peers_connected", std::bind(&torrent::ConnectionList::size, CMD2_BIND_CL)); + CMD2_DL ("d.peers_not_connected", std::bind(&torrent::PeerList::available_list_size, CMD2_BIND_PL)); - CMD2_DL_U ("d.peers_complete", CMD2_ON_DL(peers_complete)); + CMD2_DL ("d.peers_complete", CMD2_ON_DL(peers_complete)); CMD2_DL ("d.peers_accounted", CMD2_ON_DL(peers_accounted)); CMD2_DL_V ("d.disconnect.seeders", std::bind(&torrent::ConnectionList::erase_seeders, CMD2_BIND_CL)); @@ -837,26 +817,26 @@ initialize_command_download() { CMD2_DL_V ("d.accepting_seeders.enable", std::bind(&torrent::DownloadInfo::public_set_flags, CMD2_BIND_INFO, torrent::DownloadInfo::flag_accepting_seeders)); CMD2_DL_V ("d.accepting_seeders.disable", std::bind(&torrent::DownloadInfo::public_unset_flags, CMD2_BIND_INFO, torrent::DownloadInfo::flag_accepting_seeders)); - CMD2_DL_U ("d.throttle_name", std::bind(&download_get_variable, std::placeholders::_1, "rtorrent", "throttle_name")); - CMD2_DL_STRING_V_U("d.throttle_name.set", std::bind(&core::Download::set_throttle_name, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL ("d.throttle_name", std::bind(&download_get_variable, std::placeholders::_1, "rtorrent", "throttle_name")); + CMD2_DL_STRING_V("d.throttle_name.set", std::bind(&core::Download::set_throttle_name, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_U ("d.bytes_done", CMD2_ON_DL(bytes_done)); - CMD2_DL_U ("d.ratio", std::bind(&retrieve_d_ratio, std::placeholders::_1)); - CMD2_DL_U ("d.chunks_hashed", CMD2_ON_DL(chunks_hashed)); - CMD2_DL_U ("d.free_diskspace", CMD2_ON_FL(free_diskspace)); + CMD2_DL ("d.bytes_done", CMD2_ON_DL(bytes_done)); + CMD2_DL ("d.ratio", std::bind(&retrieve_d_ratio, std::placeholders::_1)); + CMD2_DL ("d.chunks_hashed", CMD2_ON_DL(chunks_hashed)); + CMD2_DL ("d.free_diskspace", CMD2_ON_FL(free_diskspace)); CMD2_DL ("d.size_files", CMD2_ON_FL(size_files)); - CMD2_DL_U ("d.size_bytes", CMD2_ON_FL(size_bytes)); - CMD2_DL_U ("d.size_chunks", CMD2_ON_FL(size_chunks)); - CMD2_DL_U ("d.chunk_size", CMD2_ON_FL(chunk_size)); - CMD2_DL_U ("d.size_pex", CMD2_ON_DL(size_pex)); + CMD2_DL ("d.size_bytes", CMD2_ON_FL(size_bytes)); + CMD2_DL ("d.size_chunks", CMD2_ON_FL(size_chunks)); + CMD2_DL ("d.chunk_size", CMD2_ON_FL(chunk_size)); + CMD2_DL ("d.size_pex", CMD2_ON_DL(size_pex)); CMD2_DL ("d.max_size_pex", CMD2_ON_DL(max_size_pex)); CMD2_DL ("d.chunks_seen", std::bind(&d_chunks_seen, std::placeholders::_1)); - CMD2_DL_U ("d.completed_bytes", CMD2_ON_FL(completed_bytes)); - CMD2_DL_U ("d.completed_chunks", CMD2_ON_FL(completed_chunks)); - CMD2_DL_U ("d.left_bytes", CMD2_ON_FL(left_bytes)); + CMD2_DL ("d.completed_bytes", CMD2_ON_FL(completed_bytes)); + CMD2_DL ("d.completed_chunks", CMD2_ON_FL(completed_chunks)); + CMD2_DL ("d.left_bytes", CMD2_ON_FL(left_bytes)); CMD2_DL ("d.wanted_chunks", CMD2_ON_DATA(wanted_chunks)); @@ -864,10 +844,10 @@ initialize_command_download() { CMD2_DL_V ("d.tracker_announce", std::bind(&torrent::Download::manual_request, CMD2_BIND_DL, false)); CMD2_DL_V ("d.tracker_announce.force", std::bind(&torrent::Download::manual_request, CMD2_BIND_DL, true)); - CMD2_DL_U ("d.tracker_numwant", std::bind(&torrent::tracker::TrackerControllerWrapper::numwant, CMD2_BIND_TC)); - CMD2_DL_VALUE_V_U("d.tracker_numwant.set", std::bind(&torrent::tracker::TrackerControllerWrapper::set_numwant, CMD2_BIND_TC, std::placeholders::_2)); + CMD2_DL ("d.tracker_numwant", std::bind(&torrent::tracker::TrackerControllerWrapper::numwant, CMD2_BIND_TC)); + CMD2_DL_VALUE_V ("d.tracker_numwant.set", std::bind(&torrent::tracker::TrackerControllerWrapper::set_numwant, CMD2_BIND_TC, std::placeholders::_2)); // TODO: Deprecate 'd.tracker_focus'. - CMD2_DL_U ("d.tracker_focus", std::bind(&core::Download::tracker_list_size, std::placeholders::_1)); + CMD2_DL ("d.tracker_focus", std::bind(&core::Download::tracker_list_size, std::placeholders::_1)); CMD2_DL ("d.tracker_size", std::bind(&core::Download::tracker_list_size, std::placeholders::_1)); CMD2_DL ("d.tracker.has_active", std::bind(&torrent::tracker::TrackerControllerWrapper::has_active_trackers, CMD2_BIND_TC)); @@ -876,14 +856,14 @@ initialize_command_download() { CMD2_DL_LIST ("d.tracker.insert", std::bind(&download_tracker_insert, std::placeholders::_1, std::placeholders::_2)); CMD2_DL_VALUE_V ("d.tracker.send_scrape", [](auto download, uint64_t arg) { download->tracker_controller().scrape_request(arg); }); - CMD2_DL_U ("d.directory", CMD2_ON_FL(root_dir)); - CMD2_DL_STRING_V_U("d.directory.set", std::bind(&apply_d_directory, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_U ("d.directory_base", CMD2_ON_FL(root_dir)); - CMD2_DL_STRING_V_U("d.directory_base.set", std::bind(&core::Download::set_root_directory, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL ("d.directory", CMD2_ON_FL(root_dir)); + CMD2_DL_STRING_V("d.directory.set", std::bind(&apply_d_directory, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL ("d.directory_base", CMD2_ON_FL(root_dir)); + CMD2_DL_STRING_V("d.directory_base.set", std::bind(&core::Download::set_root_directory, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_U ("d.priority", std::bind(&core::Download::priority, std::placeholders::_1)); - CMD2_DL_U ("d.priority_str", std::bind(&retrieve_d_priority_str, std::placeholders::_1)); - CMD2_DL_VALUE_V_U("d.priority.set", std::bind(&core::Download::set_priority, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL ("d.priority", std::bind(&core::Download::priority, std::placeholders::_1)); + CMD2_DL ("d.priority_str", std::bind(&retrieve_d_priority_str, std::placeholders::_1)); + CMD2_DL_VALUE_V ("d.priority.set", std::bind(&core::Download::set_priority, std::placeholders::_1, std::placeholders::_2)); // CMD2_DL ("d.group", std::bind(&torrent::resource_manager_entry::group, // std::bind(&torrent::ResourceManager::entry_at, torrent::resource_manager(), @@ -899,9 +879,122 @@ initialize_command_download() { CMD2_DL ("d.group.name", std::bind(&cg_d_group_name, std::placeholders::_1)); CMD2_DL_V ("d.group.set", std::bind(&cg_d_group_set, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_LIST_U ("f.multicall", std::bind(&f_multicall, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_LIST_U ("p.multicall", std::bind(&p_multicall, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_LIST_U ("t.multicall", std::bind(&t_multicall, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_LIST ("f.multicall", std::bind(&f_multicall, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_LIST ("p.multicall", std::bind(&p_multicall, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_LIST ("t.multicall", std::bind(&t_multicall, std::placeholders::_1, std::placeholders::_2)); - CMD2_ANY_LIST_U ("p.call_target", std::bind(&p_call_target, std::placeholders::_2)); + CMD2_ANY_LIST ("p.call_target", std::bind(&p_call_target, std::placeholders::_2)); + + rpc::rpc.mark_safe("add_peer"); + rpc::rpc.mark_safe("d.hash"); + rpc::rpc.mark_safe("d.local_id"); + rpc::rpc.mark_safe("d.local_id_html"); + rpc::rpc.mark_safe("d.bitfield"); + rpc::rpc.mark_safe("d.base_path"); + rpc::rpc.mark_safe("d.base_filename"); + rpc::rpc.mark_safe("d.name"); + rpc::rpc.mark_safe("d.directory"); + rpc::rpc.mark_safe("d.directory.set"); + rpc::rpc.mark_safe("d.directory_base"); + rpc::rpc.mark_safe("d.directory_base.set"); + rpc::rpc.mark_safe("d.creation_date"); + rpc::rpc.mark_safe("d.load_date"); + rpc::rpc.mark_safe("d.up.rate"); + rpc::rpc.mark_safe("d.up.total"); + rpc::rpc.mark_safe("d.down.rate"); + rpc::rpc.mark_safe("d.down.total"); + rpc::rpc.mark_safe("d.skip.rate"); + rpc::rpc.mark_safe("d.skip.total"); + rpc::rpc.mark_safe("d.is_open"); + rpc::rpc.mark_safe("d.is_active"); + rpc::rpc.mark_safe("d.is_hash_checked"); + rpc::rpc.mark_safe("d.is_hash_checking"); + rpc::rpc.mark_safe("d.is_multi_file"); + rpc::rpc.mark_safe("d.is_private"); + rpc::rpc.mark_safe("d.is_pex_active"); + rpc::rpc.mark_safe("d.is_partially_done"); + rpc::rpc.mark_safe("d.is_not_partially_done"); + rpc::rpc.mark_safe("d.is_meta"); + rpc::rpc.mark_safe("d.peer_exchange"); + rpc::rpc.mark_safe("d.peer_exchange.set"); + rpc::rpc.mark_safe("d.resume"); + rpc::rpc.mark_safe("d.pause"); + rpc::rpc.mark_safe("d.open"); + rpc::rpc.mark_safe("d.close"); + rpc::rpc.mark_safe("d.close.directly"); + rpc::rpc.mark_safe("d.erase"); + rpc::rpc.mark_safe("d.check_hash"); + rpc::rpc.mark_safe("d.save_resume"); + rpc::rpc.mark_safe("d.save_full_session"); + rpc::rpc.mark_safe("d.update_priorities"); + rpc::rpc.mark_safe("d.custom"); + rpc::rpc.mark_safe("d.custom.set"); + rpc::rpc.mark_safe("d.custom1"); + rpc::rpc.mark_safe("d.custom1.set"); + rpc::rpc.mark_safe("d.custom2"); + rpc::rpc.mark_safe("d.custom2.set"); + rpc::rpc.mark_safe("d.custom3"); + rpc::rpc.mark_safe("d.custom3.set"); + rpc::rpc.mark_safe("d.custom4"); + rpc::rpc.mark_safe("d.custom4.set"); + rpc::rpc.mark_safe("d.custom5"); + rpc::rpc.mark_safe("d.custom5.set"); + rpc::rpc.mark_safe("d.create_link"); + rpc::rpc.mark_safe("d.delete_link"); + rpc::rpc.mark_safe("d.delete_tied"); + rpc::rpc.mark_safe("d.size_bytes"); + rpc::rpc.mark_safe("d.size_chunks"); + rpc::rpc.mark_safe("d.size_pex"); + rpc::rpc.mark_safe("d.completed_bytes"); + rpc::rpc.mark_safe("d.completed_chunks"); + rpc::rpc.mark_safe("d.left_bytes"); + rpc::rpc.mark_safe("d.chunk_size"); + rpc::rpc.mark_safe("d.priority"); + rpc::rpc.mark_safe("d.priority.set"); + rpc::rpc.mark_safe("d.priority_str"); + rpc::rpc.mark_safe("d.state"); + rpc::rpc.mark_safe("d.state.set"); + rpc::rpc.mark_safe("d.state_changed"); + rpc::rpc.mark_safe("d.state_changed.set"); + rpc::rpc.mark_safe("d.state_counter"); + rpc::rpc.mark_safe("d.state_counter.set"); + rpc::rpc.mark_safe("d.connection_current"); + rpc::rpc.mark_safe("d.connection_current.set"); + rpc::rpc.mark_safe("d.connection_leech"); + rpc::rpc.mark_safe("d.connection_leech.set"); + rpc::rpc.mark_safe("d.connection_seed"); + rpc::rpc.mark_safe("d.connection_seed.set"); + rpc::rpc.mark_safe("d.throttle_name"); + rpc::rpc.mark_safe("d.throttle_name.set"); + rpc::rpc.mark_safe("d.uploads_max"); + rpc::rpc.mark_safe("d.uploads_max.set"); + rpc::rpc.mark_safe("d.downloads_max"); + rpc::rpc.mark_safe("d.downloads_max.set"); + rpc::rpc.mark_safe("d.peers_min"); + rpc::rpc.mark_safe("d.peers_min.set"); + rpc::rpc.mark_safe("d.peers_max"); + rpc::rpc.mark_safe("d.peers_max.set"); + rpc::rpc.mark_safe("d.peers_connected"); + rpc::rpc.mark_safe("d.peers_not_connected"); + rpc::rpc.mark_safe("d.peers_complete"); + rpc::rpc.mark_safe("d.tracker_numwant"); + rpc::rpc.mark_safe("d.tracker_numwant.set"); + rpc::rpc.mark_safe("d.tracker_focus"); + rpc::rpc.mark_safe("d.message"); + rpc::rpc.mark_safe("d.message.set"); + rpc::rpc.mark_safe("d.tied_to_file"); + rpc::rpc.mark_safe("d.tied_to_file.set"); + rpc::rpc.mark_safe("d.hashing"); + rpc::rpc.mark_safe("d.hashing.set"); + rpc::rpc.mark_safe("d.hashing_failed"); + rpc::rpc.mark_safe("d.hashing_failed.set"); + rpc::rpc.mark_safe("d.free_diskspace"); + rpc::rpc.mark_safe("d.views"); + rpc::rpc.mark_safe("d.views.remove"); + rpc::rpc.mark_safe("d.views.push_back_unique"); + rpc::rpc.mark_safe("d.ratio"); + rpc::rpc.mark_safe("f.multicall"); + rpc::rpc.mark_safe("p.multicall"); + rpc::rpc.mark_safe("p.call_target"); + rpc::rpc.mark_safe("t.multicall"); } diff --git a/src/command_dynamic.cc b/src/command_dynamic.cc index 4e236db3..ad030eb3 100644 --- a/src/command_dynamic.cc +++ b/src/command_dynamic.cc @@ -406,11 +406,11 @@ void initialize_command_dynamic() { // clang-format off #ifdef HAVE_XMLRPC_TINYXML2 - CMD2_ANY_U ("system.listMethods", std::bind(&system_listMethods)); // only used by tinyxml2 + CMD2_ANY ("system.listMethods", std::bind(&system_listMethods)); // only used by tinyxml2 #endif // Keep these for future use when we deprecate more commands. - CMD2_VAR_BOOL_U("method.use_deprecated", false); + CMD2_VAR_BOOL ("method.use_deprecated", false); CMD2_VAR_VALUE ("method.use_intermediate", 3); CMD2_ANY_LIST ("method.insert", std::bind(&system_method_insert, std::placeholders::_2)); @@ -426,33 +426,57 @@ initialize_command_dynamic() { CMD2_ANY_STRING ("method.erase", std::bind(&system_method_erase, std::placeholders::_2)); CMD2_ANY_LIST ("method.redirect", std::bind(&system_method_redirect, std::placeholders::_2)); - CMD2_ANY_STRING_U("method.get", std::bind(&rpc::object_storage::get_str, control->object_storage(), + CMD2_ANY_STRING ("method.get", std::bind(&rpc::object_storage::get_str, control->object_storage(), std::placeholders::_2)); CMD2_ANY_LIST ("method.set", std::bind(&system_method_set_function, std::placeholders::_2)); - CMD2_ANY_STRING_U("method.const", std::bind(&rpc::object_storage::has_flag_str, control->object_storage(), + CMD2_ANY_STRING ("method.const", std::bind(&rpc::object_storage::has_flag_str, control->object_storage(), std::placeholders::_2, rpc::object_storage::flag_constant)); CMD2_ANY_STRING_V("method.const.enable", std::bind(&rpc::object_storage::enable_flag_str, control->object_storage(), std::placeholders::_2, rpc::object_storage::flag_constant)); - CMD2_ANY_LIST_U ("method.has_key", std::bind(&system_method_has_key, std::placeholders::_2)); + CMD2_ANY_LIST ("method.has_key", std::bind(&system_method_has_key, std::placeholders::_2)); CMD2_ANY_LIST ("method.set_key", std::bind(&system_method_set_key, std::placeholders::_2)); - CMD2_ANY_STRING_U("method.list_keys", std::bind(&system_method_list_keys, std::placeholders::_2)); + CMD2_ANY_STRING ("method.list_keys", std::bind(&system_method_list_keys, std::placeholders::_2)); - CMD2_ANY_STRING_U("method.rlookup", std::bind(&rpc::object_storage::rlookup_obj_list, control->object_storage(), std::placeholders::_2)); + CMD2_ANY_STRING ("method.rlookup", std::bind(&rpc::object_storage::rlookup_obj_list, control->object_storage(), std::placeholders::_2)); CMD2_ANY_STRING_V("method.rlookup.clear", std::bind(&rpc::object_storage::rlookup_clear, control->object_storage(), std::placeholders::_2)); - CMD2_ANY_U ("catch", std::bind(&cmd_catch, std::placeholders::_1, std::placeholders::_2)); + CMD2_ANY ("catch", std::bind(&cmd_catch, std::placeholders::_1, std::placeholders::_2)); - CMD2_ANY_U ("strings.choke_heuristics", std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS)); - CMD2_ANY_U ("strings.choke_heuristics.upload", std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_UPLOAD)); - CMD2_ANY_U ("strings.choke_heuristics.download", std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_DOWNLOAD)); - CMD2_ANY_U ("strings.connection_type", std::bind(&torrent::option_list_strings, torrent::OPTION_CONNECTION_TYPE)); - CMD2_ANY_U ("strings.encryption", std::bind(&torrent::option_list_strings, torrent::OPTION_ENCRYPTION)); - CMD2_ANY_U ("strings.ip_filter", std::bind(&torrent::option_list_strings, torrent::OPTION_IP_FILTER)); - CMD2_ANY_U ("strings.ip_tos", std::bind(&torrent::option_list_strings, torrent::OPTION_IP_TOS)); - CMD2_ANY_U ("strings.log_group", std::bind(&torrent::option_list_strings, torrent::OPTION_LOG_GROUP)); - CMD2_ANY_U ("strings.tracker_event", std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_EVENT)); - CMD2_ANY_U ("strings.tracker_mode", std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_MODE)); + CMD2_ANY ("strings.choke_heuristics", std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS)); + CMD2_ANY ("strings.choke_heuristics.upload", std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_UPLOAD)); + CMD2_ANY ("strings.choke_heuristics.download", std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_DOWNLOAD)); + CMD2_ANY ("strings.connection_type", std::bind(&torrent::option_list_strings, torrent::OPTION_CONNECTION_TYPE)); + CMD2_ANY ("strings.encryption", std::bind(&torrent::option_list_strings, torrent::OPTION_ENCRYPTION)); + CMD2_ANY ("strings.ip_filter", std::bind(&torrent::option_list_strings, torrent::OPTION_IP_FILTER)); + CMD2_ANY ("strings.ip_tos", std::bind(&torrent::option_list_strings, torrent::OPTION_IP_TOS)); + CMD2_ANY ("strings.log_group", std::bind(&torrent::option_list_strings, torrent::OPTION_LOG_GROUP)); + CMD2_ANY ("strings.tracker_event", std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_EVENT)); + CMD2_ANY ("strings.tracker_mode", std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_MODE)); // clang-format on + +#ifdef HAVE_XMLRPC_TINYXML2 + rpc::rpc.mark_safe("system.listMethods"); +#endif + + rpc::rpc.mark_safe("method.use_deprecated"); + rpc::rpc.mark_safe("method.use_deprecated.set"); + rpc::rpc.mark_safe("method.const"); + rpc::rpc.mark_safe("method.has_key"); + rpc::rpc.mark_safe("method.list_keys"); + rpc::rpc.mark_safe("method.get"); + rpc::rpc.mark_safe("method.rlookup"); + rpc::rpc.mark_safe("catch"); + + rpc::rpc.mark_safe("strings.choke_heuristics"); + rpc::rpc.mark_safe("strings.choke_heuristics.upload"); + rpc::rpc.mark_safe("strings.choke_heuristics.download"); + rpc::rpc.mark_safe("strings.connection_type"); + rpc::rpc.mark_safe("strings.encryption"); + rpc::rpc.mark_safe("strings.ip_filter"); + rpc::rpc.mark_safe("strings.ip_tos"); + rpc::rpc.mark_safe("strings.log_group"); + rpc::rpc.mark_safe("strings.tracker_event"); + rpc::rpc.mark_safe("strings.tracker_mode"); } diff --git a/src/command_events.cc b/src/command_events.cc index 02b2f184..14d7fcf8 100644 --- a/src/command_events.cc +++ b/src/command_events.cc @@ -311,10 +311,10 @@ void initialize_command_events() { CMD2_ANY_STRING ("on_ratio", std::bind(&apply_on_ratio, std::placeholders::_2)); - CMD2_ANY_U ("start_tied", std::bind(&apply_start_tied)); - CMD2_ANY_U ("stop_untied", std::bind(&apply_stop_untied)); - CMD2_ANY_U ("close_untied", std::bind(&apply_close_untied)); - CMD2_ANY_U ("remove_untied", std::bind(&apply_remove_untied)); + CMD2_ANY ("start_tied", std::bind(&apply_start_tied)); + CMD2_ANY ("stop_untied", std::bind(&apply_stop_untied)); + CMD2_ANY ("close_untied", std::bind(&apply_close_untied)); + CMD2_ANY ("remove_untied", std::bind(&apply_remove_untied)); // TODO: Deprecate schedule2 in the future. CMD2_ANY_LIST ("schedule", std::bind(&apply_schedule, std::placeholders::_2)); @@ -325,23 +325,43 @@ initialize_command_events() { CMD2_ANY_STRING_V("import", std::bind(&apply_import, std::placeholders::_2)); CMD2_ANY_STRING_V("try_import", std::bind(&apply_try_import, std::placeholders::_2)); - CMD2_ANY_LIST_U ("load.normal", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_tied)); - CMD2_ANY_LIST_U ("load.verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied)); - CMD2_ANY_LIST_U ("load.start", std::bind(&apply_load, std::placeholders::_2, + CMD2_ANY_LIST ("load.normal", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_tied)); + CMD2_ANY_LIST ("load.verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied)); + CMD2_ANY_LIST ("load.start", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_tied | core::Manager::create_start)); - CMD2_ANY_LIST_U ("load.start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied | core::Manager::create_start)); - CMD2_ANY_LIST_U ("load.raw", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_raw_data)); - CMD2_ANY_LIST_U ("load.raw_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_raw_data)); - CMD2_ANY_LIST_U ("load.raw_start", std::bind(&apply_load, std::placeholders::_2, + CMD2_ANY_LIST ("load.start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied | core::Manager::create_start)); + CMD2_ANY_LIST ("load.raw", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_raw_data)); + CMD2_ANY_LIST ("load.raw_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_raw_data)); + CMD2_ANY_LIST ("load.raw_start", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_start | core::Manager::create_raw_data)); - CMD2_ANY_LIST_U ("load.raw_start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_start | core::Manager::create_raw_data)); + CMD2_ANY_LIST ("load.raw_start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_start | core::Manager::create_raw_data)); - CMD2_ANY_VALUE_U ("close_low_diskspace", std::bind(&apply_close_low_diskspace, std::placeholders::_2, 99)); - CMD2_ANY_VALUE_U ("close_low_diskspace.normal", std::bind(&apply_close_low_diskspace, std::placeholders::_2, 3)); + CMD2_ANY_VALUE ("close_low_diskspace", std::bind(&apply_close_low_diskspace, std::placeholders::_2, 99)); + CMD2_ANY_VALUE ("close_low_diskspace.normal", std::bind(&apply_close_low_diskspace, std::placeholders::_2, 3)); - CMD2_ANY_LIST_U ("download_list", std::bind(&apply_download_list, std::placeholders::_2)); - CMD2_ANY_LIST_U ("d.multicall2", std::bind(&d_multicall, std::placeholders::_2)); - CMD2_ANY_LIST_U ("d.multicall.filtered", std::bind(&d_multicall_filtered, std::placeholders::_2)); + CMD2_ANY_LIST ("download_list", std::bind(&apply_download_list, std::placeholders::_2)); + CMD2_ANY_LIST ("d.multicall2", std::bind(&d_multicall, std::placeholders::_2)); + CMD2_ANY_LIST ("d.multicall.filtered", std::bind(&d_multicall_filtered, std::placeholders::_2)); CMD2_ANY_LIST ("directory.watch.added", std::bind(&directory_watch_added, std::placeholders::_2)); + + rpc::rpc.mark_safe("start_tied"); + rpc::rpc.mark_safe("stop_untied"); + rpc::rpc.mark_safe("close_untied"); + rpc::rpc.mark_safe("remove_untied"); + + rpc::rpc.mark_safe("load.normal"); + rpc::rpc.mark_safe("load.verbose"); + rpc::rpc.mark_safe("load.start"); + rpc::rpc.mark_safe("load.start_verbose"); + rpc::rpc.mark_safe("load.raw"); + rpc::rpc.mark_safe("load.raw_verbose"); + rpc::rpc.mark_safe("load.raw_start"); + rpc::rpc.mark_safe("load.raw_start_verbose"); + + rpc::rpc.mark_safe("close_low_diskspace"); + rpc::rpc.mark_safe("close_low_diskspace.normal"); + rpc::rpc.mark_safe("download_list"); + rpc::rpc.mark_safe("d.multicall2"); + rpc::rpc.mark_safe("d.multicall.filtered"); } diff --git a/src/command_file.cc b/src/command_file.cc index 693e743b..581e696b 100644 --- a/src/command_file.cc +++ b/src/command_file.cc @@ -62,45 +62,73 @@ apply_fi_filename_last(torrent::FileListIterator* itr) { void initialize_command_file() { - CMD2_FILE_U("f.is_created", std::bind(&torrent::File::is_created, std::placeholders::_1)); - CMD2_FILE_U("f.is_open", std::bind(&torrent::File::is_open, std::placeholders::_1)); + CMD2_FILE("f.is_created", std::bind(&torrent::File::is_created, std::placeholders::_1)); + CMD2_FILE("f.is_open", std::bind(&torrent::File::is_open, std::placeholders::_1)); - CMD2_FILE_U("f.is_create_queued", std::bind(&torrent::File::is_create_queued, std::placeholders::_1)); - CMD2_FILE_U("f.is_resize_queued", std::bind(&torrent::File::is_resize_queued, std::placeholders::_1)); + CMD2_FILE("f.is_create_queued", std::bind(&torrent::File::is_create_queued, std::placeholders::_1)); + CMD2_FILE("f.is_resize_queued", std::bind(&torrent::File::is_resize_queued, std::placeholders::_1)); CMD2_FILE_VALUE_V("f.set_create_queued", std::bind(&torrent::File::set_flags, std::placeholders::_1, torrent::File::flag_create_queued)); CMD2_FILE_VALUE_V("f.set_resize_queued", std::bind(&torrent::File::set_flags, std::placeholders::_1, torrent::File::flag_resize_queued)); CMD2_FILE_VALUE_V("f.unset_create_queued", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_create_queued)); CMD2_FILE_VALUE_V("f.unset_resize_queued", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_resize_queued)); - CMD2_FILE_U ("f.prioritize_first", std::bind(&torrent::File::has_flags, std::placeholders::_1, torrent::File::flag_prioritize_first)); - CMD2_FILE_V_U("f.prioritize_first.enable", std::bind(&torrent::File::set_flags, std::placeholders::_1, torrent::File::flag_prioritize_first)); - CMD2_FILE_V_U("f.prioritize_first.disable", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_prioritize_first)); - CMD2_FILE_U ("f.prioritize_last", std::bind(&torrent::File::has_flags, std::placeholders::_1, torrent::File::flag_prioritize_last)); - CMD2_FILE_V_U("f.prioritize_last.enable", std::bind(&torrent::File::set_flags, std::placeholders::_1, torrent::File::flag_prioritize_last)); - CMD2_FILE_V_U("f.prioritize_last.disable", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_prioritize_last)); + CMD2_FILE ("f.prioritize_first", std::bind(&torrent::File::has_flags, std::placeholders::_1, torrent::File::flag_prioritize_first)); + CMD2_FILE_V("f.prioritize_first.enable", std::bind(&torrent::File::set_flags, std::placeholders::_1, torrent::File::flag_prioritize_first)); + CMD2_FILE_V("f.prioritize_first.disable", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_prioritize_first)); + CMD2_FILE ("f.prioritize_last", std::bind(&torrent::File::has_flags, std::placeholders::_1, torrent::File::flag_prioritize_last)); + CMD2_FILE_V("f.prioritize_last.enable", std::bind(&torrent::File::set_flags, std::placeholders::_1, torrent::File::flag_prioritize_last)); + CMD2_FILE_V("f.prioritize_last.disable", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_prioritize_last)); - CMD2_FILE_U("f.size_bytes", std::bind(&torrent::File::size_bytes, std::placeholders::_1)); - CMD2_FILE_U("f.size_chunks", std::bind(&torrent::File::size_chunks, std::placeholders::_1)); - CMD2_FILE_U("f.completed_chunks", std::bind(&torrent::File::completed_chunks, std::placeholders::_1)); + CMD2_FILE("f.size_bytes", std::bind(&torrent::File::size_bytes, std::placeholders::_1)); + CMD2_FILE("f.size_chunks", std::bind(&torrent::File::size_chunks, std::placeholders::_1)); + CMD2_FILE("f.completed_chunks", std::bind(&torrent::File::completed_chunks, std::placeholders::_1)); - CMD2_FILE_U("f.offset", std::bind(&torrent::File::offset, std::placeholders::_1)); - CMD2_FILE_U("f.range_first", std::bind(&torrent::File::range_first, std::placeholders::_1)); - CMD2_FILE_U("f.range_second", std::bind(&torrent::File::range_second, std::placeholders::_1)); + CMD2_FILE("f.offset", std::bind(&torrent::File::offset, std::placeholders::_1)); + CMD2_FILE("f.range_first", std::bind(&torrent::File::range_first, std::placeholders::_1)); + CMD2_FILE("f.range_second", std::bind(&torrent::File::range_second, std::placeholders::_1)); - CMD2_FILE_U("f.priority", std::bind(&torrent::File::priority, std::placeholders::_1)); - CMD2_FILE_VALUE_V_U("f.priority.set", std::bind(&apply_f_set_priority, std::placeholders::_1, std::placeholders::_2)); + CMD2_FILE("f.priority", std::bind(&torrent::File::priority, std::placeholders::_1)); + CMD2_FILE_VALUE_V("f.priority.set", std::bind(&apply_f_set_priority, std::placeholders::_1, std::placeholders::_2)); - CMD2_FILE_U("f.path", std::bind(&apply_f_path, std::placeholders::_1)); - CMD2_FILE_U("f.path_components", std::bind(&apply_f_path_components, std::placeholders::_1)); - CMD2_FILE_U("f.path_depth", std::bind(&apply_f_path_depth, std::placeholders::_1)); - CMD2_FILE_U("f.frozen_path", std::bind(&torrent::File::frozen_path, std::placeholders::_1)); + CMD2_FILE("f.path", std::bind(&apply_f_path, std::placeholders::_1)); + CMD2_FILE("f.path_components", std::bind(&apply_f_path_components, std::placeholders::_1)); + CMD2_FILE("f.path_depth", std::bind(&apply_f_path_depth, std::placeholders::_1)); + CMD2_FILE("f.frozen_path", std::bind(&torrent::File::frozen_path, std::placeholders::_1)); - CMD2_FILE_U("f.match_depth_prev", std::bind(&torrent::File::match_depth_prev, std::placeholders::_1)); - CMD2_FILE_U("f.match_depth_next", std::bind(&torrent::File::match_depth_next, std::placeholders::_1)); + CMD2_FILE("f.match_depth_prev", std::bind(&torrent::File::match_depth_prev, std::placeholders::_1)); + CMD2_FILE("f.match_depth_next", std::bind(&torrent::File::match_depth_next, std::placeholders::_1)); - CMD2_FILE_U("f.last_touched", std::bind(&torrent::File::last_touched, std::placeholders::_1)); + CMD2_FILE("f.last_touched", std::bind(&torrent::File::last_touched, std::placeholders::_1)); - CMD2_FILEITR_U("fi.filename_last", std::bind(&apply_fi_filename_last, std::placeholders::_1)); - CMD2_FILEITR_U("fi.is_file", std::bind(&torrent::FileListIterator::is_file, std::placeholders::_1)); + CMD2_FILEITR("fi.filename_last", std::bind(&apply_fi_filename_last, std::placeholders::_1)); + CMD2_FILEITR("fi.is_file", std::bind(&torrent::FileListIterator::is_file, std::placeholders::_1)); + + rpc::rpc.mark_safe("f.path"); + rpc::rpc.mark_safe("f.path_components"); + rpc::rpc.mark_safe("f.path_depth"); + rpc::rpc.mark_safe("f.frozen_path"); + rpc::rpc.mark_safe("f.offset"); + rpc::rpc.mark_safe("f.size_bytes"); + rpc::rpc.mark_safe("f.size_chunks"); + rpc::rpc.mark_safe("f.completed_chunks"); + rpc::rpc.mark_safe("f.range_first"); + rpc::rpc.mark_safe("f.range_second"); + rpc::rpc.mark_safe("f.priority"); + rpc::rpc.mark_safe("f.priority.set"); + rpc::rpc.mark_safe("f.is_created"); + rpc::rpc.mark_safe("f.is_open"); + rpc::rpc.mark_safe("f.is_create_queued"); + rpc::rpc.mark_safe("f.is_resize_queued"); + rpc::rpc.mark_safe("f.prioritize_first"); + rpc::rpc.mark_safe("f.prioritize_first.enable"); + rpc::rpc.mark_safe("f.prioritize_first.disable"); + rpc::rpc.mark_safe("f.prioritize_last"); + rpc::rpc.mark_safe("f.prioritize_last.enable"); + rpc::rpc.mark_safe("f.prioritize_last.disable"); + rpc::rpc.mark_safe("f.last_touched"); + rpc::rpc.mark_safe("f.match_depth_prev"); + rpc::rpc.mark_safe("f.match_depth_next"); + rpc::rpc.mark_safe("fi.filename_last"); + rpc::rpc.mark_safe("fi.is_file"); } diff --git a/src/command_groups.cc b/src/command_groups.cc index 8a922aed..645058fb 100644 --- a/src/command_groups.cc +++ b/src/command_groups.cc @@ -337,12 +337,12 @@ options. void initialize_command_groups() { - CMD2_ANY_U ("choke_group.list", std::bind(&apply_cg_list)); + CMD2_ANY ("choke_group.list", std::bind(&apply_cg_list)); CMD2_ANY_STRING ("choke_group.insert", std::bind(&apply_cg_insert, std::placeholders::_2)); #if USE_CHOKE_GROUP - CMD2_ANY_U ("choke_group.size", std::bind(&torrent::ResourceManager::group_size, torrent::resource_manager())); - CMD2_ANY_STRING_U("choke_group.index_of", std::bind(&torrent::ResourceManager::group_index_of, torrent::resource_manager(), std::placeholders::_2)); + CMD2_ANY ("choke_group.size", std::bind(&torrent::ResourceManager::group_size, torrent::resource_manager())); + CMD2_ANY_STRING ("choke_group.index_of", std::bind(&torrent::ResourceManager::group_index_of, torrent::resource_manager(), std::placeholders::_2)); #else apply_cg_insert("default"); @@ -352,37 +352,57 @@ initialize_command_groups() { // Commands specific for a group. Supports as the first argument the // name, the index or a negative index. - CMD2_ANY_U ("choke_group.general.size", std::bind(&torrent::choke_group::size, CG_GROUP_AT())); + CMD2_ANY ("choke_group.general.size", std::bind(&torrent::choke_group::size, CG_GROUP_AT())); - CMD2_ANY_U ("choke_group.tracker.mode", std::bind(&torrent::option_as_string, torrent::OPTION_TRACKER_MODE, + CMD2_ANY ("choke_group.tracker.mode", std::bind(&torrent::option_as_string, torrent::OPTION_TRACKER_MODE, std::bind(&torrent::choke_group::tracker_mode, CG_GROUP_AT()))); CMD2_ANY_LIST ("choke_group.tracker.mode.set", std::bind(&apply_cg_tracker_mode_set, std::placeholders::_2)); CMD2_ANY ("choke_group.all.up.update_balance", std::bind(&apply_cg_all_update_balance, true)); CMD2_ANY ("choke_group.all.down.update_balance", std::bind(&apply_cg_all_update_balance, false)); - CMD2_ANY_U ("choke_group.up.rate", std::bind(&torrent::choke_group::up_rate, CG_GROUP_AT())); - CMD2_ANY_U ("choke_group.down.rate", std::bind(&torrent::choke_group::down_rate, CG_GROUP_AT())); + CMD2_ANY ("choke_group.up.rate", std::bind(&torrent::choke_group::up_rate, CG_GROUP_AT())); + CMD2_ANY ("choke_group.down.rate", std::bind(&torrent::choke_group::down_rate, CG_GROUP_AT())); CMD2_ANY ("choke_group.up.max.unlimited", std::bind(&torrent::choke_queue::is_unlimited, CHOKE_GROUP(&torrent::choke_group::up_queue))); - CMD2_ANY_U ("choke_group.up.max", std::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::up_queue))); + CMD2_ANY ("choke_group.up.max", std::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::up_queue))); CMD2_ANY_LIST ("choke_group.up.max.set", std::bind(&apply_cg_max_set, std::placeholders::_2, true)); - CMD2_ANY_U ("choke_group.up.total", std::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::up_queue))); - CMD2_ANY_U ("choke_group.up.queued", std::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::up_queue))); - CMD2_ANY_U ("choke_group.up.unchoked", std::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::up_queue))); - CMD2_ANY_U ("choke_group.up.heuristics", std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, + CMD2_ANY ("choke_group.up.total", std::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::up_queue))); + CMD2_ANY ("choke_group.up.queued", std::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::up_queue))); + CMD2_ANY ("choke_group.up.unchoked", std::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::up_queue))); + CMD2_ANY ("choke_group.up.heuristics", std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, std::bind(&torrent::choke_queue::heuristics, CHOKE_GROUP(&torrent::choke_group::up_queue)))); CMD2_ANY_LIST ("choke_group.up.heuristics.set", std::bind(&apply_cg_heuristics_set, std::placeholders::_2, true)); CMD2_ANY ("choke_group.down.max.unlimited", std::bind(&torrent::choke_queue::is_unlimited, CHOKE_GROUP(&torrent::choke_group::down_queue))); - CMD2_ANY_U ("choke_group.down.max", std::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::down_queue))); + CMD2_ANY ("choke_group.down.max", std::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::down_queue))); CMD2_ANY_LIST ("choke_group.down.max.set", std::bind(&apply_cg_max_set, std::placeholders::_2, false)); - CMD2_ANY_U ("choke_group.down.total", std::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::down_queue))); - CMD2_ANY_U ("choke_group.down.queued", std::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::down_queue))); - CMD2_ANY_U ("choke_group.down.unchoked", std::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::down_queue))); - CMD2_ANY_U ("choke_group.down.heuristics", std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, + CMD2_ANY ("choke_group.down.total", std::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::down_queue))); + CMD2_ANY ("choke_group.down.queued", std::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::down_queue))); + CMD2_ANY ("choke_group.down.unchoked", std::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::down_queue))); + CMD2_ANY ("choke_group.down.heuristics", std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, std::bind(&torrent::choke_queue::heuristics, CHOKE_GROUP(&torrent::choke_group::down_queue)))); CMD2_ANY_LIST ("choke_group.down.heuristics.set", std::bind(&apply_cg_heuristics_set, std::placeholders::_2, false)); + + rpc::rpc.mark_safe("choke_group.list"); + rpc::rpc.mark_safe("choke_group.size"); + rpc::rpc.mark_safe("choke_group.index_of"); + rpc::rpc.mark_safe("choke_group.general.size"); + rpc::rpc.mark_safe("choke_group.tracker.mode"); + rpc::rpc.mark_safe("choke_group.up.rate"); + rpc::rpc.mark_safe("choke_group.down.rate"); + rpc::rpc.mark_safe("choke_group.up.max"); + rpc::rpc.mark_safe("choke_group.up.max.unlimited"); + rpc::rpc.mark_safe("choke_group.up.total"); + rpc::rpc.mark_safe("choke_group.up.queued"); + rpc::rpc.mark_safe("choke_group.up.unchoked"); + rpc::rpc.mark_safe("choke_group.up.heuristics"); + rpc::rpc.mark_safe("choke_group.down.max"); + rpc::rpc.mark_safe("choke_group.down.max.unlimited"); + rpc::rpc.mark_safe("choke_group.down.total"); + rpc::rpc.mark_safe("choke_group.down.queued"); + rpc::rpc.mark_safe("choke_group.down.unchoked"); + rpc::rpc.mark_safe("choke_group.down.heuristics"); } diff --git a/src/command_helpers.h b/src/command_helpers.h index 44cfad50..07d06eda 100644 --- a/src/command_helpers.h +++ b/src/command_helpers.h @@ -19,11 +19,6 @@ void initialize_commands(); rpc::commands.insert_slot::type>(key, slot, &rpc::function, \ rpc::CommandMap::flag_dont_delete, NULL, NULL); -#define CMD2_A_FUNCTION_U(key, function, slot, parm, doc) \ - rpc::commands.insert_slot::type>(key, slot, &rpc::function, \ - rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_rpc | \ - rpc::CommandMap::flag_untrusted_safe, NULL, NULL); - #define CMD2_ANY(key, slot) CMD2_A_FUNCTION(key, command_base_call, slot, "i:", "") #define CMD2_ANY_P(key, slot) CMD2_A_FUNCTION_PRIVATE(key, command_base_call, slot, "i:", "") @@ -40,42 +35,6 @@ void initialize_commands(); #define CMD2_ANY_LIST(key, slot) CMD2_A_FUNCTION(key, command_base_call_list, slot, "i:", "") -#define CMD2_ANY_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, slot, "i:", "") -#define CMD2_ANY_VOID_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, object_convert_void(slot), "i:", "") -#define CMD2_ANY_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_list, object_convert_void(slot), "i:", "") -#define CMD2_ANY_L_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_list, slot, "A:", "") - -#define CMD2_ANY_VALUE_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value, slot, "i:i", "") -#define CMD2_ANY_VALUE_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value, object_convert_void(slot), "i:i", "") -#define CMD2_ANY_VALUE_KB_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value_kb, object_convert_void(slot), "i:i", "") - -#define CMD2_ANY_STRING_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_string, slot, "i:s", "") -#define CMD2_ANY_STRING_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_string, object_convert_void(slot), "i:s", "") - -#define CMD2_ANY_LIST_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_list, slot, "i:", "") - -#define CMD2_DL_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, slot, "i:", "") -#define CMD2_DL_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, object_convert_void(slot), "i:", "") -#define CMD2_DL_VALUE_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value, slot, "i:", "") -#define CMD2_DL_VALUE_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value, object_convert_void(slot), "i:", "") -#define CMD2_DL_STRING_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_string, slot, "i:", "") -#define CMD2_DL_STRING_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_string, object_convert_void(slot), "i:", "") -#define CMD2_DL_LIST_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_list, slot, "i:", "") - -#define CMD2_FILE_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, slot, "i:", "") -#define CMD2_FILE_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, object_convert_void(slot), "i:", "") -#define CMD2_FILE_VALUE_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value, object_convert_void(slot), "i:i", "") - -#define CMD2_FILEITR_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, slot, "i:", "") - -#define CMD2_PEER_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, slot, "i:", "") -#define CMD2_PEER_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, object_convert_void(slot), "i:", "") -#define CMD2_PEER_VALUE_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value, object_convert_void(slot), "i:i", "") - -#define CMD2_TRACKER_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, slot, "i:", "") -#define CMD2_TRACKER_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call, object_convert_void(slot), "i:", "") -#define CMD2_TRACKER_VALUE_V_U(key, slot) CMD2_A_FUNCTION_U(key, command_base_call_value, object_convert_void(slot), "i:i", "") - #define CMD2_DL(key, slot) CMD2_A_FUNCTION(key, command_base_call, slot, "i:", "") #define CMD2_DL_V(key, slot) CMD2_A_FUNCTION(key, command_base_call, object_convert_void(slot), "i:", "") #define CMD2_DL_VALUE(key, slot) CMD2_A_FUNCTION(key, command_base_call_value, slot, "i:", "") @@ -137,79 +96,10 @@ void initialize_commands(); CMD2_ANY_VOID(key ".push_back", std::bind(&rpc::object_storage::list_push_back, control->object_storage(), \ torrent::raw_string::from_c_str(key), std::placeholders::_2)); -#define CMD2_VAR_BOOL_U(key, value) \ - control->object_storage()->insert_c_str(key, int64_t(value), rpc::object_storage::flag_bool_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_VALUE_U(key ".set", std::bind(&rpc::object_storage::set_bool, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - -#define CMD2_VAR_BOOL_U_GET(key, value) \ - control->object_storage()->insert_c_str(key, int64_t(value), rpc::object_storage::flag_bool_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_VALUE(key ".set", std::bind(&rpc::object_storage::set_bool, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - -#define CMD2_VAR_VALUE_U(key, value) \ - control->object_storage()->insert_c_str(key, int64_t(value), rpc::object_storage::flag_value_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_VALUE_U(key ".set", std::bind(&rpc::object_storage::set_value, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - -#define CMD2_VAR_VALUE_U_GET(key, value) \ - control->object_storage()->insert_c_str(key, int64_t(value), rpc::object_storage::flag_value_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_VALUE(key ".set", std::bind(&rpc::object_storage::set_value, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - -#define CMD2_VAR_STRING_U(key, value) \ - control->object_storage()->insert_c_str(key, value, rpc::object_storage::flag_string_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_STRING_U(key ".set", std::bind(&rpc::object_storage::set_string, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - -#define CMD2_VAR_STRING_U_GET(key, value) \ - control->object_storage()->insert_c_str(key, value, rpc::object_storage::flag_string_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_STRING(key ".set", std::bind(&rpc::object_storage::set_string, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - -#define CMD2_VAR_C_STRING_U(key, value) \ - control->object_storage()->insert_c_str(key, value, rpc::object_storage::flag_string_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); - -#define CMD2_VAR_LIST_U(key) \ - control->object_storage()->insert_c_str(key, torrent::Object::create_list(), rpc::object_storage::flag_list_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_LIST_U(key ".set", std::bind(&rpc::object_storage::set_list, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); \ - CMD2_ANY_VOID_U(key ".push_back", std::bind(&rpc::object_storage::list_push_back, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - -#define CMD2_VAR_LIST_U_GET(key) \ - control->object_storage()->insert_c_str(key, torrent::Object::create_list(), rpc::object_storage::flag_list_type); \ - CMD2_ANY_U(key, std::bind(&rpc::object_storage::get, control->object_storage(), \ - torrent::raw_string::from_c_str(key))); \ - CMD2_ANY_LIST(key ".set", std::bind(&rpc::object_storage::set_list, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); \ - CMD2_ANY_VOID(key ".push_back", std::bind(&rpc::object_storage::list_push_back, control->object_storage(), \ - torrent::raw_string::from_c_str(key), std::placeholders::_2)); - #define CMD2_FUNC_SINGLE(key, cmds) \ CMD2_ANY(key, std::bind(&rpc::command_function_call_object, torrent::Object(torrent::raw_string::from_c_str(cmds)), \ std::placeholders::_1, std::placeholders::_2)); -#define CMD2_FUNC_SINGLE_U(key, cmds) \ - CMD2_ANY_U(key, std::bind(&rpc::command_function_call_object, torrent::Object(torrent::raw_string::from_c_str(cmds)), \ - std::placeholders::_1, std::placeholders::_2)); - #define CMD2_REDIRECT(from_key, to_key) \ rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_dont_delete); #define CMD2_REDIRECT_NO_EXPORT(from_key, to_key) \ diff --git a/src/command_local.cc b/src/command_local.cc index 7534c250..dc97ed22 100644 --- a/src/command_local.cc +++ b/src/command_local.cc @@ -120,6 +120,15 @@ group_insert(const torrent::Object::list_type& args) { rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.max", "value", (int64_t)300)); rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.upload", "value", (int64_t)20 << 20)); + rpc::rpc.mark_safe("group." + name + ".view"); + rpc::rpc.mark_safe("group." + name + ".view.set"); + rpc::rpc.mark_safe("group." + name + ".ratio.min"); + rpc::rpc.mark_safe("group." + name + ".ratio.min.set"); + rpc::rpc.mark_safe("group." + name + ".ratio.max"); + rpc::rpc.mark_safe("group." + name + ".ratio.max.set"); + rpc::rpc.mark_safe("group." + name + ".ratio.upload"); + rpc::rpc.mark_safe("group." + name + ".ratio.upload.set"); + if (rpc::call_command_value("method.use_intermediate") == 3) { // Cleaned up in 0.16.1: @@ -133,23 +142,6 @@ group_insert(const torrent::Object::list_type& args) { CMD2_REDIRECT_MUTABLE("group2." + name + ".ratio.upload.set", "group." + name + ".ratio.upload.set"); } - // Mark safe group.* commands for untrusted connections. - // group.*.ratio.enable, .disable, and .command are NOT safe - // (they call schedule2/schedule_remove2/execute arbitrary commands). - auto set_safe = [](const std::string& key) { - auto itr = rpc::commands.find(key); - if (itr != rpc::commands.end()) - itr->second.m_flags |= rpc::CommandMap::flag_untrusted_safe; - }; - set_safe("group." + name + ".view"); - set_safe("group." + name + ".view.set"); - set_safe("group." + name + ".ratio.min"); - set_safe("group." + name + ".ratio.min.set"); - set_safe("group." + name + ".ratio.max"); - set_safe("group." + name + ".ratio.max.set"); - set_safe("group." + name + ".ratio.upload"); - set_safe("group." + name + ".ratio.upload.set"); - return name; } @@ -207,101 +199,101 @@ initialize_command_local() { torrent::ChunkManager* chunkManager = torrent::chunk_manager(); torrent::FileManager* fileManager = torrent::file_manager(); - CMD2_ANY_U ("system.hostname", std::bind(&system_hostname)); - CMD2_ANY_U ("system.pid", std::bind(&getpid)); + CMD2_ANY ("system.hostname", std::bind(&system_hostname)); + CMD2_ANY ("system.pid", std::bind(&getpid)); - CMD2_VAR_C_STRING_U("system.api_version", (int64_t)API_VERSION); - CMD2_VAR_C_STRING_U("system.client_version", PACKAGE_VERSION); - CMD2_VAR_C_STRING_U("system.library_version", torrent::version()); + CMD2_VAR_C_STRING("system.api_version", (int64_t)API_VERSION); + CMD2_VAR_C_STRING("system.client_version", PACKAGE_VERSION); + CMD2_VAR_C_STRING("system.library_version", torrent::version()); - CMD2_VAR_VALUE_U_GET("system.file.allocate", 0); - CMD2_VAR_VALUE_U_GET("system.file.max_size", (int64_t)512 << 30); - CMD2_VAR_VALUE_U_GET("system.file.split_size", -1); - CMD2_VAR_STRING_U_GET("system.file.split_suffix", ".part"); + CMD2_VAR_VALUE ("system.file.allocate", 0); + CMD2_VAR_VALUE ("system.file.max_size", (int64_t)512 << 30); + CMD2_VAR_VALUE ("system.file.split_size", -1); + CMD2_VAR_STRING ("system.file.split_suffix", ".part"); - CMD2_ANY_U ("system.file_status_cache.size", std::bind(&utils::FileStatusCache::size, + CMD2_ANY ("system.file_status_cache.size", std::bind(&utils::FileStatusCache::size, (utils::FileStatusCache::base_type*)control->core()->file_status_cache())); - CMD2_ANY_V_U ("system.file_status_cache.prune", std::bind(&utils::FileStatusCache::prune, control->core()->file_status_cache())); + CMD2_ANY_V ("system.file_status_cache.prune", std::bind(&utils::FileStatusCache::prune, control->core()->file_status_cache())); - CMD2_VAR_BOOL_U_GET("file.prioritize_toc", 0); - CMD2_VAR_LIST_U_GET("file.prioritize_toc.first"); - CMD2_VAR_LIST_U_GET("file.prioritize_toc.last"); + CMD2_VAR_BOOL ("file.prioritize_toc", 0); + CMD2_VAR_LIST ("file.prioritize_toc.first"); + CMD2_VAR_LIST ("file.prioritize_toc.last"); - CMD2_ANY_U ("system.files.advise_random", std::bind(&FM_t::advise_random, fileManager)); + CMD2_ANY ("system.files.advise_random", std::bind(&FM_t::advise_random, fileManager)); CMD2_ANY_VALUE_V ("system.files.advise_random.set", std::bind(&FM_t::set_advise_random, fileManager, std::placeholders::_2)); - CMD2_ANY_U ("system.files.advise_random.hashing", std::bind(&FM_t::advise_random_hashing, fileManager)); + CMD2_ANY ("system.files.advise_random.hashing", std::bind(&FM_t::advise_random_hashing, fileManager)); CMD2_ANY_VALUE_V ("system.files.advise_random.hashing.set", std::bind(&FM_t::set_advise_random_hashing, fileManager, std::placeholders::_2)); - CMD2_ANY_U ("system.files.session.fdatasync", [](auto, auto) { return session_thread::manager()->use_fsyncdisk(); }); + CMD2_ANY ("system.files.session.fdatasync", [](auto, auto) { return session_thread::manager()->use_fsyncdisk(); }); CMD2_ANY_VALUE_V ("system.files.session.fdatasync.set", [](auto, auto& value) { return session_thread::manager()->set_use_fsyncdisk(value); }); - CMD2_ANY_U ("system.files.opened_counter", std::bind(&FM_t::files_opened_counter, fileManager)); - CMD2_ANY_U ("system.files.closed_counter", std::bind(&FM_t::files_closed_counter, fileManager)); - CMD2_ANY_U ("system.files.failed_counter", std::bind(&FM_t::files_failed_counter, fileManager)); + CMD2_ANY ("system.files.opened_counter", std::bind(&FM_t::files_opened_counter, fileManager)); + CMD2_ANY ("system.files.closed_counter", std::bind(&FM_t::files_closed_counter, fileManager)); + CMD2_ANY ("system.files.failed_counter", std::bind(&FM_t::files_failed_counter, fileManager)); CMD2_ANY_STRING ("system.env", std::bind(&system_env, std::placeholders::_2)); - CMD2_ANY_U ("system.time", []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object { + CMD2_ANY ("system.time", []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object { return torrent::this_thread::cached_seconds().count(); }); - CMD2_ANY_U ("system.time_seconds", []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object { + CMD2_ANY ("system.time_seconds", []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object { return torrent::utils::cast_seconds(torrent::utils::time_since_epoch()).count(); }); - CMD2_ANY_U ("system.time_usec", []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object { + CMD2_ANY ("system.time_usec", []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object { return torrent::utils::time_since_epoch().count(); }); CMD2_ANY_VALUE_V ("system.umask.set", std::bind(&umask, std::placeholders::_2)); - CMD2_VAR_BOOL_U_GET("system.daemon", false); + CMD2_VAR_BOOL ("system.daemon", false); CMD2_ANY_V ("system.shutdown.normal", std::bind(&Control::receive_normal_shutdown, control)); CMD2_ANY_V ("system.shutdown.quick", std::bind(&Control::receive_quick_shutdown, control)); CMD2_REDIRECT_NO_EXPORT("system.shutdown", "system.shutdown.normal"); - CMD2_ANY_U ("system.cwd", std::bind(&system_get_cwd)); + CMD2_ANY ("system.cwd", std::bind(&system_get_cwd)); CMD2_ANY_STRING ("system.cwd.set", std::bind(&system_set_cwd, std::placeholders::_2)); - CMD2_ANY_U ("pieces.sync.always_safe", std::bind(&CM_t::safe_sync, chunkManager)); + CMD2_ANY ("pieces.sync.always_safe", std::bind(&CM_t::safe_sync, chunkManager)); CMD2_ANY_VALUE_V ("pieces.sync.always_safe.set", std::bind(&CM_t::set_safe_sync, chunkManager, std::placeholders::_2)); - CMD2_ANY_U ("pieces.sync.safe_free_diskspace", std::bind(&CM_t::safe_free_diskspace, chunkManager)); - CMD2_ANY_U ("pieces.sync.timeout", std::bind(&CM_t::timeout_sync, chunkManager)); + CMD2_ANY ("pieces.sync.safe_free_diskspace", std::bind(&CM_t::safe_free_diskspace, chunkManager)); + CMD2_ANY ("pieces.sync.timeout", std::bind(&CM_t::timeout_sync, chunkManager)); CMD2_ANY_VALUE_V ("pieces.sync.timeout.set", std::bind(&CM_t::set_timeout_sync, chunkManager, std::placeholders::_2)); - CMD2_ANY_U ("pieces.sync.timeout_safe", std::bind(&CM_t::timeout_safe_sync, chunkManager)); + CMD2_ANY ("pieces.sync.timeout_safe", std::bind(&CM_t::timeout_safe_sync, chunkManager)); CMD2_ANY_VALUE_V ("pieces.sync.timeout_safe.set", std::bind(&CM_t::set_timeout_safe_sync, chunkManager, std::placeholders::_2)); - CMD2_ANY_U ("pieces.sync.queue_size", std::bind(&CM_t::sync_queue_size, chunkManager)); + CMD2_ANY ("pieces.sync.queue_size", std::bind(&CM_t::sync_queue_size, chunkManager)); - CMD2_ANY_U ("pieces.preload.type", std::bind(&CM_t::preload_type, chunkManager)); + CMD2_ANY ("pieces.preload.type", std::bind(&CM_t::preload_type, chunkManager)); CMD2_ANY_VALUE_V ("pieces.preload.type.set", std::bind(&CM_t::set_preload_type, chunkManager, std::placeholders::_2)); - CMD2_ANY_U ("pieces.preload.min_size", std::bind(&CM_t::preload_min_size, chunkManager)); + CMD2_ANY ("pieces.preload.min_size", std::bind(&CM_t::preload_min_size, chunkManager)); CMD2_ANY_VALUE_V ("pieces.preload.min_size.set", std::bind(&CM_t::set_preload_min_size, chunkManager, std::placeholders::_2)); - CMD2_ANY_U ("pieces.preload.min_rate", std::bind(&CM_t::preload_required_rate, chunkManager)); + CMD2_ANY ("pieces.preload.min_rate", std::bind(&CM_t::preload_required_rate, chunkManager)); CMD2_ANY_VALUE_V ("pieces.preload.min_rate.set", std::bind(&CM_t::set_preload_required_rate, chunkManager, std::placeholders::_2)); - CMD2_ANY_U ("pieces.memory.current", std::bind(&CM_t::memory_usage, chunkManager)); - CMD2_ANY_U ("pieces.memory.sync_queue", std::bind(&CM_t::sync_queue_memory_usage, chunkManager)); - CMD2_ANY_U ("pieces.memory.block_count", std::bind(&CM_t::memory_block_count, chunkManager)); - CMD2_ANY_U ("pieces.memory.max", std::bind(&CM_t::max_memory_usage, chunkManager)); + CMD2_ANY ("pieces.memory.current", std::bind(&CM_t::memory_usage, chunkManager)); + CMD2_ANY ("pieces.memory.sync_queue", std::bind(&CM_t::sync_queue_memory_usage, chunkManager)); + CMD2_ANY ("pieces.memory.block_count", std::bind(&CM_t::memory_block_count, chunkManager)); + CMD2_ANY ("pieces.memory.max", std::bind(&CM_t::max_memory_usage, chunkManager)); CMD2_ANY_VALUE_V ("pieces.memory.max.set", std::bind(&CM_t::set_max_memory_usage, chunkManager, std::placeholders::_2)); - CMD2_ANY_U ("pieces.stats_preloaded", std::bind(&CM_t::stats_preloaded, chunkManager)); - CMD2_ANY_U ("pieces.stats_not_preloaded", std::bind(&CM_t::stats_not_preloaded, chunkManager)); + CMD2_ANY ("pieces.stats_preloaded", std::bind(&CM_t::stats_preloaded, chunkManager)); + CMD2_ANY ("pieces.stats_not_preloaded", std::bind(&CM_t::stats_not_preloaded, chunkManager)); - CMD2_ANY_U ("pieces.stats.total_size", std::bind(&apply_pieces_stats_total_size)); + CMD2_ANY ("pieces.stats.total_size", std::bind(&apply_pieces_stats_total_size)); - CMD2_ANY_U ("pieces.hash.queue_size", std::bind(&torrent::main_thread::hash_queue_size)); - CMD2_VAR_BOOL_U_GET("pieces.hash.on_completion", true); + CMD2_ANY ("pieces.hash.queue_size", std::bind(&torrent::main_thread::hash_queue_size)); + CMD2_VAR_BOOL ("pieces.hash.on_completion", true); - CMD2_VAR_STRING_U_GET("directory.default", "./"); + CMD2_VAR_STRING ("directory.default", "./"); - CMD2_VAR_STRING_U_GET("session.name", ""); - CMD2_ANY_U ("session.path", [](auto, auto) { return session_thread::manager()->path(); }); + CMD2_VAR_STRING ("session.name", ""); + CMD2_ANY ("session.path", [](auto, auto) { return session_thread::manager()->path(); }); CMD2_ANY_STRING_V("session.path.set", [](auto, auto& str) { return session_thread::manager()->set_path(str); }); - CMD2_ANY_U ("session.use_lock", [](auto, auto) { return session_thread::manager()->use_lock(); }); + CMD2_ANY ("session.use_lock", [](auto, auto) { return session_thread::manager()->use_lock(); }); CMD2_ANY_VALUE_V ("session.use_lock.set", [](auto, auto& value) { return session_thread::manager()->set_use_lock(value); }); - CMD2_VAR_BOOL_U_GET("session.on_completion", true); + CMD2_VAR_BOOL ("session.on_completion", true); CMD2_ANY_V ("session.save", [dList](auto, auto) { return dList->session_save(); }); - CMD2_ANY_U ("magnet.path", [](auto, auto) { return control->core()->magnet_path(); }); + CMD2_ANY ("magnet.path", [](auto, auto) { return control->core()->magnet_path(); }); CMD2_ANY_STRING_V("magnet.path.set", [](auto, auto& str) { return control->core()->set_magnet_path(str); }); #ifdef HAVE_LUA @@ -340,4 +332,8 @@ initialize_command_local() { CMD2_ANY_P("argument.3", std::bind(&rpc::command_base::argument_ref, 3)); CMD2_ANY_LIST ("group.insert", std::bind(&group_insert, std::placeholders::_2)); + + rpc::rpc.mark_safe("system.api_version"); + rpc::rpc.mark_safe("system.client_version"); + rpc::rpc.mark_safe("system.library_version"); } diff --git a/src/command_network.cc b/src/command_network.cc index 6d19e987..a42e181e 100644 --- a/src/command_network.cc +++ b/src/command_network.cc @@ -170,12 +170,12 @@ initialize_command_network() { CMD2_ANY_STRING ("encoding.add", std::bind(&apply_encoding_list, std::placeholders::_2)); // Isn't port_open used? - CMD2_VAR_BOOL_U_GET ("network.port_open", true); - CMD2_VAR_BOOL_U_GET ("network.port_random", true); - CMD2_VAR_STRING_U_GET ("network.port_range", "6881-6999"); + CMD2_VAR_BOOL ("network.port_open", true); + CMD2_VAR_BOOL ("network.port_random", true); + CMD2_VAR_STRING ("network.port_range", "6881-6999"); - CMD2_ANY_U ("network.listen.port", [](auto, auto) { return torrent::runtime::listen_port(); }); - CMD2_ANY_U ("network.listen.backlog", [nw_config](auto, auto) { return nw_config->listen_backlog(); }); + CMD2_ANY ("network.listen.port", [](auto, auto) { return torrent::runtime::listen_port(); }); + CMD2_ANY ("network.listen.backlog", [nw_config](auto, auto) { return nw_config->listen_backlog(); }); CMD2_ANY_VALUE_V ("network.listen.backlog.set", [nw_config](auto, auto& value) { return nw_config->set_listen_backlog(value); }); CMD2_VAR_BOOL ("protocol.pex", true); @@ -195,12 +195,12 @@ initialize_command_network() { CMD2_ANY_STRING_V("network.http.capath.set", [http_stack](auto, auto& str) { return http_stack->set_http_capath(str); }); CMD2_ANY ("network.http.dns_cache_timeout", [http_stack](auto, auto) { return http_stack->dns_timeout(); }); CMD2_ANY_VALUE_V ("network.http.dns_cache_timeout.set", [http_stack](auto, auto& value) { return http_stack->set_dns_timeout(value); }); - CMD2_ANY_U ("network.http.current_open", [http_stack](auto, auto) { return http_stack->size(); }); - CMD2_ANY_U ("network.http.max_cache_connections", [http_stack](auto, auto) { return http_stack->max_cache_connections(); }); + CMD2_ANY ("network.http.current_open", [http_stack](auto, auto) { return http_stack->size(); }); + CMD2_ANY ("network.http.max_cache_connections", [http_stack](auto, auto) { return http_stack->max_cache_connections(); }); CMD2_ANY_VALUE_V ("network.http.max_cache_connections.set", [http_stack](auto, auto& value) { return http_stack->set_max_cache_connections(value); }); - CMD2_ANY_U ("network.http.max_host_connections", [http_stack](auto, auto) { return http_stack->max_host_connections(); }); + CMD2_ANY ("network.http.max_host_connections", [http_stack](auto, auto) { return http_stack->max_host_connections(); }); CMD2_ANY_VALUE_V ("network.http.max_host_connections.set", [http_stack](auto, auto& value) { return http_stack->set_max_host_connections(value); }); - CMD2_ANY_U ("network.http.max_total_connections", [http_stack](auto, auto) { return http_stack->max_total_connections(); }); + CMD2_ANY ("network.http.max_total_connections", [http_stack](auto, auto) { return http_stack->max_total_connections(); }); CMD2_ANY_VALUE_V ("network.http.max_total_connections.set", [http_stack](auto, auto& value) { return http_stack->set_max_total_connections(value); }); CMD2_ANY ("network.http.proxy_address", [http_stack](auto, auto) { return http_stack->http_proxy(); }); CMD2_ANY_STRING_V("network.http.proxy_address.set", [http_stack](auto, auto& str) { return http_stack->set_http_proxy(str); }); @@ -209,20 +209,20 @@ initialize_command_network() { CMD2_ANY ("network.http.ssl_verify_peer", [http_stack](auto, auto) { return http_stack->ssl_verify_peer(); }); CMD2_ANY_VALUE_V ("network.http.ssl_verify_peer.set", [http_stack](auto, auto& value) { return http_stack->set_ssl_verify_peer(value); }); - CMD2_ANY_U ("network.send_buffer.size", [nw_config](auto, auto) { return nw_config->send_buffer_size(); }); + CMD2_ANY ("network.send_buffer.size", [nw_config](auto, auto) { return nw_config->send_buffer_size(); }); CMD2_ANY_VALUE_V ("network.send_buffer.size.set", [nw_config](auto, auto& value) { return nw_config->set_send_buffer_size(value); }); - CMD2_ANY_U ("network.receive_buffer.size", [nw_config](auto, auto) { return nw_config->receive_buffer_size(); }); + CMD2_ANY ("network.receive_buffer.size", [nw_config](auto, auto) { return nw_config->receive_buffer_size(); }); CMD2_ANY_VALUE_V ("network.receive_buffer.size.set", [nw_config](auto, auto& value) { return nw_config->set_receive_buffer_size(value); }); CMD2_ANY_STRING ("network.tos.set", [](auto, auto& str) { return apply_tos(str); }); - CMD2_ANY_U ("network.bind_address", [nw_config](auto, auto) { return nw_config->bind_address_best_match_str(); }); + CMD2_ANY ("network.bind_address", [nw_config](auto, auto) { return nw_config->bind_address_best_match_str(); }); CMD2_ANY_STRING_V("network.bind_address.set", [nw_config](auto, auto& str) { return nw_config->set_bind_address_str(str); }); CMD2_ANY ("network.bind_address.ipv4", [nw_config](auto, auto) { return nw_config->bind_inet_address_str(); }); CMD2_ANY_STRING_V("network.bind_address.ipv4.set", [nw_config](auto, auto& str) { return nw_config->set_bind_inet_address_str(str); }); CMD2_ANY ("network.bind_address.ipv6", [nw_config](auto, auto) { return nw_config->bind_inet6_address_str(); }); CMD2_ANY_STRING_V("network.bind_address.ipv6.set", [nw_config](auto, auto& str) { return nw_config->set_bind_inet6_address_str(str); }); - CMD2_ANY_U ("network.local_address", [nw_config](auto, auto) { return nw_config->local_address_best_match_str(); }); + CMD2_ANY ("network.local_address", [nw_config](auto, auto) { return nw_config->local_address_best_match_str(); }); CMD2_ANY_STRING_V("network.local_address.set", [nw_config](auto, auto& str) { return nw_config->set_local_address_str(str); }); CMD2_ANY ("network.local_address.ipv4", [nw_config](auto, auto) { return nw_config->local_inet_address_str(); }); CMD2_ANY_STRING_V("network.local_address.ipv4.set", [nw_config](auto, auto& str) { return nw_config->set_local_inet_address_str(str); }); @@ -232,12 +232,12 @@ initialize_command_network() { CMD2_ANY ("network.proxy_address", [nw_config](auto, auto) { return nw_config->proxy_address_str(); }); CMD2_ANY_STRING_V("network.proxy_address.set", [](auto, auto& str) { return control->core()->set_proxy_address(str); }); - CMD2_ANY_U ("network.open_files", [file_manager](auto, auto) { return file_manager->open_files(); }); - CMD2_ANY_U ("network.max_open_files", [file_manager](auto, auto) { return file_manager->max_open_files(); }); + CMD2_ANY ("network.open_files", [file_manager](auto, auto) { return file_manager->open_files(); }); + CMD2_ANY ("network.max_open_files", [file_manager](auto, auto) { return file_manager->max_open_files(); }); CMD2_ANY_VALUE_V ("network.max_open_files.set", [file_manager](auto, auto& value) { return file_manager->set_max_open_files(value); }); - CMD2_ANY_U ("network.total_handshakes", [](auto, auto) { return torrent::total_handshakes(); }); + CMD2_ANY ("network.total_handshakes", [](auto, auto) { return torrent::total_handshakes(); }); CMD2_ANY ("network.open_sockets", [cm](auto, auto) { return cm->size(); }); - CMD2_ANY_U ("network.max_open_sockets", [cm](auto, auto) { return cm->max_size(); }); + CMD2_ANY ("network.max_open_sockets", [cm](auto, auto) { return cm->max_size(); }); CMD2_ANY_VALUE_V ("network.max_open_sockets.set", [cm](auto, auto& value) { return cm->set_max_size(value); }); CMD2_ANY_STRING ("network.scgi.open_port", std::bind(&apply_scgi, std::placeholders::_2, 1)); @@ -245,11 +245,11 @@ initialize_command_network() { CMD2_VAR_BOOL ("network.scgi.dont_route", false); CMD2_ANY_STRING ("network.xmlrpc.dialect.set", [](const auto&, const auto& arg) { return apply_xmlrpc_dialect(arg); }) - CMD2_ANY_U ("network.xmlrpc.size_limit", [](const auto&, const auto&) { return rpc::rpc.size_limit(); }); - CMD2_ANY_VALUE_V_U ("network.xmlrpc.size_limit.set", [](const auto&, const auto& arg) { return rpc::rpc.set_size_limit(arg); }); + CMD2_ANY ("network.xmlrpc.size_limit", [](const auto&, const auto&) { return rpc::rpc.size_limit(); }); + CMD2_ANY_VALUE_V ("network.xmlrpc.size_limit.set", [](const auto&, const auto& arg) { return rpc::rpc.set_size_limit(arg); }); - CMD2_VAR_BOOL_U_GET("network.rpc.use_xmlrpc", true); - CMD2_VAR_BOOL_U_GET("network.rpc.use_jsonrpc", true); + CMD2_VAR_BOOL ("network.rpc.use_xmlrpc", true); + CMD2_VAR_BOOL ("network.rpc.use_jsonrpc", true); CMD2_ANY ("network.block.ipv4", [nw_config](auto, auto) { return nw_config->is_block_ipv4(); }); CMD2_ANY_VALUE_V ("network.block.ipv4.set", [nw_config](auto, auto& value) { return nw_config->set_block_ipv4(value); }); @@ -261,4 +261,29 @@ initialize_command_network() { CMD2_ANY_VALUE_V ("network.block.outgoing.set", [nw_config](auto, auto& value) { return nw_config->set_block_outgoing(value); }); CMD2_ANY ("network.prefer.ipv6", [nw_config](auto, auto) { return nw_config->is_prefer_ipv6(); }); CMD2_ANY_VALUE_V ("network.prefer.ipv6.set", [nw_config](auto, auto& value) { return nw_config->set_prefer_ipv6(value); }); + + rpc::rpc.mark_safe("network.port_open"); + rpc::rpc.mark_safe("network.port_random"); + rpc::rpc.mark_safe("network.port_range"); + rpc::rpc.mark_safe("network.listen.port"); + rpc::rpc.mark_safe("network.listen.backlog"); + + rpc::rpc.mark_safe("network.http.current_open"); + rpc::rpc.mark_safe("network.http.max_cache_connections"); + rpc::rpc.mark_safe("network.http.max_host_connections"); + rpc::rpc.mark_safe("network.http.max_total_connections"); + + rpc::rpc.mark_safe("network.open_files"); + rpc::rpc.mark_safe("network.max_open_files"); + rpc::rpc.mark_safe("network.max_open_sockets"); + rpc::rpc.mark_safe("network.total_handshakes"); + + rpc::rpc.mark_safe("network.send_buffer.size"); + rpc::rpc.mark_safe("network.receive_buffer.size"); + rpc::rpc.mark_safe("network.bind_address"); + rpc::rpc.mark_safe("network.local_address"); + rpc::rpc.mark_safe("network.xmlrpc.size_limit"); + + rpc::rpc.mark_safe("network.rpc.use_xmlrpc"); + rpc::rpc.mark_safe("network.rpc.use_jsonrpc"); } diff --git a/src/command_peer.cc b/src/command_peer.cc index bc8054fc..ecd516b4 100644 --- a/src/command_peer.cc +++ b/src/command_peer.cc @@ -67,37 +67,63 @@ retrieve_p_completed_percent(torrent::Peer* peer) { void initialize_command_peer() { - CMD2_PEER_U("p.id", std::bind(&retrieve_p_id, std::placeholders::_1)); - CMD2_PEER_U("p.id_html", std::bind(&retrieve_p_id_html, std::placeholders::_1)); - CMD2_PEER_U("p.client_version", std::bind(&retrieve_p_client_version, std::placeholders::_1)); + CMD2_PEER("p.id", std::bind(&retrieve_p_id, std::placeholders::_1)); + CMD2_PEER("p.id_html", std::bind(&retrieve_p_id_html, std::placeholders::_1)); + CMD2_PEER("p.client_version", std::bind(&retrieve_p_client_version, std::placeholders::_1)); - CMD2_PEER_U("p.options_str", std::bind(&retrieve_p_options_str, std::placeholders::_1)); + CMD2_PEER("p.options_str", std::bind(&retrieve_p_options_str, std::placeholders::_1)); - CMD2_PEER_U("p.is_encrypted", std::bind(&torrent::Peer::is_encrypted, std::placeholders::_1)); - CMD2_PEER_U("p.is_incoming", std::bind(&torrent::Peer::is_incoming, std::placeholders::_1)); - CMD2_PEER_U("p.is_obfuscated", std::bind(&torrent::Peer::is_obfuscated, std::placeholders::_1)); - CMD2_PEER_U("p.is_snubbed", std::bind(&torrent::Peer::is_snubbed, std::placeholders::_1)); + CMD2_PEER("p.is_encrypted", std::bind(&torrent::Peer::is_encrypted, std::placeholders::_1)); + CMD2_PEER("p.is_incoming", std::bind(&torrent::Peer::is_incoming, std::placeholders::_1)); + CMD2_PEER("p.is_obfuscated", std::bind(&torrent::Peer::is_obfuscated, std::placeholders::_1)); + CMD2_PEER("p.is_snubbed", std::bind(&torrent::Peer::is_snubbed, std::placeholders::_1)); - CMD2_PEER_U("p.is_unwanted", std::bind(&torrent::PeerInfo::is_unwanted, std::bind(&torrent::Peer::peer_info, std::placeholders::_1))); - CMD2_PEER_U("p.is_preferred", std::bind(&torrent::PeerInfo::is_preferred, std::bind(&torrent::Peer::peer_info, std::placeholders::_1))); + CMD2_PEER("p.is_unwanted", std::bind(&torrent::PeerInfo::is_unwanted, std::bind(&torrent::Peer::peer_info, std::placeholders::_1))); + CMD2_PEER("p.is_preferred", std::bind(&torrent::PeerInfo::is_preferred, std::bind(&torrent::Peer::peer_info, std::placeholders::_1))); - CMD2_PEER_U("p.address", std::bind(&retrieve_p_address, std::placeholders::_1)); - CMD2_PEER_U("p.port", std::bind(&retrieve_p_port, std::placeholders::_1)); + CMD2_PEER("p.address", std::bind(&retrieve_p_address, std::placeholders::_1)); + CMD2_PEER("p.port", std::bind(&retrieve_p_port, std::placeholders::_1)); - CMD2_PEER_U("p.completed_percent", std::bind(&retrieve_p_completed_percent, std::placeholders::_1)); + CMD2_PEER("p.completed_percent", std::bind(&retrieve_p_completed_percent, std::placeholders::_1)); - CMD2_PEER_U("p.up_rate", std::bind(&torrent::Rate::rate, std::bind(&torrent::Peer::up_rate, std::placeholders::_1))); - CMD2_PEER_U("p.up_total", std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::up_rate, std::placeholders::_1))); - CMD2_PEER_U("p.down_rate", std::bind(&torrent::Rate::rate, std::bind(&torrent::Peer::down_rate, std::placeholders::_1))); - CMD2_PEER_U("p.down_total", std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::down_rate, std::placeholders::_1))); - CMD2_PEER_U("p.peer_rate", std::bind(&torrent::Rate::rate, std::bind(&torrent::Peer::peer_rate, std::placeholders::_1))); - CMD2_PEER_U("p.peer_total", std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::peer_rate, std::placeholders::_1))); + CMD2_PEER("p.up_rate", std::bind(&torrent::Rate::rate, std::bind(&torrent::Peer::up_rate, std::placeholders::_1))); + CMD2_PEER("p.up_total", std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::up_rate, std::placeholders::_1))); + CMD2_PEER("p.down_rate", std::bind(&torrent::Rate::rate, std::bind(&torrent::Peer::down_rate, std::placeholders::_1))); + CMD2_PEER("p.down_total", std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::down_rate, std::placeholders::_1))); + CMD2_PEER("p.peer_rate", std::bind(&torrent::Rate::rate, std::bind(&torrent::Peer::peer_rate, std::placeholders::_1))); + CMD2_PEER("p.peer_total", std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::peer_rate, std::placeholders::_1))); - CMD2_PEER_U ("p.snubbed", std::bind(&torrent::Peer::is_snubbed, std::placeholders::_1)); - CMD2_PEER_VALUE_V_U("p.snubbed.set", std::bind(&torrent::Peer::set_snubbed, std::placeholders::_1, std::placeholders::_2)); - CMD2_PEER_U ("p.banned", std::bind(&torrent::Peer::is_banned, std::placeholders::_1)); - CMD2_PEER_VALUE_V_U("p.banned.set", std::bind(&torrent::Peer::set_banned, std::placeholders::_1, std::placeholders::_2)); + CMD2_PEER ("p.snubbed", std::bind(&torrent::Peer::is_snubbed, std::placeholders::_1)); + CMD2_PEER_VALUE_V("p.snubbed.set", std::bind(&torrent::Peer::set_snubbed, std::placeholders::_1, std::placeholders::_2)); + CMD2_PEER ("p.banned", std::bind(&torrent::Peer::is_banned, std::placeholders::_1)); + CMD2_PEER_VALUE_V("p.banned.set", std::bind(&torrent::Peer::set_banned, std::placeholders::_1, std::placeholders::_2)); - CMD2_PEER_V_U("p.disconnect", std::bind(&torrent::Peer::disconnect, std::placeholders::_1, 0)); - CMD2_PEER_V_U("p.disconnect_delayed", std::bind(&torrent::Peer::disconnect, std::placeholders::_1, torrent::ConnectionList::disconnect_delayed)); + CMD2_PEER_V("p.disconnect", std::bind(&torrent::Peer::disconnect, std::placeholders::_1, 0)); + CMD2_PEER_V("p.disconnect_delayed", std::bind(&torrent::Peer::disconnect, std::placeholders::_1, torrent::ConnectionList::disconnect_delayed)); + + rpc::rpc.mark_safe("p.address"); + rpc::rpc.mark_safe("p.port"); + rpc::rpc.mark_safe("p.client_version"); + rpc::rpc.mark_safe("p.options_str"); + rpc::rpc.mark_safe("p.id"); + rpc::rpc.mark_safe("p.id_html"); + rpc::rpc.mark_safe("p.up_rate"); + rpc::rpc.mark_safe("p.up_total"); + rpc::rpc.mark_safe("p.down_rate"); + rpc::rpc.mark_safe("p.down_total"); + rpc::rpc.mark_safe("p.peer_rate"); + rpc::rpc.mark_safe("p.peer_total"); + rpc::rpc.mark_safe("p.is_encrypted"); + rpc::rpc.mark_safe("p.is_incoming"); + rpc::rpc.mark_safe("p.is_obfuscated"); + rpc::rpc.mark_safe("p.is_snubbed"); + rpc::rpc.mark_safe("p.is_unwanted"); + rpc::rpc.mark_safe("p.is_preferred"); + rpc::rpc.mark_safe("p.snubbed"); + rpc::rpc.mark_safe("p.snubbed.set"); + rpc::rpc.mark_safe("p.banned"); + rpc::rpc.mark_safe("p.banned.set"); + rpc::rpc.mark_safe("p.completed_percent"); + rpc::rpc.mark_safe("p.disconnect"); + rpc::rpc.mark_safe("p.disconnect_delayed"); } diff --git a/src/command_throttle.cc b/src/command_throttle.cc index 10e1cacd..058862b1 100644 --- a/src/command_throttle.cc +++ b/src/command_throttle.cc @@ -147,47 +147,47 @@ throttle_update(const char* variable, int64_t value) { void initialize_command_throttle() { - CMD2_ANY_U ("throttle.unchoked_uploads", std::bind(&torrent::ResourceManager::currently_upload_unchoked, torrent::resource_manager())); - CMD2_ANY_U ("throttle.max_unchoked_uploads", std::bind(&torrent::ResourceManager::max_upload_unchoked, torrent::resource_manager())); - CMD2_ANY_U ("throttle.unchoked_downloads", std::bind(&torrent::ResourceManager::currently_download_unchoked, torrent::resource_manager())); - CMD2_ANY_U ("throttle.max_unchoked_downloads", std::bind(&torrent::ResourceManager::max_download_unchoked, torrent::resource_manager())); + CMD2_ANY ("throttle.unchoked_uploads", std::bind(&torrent::ResourceManager::currently_upload_unchoked, torrent::resource_manager())); + CMD2_ANY ("throttle.max_unchoked_uploads", std::bind(&torrent::ResourceManager::max_upload_unchoked, torrent::resource_manager())); + CMD2_ANY ("throttle.unchoked_downloads", std::bind(&torrent::ResourceManager::currently_download_unchoked, torrent::resource_manager())); + CMD2_ANY ("throttle.max_unchoked_downloads", std::bind(&torrent::ResourceManager::max_download_unchoked, torrent::resource_manager())); - CMD2_VAR_VALUE_U ("throttle.min_peers.normal", 100); - CMD2_VAR_VALUE_U ("throttle.max_peers.normal", 200); - CMD2_VAR_VALUE_U ("throttle.min_peers.seed", -1); - CMD2_VAR_VALUE_U ("throttle.max_peers.seed", -1); + CMD2_VAR_VALUE ("throttle.min_peers.normal", 100); + CMD2_VAR_VALUE ("throttle.max_peers.normal", 200); + CMD2_VAR_VALUE ("throttle.min_peers.seed", -1); + CMD2_VAR_VALUE ("throttle.max_peers.seed", -1); - CMD2_VAR_VALUE_U ("throttle.min_uploads", 0); - CMD2_VAR_VALUE_U ("throttle.max_uploads", 50); - CMD2_VAR_VALUE_U ("throttle.min_downloads", 0); - CMD2_VAR_VALUE_U ("throttle.max_downloads", 50); + CMD2_VAR_VALUE ("throttle.min_uploads", 0); + CMD2_VAR_VALUE ("throttle.max_uploads", 50); + CMD2_VAR_VALUE ("throttle.min_downloads", 0); + CMD2_VAR_VALUE ("throttle.max_downloads", 50); - CMD2_VAR_VALUE_U ("throttle.max_uploads.div._val", 1); - CMD2_VAR_VALUE_U ("throttle.max_uploads.global._val", 0); - CMD2_VAR_VALUE_U ("throttle.max_downloads.div._val", 1); - CMD2_VAR_VALUE_U ("throttle.max_downloads.global._val", 0); + CMD2_VAR_VALUE ("throttle.max_uploads.div._val", 1); + CMD2_VAR_VALUE ("throttle.max_uploads.global._val", 0); + CMD2_VAR_VALUE ("throttle.max_downloads.div._val", 1); + CMD2_VAR_VALUE ("throttle.max_downloads.global._val", 0); CMD2_REDIRECT ("throttle.max_uploads.div", "throttle.max_uploads.div._val"); CMD2_REDIRECT ("throttle.max_uploads.global", "throttle.max_uploads.global._val"); CMD2_REDIRECT ("throttle.max_downloads.div", "throttle.max_downloads.div._val"); CMD2_REDIRECT ("throttle.max_downloads.global", "throttle.max_downloads.global._val"); - CMD2_ANY_VALUE_U ("throttle.max_uploads.div.set", std::bind(&throttle_update, "throttle.max_uploads.div._val.set", std::placeholders::_2)); - CMD2_ANY_VALUE_U ("throttle.max_uploads.global.set", std::bind(&throttle_update, "throttle.max_uploads.global._val.set", std::placeholders::_2)); - CMD2_ANY_VALUE_U ("throttle.max_downloads.div.set", std::bind(&throttle_update, "throttle.max_downloads.div._val.set", std::placeholders::_2)); - CMD2_ANY_VALUE_U ("throttle.max_downloads.global.set", std::bind(&throttle_update, "throttle.max_downloads.global._val.set", std::placeholders::_2)); + CMD2_ANY_VALUE ("throttle.max_uploads.div.set", std::bind(&throttle_update, "throttle.max_uploads.div._val.set", std::placeholders::_2)); + CMD2_ANY_VALUE ("throttle.max_uploads.global.set", std::bind(&throttle_update, "throttle.max_uploads.global._val.set", std::placeholders::_2)); + CMD2_ANY_VALUE ("throttle.max_downloads.div.set", std::bind(&throttle_update, "throttle.max_downloads.div._val.set", std::placeholders::_2)); + CMD2_ANY_VALUE ("throttle.max_downloads.global.set", std::bind(&throttle_update, "throttle.max_downloads.global._val.set", std::placeholders::_2)); // TODO: Move the logic into some libtorrent function. - CMD2_ANY_U ("throttle.global_up.rate", std::bind(&torrent::Rate::rate, torrent::up_rate())); - CMD2_ANY_U ("throttle.global_up.total", std::bind(&torrent::Rate::total, torrent::up_rate())); - CMD2_ANY_U ("throttle.global_up.max_rate", std::bind(&torrent::Throttle::max_rate, torrent::up_throttle_global())); - CMD2_ANY_VALUE_V_U ("throttle.global_up.max_rate.set", std::bind(&ui::Root::set_up_throttle_i64, control->ui(), std::placeholders::_2)); - CMD2_ANY_VALUE_KB_U("throttle.global_up.max_rate.set_kb", std::bind(&ui::Root::set_up_throttle_i64, control->ui(), std::placeholders::_2)); - CMD2_ANY_U ("throttle.global_down.rate", std::bind(&torrent::Rate::rate, torrent::down_rate())); - CMD2_ANY_U ("throttle.global_down.total", std::bind(&torrent::Rate::total, torrent::down_rate())); - CMD2_ANY_U ("throttle.global_down.max_rate", std::bind(&torrent::Throttle::max_rate, torrent::down_throttle_global())); - CMD2_ANY_VALUE_V_U ("throttle.global_down.max_rate.set", std::bind(&ui::Root::set_down_throttle_i64, control->ui(), std::placeholders::_2)); - CMD2_ANY_VALUE_KB_U("throttle.global_down.max_rate.set_kb", std::bind(&ui::Root::set_down_throttle_i64, control->ui(), std::placeholders::_2)); + CMD2_ANY ("throttle.global_up.rate", std::bind(&torrent::Rate::rate, torrent::up_rate())); + CMD2_ANY ("throttle.global_up.total", std::bind(&torrent::Rate::total, torrent::up_rate())); + CMD2_ANY ("throttle.global_up.max_rate", std::bind(&torrent::Throttle::max_rate, torrent::up_throttle_global())); + CMD2_ANY_VALUE_V ("throttle.global_up.max_rate.set", std::bind(&ui::Root::set_up_throttle_i64, control->ui(), std::placeholders::_2)); + CMD2_ANY_VALUE_KB("throttle.global_up.max_rate.set_kb", std::bind(&ui::Root::set_up_throttle_i64, control->ui(), std::placeholders::_2)); + CMD2_ANY ("throttle.global_down.rate", std::bind(&torrent::Rate::rate, torrent::down_rate())); + CMD2_ANY ("throttle.global_down.total", std::bind(&torrent::Rate::total, torrent::down_rate())); + CMD2_ANY ("throttle.global_down.max_rate", std::bind(&torrent::Throttle::max_rate, torrent::down_throttle_global())); + CMD2_ANY_VALUE_V ("throttle.global_down.max_rate.set", std::bind(&ui::Root::set_down_throttle_i64, control->ui(), std::placeholders::_2)); + CMD2_ANY_VALUE_KB("throttle.global_down.max_rate.set_kb", std::bind(&ui::Root::set_down_throttle_i64, control->ui(), std::placeholders::_2)); // Temporary names, need to change this to accept real rates rather // than kB. @@ -195,8 +195,64 @@ initialize_command_throttle() { CMD2_ANY_LIST ("throttle.down", std::bind(&apply_throttle, std::placeholders::_2, false)); CMD2_ANY_LIST ("throttle.ip", std::bind(&apply_address_throttle, std::placeholders::_2)); - CMD2_ANY_STRING_U ("throttle.up.max", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_max)); - CMD2_ANY_STRING_U ("throttle.up.rate", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_rate)); - CMD2_ANY_STRING_U ("throttle.down.max", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_max)); - CMD2_ANY_STRING_U ("throttle.down.rate", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_rate)); + CMD2_ANY_STRING ("throttle.up.max", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_max)); + CMD2_ANY_STRING ("throttle.up.rate", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_rate)); + CMD2_ANY_STRING ("throttle.down.max", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_max)); + CMD2_ANY_STRING ("throttle.down.rate", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_rate)); + + rpc::rpc.mark_safe("throttle.unchoked_uploads"); + rpc::rpc.mark_safe("throttle.max_unchoked_uploads"); + rpc::rpc.mark_safe("throttle.unchoked_downloads"); + rpc::rpc.mark_safe("throttle.max_unchoked_downloads"); + + rpc::rpc.mark_safe("throttle.min_peers.normal"); + rpc::rpc.mark_safe("throttle.min_peers.normal.set"); + rpc::rpc.mark_safe("throttle.max_peers.normal"); + rpc::rpc.mark_safe("throttle.max_peers.normal.set"); + rpc::rpc.mark_safe("throttle.min_peers.seed"); + rpc::rpc.mark_safe("throttle.min_peers.seed.set"); + rpc::rpc.mark_safe("throttle.max_peers.seed"); + rpc::rpc.mark_safe("throttle.max_peers.seed.set"); + + rpc::rpc.mark_safe("throttle.min_uploads"); + rpc::rpc.mark_safe("throttle.min_uploads.set"); + rpc::rpc.mark_safe("throttle.max_uploads"); + rpc::rpc.mark_safe("throttle.max_uploads.set"); + rpc::rpc.mark_safe("throttle.min_downloads"); + rpc::rpc.mark_safe("throttle.min_downloads.set"); + rpc::rpc.mark_safe("throttle.max_downloads"); + rpc::rpc.mark_safe("throttle.max_downloads.set"); + + rpc::rpc.mark_safe("throttle.max_uploads.div"); + rpc::rpc.mark_safe("throttle.max_uploads.div.set"); + rpc::rpc.mark_safe("throttle.max_uploads.div._val"); + rpc::rpc.mark_safe("throttle.max_uploads.div._val.set"); + rpc::rpc.mark_safe("throttle.max_uploads.global"); + rpc::rpc.mark_safe("throttle.max_uploads.global.set"); + rpc::rpc.mark_safe("throttle.max_uploads.global._val"); + rpc::rpc.mark_safe("throttle.max_uploads.global._val.set"); + rpc::rpc.mark_safe("throttle.max_downloads.div"); + rpc::rpc.mark_safe("throttle.max_downloads.div.set"); + rpc::rpc.mark_safe("throttle.max_downloads.div._val"); + rpc::rpc.mark_safe("throttle.max_downloads.div._val.set"); + rpc::rpc.mark_safe("throttle.max_downloads.global"); + rpc::rpc.mark_safe("throttle.max_downloads.global.set"); + rpc::rpc.mark_safe("throttle.max_downloads.global._val"); + rpc::rpc.mark_safe("throttle.max_downloads.global._val.set"); + + rpc::rpc.mark_safe("throttle.global_up.rate"); + rpc::rpc.mark_safe("throttle.global_up.total"); + rpc::rpc.mark_safe("throttle.global_up.max_rate"); + rpc::rpc.mark_safe("throttle.global_up.max_rate.set"); + rpc::rpc.mark_safe("throttle.global_up.max_rate.set_kb"); + rpc::rpc.mark_safe("throttle.global_down.rate"); + rpc::rpc.mark_safe("throttle.global_down.total"); + rpc::rpc.mark_safe("throttle.global_down.max_rate"); + rpc::rpc.mark_safe("throttle.global_down.max_rate.set"); + rpc::rpc.mark_safe("throttle.global_down.max_rate.set_kb"); + + rpc::rpc.mark_safe("throttle.up.max"); + rpc::rpc.mark_safe("throttle.up.rate"); + rpc::rpc.mark_safe("throttle.down.max"); + rpc::rpc.mark_safe("throttle.down.rate"); } diff --git a/src/command_tracker.cc b/src/command_tracker.cc index 2bca366b..4f73b505 100644 --- a/src/command_tracker.cc +++ b/src/command_tracker.cc @@ -88,12 +88,12 @@ apply_enable_trackers(int64_t arg) { void initialize_command_tracker() { - CMD2_TRACKER_U ("t.is_busy", std::bind(&torrent::tracker::Tracker::is_busy, std::placeholders::_1)); - CMD2_TRACKER_U ("t.is_enabled", std::bind(&torrent::tracker::Tracker::is_enabled, std::placeholders::_1)); - CMD2_TRACKER_U ("t.is_extra_tracker", std::bind(&torrent::tracker::Tracker::is_extra_tracker, std::placeholders::_1)); - CMD2_TRACKER_U ("t.is_open", std::bind(&torrent::tracker::Tracker::is_busy, std::placeholders::_1)); + CMD2_TRACKER ("t.is_busy", std::bind(&torrent::tracker::Tracker::is_busy, std::placeholders::_1)); + CMD2_TRACKER ("t.is_enabled", std::bind(&torrent::tracker::Tracker::is_enabled, std::placeholders::_1)); + CMD2_TRACKER ("t.is_extra_tracker", std::bind(&torrent::tracker::Tracker::is_extra_tracker, std::placeholders::_1)); + CMD2_TRACKER ("t.is_open", std::bind(&torrent::tracker::Tracker::is_busy, std::placeholders::_1)); CMD2_TRACKER ("t.is_scrapable", std::bind(&torrent::tracker::Tracker::is_scrapable, std::placeholders::_1)); - CMD2_TRACKER_U ("t.is_usable", std::bind(&torrent::tracker::Tracker::is_usable, std::placeholders::_1)); + CMD2_TRACKER ("t.is_usable", std::bind(&torrent::tracker::Tracker::is_usable, std::placeholders::_1)); // TODO: Deprecate. CMD2_TRACKER ("t.can_scrape", std::bind(&torrent::tracker::Tracker::is_scrapable, std::placeholders::_1)); @@ -101,37 +101,37 @@ initialize_command_tracker() { CMD2_TRACKER_V ("t.enable", std::bind(&torrent::tracker::Tracker::enable, std::placeholders::_1)); CMD2_TRACKER_V ("t.disable", std::bind(&torrent::tracker::Tracker::disable, std::placeholders::_1)); - CMD2_TRACKER_VALUE_V_U("t.is_enabled.set", std::bind(&tracker_set_enabled, std::placeholders::_1, std::placeholders::_2)); + CMD2_TRACKER_VALUE_V("t.is_enabled.set", std::bind(&tracker_set_enabled, std::placeholders::_1, std::placeholders::_2)); - CMD2_TRACKER_U ("t.url", std::bind(&torrent::tracker::Tracker::url, std::placeholders::_1)); - CMD2_TRACKER_U ("t.group", std::bind(&torrent::tracker::Tracker::group, std::placeholders::_1)); - CMD2_TRACKER_U ("t.type", std::bind(&torrent::tracker::Tracker::type, std::placeholders::_1)); - CMD2_TRACKER_U ("t.id", std::bind(&torrent::tracker::Tracker::tracker_id, std::placeholders::_1)); + CMD2_TRACKER ("t.url", std::bind(&torrent::tracker::Tracker::url, std::placeholders::_1)); + CMD2_TRACKER ("t.group", std::bind(&torrent::tracker::Tracker::group, std::placeholders::_1)); + CMD2_TRACKER ("t.type", std::bind(&torrent::tracker::Tracker::type, std::placeholders::_1)); + CMD2_TRACKER ("t.id", std::bind(&torrent::tracker::Tracker::tracker_id, std::placeholders::_1)); CMD2_TRACKER ("t.latest_event", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().latest_event(); }); CMD2_TRACKER ("t.latest_new_peers", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().latest_new_peers(); }); CMD2_TRACKER ("t.latest_sum_peers", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().latest_sum_peers(); }); - CMD2_TRACKER_U ("t.normal_interval", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().normal_interval(); }); + CMD2_TRACKER ("t.normal_interval", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().normal_interval(); }); CMD2_TRACKER ("t.min_interval", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().min_interval(); }); - CMD2_TRACKER_U ("t.activity_time_next", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().activity_time_next(); }); - CMD2_TRACKER_U ("t.activity_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().activity_time_last(); }); + CMD2_TRACKER ("t.activity_time_next", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().activity_time_next(); }); + CMD2_TRACKER ("t.activity_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().activity_time_last(); }); CMD2_TRACKER ("t.success_time_next", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_time_next(); }); - CMD2_TRACKER_U ("t.success_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_time_last(); }); - CMD2_TRACKER_U ("t.success_counter", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_counter(); }); + CMD2_TRACKER ("t.success_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_time_last(); }); + CMD2_TRACKER ("t.success_counter", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_counter(); }); CMD2_TRACKER ("t.failed_time_next", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_time_next(); }); - CMD2_TRACKER_U ("t.failed_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_time_last(); }); - CMD2_TRACKER_U ("t.failed_counter", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_counter(); }); + CMD2_TRACKER ("t.failed_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_time_last(); }); + CMD2_TRACKER ("t.failed_counter", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_counter(); }); - CMD2_TRACKER_U ("t.scrape_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_time_last(); }); - CMD2_TRACKER_U ("t.scrape_counter", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_counter(); }); + CMD2_TRACKER ("t.scrape_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_time_last(); }); + CMD2_TRACKER ("t.scrape_counter", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_counter(); }); - CMD2_TRACKER_U ("t.scrape_complete", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_complete(); }); - CMD2_TRACKER_U ("t.scrape_incomplete", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_incomplete(); }); - CMD2_TRACKER_U ("t.scrape_downloaded", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_downloaded(); }); + CMD2_TRACKER ("t.scrape_complete", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_complete(); }); + CMD2_TRACKER ("t.scrape_incomplete", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_incomplete(); }); + CMD2_TRACKER ("t.scrape_downloaded", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_downloaded(); }); CMD2_ANY_VALUE ("trackers.enable", std::bind(&apply_enable_trackers, int64_t(1))); CMD2_ANY_VALUE ("trackers.disable", std::bind(&apply_enable_trackers, int64_t(0))); @@ -141,14 +141,43 @@ initialize_command_tracker() { auto dht_manager = control->dht_manager(); - CMD2_ANY_STRING_V_U ("dht.mode.set", std::bind(&core::DhtManager::set_mode, control->dht_manager(), std::placeholders::_2)); - CMD2_ANY_U ("dht.port", [](auto, auto) { return torrent::runtime::network_manager()->dht_controller()->port(); }); + CMD2_ANY_STRING_V ("dht.mode.set", std::bind(&core::DhtManager::set_mode, control->dht_manager(), std::placeholders::_2)); + CMD2_ANY ("dht.port", [](auto, auto) { return torrent::runtime::network_manager()->dht_controller()->port(); }); CMD2_ANY_VALUE_V ("dht.port.set", [](auto, auto) { lt_log_print(torrent::LOG_DHT_ERROR, "dht.port.set is no longer supported, use dht.override_port.set", 0); }); - CMD2_ANY_U ("dht.override_port", std::bind(&torrent::net::NetworkConfig::override_dht_port, torrent::config::network_config())); + CMD2_ANY ("dht.override_port", std::bind(&torrent::net::NetworkConfig::override_dht_port, torrent::config::network_config())); CMD2_ANY_VALUE_V ("dht.override_port.set", std::bind(&torrent::net::NetworkConfig::set_override_dht_port, torrent::config::network_config(), std::placeholders::_2)); - CMD2_ANY_STRING_U ("dht.add_node", std::bind(&apply_dht_add_node, std::placeholders::_2)); - CMD2_ANY_U ("dht.statistics", std::bind(&core::DhtManager::dht_statistics, dht_manager)); + CMD2_ANY_STRING ("dht.add_node", std::bind(&apply_dht_add_node, std::placeholders::_2)); + CMD2_ANY ("dht.statistics", std::bind(&core::DhtManager::dht_statistics, dht_manager)); + + rpc::rpc.mark_safe("t.url"); + rpc::rpc.mark_safe("t.group"); + rpc::rpc.mark_safe("t.id"); + rpc::rpc.mark_safe("t.type"); + rpc::rpc.mark_safe("t.is_usable"); + rpc::rpc.mark_safe("t.is_busy"); + rpc::rpc.mark_safe("t.is_enabled"); + rpc::rpc.mark_safe("t.is_enabled.set"); + rpc::rpc.mark_safe("t.is_extra_tracker"); + rpc::rpc.mark_safe("t.is_open"); + rpc::rpc.mark_safe("t.normal_interval"); + rpc::rpc.mark_safe("t.scrape_time_last"); + rpc::rpc.mark_safe("t.scrape_counter"); + rpc::rpc.mark_safe("t.success_time_last"); + rpc::rpc.mark_safe("t.success_counter"); + rpc::rpc.mark_safe("t.failed_time_last"); + rpc::rpc.mark_safe("t.failed_counter"); + rpc::rpc.mark_safe("t.activity_time_last"); + rpc::rpc.mark_safe("t.activity_time_next"); + rpc::rpc.mark_safe("t.scrape_complete"); + rpc::rpc.mark_safe("t.scrape_incomplete"); + rpc::rpc.mark_safe("t.scrape_downloaded"); + + rpc::rpc.mark_safe("dht.mode.set"); + rpc::rpc.mark_safe("dht.port"); + rpc::rpc.mark_safe("dht.override_port"); + rpc::rpc.mark_safe("dht.add_node"); + rpc::rpc.mark_safe("dht.statistics"); } diff --git a/src/command_ui.cc b/src/command_ui.cc index db6a2952..2307fe88 100644 --- a/src/command_ui.cc +++ b/src/command_ui.cc @@ -779,7 +779,7 @@ initialize_command_ui() { CMD2_ANY_STRING("view.add", object_convert_void(std::bind(&core::ViewManager::insert_throw, control->view_manager(), std::placeholders::_2))); - CMD2_ANY_L_U ("view.list", std::bind(&apply_view_list)); + CMD2_ANY_L ("view.list", std::bind(&apply_view_list)); CMD2_ANY_LIST("view.set", std::bind(&apply_view_set, std::placeholders::_2)); CMD2_ANY_LIST ("view.filter", std::bind(&apply_view_event, &core::ViewManager::set_filter, std::placeholders::_2)); @@ -797,30 +797,30 @@ initialize_command_ui() { // Cleanup and add . to view. - CMD2_ANY_STRING_U("view.size", std::bind(&cmd_view_size, std::placeholders::_2)); - CMD2_ANY_STRING_U("view.size_not_visible", std::bind(&cmd_view_size_not_visible, std::placeholders::_2)); + CMD2_ANY_STRING("view.size", std::bind(&cmd_view_size, std::placeholders::_2)); + CMD2_ANY_STRING("view.size_not_visible", std::bind(&cmd_view_size_not_visible, std::placeholders::_2)); CMD2_ANY_STRING("view.persistent", std::bind(&cmd_view_persistent, std::placeholders::_2)); - CMD2_ANY_STRING_V_U("view.filter_all", std::bind(&core::View::filter, std::bind(&core::ViewManager::find_ptr_throw, control->view_manager(), std::placeholders::_2))); + CMD2_ANY_STRING_V("view.filter_all", std::bind(&core::View::filter, std::bind(&core::ViewManager::find_ptr_throw, control->view_manager(), std::placeholders::_2))); - CMD2_DL_STRING_U("view.filter_download", std::bind(&cmd_view_filter_download, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_STRING_U("view.set_visible", std::bind(&cmd_view_set_visible, std::placeholders::_1, std::placeholders::_2)); - CMD2_DL_STRING_U("view.set_not_visible", std::bind(&cmd_view_set_not_visible, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_STRING ("view.filter_download", std::bind(&cmd_view_filter_download, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_STRING ("view.set_visible", std::bind(&cmd_view_set_visible, std::placeholders::_1, std::placeholders::_2)); + CMD2_DL_STRING ("view.set_not_visible", std::bind(&cmd_view_set_not_visible, std::placeholders::_1, std::placeholders::_2)); // Commands that affect the default rtorrent UI. - CMD2_DL_U ("ui.unfocus_download", std::bind(&cmd_ui_unfocus_download, std::placeholders::_1)); - CMD2_ANY_U ("ui.current_view", std::bind(&cmd_ui_current_view)); - CMD2_ANY_STRING_U("ui.current_view.set", std::bind(&cmd_ui_set_view, std::placeholders::_2)); + CMD2_DL ("ui.unfocus_download", std::bind(&cmd_ui_unfocus_download, std::placeholders::_1)); + CMD2_ANY ("ui.current_view", std::bind(&cmd_ui_current_view)); + CMD2_ANY_STRING("ui.current_view.set", std::bind(&cmd_ui_set_view, std::placeholders::_2)); - CMD2_ANY_U ("ui.input.history.size", std::bind(&ui::Root::get_input_history_size, control->ui())); + CMD2_ANY ("ui.input.history.size", std::bind(&ui::Root::get_input_history_size, control->ui())); CMD2_ANY_VALUE_V("ui.input.history.size.set", std::bind(&ui::Root::set_input_history_size, control->ui(), std::placeholders::_2)); - CMD2_ANY_V_U ("ui.input.history.clear", std::bind(&ui::Root::clear_input_history, control->ui())); + CMD2_ANY_V ("ui.input.history.clear", std::bind(&ui::Root::clear_input_history, control->ui())); - CMD2_VAR_VALUE_U("ui.throttle.global.step.small", 5); - CMD2_VAR_VALUE_U("ui.throttle.global.step.medium", 50); - CMD2_VAR_VALUE_U("ui.throttle.global.step.large", 500); + CMD2_VAR_VALUE ("ui.throttle.global.step.small", 5); + CMD2_VAR_VALUE ("ui.throttle.global.step.medium", 50); + CMD2_VAR_VALUE ("ui.throttle.global.step.large", 500); - CMD2_VAR_VALUE_U("ui.focus.page_size", 0); + CMD2_VAR_VALUE ("ui.focus.page_size", 0); CMD2_ANY_LIST ("ui.status.throttle.up.set", std::bind(&cmd_status_throttle_names, true, std::placeholders::_2)); CMD2_ANY_LIST ("ui.status.throttle.down.set", std::bind(&cmd_status_throttle_names, false, std::placeholders::_2)); @@ -829,38 +829,38 @@ initialize_command_ui() { CMD2_ANY_STRING_V("ui.keymap.style.set", std::bind(&ui::Root::set_keymap_style, control->ui(), std::placeholders::_2)); // TODO: Add 'option_string' for rtorrent-specific options. - CMD2_VAR_STRING_U_GET("ui.torrent_list.layout", "full"); + CMD2_VAR_STRING("ui.torrent_list.layout", "full"); // Move. - CMD2_ANY_U("print", &apply_print); - CMD2_ANY_U("cat", &apply_cat); - CMD2_ANY_LIST_U("value", &apply_value); + CMD2_ANY("print", &apply_print); + CMD2_ANY("cat", &apply_cat); + CMD2_ANY_LIST("value", &apply_value); CMD2_ANY("try", &apply_try); - CMD2_ANY_U("if", std::bind(&apply_if, std::placeholders::_1, std::placeholders::_2, 0)); - CMD2_ANY_U("not", &apply_not); + CMD2_ANY("if", std::bind(&apply_if, std::placeholders::_1, std::placeholders::_2, 0)); + CMD2_ANY("not", &apply_not); CMD2_ANY("false", &apply_false); - CMD2_ANY_U("and", &apply_and); - CMD2_ANY_U("or", &apply_or); + CMD2_ANY("and", &apply_and); + CMD2_ANY("or", &apply_or); // A temporary command for handling stuff until we get proper // support for seperation of commands and literals. - CMD2_ANY_U("branch", std::bind(&apply_if, std::placeholders::_1, std::placeholders::_2, 1)); + CMD2_ANY("branch", std::bind(&apply_if, std::placeholders::_1, std::placeholders::_2, 1)); CMD2_ANY_LIST("less", &apply_less); CMD2_ANY_LIST("greater", &apply_greater); CMD2_ANY_LIST("equal", &apply_equal); - CMD2_ANY_LIST_U("compare", &apply_compare); + CMD2_ANY_LIST("compare", &apply_compare); CMD2_ANY_LIST("match", &apply_match); - CMD2_ANY_VALUE_U("convert.gm_time", std::bind(&apply_to_time, std::placeholders::_2, 0)); - CMD2_ANY_VALUE_U("convert.gm_date", std::bind(&apply_to_time, std::placeholders::_2, 0x2)); - CMD2_ANY_VALUE_U("convert.time", std::bind(&apply_to_time, std::placeholders::_2, 0x1)); - CMD2_ANY_VALUE_U("convert.date", std::bind(&apply_to_time, std::placeholders::_2, 0x1 | 0x2)); - CMD2_ANY_VALUE_U("convert.elapsed_time", std::bind(&apply_to_elapsed_time, std::placeholders::_2)); - CMD2_ANY_VALUE_U("convert.kb", std::bind(&apply_to_kb, std::placeholders::_2)); - CMD2_ANY_VALUE_U("convert.mb", std::bind(&apply_to_mb, std::placeholders::_2)); - CMD2_ANY_VALUE_U("convert.xb", std::bind(&apply_to_xb, std::placeholders::_2)); - CMD2_ANY_VALUE_U("convert.throttle", std::bind(&apply_to_throttle, std::placeholders::_2)); + CMD2_ANY_VALUE("convert.gm_time", std::bind(&apply_to_time, std::placeholders::_2, 0)); + CMD2_ANY_VALUE("convert.gm_date", std::bind(&apply_to_time, std::placeholders::_2, 0x2)); + CMD2_ANY_VALUE("convert.time", std::bind(&apply_to_time, std::placeholders::_2, 0x1)); + CMD2_ANY_VALUE("convert.date", std::bind(&apply_to_time, std::placeholders::_2, 0x1 | 0x2)); + CMD2_ANY_VALUE("convert.elapsed_time", std::bind(&apply_to_elapsed_time, std::placeholders::_2)); + CMD2_ANY_VALUE("convert.kb", std::bind(&apply_to_kb, std::placeholders::_2)); + CMD2_ANY_VALUE("convert.mb", std::bind(&apply_to_mb, std::placeholders::_2)); + CMD2_ANY_VALUE("convert.xb", std::bind(&apply_to_xb, std::placeholders::_2)); + CMD2_ANY_VALUE("convert.throttle", std::bind(&apply_to_throttle, std::placeholders::_2)); CMD2_ANY_LIST("math.add", [](auto, const auto& args) { return apply_math_basic("math.add", std::plus(), args); }); CMD2_ANY_LIST("math.sub", [](auto, const auto& args) { return apply_math_basic("math.sub", std::minus(), args); }); @@ -873,8 +873,8 @@ initialize_command_ui() { CMD2_ANY_LIST("math.avg", std::bind(&apply_arith_other, "average", std::placeholders::_2)); CMD2_ANY_LIST("math.med", std::bind(&apply_arith_other, "median", std::placeholders::_2)); - CMD2_ANY_LIST_U ("elapsed.less", std::bind(&apply_elapsed_less, std::placeholders::_2)); - CMD2_ANY_LIST_U ("elapsed.greater", std::bind(&apply_elapsed_greater, std::placeholders::_2)); + CMD2_ANY_LIST ("elapsed.less", std::bind(&apply_elapsed_less, std::placeholders::_2)); + CMD2_ANY_LIST ("elapsed.greater", std::bind(&apply_elapsed_greater, std::placeholders::_2)); // Build set/get methods for all color definitions for (int color_id = 1; color_id < display::RCOLOR_MAX; color_id++) { @@ -888,4 +888,28 @@ initialize_command_ui() { return control->object_storage()->get_str(display::color_vars[color_id]); }); } + + rpc::rpc.mark_safe("view.set_visible"); + rpc::rpc.mark_safe("view.set_not_visible"); + + rpc::rpc.mark_safe("cat"); + rpc::rpc.mark_safe("if"); + rpc::rpc.mark_safe("branch"); + rpc::rpc.mark_safe("and"); + rpc::rpc.mark_safe("or"); + rpc::rpc.mark_safe("not"); + rpc::rpc.mark_safe("value"); + rpc::rpc.mark_safe("compare"); + rpc::rpc.mark_safe("elapsed.less"); + rpc::rpc.mark_safe("elapsed.greater"); + + rpc::rpc.mark_safe("convert.gm_time"); + rpc::rpc.mark_safe("convert.gm_date"); + rpc::rpc.mark_safe("convert.time"); + rpc::rpc.mark_safe("convert.date"); + rpc::rpc.mark_safe("convert.elapsed_time"); + rpc::rpc.mark_safe("convert.kb"); + rpc::rpc.mark_safe("convert.mb"); + rpc::rpc.mark_safe("convert.xb"); + rpc::rpc.mark_safe("convert.throttle"); } diff --git a/src/main.cc b/src/main.cc index 7798305b..737d94d2 100644 --- a/src/main.cc +++ b/src/main.cc @@ -418,7 +418,8 @@ main(int argc, char** argv) { // Deprecate: - CMD2_VAR_STRING_U_GET("dht.throttle.name", "deprecated"); + CMD2_VAR_STRING("dht.throttle.name", "deprecated"); + rpc::rpc.mark_safe("dht.throttle.name"); CMD2_REDIRECT("network.http.max_open", "network.http.max_total_connections"); CMD2_REDIRECT("network.http.max_open.set", "network.http.max_total_connections.set"); diff --git a/src/rpc/command_map.cc b/src/rpc/command_map.cc index 6816be47..1675e077 100644 --- a/src/rpc/command_map.cc +++ b/src/rpc/command_map.cc @@ -98,7 +98,7 @@ CommandMap::call_command(const key_type& key, const mapped_type& arg, const targ if (itr == base_type::end()) throw torrent::input_error("Command \"" + std::string(key) + "\" does not exist."); - if (!RpcManager::is_trusted() && !(itr->second.m_flags & flag_untrusted_safe)) + if (!rpc.is_trusted() && !(itr->second.m_flags & flag_untrusted_safe)) throw untrusted_error("Command \"" + std::string(key) + "\" is not allowed for untrusted connections."); return itr->second.m_anySlot(&itr->second.m_variable, target, arg); @@ -106,7 +106,7 @@ CommandMap::call_command(const key_type& key, const mapped_type& arg, const targ const CommandMap::mapped_type CommandMap::call_command(iterator itr, const mapped_type& arg, const target_type& target) { - if (!RpcManager::is_trusted() && !(itr->second.m_flags & flag_untrusted_safe)) + if (!rpc.is_trusted() && !(itr->second.m_flags & flag_untrusted_safe)) throw untrusted_error("Command \"" + itr->first + "\" is not allowed for untrusted connections."); return itr->second.m_anySlot(&itr->second.m_variable, target, arg); diff --git a/src/rpc/rpc_manager.cc b/src/rpc/rpc_manager.cc index 04876929..f4720883 100644 --- a/src/rpc/rpc_manager.cc +++ b/src/rpc/rpc_manager.cc @@ -21,8 +21,6 @@ ExecFile execFile; // CommandMap::call_command(), which catches all command execution // including nested calls through argument expansion. -thread_local bool RpcManager::m_trusted = true; - bool RpcManager::set_trusted(bool trusted) { bool prev = m_trusted; @@ -31,7 +29,7 @@ RpcManager::set_trusted(bool trusted) { } bool -RpcManager::is_trusted() { +RpcManager::is_trusted() const { return m_trusted; } @@ -146,6 +144,20 @@ RpcManager::process(RPCType type, const char* in_buffer, uint32_t length, slot_r } } +bool +RpcManager::process_untrusted(RPCType type, const char* in_buffer, uint32_t length, slot_response_callback callback) { + bool previous = set_trusted(false); + + try { + bool result = process(type, in_buffer, length, callback); + set_trusted(previous); + return result; + } catch (...) { + set_trusted(previous); + throw; + } +} + void RpcManager::initialize_handlers() { if (m_handlers_initialized) @@ -197,4 +209,14 @@ RpcManager::insert_command(const char* name, const char* parm, const char* doc) m_jsonrpc.insert_command(name, parm, doc); } +void +RpcManager::mark_safe(const std::string& key) { + auto itr = commands.find(key); + + if (itr == commands.end()) + return; + + itr->second.m_flags |= CommandMap::flag_untrusted_safe; +} + } // namespace rpc diff --git a/src/rpc/rpc_manager.h b/src/rpc/rpc_manager.h index bf870a96..55e9b502 100644 --- a/src/rpc/rpc_manager.h +++ b/src/rpc/rpc_manager.h @@ -4,6 +4,7 @@ #include #include #include +#include #include "rpc/command.h" #include "rpc/command_map.h" @@ -34,15 +35,10 @@ private: std::string m_msg; }; -class untrusted_error : public torrent::base_error { +class untrusted_error : public torrent::input_error { public: - untrusted_error(std::string msg) : m_msg(std::move(msg)) {} + using torrent::input_error::input_error; virtual ~untrusted_error() throw() = default; - - virtual const char* what() const throw() { return m_msg.c_str(); } - -private: - std::string m_msg; }; class RpcManager { @@ -74,8 +70,10 @@ public: void set_type_enabled(RPCType type, bool enabled); bool process(RPCType type, const char* in_buffer, uint32_t length, slot_response_callback callback); + bool process_untrusted(RPCType type, const char* in_buffer, uint32_t length, slot_response_callback callback); void insert_command(const char* name, const char* parm, const char* doc); + void mark_safe(const std::string& key); slot_download& slot_find_download() { return m_slot_find_download; } slot_file& slot_find_file() { return m_slot_find_file; } @@ -85,13 +83,13 @@ public: // Trusted/untrusted XMLRPC connection model. // When an SCGI request includes the UNTRUSTED_CONNECTION header, // commands without flag_untrusted_safe are blocked. - static bool set_trusted(bool trusted); - static bool is_trusted(); + bool set_trusted(bool trusted); + bool is_trusted() const; static void object_to_target(const torrent::Object& obj, int callFlags, rpc::target_type* target, std::function* deleter); private: - static thread_local bool m_trusted; + bool m_trusted{true}; XmlRpc m_xmlrpc; JsonRpc m_jsonrpc; diff --git a/src/rpc/scgi_task.cc b/src/rpc/scgi_task.cc index 3046e9d5..afe95fba 100644 --- a/src/rpc/scgi_task.cc +++ b/src/rpc/scgi_task.cc @@ -305,20 +305,15 @@ SCgiTask::receive_call(const char* buffer, uint32_t length) { } torrent::main_thread::thread()->callback_interrupt_polling(this, [buffer, length, result_callback, trusted, rpc_type]() { - rpc::RpcManager::set_trusted(trusted); + auto callback = [result_callback](const char* b, uint32_t l) { + result_callback(b, l); + return true; + }; - try { - rpc.process(rpc_type, buffer, length, - [result_callback](const char* b, uint32_t l) { - result_callback(b, l); - return true; - }); - } catch (...) { - rpc::RpcManager::set_trusted(true); - throw; - } - - rpc::RpcManager::set_trusted(true); + if (trusted) + rpc.process(rpc_type, buffer, length, callback); + else + rpc.process_untrusted(rpc_type, buffer, length, callback); }); }