Stuff.

configure.ac

@@ -1,6 +1,6 @@
 m4_pattern_allow([PKG_CHECK_EXISTS])
 
-AC_INIT([rtorrent],[0.16.18],[sundell.software@gmail.com])
+AC_INIT([rtorrent],[0.16.17],[sundell.software@gmail.com])
 
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_MACRO_DIRS([scripts])
@@ -47,7 +47,7 @@ fi
 
 PKG_CHECK_MODULES([CPPUNIT], [cppunit],, [no_cppunit="yes"])
 PKG_CHECK_MODULES([ZLIB], [zlib])
-PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.18])
+PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.17])
 
 AC_LANG_PUSH(C++)
 TORRENT_WITH_XMLRPC_C

src/command_download.cc

@@ -974,7 +974,6 @@ initialize_command_download() {
   rpc::rpc.mark_safe("d.size_pex");
   rpc::rpc.mark_safe("d.completed_bytes");
   rpc::rpc.mark_safe("d.complete");
-  rpc::rpc.mark_safe("d.timestamp.started");
   rpc::rpc.mark_safe("d.timestamp.finished");
   rpc::rpc.mark_safe("d.bytes_done");
   rpc::rpc.mark_safe("d.peers_accounted");

src/command_dynamic.cc

@@ -444,20 +444,16 @@ initialize_command_dynamic() {
 
   CMD2_ANY         ("catch", std::bind(&cmd_catch, std::placeholders::_1, std::placeholders::_2));
 
-  CMD2_ANY_STRING  ("enum.log_group",                    [](auto, const auto& str) { return torrent::option_find_string_str(torrent::OPTION_LOG_GROUP, str); });
-
-  CMD2_ANY         ("strings.choke_heuristics",          [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_CHOKE_HEURISTICS); });
-  CMD2_ANY         ("strings.choke_heuristics.upload",   [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_CHOKE_HEURISTICS_UPLOAD); });
-  CMD2_ANY         ("strings.choke_heuristics.download", [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_CHOKE_HEURISTICS_DOWNLOAD); });
-  CMD2_ANY         ("strings.connection_type",           [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_CONNECTION_TYPE); });
-  CMD2_ANY         ("strings.encryption",                [](auto, auto) { return torrent::Object::create_list(); });
-  CMD2_ANY         ("strings.encryption.handshake",      [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_ENCRYPTION_HANDSHAKE); });
-  CMD2_ANY         ("strings.encryption.stream",         [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_ENCRYPTION_STREAM); });
-  CMD2_ANY         ("strings.ip_filter",                 [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_IP_FILTER); });
-  CMD2_ANY         ("strings.ip_tos",                    [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_IP_TOS); });
-  CMD2_ANY         ("strings.log_group",                 [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_LOG_GROUP); });
-  CMD2_ANY         ("strings.tracker_event",             [](auto, auto) { return torrent::option_list_strings(torrent::OPTION_TRACKER_EVENT); });
-  CMD2_ANY         ("strings.tracker_mode",              [](auto, auto) { return 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
@@ -472,8 +468,6 @@ initialize_command_dynamic() {
   rpc::rpc.mark_safe("method.rlookup");
   rpc::rpc.mark_safe("catch");
 
-  rpc::rpc.mark_safe("enum.log_group");
-
   rpc::rpc.mark_safe("strings.choke_heuristics");
   rpc::rpc.mark_safe("strings.choke_heuristics.upload");
   rpc::rpc.mark_safe("strings.choke_heuristics.download");

src/command_local.cc

@@ -190,6 +190,10 @@ initialize_command_local() {
   core::DownloadList*    dList = control->core()->download_list();
   torrent::FileManager*  fileManager = torrent::file_manager();
 
+  if (rpc::call_command_value("method.use_deprecated") == 1) {
+    CMD_ANY_LIST    ("file.append",    std::bind(&cmd_file_append, std::placeholders::_2));
+  }
+
   CMD_ANY         ("system.hostname", std::bind(&system_hostname));
   CMD_ANY         ("system.pid",      std::bind(&getpid));
 

src/command_logging.cc

@@ -1,7 +1,6 @@
 #include "config.h"
 
 #include <fcntl.h>
-#include <iterator>
 #include <stdio.h>
 #include <unistd.h>
 #include <torrent/data/chunk_utils.h>
@@ -16,7 +15,6 @@
 #include "core/download.h"
 #include "core/download_list.h"
 #include "core/manager.h"
-#include "rpc/parse.h"
 #include "rpc/parse_commands.h"
 
 torrent::Object
@@ -40,32 +38,6 @@ apply_log_add_output(const torrent::Object::list_type& args) {
   return torrent::Object();
 }
 
-torrent::Object
-apply_log_print(const torrent::Object::list_type& args) {
-  if (args.size() < 2)
-    throw torrent::input_error("Invalid number of arguments.");
-
-  torrent::Object::value_type group;
-
-  if (args.front().is_value())
-    group = args.front().as_value();
-  else if (args.front().is_string())
-    group = torrent::option_find_string_str(torrent::OPTION_LOG_GROUP, args.front().as_string());
-  else
-    throw torrent::input_error("Invalid log group.");
-
-  if (group < 0 || group >= torrent::LOG_GROUP_MAX_SIZE)
-    throw torrent::input_error("Invalid log group.");
-
-  std::string message;
-
-  for (auto itr = std::next(args.begin()); itr != args.end(); ++itr)
-    rpc::print_object_std(&message, &*itr, 0);
-
-  torrent::log_groups[group].internal_print(message);
-  return torrent::Object();
-}
-
 // TODO: Deprecated.
 torrent::Object
 apply_log(const torrent::Object::string_type& arg, int logType) {
@@ -140,7 +112,6 @@ initialize_command_logging() {
   CMD2_ANY_STRING_V("log.close",            std::bind(&torrent::log_close_output_str, std::placeholders::_2));
 
   CMD2_ANY_LIST    ("log.add_output",       std::bind(&apply_log_add_output, std::placeholders::_2));
-  CMD2_ANY_LIST    ("log.print",            std::bind(&apply_log_print, std::placeholders::_2));
 
   CMD2_ANY_STRING  ("log.execute",          std::bind(&apply_log, std::placeholders::_2, 0));
   CMD2_ANY_STRING  ("log.vmmap.dump",       std::bind(&log_vmmap_dump, std::placeholders::_2));

src/command_network.cc

@@ -9,9 +9,7 @@
 #include <torrent/download/resource_manager.h>
 #include <torrent/net/http_stack.h>
 #include <torrent/net/socket_address.h>
-#include <torrent/runtime/client_config.h>
 #include <torrent/runtime/network_config.h>
-#include <torrent/runtime/network_manager.h>
 #include <torrent/runtime/proxy_manager.h>
 #include <torrent/runtime/runtime.h>
 #include <torrent/runtime/socket_manager.h>
@@ -34,116 +32,22 @@
 #include <systemd/sd-daemon.h>
 #endif
 
-torrent::Object
-listen_port_range() {
-  auto port_range = torrent::runtime::client_config()->listen_port_range();
-
-  return std::to_string(port_range.first) + "-" + std::to_string(port_range.second);
-}
-
-void
-set_listen_port_range(const std::string& arg) {
-  unsigned int port_first{}, port_last{};
-
-  if (std::sscanf(arg.c_str(), "%i-%i", &port_first, &port_last) != 2)
-    throw torrent::input_error("Invalid port_range argument.");
-
-  if (port_first >= (1 << 16) || port_last >= (1 << 16))
-    throw torrent::input_error("Port range out-of-bounds.");
-
-  torrent::runtime::client_config()->set_listen_port_range(port_first, port_last);
-}
-
-torrent::Object
-get_encryption() {
-  auto encryption_modes = torrent::runtime::network_config()->encryption_modes();
-
-  return torrent::option_to_str_or_throw(torrent::OPTION_ENCRYPTION_HANDSHAKE, encryption_modes.first) + "," +
-    torrent::option_to_str_or_throw(torrent::OPTION_ENCRYPTION_STREAM, encryption_modes.second);
-}
-
-torrent::Object
-get_handshake_encryption() {
-  auto encryption_modes = torrent::runtime::network_config()->encryption_modes();
-
-  return torrent::option_to_str_or_throw(torrent::OPTION_ENCRYPTION_MODE, encryption_modes.first);
-}
-
-torrent::Object
-get_stream_encryption() {
-  auto encryption_modes = torrent::runtime::network_config()->encryption_modes();
-
-  return torrent::option_to_str_or_throw(torrent::OPTION_ENCRYPTION_MODE, encryption_modes.second);
-}
-
-torrent::Object
-apply_obsolete_encryption(const torrent::Object::list_type& args) {
-  torrent::encryption_mode handshake_mode{torrent::ENCRYPTION_MODE_ALLOW};
-  torrent::encryption_mode stream_mode{torrent::ENCRYPTION_MODE_ALLOW};
-
-  for (auto& itr : args) {
-    auto arg = itr.as_string();
-
-    if (arg == "none") {
-      handshake_mode = torrent::ENCRYPTION_MODE_DENY;
-      stream_mode    = torrent::ENCRYPTION_MODE_DENY;
-      break;
-
-    } else if (arg == "allow_incoming") {
-    } else if (arg == "try_outgoing") {
-    } else if (arg == "require") {
-      handshake_mode = torrent::ENCRYPTION_MODE_REQUIRE;
-
-    } else if (arg == "require_RC4" || arg == "require_rc4") {
-      handshake_mode = torrent::ENCRYPTION_MODE_REQUIRE;
-      stream_mode    = torrent::ENCRYPTION_MODE_REQUIRE;
-      break;
-
-    } else if (arg == "enable_retry") {
-    } else if (arg == "prefer_plaintext") {
-    } else {
-      throw torrent::input_error("Invalid encryption option: '" + arg + "'");
-    }
-  }
-
-  lt_log_print(torrent::LOG_WARN, "Obsolete encryption options used, use 'handshake_{deny,allow,prefer,require}, stream_{deny,allow,prefer,require}' instead.");
-
-  torrent::runtime::network_config()->set_encryption_modes(handshake_mode, stream_mode);
-  return {};
-}
-
 torrent::Object
 apply_encryption(const torrent::Object::list_type& args) {
-  if (args.empty())
-    throw torrent::input_error("No encryption options specified.");
+  uint32_t options_mask = torrent::runtime::NetworkConfig::encryption_none;
 
-  torrent::encryption_mode encryption_mode, handshake_mode, stream_mode;
+  for (const auto& arg : args) {
+    uint32_t opt = torrent::option_find_string(torrent::OPTION_ENCRYPTION, arg.as_string().c_str());
 
-  if (args.size() == 1) {
-    try {
-      encryption_mode = static_cast<torrent::encryption_mode>(torrent::option_find_string_str(torrent::OPTION_ENCRYPTION_MODE, args.front().as_string()));
-
-    } catch (torrent::input_error& e) {
-      return apply_obsolete_encryption(args);
-    }
-
-    torrent::runtime::network_config()->set_encryption_modes(encryption_mode, encryption_mode);
-    return {};
+    if (opt == torrent::runtime::NetworkConfig::encryption_none)
+      options_mask = torrent::runtime::NetworkConfig::encryption_none;
+    else
+      options_mask |= opt;
   }
 
-  if (args.size() != 2)
-    return apply_obsolete_encryption(args);
+  torrent::runtime::network_config()->set_encryption_options(options_mask);
 
-  try {
-    handshake_mode = static_cast<torrent::encryption_mode>(torrent::option_find_string_str(torrent::OPTION_ENCRYPTION_HANDSHAKE, args.front().as_string()));
-    stream_mode    = static_cast<torrent::encryption_mode>(torrent::option_find_string_str(torrent::OPTION_ENCRYPTION_STREAM, args.back().as_string()));
-
-  } catch (torrent::input_error& e) {
-    return apply_obsolete_encryption(args);
-  }
-
-  torrent::runtime::network_config()->set_encryption_modes(handshake_mode, stream_mode);
-  return {};
+  return torrent::Object();
 }
 
 torrent::Object
@@ -316,22 +220,17 @@ initialize_command_network() {
   auto http_stack     = torrent::net_thread::http_stack();
   auto nw_config      = torrent::runtime::network_config();
 
-  CMD_ANY         ("network.listen.port",            [](auto, auto)        { return torrent::runtime::network_manager()->listen_port(); });
-  CMD_ANY_VALUE_V ("network.listen.port.set",        [](auto, auto& value) { return torrent::runtime::network_manager()->set_listen_port(value); });
-  CMD_ANY         ("network.listen.port.random",     [](auto, auto)        { return torrent::runtime::client_config()->listen_port_random(); });
-  CMD_ANY_VALUE_V ("network.listen.port.random.set", [](auto, auto& value) { return torrent::runtime::client_config()->set_listen_port_random(value); });
-  CMD_ANY         ("network.listen.port.range",      [](auto, auto)        { return listen_port_range(); });
-  CMD_ANY_STRING_V("network.listen.port.range.set",  [](auto, auto& value) { return set_listen_port_range(value); });
-  CMD_ANY         ("network.listen.backlog",         [](auto, auto)        { return torrent::runtime::network_config()->listen_backlog(); });
-  CMD_ANY_VALUE_V ("network.listen.backlog.set",     [](auto, auto& value) { return torrent::runtime::network_config()->set_listen_backlog(value); });
+  // Isn't port_open used?
+  CMD_VAR_BOOL    ("network.port_open",   true);
+  CMD_VAR_BOOL    ("network.port_random", true);
+  CMD_VAR_STRING  ("network.port_range",  "6881-6999");
 
-  CMD_ANY         ("protocol.pex",                   [](auto, auto)        { return torrent::runtime::client_config()->is_pex_enabled(); });
-  CMD_ANY_VALUE_V ("protocol.pex.set",               [](auto, auto& value) { return torrent::runtime::client_config()->set_pex_enabled(value); });
+  CMD_ANY         ("network.listen.port",        [](auto, auto)                 { return torrent::runtime::listen_port(); });
+  CMD_ANY         ("network.listen.backlog",     [nw_config](auto, auto)        { return nw_config->listen_backlog(); });
+  CMD_ANY_VALUE_V ("network.listen.backlog.set", [nw_config](auto, auto& value) { return nw_config->set_listen_backlog(value); });
 
-  CMD_ANY_LIST    ("protocol.encryption",            [](auto, auto)        { return get_encryption(); });
-  CMD_ANY_LIST    ("protocol.encryption.set",        [](auto, auto& args)  { return apply_encryption(args); });
-  CMD_ANY_LIST    ("protocol.encryption.handshake",  [](auto, auto)        { return get_handshake_encryption(); });
-  CMD_ANY_LIST    ("protocol.encryption.stream",     [](auto, auto)        { return get_stream_encryption(); });
+  CMD_VAR_BOOL    ("protocol.pex",               true);
+  CMD_ANY_LIST    ("protocol.encryption.set",    [](auto, auto& args)           { return apply_encryption(args); });
 
   CMD_VAR_STRING  ("protocol.connection.leech",            "leech");
   CMD_VAR_STRING  ("protocol.connection.seed",             "seed");
@@ -402,10 +301,8 @@ initialize_command_network() {
   CMD_ANY         ("network.xmlrpc.size_limit",              [](auto, auto)                  { return rpc::rpc.size_limit(); });
   CMD_ANY_VALUE_V ("network.xmlrpc.size_limit.set",          [](auto, auto& arg)             { return rpc::rpc.set_size_limit(arg); });
 
-  CMD_ANY         ("network.rpc.use_xmlrpc",                 [](auto, auto)                  { return rpc::rpc.use_xmlrpc(); });
-  CMD_ANY_VALUE_V ("network.rpc.use_xmlrpc.set",             [](auto, auto& arg)             { return rpc::rpc.set_use_xmlrpc(arg); });
-  CMD_ANY         ("network.rpc.use_jsonrpc",                [](auto, auto)                  { return rpc::rpc.use_jsonrpc(); });
-  CMD_ANY_VALUE_V ("network.rpc.use_jsonrpc.set",            [](auto, auto& arg)             { return rpc::rpc.set_use_jsonrpc(arg); });
+  CMD_VAR_BOOL    ("network.rpc.use_xmlrpc",                 true);
+  CMD_VAR_BOOL    ("network.rpc.use_jsonrpc",                true);
 
   CMD_ANY         ("network.block.ipv4",                     [nw_config](auto, auto)         { return nw_config->is_block_ipv4(); });
   CMD_ANY_VALUE_V ("network.block.ipv4.set",                 [nw_config](auto, auto& value)  { return nw_config->set_block_ipv4(value); });

src/command_tracker.cc

@@ -142,7 +142,7 @@ initialize_command_tracker() {
       lt_log_print(torrent::LOG_DHT_ERROR, "dht.port.set is no longer supported, use dht.override_port.set", 0);
     });
   CMD2_ANY            ("dht.override_port",     [](auto, auto)        { return torrent::runtime::network_config()->override_dht_port(); });
-  CMD2_ANY_VALUE_V    ("dht.override_port.set", [](auto, auto& value) { return torrent::runtime::network_manager()->set_dht_port(value); });
+  CMD2_ANY_VALUE_V    ("dht.override_port.set", [](auto, auto& value) { return torrent::runtime::network_config()->set_override_dht_port(value); });
 
   CMD2_ANY_STRING     ("dht.add_node",          [](auto, auto& str)   { return apply_dht_add_node(str); });
   CMD2_ANY            ("dht.statistics",        [](auto, auto)        { return control->dht_manager()->dht_statistics(); });

src/core/download_factory.cc

@@ -15,7 +15,6 @@
 #include <torrent/rate.h>
 #include <torrent/data/file_utils.h>
 #include <torrent/net/http_stack.h>
-#include <torrent/runtime/client_config.h>
 #include <torrent/utils/string_manip.h>
 
 #include "control.h"
@@ -272,7 +271,7 @@ DownloadFactory::receive_success() {
   if (!m_session && m_variables["tied_to_file"].as_value())
     rpc::call_command("d.tied_to_file.set", m_uri.empty() ? m_variables["tied_file"] : m_uri, rpc::make_target(download));
 
-  rpc::call_command("d.peer_exchange.set", torrent::runtime::client_config()->is_pex_enabled(), rpc::make_target(download));
+  rpc::call_command("d.peer_exchange.set", rpc::call_command_value("protocol.pex"), rpc::make_target(download));
 
   torrent::resume_load_addresses(*download->download(), resumeObject);
   torrent::resume_load_file_priorities(*download->download(), resumeObject);

src/core/manager.cc

@@ -33,8 +33,6 @@
 #include "core/http_queue.h"
 #include "core/view.h"
 
-#include <torrent/runtime/client_config.h>
-
 namespace core {
 
 const int Manager::create_start;
@@ -162,6 +160,40 @@ Manager::shutdown(bool force) {
   }
 }
 
+void
+Manager::listen_open() {
+  // This stuff really should be moved outside of manager, make it
+  // part of the init script.
+  if (!rpc::call_command_value("network.port_open"))
+    return;
+
+  int portFirst, portLast;
+  torrent::Object portRange = rpc::call_command("network.port_range");
+
+  if (!portRange.is_string())
+    throw torrent::input_error("Invalid port_range argument type.");
+
+  if (std::sscanf(portRange.as_string().c_str(), "%i-%i", &portFirst, &portLast) != 2)
+    throw torrent::input_error("Invalid port_range argument.");
+
+  if (portFirst > portLast || portLast >= (1 << 16))
+    throw torrent::input_error("Invalid port range.");
+
+  if (rpc::call_command_value("network.port_random")) {
+    int boundary = portFirst + random() % (portLast - portFirst + 1);
+
+    if (torrent::runtime::network_manager()->listen_open(boundary, portLast) ||
+        torrent::runtime::network_manager()->listen_open(portFirst, boundary))
+      return;
+
+  } else {
+    if (torrent::runtime::network_manager()->listen_open(portFirst, portLast))
+      return;
+  }
+
+  throw torrent::input_error("Could not open/bind port for listening: " + std::string(std::strerror(errno)));
+}
+
 void
 Manager::receive_http_failed(std::string msg) {
   push_log_std("Http download error: \"" + msg + "\"");

src/core/manager.h

@@ -55,6 +55,8 @@ public:
 
   void                cleanup();
 
+  void                listen_open();
+
   const std::string&  magnet_path();
   void                set_magnet_path(const std::string& path);
 

src/main.cc

@@ -301,6 +301,8 @@ main(int argc, char** argv) {
        "schedule = low_diskspace,5,60,((close_low_diskspace,500M))\n"
        "schedule = prune_file_status,3600,86400,((system.file_status_cache.prune))\n"
 
+       "protocol.encryption.set=allow_incoming,prefer_plaintext,enable_retry\n"
+
        "ui.color.focus.set=reverse\n"
     );
 
@@ -344,9 +346,8 @@ main(int argc, char** argv) {
     CMD_REDIRECT("directory",             "directory.default.set");
     CMD_REDIRECT("session",               "session.path.set");
 
-    CMD_REDIRECT_NO_EXPORT("port_range",  "network.listen.port.range.set");
-    CMD_REDIRECT_NO_EXPORT("scgi_port",   "network.scgi.open_port");
-    CMD_REDIRECT_NO_EXPORT("scgi_local",  "network.scgi.open_local");
+    CMD_REDIRECT("scgi_port",             "network.scgi.open_port");
+    CMD_REDIRECT("scgi_local",            "network.scgi.open_local");
 
     CMD_REDIRECT("to_gm_time",            "convert.gm_time");
     CMD_REDIRECT("to_gm_date",            "convert.gm_date");
@@ -390,6 +391,8 @@ main(int argc, char** argv) {
       CMD_REDIRECT("schedule2",        "schedule");
       CMD_REDIRECT("schedule_remove2", "schedule.remove");
 
+      // TODO: Remove file.append when cleaning these up.
+
       CMD_REDIRECT("bind",                  "network.bind_address.set");
       CMD_REDIRECT("ip",                    "network.local_address.set");
       CMD_REDIRECT("port_range",            "network.port_range.set");
@@ -417,20 +420,6 @@ main(int argc, char** argv) {
           lt_log_print(torrent::LOG_WARN, "The 'throttle.ip' command is deprecated and does nothing.");
           return torrent::Object();
         });
-
-      CMD_ANY("network.port_open", [](auto, auto) {
-          lt_log_print(torrent::LOG_WARN, "The 'network.port_open' command is deprecated and does nothing.");
-          return torrent::Object();
-        });
-      CMD_ANY("network.port_open.set", [](auto, auto) {
-          lt_log_print(torrent::LOG_WARN, "The 'network.port_open.set' command is deprecated and does nothing.");
-          return torrent::Object();
-        });
-
-      CMD_REDIRECT("network.port_random",     "network.listen.port.random");
-      CMD_REDIRECT("network.port_random.set", "network.listen.port.random.set");
-      CMD_REDIRECT("network.port_range",      "network.listen.port.range");
-      CMD_REDIRECT("network.port_range.set",  "network.listen.port.range.set");
     }
 
     {
@@ -466,6 +455,8 @@ main(int argc, char** argv) {
     torrent::net_thread::http_stack()->set_user_agent(USER_AGENT);
     torrent::runtime::initialize_network();
 
+    control->core()->listen_open();
+
     // Load session torrents and perform scheduled tasks to ensure session torrents are loaded
     // before arg torrents.
     control->dht_manager()->set_auto_if_untouched_and_has_session();

src/pid_watcher.cc

@@ -1,20 +0,0 @@
-#include "config.h"
-
-#include "pid_watcher.h"
-
-#include <cassert>
-#include <torrent/exceptions.h>
-
-PidWatcher::PidWatcher(std::thread::id thread_id)
-  : m_thread_id(thread_id) {
-}
-
-PidWatcher::~PidWatcher() = default;
-
-void
-PidWatcher::prepare_spawn() {
-  assert(std::this_thread::get_id() == m_thread_id);
-
-  if (m_spawn_in_progress.exchange(true, std::memory_order_acquire))
-    throw torrent::internal_error("PidWatcher::prepare_spawn() called while spawn already in progress.");
-}

src/pid_watcher.h

@@ -1,27 +0,0 @@
-#ifndef RTORRENT_PID_WATCHER_H
-#define RTORRENT_PID_WATCHER_H
-
-#include <torrent/common.h>
-
-struct atomic_queue {
-  std::array<std::atomic<pid_t>, 16> queue{};
-
-
-class PidWatcher {
-public:
-  PidWatcher(std::thread::id thread_id);
-  ~PidWatcher();
-
-  void                prepare_spawn();
-  void                completed_spawn(pid_t pid);
-
-private:
-  std::thread::id     m_thread_id;
-
-  align_cacheline
-
-  std::atomic<bool>   m_spawn_in_progress{};
-
-};
-
-#endif

src/rpc/rpc_manager.cc

@@ -113,20 +113,25 @@ bool
 RpcManager::process(RPCType type, const char* in_buffer, uint32_t length, slot_response_callback callback) {
   switch (type) {
   case RPCType::XML:
-    if (!m_xmlrpc.is_valid() || !m_use_xmlrpc) {
+    // TODO: 'network.rpc.use_xmlrpc' should be a bool in RpcManager, not a command variable.
+    if (m_xmlrpc.is_valid() && rpc::call_command_value("network.rpc.use_xmlrpc")) {
+      return m_xmlrpc.process(in_buffer, length, callback);
+
+    } else {
       const std::string response = "<?xml version=\"1.0\"?><methodResponse><fault><value><struct><member><name>faultCode</name><value><i8>-501</i8></value></member><member><name>faultString</name><value><string>XML-RPC not supported</string></value></member></struct></value></fault></methodResponse>";
       return callback(response.c_str(), response.size());
     }
-
-    return m_xmlrpc.process(in_buffer, length, callback);
+    break;
 
   case RPCType::JSON:
-    if (!m_use_jsonrpc) {
+    if (rpc::call_command_value("network.rpc.use_jsonrpc")) {
+      return m_jsonrpc.process(in_buffer, length, callback);
+
+    } else {
       const std::string response = "{\"jsonrpc\":\"2.0\",\"error\":{\"code\":-32601,\"message\":\"JSON-RPC not supported\"},\"id\":null}";
       return callback(response.c_str(), response.size());
     }
-
-    return m_jsonrpc.process(in_buffer, length, callback);
+    break;
 
   default:
     throw torrent::input_error("invalid parameters: unknown RPC type");
@@ -167,6 +172,32 @@ RpcManager::cleanup() {
   m_jsonrpc.cleanup();
 }
 
+bool
+RpcManager::is_type_enabled(RPCType type) const {
+  switch (type) {
+  case RPCType::XML:
+    return m_is_xmlrpc_enabled;
+  case RPCType::JSON:
+    return m_is_jsonrpc_enabled;
+  default:
+    throw torrent::input_error("invalid parameters: unknown RPC type");
+  }
+}
+
+void
+RpcManager::set_type_enabled(RPCType type, bool enabled) {
+  switch (type) {
+  case RPCType::XML:
+    m_is_xmlrpc_enabled = enabled;
+    break;
+  case RPCType::JSON:
+    m_is_jsonrpc_enabled = enabled;
+    break;
+  default:
+    throw torrent::input_error("invalid parameters: unknown RPC type");
+  }
+}
+
 void
 RpcManager::insert_command(const char* name, const char* parm, const char* doc) {
   m_xmlrpc.insert_command(name, parm, doc);

src/rpc/rpc_manager.h

@@ -67,11 +67,8 @@ public:
   int                 dialect()                     { return m_xmlrpc.dialect(); }
   void                set_dialect(int dialect)      { m_xmlrpc.set_dialect(dialect); }
 
-  bool                use_xmlrpc() const;
-  void                set_use_xmlrpc(bool v);
-
-  bool                use_jsonrpc() const;
-  void                set_use_jsonrpc(bool v);
+  bool                is_type_enabled(RPCType type) const;
+  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);
@@ -105,9 +102,8 @@ private:
   JsonRpc       m_jsonrpc;
 
   bool          m_handlers_initialized{};
-
-  bool          m_use_jsonrpc{true};
-  bool          m_use_xmlrpc{true};
+  bool          m_is_jsonrpc_enabled{true};
+  bool          m_is_xmlrpc_enabled{true};
 
   std::atomic<bool>         m_scgi_allow_compression{true};
   std::atomic<unsigned int> m_scgi_min_compress_size{1000};
@@ -120,11 +116,6 @@ private:
 
 extern RpcManager rpc;
 
-inline bool RpcManager::use_xmlrpc() const      { return m_use_xmlrpc; }
-inline void RpcManager::set_use_xmlrpc(bool v)  { m_use_xmlrpc = v; }
-inline bool RpcManager::use_jsonrpc() const     { return m_use_jsonrpc; }
-inline void RpcManager::set_use_jsonrpc(bool v) { m_use_jsonrpc = v; }
-
 } // namespace rpc
 
 #endif

src/setup.cc

@@ -38,7 +38,7 @@ parse_main_options(int argc, char** argv) {
     optionParser.insert_option('b', [](auto& arg) { rpc::call_command_set_string("network.bind_address.set", arg); });
     optionParser.insert_option('d', [](auto& arg) { rpc::call_command_set_string("directory.default.set", arg); });
     optionParser.insert_option('i', [](auto& arg) { rpc::call_command_set_string("ip", arg); });
-    optionParser.insert_option('p', [](auto& arg) { rpc::call_command_set_string("network.listen.port.range.set", arg); });
+    optionParser.insert_option('p', [](auto& arg) { rpc::call_command_set_string("network.port_range.set", arg); });
     optionParser.insert_option('s', [](auto& arg) { rpc::call_command_set_string("session", arg); });
 
     optionParser.insert_option('O',      [](auto& arg) { rpc::parse_command_single_std(arg); });

test/rpc/test_parse_options.cc

@@ -169,3 +169,20 @@ TestParseOptions::test_flag_libtorrent() {
 
   FLAG_LT_LOG_ASSERT_ERROR("resume_data|rpc_dump");
 }
+
+#define FLAGS_LT_ENCRYPTION_ASSERT(flags, result)                       \
+  CPPUNIT_ASSERT(rpc::parse_option_flags(flags, std::bind(&torrent::option_find_string_str, torrent::OPTION_ENCRYPTION, std::placeholders::_1)) == (result))
+
+#define FLAGS_LT_ENCRYPTION_ASSERT_ERROR(flags)                         \
+  ASSERT_CATCH_INPUT_ERROR(rpc::parse_option_flags(flags, std::bind(&torrent::option_find_string_str, torrent::OPTION_ENCRYPTION, std::placeholders::_1)))
+
+void
+TestParseOptions::test_flags_libtorrent() {
+  FLAGS_LT_ENCRYPTION_ASSERT("",                           torrent::runtime::NetworkConfig::encryption_none);
+  FLAGS_LT_ENCRYPTION_ASSERT("none",                       torrent::runtime::NetworkConfig::encryption_none);
+  FLAGS_LT_ENCRYPTION_ASSERT("require_rc4",                torrent::runtime::NetworkConfig::encryption_require_RC4);
+  FLAGS_LT_ENCRYPTION_ASSERT("require_RC4",                torrent::runtime::NetworkConfig::encryption_require_RC4);
+  FLAGS_LT_ENCRYPTION_ASSERT("require_RC4 | enable_retry", torrent::runtime::NetworkConfig::encryption_require_RC4 | torrent::runtime::NetworkConfig::encryption_enable_retry);
+
+  FLAGS_LT_ENCRYPTION_ASSERT_ERROR("require_");
+}

test/rpc/test_parse_options.h

@@ -14,6 +14,7 @@ class TestParseOptions : public test_fixture {
   CPPUNIT_TEST(test_flags_print_flags);
 
   CPPUNIT_TEST(test_flag_libtorrent);
+  CPPUNIT_TEST(test_flags_libtorrent);
 
   CPPUNIT_TEST_SUITE_END();
 
@@ -29,4 +30,5 @@ public:
   void test_flags_print_flags();
 
   void test_flag_libtorrent();
+  void test_flags_libtorrent();
 };