Merge branch 'master' into feature/ipc-worker

The string was freed before it was tested, and tmp was never released.

configure.ac

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

src/Makefile.am

@@ -195,6 +195,7 @@ libsub_root_a_SOURCES = \
 	command_tracker.cc \
 	command_scheduler.cc \
 	command_string.cc \
+	command_system.cc \
 	command_ui.cc \
 	control.cc \
 	control.h \

src/command_download.cc

@@ -142,16 +142,6 @@ apply_d_delete_tied(core::Download* download) {
   return torrent::Object();
 }
 
-void
-apply_d_directory(core::Download* download, const std::string& name) {
-  if (!download->file_list()->is_multi_file())
-    download->set_root_directory(name);
-  else if (name.empty() || *name.rbegin() == '/')
-    download->set_root_directory(name + download->info()->name().str());
-  else
-    download->set_root_directory(name + "/" + download->info()->name().str());
-}
-
 torrent::Object
 apply_d_connection_type(core::Download* download, const std::string& name) {
   torrent::Download::ConnectionType t =
@@ -718,7 +708,7 @@ initialize_command_download() {
   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.close.directly", std::bind(&core::DownloadList::close_files, 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));
 
@@ -884,12 +874,11 @@ 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         ("d.directory",          CMD2_ON_FL(root_dir));
-  CMD2_DL         ("d.directory.realpath.or_empty", [](auto* download, auto) { return resolve_path(download->file_list()->root_dir()); });
-  CMD2_DL         ("d.directory.realpath.or_throw", [](auto* download, auto) { return resolve_path_or_throw(download->file_list()->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         ("d.directory",                   CMD2_ON_FL(root_dir));
+  CMD2_DL         ("d.directory.realpath.or_empty", [](auto* download, auto)     { return resolve_path(download->file_list()->root_dir()); });
+  CMD2_DL         ("d.directory.realpath.or_throw", [](auto* download, auto)     { return resolve_path_or_throw(download->file_list()->root_dir()); });
+  CMD2_DL_STRING_V("d.directory.set",               [](auto* download, auto arg) { download->set_directory(arg); });
+  CMD2_DL_STRING_V("d.directory.base.set",          [](auto* download, auto arg) { download->set_base_directory(arg); });
 
   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));
@@ -950,7 +939,6 @@ initialize_command_download() {
   rpc::rpc.mark_safe("d.name.or_base64");
   rpc::rpc.mark_safe("d.name.or_as_binary");
   rpc::rpc.mark_safe("d.directory");
-  rpc::rpc.mark_safe("d.directory_base");
   rpc::rpc.mark_safe("d.creation_date");
   rpc::rpc.mark_safe("d.load_date");
   rpc::rpc.mark_safe("d.up.rate");

src/command_helpers.cc

@@ -20,6 +20,7 @@ void initialize_command_throttle();
 void initialize_command_tracker();
 void initialize_command_scheduler();
 void initialize_command_string();
+void initialize_command_system();
 void initialize_command_ui();
 
 void
@@ -39,4 +40,5 @@ initialize_commands() {
   initialize_command_tracker();
   initialize_command_scheduler();
   initialize_command_string();
+  initialize_command_system();
 }

src/command_ip.cc

@@ -131,7 +131,7 @@ ipv4_range_parse(const char* address, uint32_t* address_start, uint32_t* address
   // copy everything up to '#'  to address_copy and work from there
   while(address[address_start_index] != '#' && address[address_start_index] != '\r' &&
         address[address_start_index] != '\n' && address[address_start_index] != '\0' &&
-        address_start_index < 4096 ) {
+        address_start_index < 4095 ) {
 
     address_copy[address_start_index] = address[address_start_index];
     address_start_index++;
@@ -206,6 +206,9 @@ ipv4_range_parse(const char* address, uint32_t* address_start, uint32_t* address
         if (mask_bits == 0) {
           mask = 0;
           end_mask = ~(uint32_t)0;
+        } else if (mask_bits == 32) {
+          mask = ~(uint32_t)0;
+          end_mask = 0;
         } else {
           mask = (~mask) << (32-mask_bits);
           end_mask = (~end_mask) >> mask_bits;

src/command_local.cc

@@ -1,34 +1,16 @@
 #include "config.h"
 
-#include <cerrno>
-#include <fcntl.h>
-#include <functional>
-#include <limits>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <torrent/torrent.h>
-#include <torrent/data/file_manager.h>
-#include <torrent/data/chunk_utils.h>
-#include <torrent/runtime/runtime.h>
 #include <torrent/runtime/memory_manager.h>
-#include <torrent/runtime/socket_manager.h>
-#include <torrent/utils/chrono.h>
-#include <torrent/utils/option_strings.h>
+#include <torrent/utils/log.h>
 
+#include "command_helpers.h"
+#include "control.h"
 #include "core/download.h"
-#include "core/download_list.h"
 #include "core/manager.h"
 #include "rpc/parse_commands.h"
+#include "rpc/lua.h"
 #include "rpc/scgi.h"
 #include "session/session_manager.h"
-#include "utils/file_status_cache.h"
-
-#include "globals.h"
-#include "rpc/lua.h"
-#include "control.h"
-#include "command_helpers.h"
 
 typedef torrent::ChunkManager CM_t;
 typedef torrent::FileManager  FM_t;
@@ -44,49 +26,6 @@ apply_pieces_stats_total_size() {
   return size;
 }
 
-torrent::Object
-system_env(const torrent::Object::string_type& arg) {
-  if (arg.empty())
-    throw torrent::input_error("system.env: Missing variable name.");
-
-  char* val = getenv(arg.c_str());
-  return std::string(val ? val : "");
-}
-
-torrent::Object
-system_hostname() {
-  char buffer[1024];
-
-  if (gethostname(buffer, 1023) == -1)
-    throw torrent::input_error("Unable to read hostname.");
-
-//   if (shorten)
-//     *std::find(buffer, buffer + 1023, '.') = '\0';
-
-  return std::string(buffer);
-}
-
-torrent::Object
-system_get_cwd() {
-  char* buffer = getcwd(NULL, 0);
-
-  if (buffer == NULL)
-    throw torrent::input_error("Unable to read cwd.");
-
-  torrent::Object result = torrent::Object(std::string(buffer));
-  free(buffer);
-
-  return result;
-}
-
-torrent::Object
-system_set_cwd(const torrent::Object::string_type& rawArgs) {
-  if (::chdir(rawArgs.c_str()) != 0)
-    throw torrent::input_error("Could not change current working directory.");
-
-  return torrent::Object();
-}
-
 inline torrent::Object::list_const_iterator
 post_increment(torrent::Object::list_const_iterator& itr, const torrent::Object::list_const_iterator& last) {
   if (itr == last)
@@ -186,104 +125,19 @@ cmd_file_append(const torrent::Object::list_type& args) {
   return torrent::Object();
 }
 
-uint32_t
-checked_socket_value(int64_t value, const char* label) {
-  if (value < 0 || value > std::numeric_limits<uint32_t>::max())
-    throw torrent::input_error(std::string("Invalid ") + label + " value.");
-
-  return static_cast<uint32_t>(value);
-}
-
 void
 initialize_command_local() {
-  core::DownloadList*    dList = control->core()->download_list();
-  torrent::FileManager*  fileManager = torrent::file_manager();
-
-  CMD_ANY         ("system.hostname", std::bind(&system_hostname));
-  CMD_ANY         ("system.pid",      std::bind(&getpid));
-
-  CMD_VAR_C_STRING("system.api_version",           (int64_t)API_VERSION);
-  CMD_VAR_C_STRING("system.client_version",        PACKAGE_VERSION);
-  CMD_VAR_C_STRING("system.library_version",       torrent::runtime::version());
-
-  CMD_VAR_VALUE   ("system.file.allocate",         0);
-  CMD_VAR_VALUE   ("system.file.max_size",         (int64_t)512 << 30);
-  CMD_VAR_VALUE   ("system.file.split_size",       -1);
-  CMD_VAR_STRING  ("system.file.split_suffix",     ".part");
-
-  CMD_ANY         ("system.file_status_cache.size",   std::bind(&utils::FileStatusCache::size,
-                                                                 (utils::FileStatusCache::base_type*)control->core()->file_status_cache()));
-  CMD_ANY_V       ("system.file_status_cache.prune",  std::bind(&utils::FileStatusCache::prune, control->core()->file_status_cache()));
-
-  CMD_VAR_BOOL    ("file.prioritize_toc",          0);
-  CMD_VAR_LIST    ("file.prioritize_toc.first");
-  CMD_VAR_LIST    ("file.prioritize_toc.last");
-
-  CMD_ANY         ("system.files.advise_random",             std::bind(&FM_t::advise_random, fileManager));
-  CMD_ANY_VALUE_V ("system.files.advise_random.set",         std::bind(&FM_t::set_advise_random, fileManager, std::placeholders::_2));
-  CMD_ANY         ("system.files.advise_random.hashing",     std::bind(&FM_t::advise_random_hashing, fileManager));
-  CMD_ANY_VALUE_V ("system.files.advise_random.hashing.set", std::bind(&FM_t::set_advise_random_hashing, fileManager, std::placeholders::_2));
-  CMD_ANY         ("system.files.session.fdatasync",         [](auto, auto)        { return session_thread::manager()->use_fsyncdisk(); });
-  CMD_ANY_VALUE_V ("system.files.session.fdatasync.set",     [](auto, auto& value) { return session_thread::manager()->set_use_fsyncdisk(value); });
-
-  CMD_ANY         ("system.files.opened_counter",     std::bind(&FM_t::files_opened_counter, fileManager));
-  CMD_ANY         ("system.files.closed_counter",     std::bind(&FM_t::files_closed_counter, fileManager));
-  CMD_ANY         ("system.files.failed_counter",     std::bind(&FM_t::files_failed_counter, fileManager));
-
-  CMD_ANY_STRING  ("system.env",                      [](auto, auto& str)   { return system_env(str); });
-
-  CMD_ANY         ("system.time",                     [](auto, auto)        { return torrent::this_thread::cached_seconds().count(); });
-  CMD_ANY         ("system.time_seconds",             [](auto, auto)        { return torrent::utils::cast_seconds(torrent::utils::time_since_epoch()).count(); });
-  CMD_ANY         ("system.time_usec",                [](auto, auto)        { return torrent::utils::time_since_epoch().count(); });
-
-  CMD_ANY_VALUE_V ("system.umask.set",                [](auto, auto& value) { return ::umask(value); });
-
-  CMD_VAR_BOOL    ("system.daemon",                   false);
-
-  CMD_ANY_V       ("system.shutdown.normal",          [](auto, auto)        { control->receive_normal_shutdown(); });
-  CMD_ANY_V       ("system.shutdown.quick",           [](auto, auto)        { control->receive_quick_shutdown(); });
-
-  CMD_REDIRECT_NO_EXPORT("system.shutdown", "system.shutdown.normal");
-
-  CMD_ANY         ("system.cwd",                      [](auto, auto)        { return system_get_cwd(); });
-  CMD_ANY_STRING  ("system.cwd.set",                  [](auto, auto& str)   { return system_set_cwd(str); });
-
-  CMD_ANY         ("system.sockets.size",             [](auto, auto)        { return torrent::runtime::socket_manager()->size(); });
-  CMD_ANY         ("system.sockets.max_size",         [](auto, auto)        { return torrent::runtime::socket_manager()->max_size(); });
-  CMD_ANY_VALUE_V ("system.sockets.max_size.set",     [](auto, auto& value) { return torrent::runtime::socket_manager()->set_max_size_and_adjust(checked_socket_value(value, "socket max size")); });
-  CMD_ANY_V       ("system.sockets.adjust_alloc",     [](auto, auto)        { torrent::runtime::socket_manager()->adjust_allocation(); });
-  CMD_ANY         ("system.sockets.reserved_alloc",   [](auto, auto)        { return torrent::runtime::socket_manager()->reserved_allocation(); });
-  CMD_ANY         ("system.sockets.available_alloc",  [](auto, auto)        { return torrent::runtime::socket_manager()->available_allocation(); });
-
-  for (uint32_t i = 0; i < torrent::runtime::SocketManager::category_count; ++i) {
-    auto category      = static_cast<torrent::runtime::socket_manager_category_t>(i);
-    auto category_name = "system.sockets." + torrent::option_to_str_or_throw(torrent::OPTION_SOCKET_CATEGORY, i);
-
-    CMD_ANY        (category_name + ".size",      [category](auto, auto) { return torrent::runtime::socket_manager()->category_managed_size(category); });
-    CMD_ANY        (category_name + ".max_size",  [category](auto, auto) { return torrent::runtime::socket_manager()->category_max_size(category); });
-
-    if (i == 0) {
-      CMD_ANY      (category_name + ".min_alloc",   [](auto, auto) { return torrent::runtime::socket_manager()->generic_min_allocation(); });
-      continue;
-    }
-
-    CMD_ANY        (category_name + ".max_alloc.limit", [category](auto, auto) { return torrent::runtime::socket_manager()->category_alloc_limit(category); });
-    CMD_ANY        (category_name + ".min_alloc.limit", [category](auto, auto) { return torrent::runtime::socket_manager()->category_alloc_minimum(category); });
-    CMD_ANY        (category_name + ".min_alloc",     [category](auto, auto) { return torrent::runtime::socket_manager()->category_min_allocation(category); });
-    CMD_ANY        (category_name + ".max_alloc",     [category](auto, auto) { return torrent::runtime::socket_manager()->category_max_allocation(category); });
-    CMD_ANY_VALUE_V(category_name + ".min_alloc.set", [category](auto, auto& value) { torrent::runtime::socket_manager()->set_category_min_allocation(category, checked_socket_value(value, "socket min alloc")); });
-    CMD_ANY_VALUE_V(category_name + ".max_alloc.set", [category](auto, auto& value) { torrent::runtime::socket_manager()->set_category_max_allocation(category, checked_socket_value(value, "socket max alloc")); });
-  }
+  core::DownloadList* dList = control->core()->download_list();
 
   CMD_ANY         ("pieces.sync.always_safe",         [](auto, auto)        { return torrent::runtime::memory_manager()->safe_sync(); });
   CMD_ANY_VALUE_V ("pieces.sync.always_safe.set",     [](auto, auto& value) { return torrent::runtime::memory_manager()->set_safe_sync(value); });
   CMD_ANY         ("pieces.sync.safe_free_diskspace", [](auto, auto)        { return torrent::runtime::memory_manager()->sync_safe_free_diskspace(); });
   CMD_ANY         ("pieces.sync.timeout",             [](auto, auto)        { return torrent::runtime::memory_manager()->timeout_sync().count(); });
   CMD_ANY_VALUE_V ("pieces.sync.timeout.set",         [](auto, auto& value) { return torrent::runtime::memory_manager()->set_timeout_sync(value); });
-  // CMD_ANY         ("pieces.sync.timeout_safe",        [](auto, auto)        { return torrent::runtime::memory_manager()->timeout_safe_sync(); });
-  // CMD_ANY_VALUE_V ("pieces.sync.timeout_safe.set",    [](auto, auto& value) { return torrent::runtime::memory_manager()->set_timeout_safe_sync(value); });
   CMD_ANY         ("pieces.sync.timeout_safe",        [](auto, auto)        { return 0; });
-  CMD_ANY_VALUE_V ("pieces.sync.timeout_safe.set",    [](auto, auto)        { });
+  CMD_ANY_VALUE_V ("pieces.sync.timeout_safe.set",    [](auto, auto)        {
+      lt_log_print(torrent::LOG_WARN, "pieces.sync.timeout_safe.set is no longer supported and does nothing.");
+    });
   CMD_ANY         ("pieces.sync.queue_size",          [](auto, auto)        { return torrent::runtime::memory_manager()->sync_queue_block_count(); });
 
   CMD_ANY         ("pieces.preload.type",             [](auto, auto)        { return torrent::runtime::memory_manager()->preload_type(); });
@@ -358,38 +212,6 @@ initialize_command_local() {
 
   CMD_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");
-  rpc::rpc.mark_safe("system.time");
-  rpc::rpc.mark_safe("system.time_seconds");
-  rpc::rpc.mark_safe("system.time_usec");
-  rpc::rpc.mark_safe("system.file.max_size");
-  rpc::rpc.mark_safe("system.file.split_size");
-  rpc::rpc.mark_safe("system.file.split_suffix");
-
-  rpc::rpc.mark_safe("system.sockets.size");
-  rpc::rpc.mark_safe("system.sockets.max_size");
-  rpc::rpc.mark_safe("system.sockets.reserved_alloc");
-  rpc::rpc.mark_safe("system.sockets.available_alloc");
-
-  for (uint32_t i = 0; i < torrent::runtime::SocketManager::category_count; ++i) {
-    auto category_name = "system.sockets." + torrent::option_to_str_or_throw(torrent::OPTION_SOCKET_CATEGORY, i);
-
-    rpc::rpc.mark_safe(category_name + ".size");
-    rpc::rpc.mark_safe(category_name + ".max_size");
-
-    if (i == 0) {
-      rpc::rpc.mark_safe(category_name + ".min_alloc");
-      continue;
-    }
-
-    rpc::rpc.mark_safe(category_name + ".max_alloc.limit");
-    rpc::rpc.mark_safe(category_name + ".min_alloc.limit");
-    rpc::rpc.mark_safe(category_name + ".min_alloc");
-    rpc::rpc.mark_safe(category_name + ".max_alloc");
-  }
-
   rpc::rpc.mark_safe("directory.default");
   rpc::rpc.mark_safe("session.path");
   rpc::rpc.mark_safe("session.path.realpath.or_empty");

src/command_logging.cc

@@ -135,7 +135,7 @@ initialize_command_logging() {
   CMD2_ANY_LIST    ("log.open_gz_file_pid",   std::bind(&apply_log_open, log_flag_append_pid | log_flag_use_gz, std::placeholders::_2));
   CMD2_ANY_LIST    ("log.append_file",        std::bind(&apply_log_open, log_flag_append_file, std::placeholders::_2));
   CMD2_ANY_LIST    ("log.append_file.flush",  std::bind(&apply_log_open, log_flag_append_file | log_flag_flush, std::placeholders::_2));
-  CMD2_ANY_LIST    ("log.append_gz_file",     std::bind(&apply_log_open, log_flag_append_file, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.append_gz_file",     std::bind(&apply_log_open, log_flag_append_file | log_flag_use_gz, std::placeholders::_2));
 
   CMD2_ANY_STRING_V("log.close",            std::bind(&torrent::log_close_output_str, std::placeholders::_2));
 

src/command_system.cc

@@ -0,0 +1,195 @@
+#include "config.h"
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <torrent/data/file_manager.h>
+#include <torrent/runtime/client_config.h>
+#include <torrent/runtime/memory_manager.h>
+#include <torrent/runtime/socket_manager.h>
+#include <torrent/runtime/runtime.h>
+#include <torrent/utils/chrono.h>
+#include <torrent/utils/option_strings.h>
+
+#include "command_helpers.h"
+#include "control.h"
+#include "globals.h"
+#include "core/manager.h"
+#include "session/session_manager.h"
+#include "utils/file_status_cache.h"
+
+
+torrent::Object
+system_env(const torrent::Object::string_type& arg) {
+  if (arg.empty())
+    throw torrent::input_error("system.env: Missing variable name.");
+
+  char* val = getenv(arg.c_str());
+  return std::string(val ? val : "");
+}
+
+torrent::Object
+system_hostname() {
+  char buffer[1024];
+
+  if (gethostname(buffer, 1023) == -1)
+    throw torrent::input_error("Unable to read hostname.");
+
+//   if (shorten)
+//     *std::find(buffer, buffer + 1023, '.') = '\0';
+
+  return std::string(buffer);
+}
+
+torrent::Object
+system_get_cwd() {
+  char* buffer = getcwd(NULL, 0);
+
+  if (buffer == NULL)
+    throw torrent::input_error("Unable to read cwd.");
+
+  torrent::Object result = torrent::Object(std::string(buffer));
+  free(buffer);
+
+  return result;
+}
+
+torrent::Object
+system_set_cwd(const torrent::Object::string_type& rawArgs) {
+  if (::chdir(rawArgs.c_str()) != 0)
+    throw torrent::input_error("Could not change current working directory.");
+
+  return torrent::Object();
+}
+
+uint32_t
+checked_socket_value(int64_t value, const char* label) {
+  if (value < 0 || value > std::numeric_limits<uint32_t>::max())
+    throw torrent::input_error(std::string("Invalid ") + label + " value.");
+
+  return static_cast<uint32_t>(value);
+}
+
+void
+initialize_command_system() {
+  CMD_ANY         ("system.hostname", std::bind(&system_hostname));
+  CMD_ANY         ("system.pid",      std::bind(&getpid));
+
+  CMD_VAR_C_STRING("system.api_version",           (int64_t)API_VERSION);
+  CMD_VAR_C_STRING("system.client_version",        PACKAGE_VERSION);
+  CMD_VAR_C_STRING("system.library_version",       torrent::runtime::version());
+
+  CMD_ANY         ("system.torrent_name.use_sanitized",     [](auto, auto)        { return torrent::runtime::client_config()->torrent_name_use_sanitized(); });
+  CMD_ANY_VALUE_V ("system.torrent_name.use_sanitized.set", [](auto, auto& value) { return torrent::runtime::client_config()->set_torrent_name_use_sanitized(value); });
+
+  CMD_VAR_VALUE   ("system.file.allocate",         0);
+  CMD_VAR_VALUE   ("system.file.max_size",         (int64_t)512 << 30);
+  CMD_VAR_VALUE   ("system.file.split_size",       -1);
+  CMD_VAR_STRING  ("system.file.split_suffix",     ".part");
+
+  CMD_ANY         ("system.file_name.replace_slash",     [](auto, auto)      { return torrent::runtime::client_config()->file_name_replace_slash(); });
+  CMD_ANY_STRING_V("system.file_name.replace_slash.set", [](auto, auto& str) { return torrent::runtime::client_config()->set_file_name_replace_slash(str); });
+
+  CMD_ANY         ("system.file_status_cache.size",      [](auto, auto)      { return control->core()->file_status_cache()->size(); });
+  CMD_ANY_V       ("system.file_status_cache.prune",     [](auto, auto)      { return control->core()->file_status_cache()->prune(); });
+
+  CMD_VAR_BOOL    ("file.prioritize_toc",          0);
+  CMD_VAR_LIST    ("file.prioritize_toc.first");
+  CMD_VAR_LIST    ("file.prioritize_toc.last");
+
+  CMD_ANY         ("system.files.advise_random",             [](auto, auto)        { return torrent::file_manager()->advise_random(); });
+  CMD_ANY_VALUE_V ("system.files.advise_random.set",         [](auto, auto& value) { return torrent::file_manager()->set_advise_random(value); });
+  CMD_ANY         ("system.files.advise_random.hashing",     [](auto, auto)        { return torrent::file_manager()->advise_random_hashing(); });
+  CMD_ANY_VALUE_V ("system.files.advise_random.hashing.set", [](auto, auto& value) { return torrent::file_manager()->set_advise_random_hashing(value); });
+  CMD_ANY         ("system.files.session.fdatasync",         [](auto, auto)        { return session_thread::manager()->use_fsyncdisk(); });
+  CMD_ANY_VALUE_V ("system.files.session.fdatasync.set",     [](auto, auto& value) { return session_thread::manager()->set_use_fsyncdisk(value); });
+
+  CMD_ANY         ("system.files.close_idle",         [](auto, auto)        { return torrent::file_manager()->close_idle_timeout().count(); });
+  CMD_ANY_VALUE_V ("system.files.close_idle.set",     [](auto, auto& value) { return torrent::file_manager()->set_close_idle_timeout(value * 1s); });
+
+  CMD_ANY         ("system.files.opened_counter",     [](auto, auto)        { return torrent::file_manager()->files_opened_counter(); });
+  CMD_ANY         ("system.files.closed_counter",     [](auto, auto)        { return torrent::file_manager()->files_closed_counter(); });
+  CMD_ANY         ("system.files.failed_counter",     [](auto, auto)        { return torrent::file_manager()->files_failed_counter(); });
+
+  CMD_ANY_STRING  ("system.env",                      [](auto, auto& str)   { return system_env(str); });
+
+  CMD_ANY         ("system.time",                     [](auto, auto)        { return torrent::this_thread::cached_seconds().count(); });
+  CMD_ANY         ("system.time_seconds",             [](auto, auto)        { return torrent::utils::cast_seconds(torrent::utils::time_since_epoch()).count(); });
+  CMD_ANY         ("system.time_usec",                [](auto, auto)        { return torrent::utils::time_since_epoch().count(); });
+
+  CMD_ANY_VALUE_V ("system.umask.set",                [](auto, auto& value) { return ::umask(value); });
+
+  CMD_VAR_BOOL    ("system.daemon",                   false);
+
+  CMD_ANY_V       ("system.shutdown.normal",          [](auto, auto)        { control->receive_normal_shutdown(); });
+  CMD_ANY_V       ("system.shutdown.quick",           [](auto, auto)        { control->receive_quick_shutdown(); });
+
+  CMD_REDIRECT_NO_EXPORT("system.shutdown", "system.shutdown.normal");
+
+  CMD_ANY         ("system.cwd",                      [](auto, auto)        { return system_get_cwd(); });
+  CMD_ANY_STRING  ("system.cwd.set",                  [](auto, auto& str)   { return system_set_cwd(str); });
+
+  CMD_ANY         ("system.sockets.size",             [](auto, auto)        { return torrent::runtime::socket_manager()->size(); });
+  CMD_ANY         ("system.sockets.max_size",         [](auto, auto)        { return torrent::runtime::socket_manager()->max_size(); });
+  CMD_ANY_VALUE_V ("system.sockets.max_size.set",     [](auto, auto& value) {
+      return torrent::runtime::socket_manager()->set_max_size_and_adjust(checked_socket_value(value, "socket max size"));
+    });
+  CMD_ANY_V       ("system.sockets.adjust_alloc",     [](auto, auto)        { torrent::runtime::socket_manager()->adjust_allocation(); });
+  CMD_ANY         ("system.sockets.reserved_alloc",   [](auto, auto)        { return torrent::runtime::socket_manager()->reserved_allocation(); });
+  CMD_ANY         ("system.sockets.available_alloc",  [](auto, auto)        { return torrent::runtime::socket_manager()->available_allocation(); });
+
+  for (uint32_t i = 0; i < torrent::runtime::SocketManager::category_count; ++i) {
+    auto category      = static_cast<torrent::runtime::socket_manager_category_t>(i);
+    auto category_name = "system.sockets." + torrent::option_to_str_or_throw(torrent::OPTION_SOCKET_CATEGORY, i);
+
+    CMD_ANY        (category_name + ".size",      [category](auto, auto) { return torrent::runtime::socket_manager()->category_managed_size(category); });
+    CMD_ANY        (category_name + ".max_size",  [category](auto, auto) { return torrent::runtime::socket_manager()->category_max_size(category); });
+
+    if (i == 0) {
+      CMD_ANY      (category_name + ".min_alloc", [](auto, auto) { return torrent::runtime::socket_manager()->generic_min_allocation(); });
+      continue;
+    }
+
+    CMD_ANY        (category_name + ".max_alloc.limit", [category](auto, auto)        { return torrent::runtime::socket_manager()->category_alloc_limit(category); });
+    CMD_ANY        (category_name + ".min_alloc.limit", [category](auto, auto)        { return torrent::runtime::socket_manager()->category_alloc_minimum(category); });
+    CMD_ANY        (category_name + ".min_alloc",       [category](auto, auto)        { return torrent::runtime::socket_manager()->category_min_allocation(category); });
+    CMD_ANY        (category_name + ".max_alloc",       [category](auto, auto)        { return torrent::runtime::socket_manager()->category_max_allocation(category); });
+    CMD_ANY_VALUE_V(category_name + ".min_alloc.set",   [category](auto, auto& value) {
+        torrent::runtime::socket_manager()->set_category_min_allocation(category, checked_socket_value(value, "socket min alloc"));
+      });
+    CMD_ANY_VALUE_V(category_name + ".max_alloc.set",   [category](auto, auto& value) {
+        torrent::runtime::socket_manager()->set_category_max_allocation(category, checked_socket_value(value, "socket max alloc"));
+      });
+  }
+
+  rpc::rpc.mark_safe("system.api_version");
+  rpc::rpc.mark_safe("system.client_version");
+  rpc::rpc.mark_safe("system.library_version");
+  rpc::rpc.mark_safe("system.time");
+  rpc::rpc.mark_safe("system.time_seconds");
+  rpc::rpc.mark_safe("system.time_usec");
+  rpc::rpc.mark_safe("system.file.max_size");
+  rpc::rpc.mark_safe("system.file.split_size");
+  rpc::rpc.mark_safe("system.file.split_suffix");
+
+  rpc::rpc.mark_safe("system.sockets.size");
+  rpc::rpc.mark_safe("system.sockets.max_size");
+  rpc::rpc.mark_safe("system.sockets.reserved_alloc");
+  rpc::rpc.mark_safe("system.sockets.available_alloc");
+
+  for (uint32_t i = 0; i < torrent::runtime::SocketManager::category_count; ++i) {
+    auto category_name = "system.sockets." + torrent::option_to_str_or_throw(torrent::OPTION_SOCKET_CATEGORY, i);
+
+    rpc::rpc.mark_safe(category_name + ".size");
+    rpc::rpc.mark_safe(category_name + ".max_size");
+
+    if (i == 0) {
+      rpc::rpc.mark_safe(category_name + ".min_alloc");
+      continue;
+    }
+
+    rpc::rpc.mark_safe(category_name + ".max_alloc.limit");
+    rpc::rpc.mark_safe(category_name + ".min_alloc.limit");
+    rpc::rpc.mark_safe(category_name + ".min_alloc");
+    rpc::rpc.mark_safe(category_name + ".max_alloc");
+  }
+}

src/control.h

@@ -118,4 +118,6 @@ private:
   std::atomic<bool>   m_shutdown_quick{};
 };
 
+extern Control* control;
+
 #endif

src/core/download.cc

@@ -101,7 +101,18 @@ Download::set_throttle_name(const std::string& name) {
 }
 
 void
-Download::set_root_directory(const std::string& path) {
+Download::set_directory(const std::string& path) {
+  if (!m_download.file_list()->is_multi_file())
+    return set_base_directory(path);
+
+  if (path.empty() || *path.rbegin() == '/')
+    return set_base_directory(path + m_download.info()->name_sanitized());
+
+  set_base_directory(path + "/" + m_download.info()->name_sanitized());
+}
+
+void
+Download::set_base_directory(const std::string& path) {
   // If the download is open, hashed and has completed chunks make
   // sure to verify that the download files are still present.
   //
@@ -120,13 +131,12 @@ Download::set_root_directory(const std::string& path) {
        !file_stat.update(file_list->front()->frozen_path().str()))) {
 
     set_message("Cannot change the directory of an open download after the files have been moved.");
-    rpc::call_command("d.state.set", (int64_t)0, rpc::make_target(this));
     control->core()->download_list()->close_directly(this);
 
     throw torrent::input_error("Cannot change the directory of an open download after the files have been moved.");
   }
 
-  control->core()->download_list()->close_directly(this);
+  control->core()->download_list()->close_files(this);
   file_list->set_root_dir(expand_path(path));
 
   bencode()->get_key("rtorrent").insert_key("directory", path);

src/core/download.h

@@ -79,7 +79,8 @@ public:
   uint32_t            resume_flags()                           { return m_resumeFlags; }
   void                set_resume_flags(uint32_t flags)         { m_resumeFlags = flags; }
 
-  void                set_root_directory(const std::string& path);
+  void                set_directory(const std::string& path);
+  void                set_base_directory(const std::string& path);
 
   void                set_throttle_name(const std::string& name);
 

src/core/download_factory.cc

@@ -7,6 +7,7 @@
 #include <functional>
 #include <sstream>
 #include <stdexcept>
+#include <sys/stat.h>
 #include <torrent/utils/log.h>
 #include <torrent/utils/resume.h>
 #include <torrent/object.h>
@@ -39,6 +40,11 @@ static constexpr const char* session_invalid_message = "Session data is invalid,
 
 static std::unique_ptr<torrent::Object>
 download_factory_load_stream(const char* filename, bool* is_invalid) {
+  struct stat sb;
+
+  if (stat(filename, &sb) != 0 || !S_ISREG(sb.st_mode))
+    return std::unique_ptr<torrent::Object>();
+
   std::fstream stream(filename, std::ios::in | std::ios::binary);
 
   if (!stream.is_open())
@@ -167,11 +173,19 @@ void
 DownloadFactory::receive_success() {
   bool session_invalid = false;
 
-  auto rtorrent_object          = download_factory_load_stream((expand_path(m_uri) + ".rtorrent").c_str(), &session_invalid);
-  auto libtorrent_resume_object = download_factory_load_stream((expand_path(m_uri) + ".libtorrent_resume").c_str(), &session_invalid);
+  std::unique_ptr<torrent::Object> rtorrent_object;
+  std::unique_ptr<torrent::Object> libtorrent_resume_object;
 
-  if (session_invalid)
-    lt_log_print(torrent::LOG_ERROR, "%s: %s", session_invalid_message, m_uri.c_str());
+  if (m_session) {
+    if (m_uri.empty())
+      throw torrent::input_error("Session torrent URI is empty.");
+
+    rtorrent_object          = download_factory_load_stream((expand_path(m_uri) + ".rtorrent").c_str(), &session_invalid);
+    libtorrent_resume_object = download_factory_load_stream((expand_path(m_uri) + ".libtorrent_resume").c_str(), &session_invalid);
+
+    if (session_invalid)
+      lt_log_print(torrent::LOG_ERROR, "%s: %s", session_invalid_message, m_uri.c_str());
+  }
 
   uint32_t tracker_key;
 

src/core/download_list.cc

@@ -254,9 +254,11 @@ DownloadList::close(Download* download) {
   }
 }
 
+// Releases the files without changing the download's state, for callers that
+// need the files closed and will keep using the download.
 void
-DownloadList::close_directly(Download* download) {
-  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Closing download directly.");
+DownloadList::close_files(Download* download) {
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Closing download files.");
 
   if (download->download()->info()->is_active()) {
     download->download()->stop(torrent::Download::stop_skip_tracker);
@@ -269,6 +271,44 @@ DownloadList::close_directly(Download* download) {
     download->download()->close();
 }
 
+void
+DownloadList::close_directly(Download* download) {
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Closing download directly.");
+
+  bool was_active = download->download()->info()->is_active();
+  bool was_open   = download->download()->info()->is_open();
+
+  close_files(download);
+  set_state_stopped(download);
+
+  if (was_active) {
+    DL_TRIGGER_EVENT(download, "event.download.paused");
+    update_paused_state(download);
+  }
+
+  if (was_open) {
+    DL_TRIGGER_EVENT(download, "event.download.hash_removed");
+    DL_TRIGGER_EVENT(download, "event.download.closed");
+  }
+}
+
+void
+DownloadList::set_state_stopped(Download* download) {
+  control->view_manager()->find_ptr_throw("stopped")->set_visible(download);
+  rpc::call_command("d.state.set", (int64_t)0, rpc::make_target(download));
+}
+
+void
+DownloadList::update_paused_state(Download* download) {
+  rpc::call_command("d.state_changed.set", torrent::this_thread::cached_seconds().count(), rpc::make_target(download));
+  rpc::call_command("d.state_counter.set", rpc::call_command_value("d.state_counter", rpc::make_target(download)), rpc::make_target(download));
+
+  // If initial seeding is complete, don't try it again when restarting.
+  if (download->is_done() &&
+      rpc::call_command("d.connection_current", torrent::Object(), rpc::make_target(download)).as_string() == "initial_seed")
+    rpc::call_command("d.connection_seed.set", rpc::call_command("d.connection_current", torrent::Object(), rpc::make_target(download)), rpc::make_target(download));
+}
+
 void
 DownloadList::close_quick(Download* download) {
   lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Closing download quickly.");
@@ -443,15 +483,7 @@ DownloadList::pause(Download* download, int flags) {
     // view.
     DL_TRIGGER_EVENT(download, "event.download.paused");
 
-    auto cached_seconds = torrent::this_thread::cached_seconds().count();
-
-    rpc::call_command("d.state_changed.set", cached_seconds, rpc::make_target(download));
-    rpc::call_command("d.state_counter.set", rpc::call_command_value("d.state_counter", rpc::make_target(download)), rpc::make_target(download));
-
-    // If initial seeding is complete, don't try it again when restarting.
-    if (download->is_done() &&
-        rpc::call_command("d.connection_current", torrent::Object(), rpc::make_target(download)).as_string() == "initial_seed")
-      rpc::call_command("d.connection_seed.set", rpc::call_command("d.connection_current", torrent::Object(), rpc::make_target(download)), rpc::make_target(download));
+    update_paused_state(download);
 
     // Save the state after all the slots, etc have been called so we
     // include the modifications they may make.
@@ -522,7 +554,7 @@ DownloadList::hash_done(Download* download) {
     // If the download was previously completed but the files were
     // f.ex deleted, then we clear the state and complete.
     if (rpc::call_command_value("d.complete", rpc::make_target(download)) && !download->is_done()) {
-      rpc::call_command("d.state.set", (int64_t)0, rpc::make_target(download));
+      set_state_stopped(download);
       download->set_message("Download registered as completed, but hash check returned unfinished chunks.");
     }
 

src/core/download_list.h

@@ -75,6 +75,7 @@ public:
 
   void                close(Download* d);
   void                close_directly(Download* d);
+  void                close_files(Download* d);
   void                close_quick(Download* d);
   void                close_throw(Download* d);
 
@@ -132,6 +133,9 @@ private:
   void                hash_done(Download* d);
   void                hash_queue(Download* d, int type);
 
+  void                set_state_stopped(Download* d);
+  void                update_paused_state(Download* d);
+
   inline void         check_contains(Download* d);
 
   void                received_finished(Download* d);

src/input/input_event.cc

@@ -11,8 +11,7 @@ namespace input {
 
 void
 InputEvent::insert() {
-  torrent::this_thread::poll()->open(this);
-  torrent::this_thread::poll()->insert_read(this);
+  torrent::this_thread::poll()->open_and_insert_read(this);
 }
 
 void

src/main.cc

@@ -112,8 +112,9 @@ main(int argc, char** argv) {
 
     torrent::log_initialize();
 
-    // TODO: Create a fake thread object for initializing other processes and enabling logging.
-    torrent::initialize_main_thread();
+    torrent::runtime::initialize_worker_process_and_main_thread([argc, argv]() {
+        parse_config_file(argc, argv, [](auto& path) { parse_config_file_comments("worker", path); });
+      });
 
     // Block SIGCHLD until all threads are created, then unblock on main-thread, to avoid SIGCHLD
     // interrupting other threads.
@@ -125,9 +126,9 @@ main(int argc, char** argv) {
     SignalHandler::set_block(SIGCHLD);
 
     // All signal handlers must restore errno if they return.
-    SignalHandler::set_handler(SIGSEGV,  std::bind(&do_panic, SIGSEGV));
-    SignalHandler::set_handler(SIGILL,   std::bind(&do_panic, SIGILL));
-    SignalHandler::set_handler(SIGFPE,   std::bind(&do_panic, SIGFPE));
+    SignalHandler::set_handler(SIGSEGV,  []() { do_panic(SIGSEGV); });
+    SignalHandler::set_handler(SIGILL,   []() { do_panic(SIGILL); });
+    SignalHandler::set_handler(SIGFPE,   []() { do_panic(SIGFPE); });
 
     // Limited list of commands with the following format:
     //
@@ -136,19 +137,17 @@ main(int argc, char** argv) {
     // # do:log.open_file=system,/usr/rakshasa/system.log
     // # do:log.add_output=system,system
     //
-    parse_config_file(argc, argv, [](auto& path) {
-        if (path.empty())
-          return;
-
-        parse_config_file_comments(path);
-      });
+    // # do-worker:log.open_file=system,/usr/rakshasa/system-worker.log
+    // # do-worker:log.add_output=system,system
+    //
+    parse_config_file(argc, argv, [](auto& path) { parse_config_file_comments("", path); });
 
     control = new Control;
 
-    SignalHandler::set_handler(SIGINT,   std::bind(&Control::receive_normal_shutdown, control));
-    SignalHandler::set_handler(SIGHUP,   std::bind(&Control::receive_normal_shutdown, control));
-    SignalHandler::set_handler(SIGTERM,  std::bind(&Control::receive_quick_shutdown, control));
-    SignalHandler::set_handler(SIGWINCH, std::bind(&display::Manager::force_redraw, control->display()));
+    SignalHandler::set_handler(SIGINT,   []() { control->receive_normal_shutdown(); });
+    SignalHandler::set_handler(SIGHUP,   []() { control->receive_normal_shutdown(); });
+    SignalHandler::set_handler(SIGTERM,  []() { control->receive_quick_shutdown(); });
+    SignalHandler::set_handler(SIGWINCH, []() { control->display()->force_redraw(); });
 
     SignalHandler::set_sigaction_handler(SIGBUS, &handle_sigbus);
 
@@ -379,6 +378,12 @@ main(int argc, char** argv) {
         lt_log_print(torrent::LOG_WARN, "network.max_open_files.set is deprecated, use system.sockets.files.min_alloc.set instead.");
       });
 
+    // TODO: Keep d.directory_base for a while as it is widely used.
+    CMD_REDIRECT("d.directory_base",     "d.directory");
+    CMD_REDIRECT("d.directory_base.set", "d.directory.base.set");
+
+    rpc::rpc.mark_safe("d.directory_base");
+
     // if (rpc::call_command_value("method.use_intermediate") == 1) {
 
     // } else if (rpc::call_command_value("method.use_intermediate") == 2) {
@@ -463,6 +468,8 @@ main(int argc, char** argv) {
     control->ui()->load_input_history();
 
     torrent::net_thread::http_stack()->set_user_agent(USER_AGENT);
+
+    torrent::runtime::initialize_worker_process();
     torrent::runtime::initialize_network();
 
     // Load session torrents and perform scheduled tasks to ensure session torrents are loaded

src/option_parser.cc

@@ -108,6 +108,6 @@ OptionParser::call_int_pair(slot_int_pair slot, const std::string& arg) {
 
   if (a < 0 || b < 0)
     throw std::runtime_error("Invalid argument, \"" + arg + "\" should be positive numbers");
-  
+
   slot(a, b);
 }

src/rpc/rpc_manager.cc

@@ -167,6 +167,14 @@ RpcManager::cleanup() {
   m_jsonrpc.cleanup();
 }
 
+void
+RpcManager::set_size_limit(uint64_t size) {
+  if (size > SCgiTask::max_content_size)
+    throw torrent::input_error("XMLRPC size limit cannot exceed the SCGI content size limit.");
+
+  m_xmlrpc.set_size_limit(size);
+}
+
 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

@@ -62,7 +62,7 @@ public:
   void                cleanup();
 
   int64_t             size_limit()                  { return m_xmlrpc.size_limit(); };
-  void                set_size_limit(uint64_t size) { m_xmlrpc.set_size_limit(size); };
+  void                set_size_limit(uint64_t size);
 
   int                 dialect()                     { return m_xmlrpc.dialect(); }
   void                set_dialect(int dialect)      { m_xmlrpc.set_dialect(dialect); }

src/rpc/scgi.cc

@@ -109,8 +109,7 @@ void
 SCgi::activate() {
   assert(torrent::this_thread::thread() == scgi_thread::thread());
 
-  torrent::this_thread::poll()->open(this);
-  torrent::this_thread::poll()->insert_read(this);
+  torrent::this_thread::poll()->open_and_insert_read(this);
 }
 
 // TODO: This should close the fd to avoid reuse.

src/rpc/scgi_task.cc

@@ -50,8 +50,7 @@ SCgiTask::open(SCgi* parent, int fd) {
                                  // m_trusted=false into the next reuse, given that the
                                  // UNTRUSTED_CONNECTION=0 parse branch is a no-op.
 
-  torrent::this_thread::poll()->open(this);
-  torrent::this_thread::poll()->insert_read(this);
+  torrent::this_thread::poll()->open_and_insert_read(this);
 
   torrent::this_thread::scheduler()->update_wait_for_ceil_seconds(&m_task_timeout, timeout_request);
 

src/rpc/scgi_task.h

@@ -16,7 +16,7 @@ class SCgiTask : public torrent::system::Event {
 public:
   static constexpr int default_buffer_size = 8191;
   static constexpr int max_header_size     = 2000;
-  static constexpr int max_content_size    = (2 << 23);
+  static constexpr int max_content_size    = (1 << 26);
 
   static constexpr auto timeout_request = std::chrono::seconds(60);
 

src/rpc/xmlrpc_c.cc

@@ -77,16 +77,18 @@ xmlrpc_list_entry_to_value(xmlrpc_env* env, xmlrpc_value* src, int index) {
   {
     const char* str;
     xmlrpc_read_string(env, tmp, &str);
+    xmlrpc_DECREF(tmp);
 
     if (env->fault_occurred)
       throw xmlrpc_error_c(env);
 
     const char* end = str;
     int64_t v3 = ::strtoll(str, (char**)&end, 0);
+    bool invalid = *str == '\0' || *end != '\0';
 
     ::free((void*)str);
 
-    if (*str == '\0' || *end != '\0')
+    if (invalid)
       throw xmlrpc_error_c(XMLRPC_TYPE_ERROR, "Invalid index.");
 
     return v3;
@@ -529,9 +531,6 @@ XmlRpc::size_limit() {
 
 void
 XmlRpc::set_size_limit(uint64_t size) {
-  if (size >= (64 << 20))
-    throw torrent::input_error("Invalid XMLRPC limit size.");
-
   xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, size);
 }
 

src/session/download_storer.cc

@@ -127,8 +127,12 @@ save_stream(const std::string& path, bool use_fsyncdisk, const std::stringstream
   if (!output.good())
     throw torrent::storage_error("failed to write stream to file : " + path);
 
+  // The data only reaches the kernel here, so this is where a full disk is seen.
   output.close();
 
+  if (!output.good())
+    throw torrent::storage_error("failed to flush stream to file : " + path);
+
   // Ensure that the new file is actually written to the disk
   int fd = ::open(path.c_str(), O_WRONLY);
 
@@ -137,13 +141,19 @@ save_stream(const std::string& path, bool use_fsyncdisk, const std::stringstream
 
   if (use_fsyncdisk) {
 #ifdef __APPLE__
-    ::fsync(fd);
+    int sync_result = ::fsync(fd);
 #else
-    ::fdatasync(fd);
+    int sync_result = ::fdatasync(fd);
 #endif
+
+    if (sync_result == -1) {
+      ::close(fd);
+      throw torrent::storage_error("failed to sync file to disk : " + path);
+    }
   }
 
-  ::close(fd);
+  if (::close(fd) == -1)
+    throw torrent::storage_error("failed to close file descriptor : " + path);
 }
 
 } // namespace anonymous

src/session/session_manager.h

@@ -126,7 +126,7 @@ private:
 
 inline bool        SessionManager::is_used() const            { return !m_path.empty(); }
 inline std::string SessionManager::path() const               { return m_path; }
-inline bool        SessionManager::use_fsyncdisk() const      { return true; }
+inline bool        SessionManager::use_fsyncdisk() const      { return m_use_fsyncdisk; }
 inline bool        SessionManager::use_lock() const           { return m_use_lock; }
 inline void        SessionManager::flush_all_pending_builds() { process_pending_builds(true); }
 

src/setup.cc

@@ -108,18 +108,22 @@ config_comment_log(const std::string& command, const std::string& raw_args) {
     throw torrent::input_error("Unknown log command: " + command);
 }
 
-// Call special commands in the format "# do:command=args" in the config file.
+// Call special commands in the format "# do:command=args" or "# do-<category>:command=args" in the config file.
 void
-parse_config_file_comments(const std::string& path) {
+parse_config_file_comments(const std::string& category, const std::string& path) {
+  if (path.empty())
+    return;
+
   std::fstream file(path, std::ios::in);
 
   if (!file.is_open())
     return;
 
   std::string line;
+  std::string prefix = category.empty() ? "# do:" : "# do-" + category + ":";
 
   while (std::getline(file, line)) {
-    if (line.size() <= 5 || line.compare(0, 5, "# do:") != 0)
+    if (line.size() <= prefix.size() || line.compare(0, prefix.size(), prefix) != 0)
       continue;
 
     auto equal_pos = line.find('=');
@@ -127,8 +131,8 @@ parse_config_file_comments(const std::string& path) {
     if (equal_pos == std::string::npos)
       throw torrent::input_error("Invalid command in config file comment: " + line);
 
-    std::string command = line.substr(5, equal_pos - 5);
-    std::string args    = line.substr(equal_pos + 1);
+    auto command = line.substr(prefix.size(), equal_pos - prefix.size());
+    auto args    = line.substr(equal_pos + 1);
 
     if (command.empty())
       throw torrent::input_error("Invalid command in config file comment: " + line);

src/setup.h

@@ -3,10 +3,11 @@
 
 #include <functional>
 #include <string>
+#include <vector>
 
 int  parse_main_options(int argc, char** argv);
 void parse_config_file(int argc, char** argv, std::function<void (const std::string&)> parse_fn);
-void parse_config_file_comments(const std::string& path);
+void parse_config_file_comments(const std::string& category, const std::string& path);
 
 void load_session_torrents(const std::string& path);
 void load_arg_torrents(char** first, char** last);

src/utils/gzip.cc

@@ -5,6 +5,8 @@
 #include <zlib.h>
 #include <torrent/exceptions.h>
 
+#include "utils/functional.h"
+
 namespace utils {
 
 void
@@ -21,6 +23,8 @@ gzip_compress_to_vector(const char* buffer, unsigned int length, std::vector<cha
   if (deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, window_bits | gzip_encoding, gzip_level, Z_DEFAULT_STRATEGY) != Z_OK)
     throw torrent::internal_error("gzip_compress_to_vector(...) could not initialize gzip deflate.");
 
+  scope_guard guard([&zs]() { deflateEnd(&zs); });
+
   auto max_response_size = deflateBound(&zs, length);
 
   output.resize(offset + max_response_size);

src/utils/gzip.h

@@ -2,6 +2,7 @@
 #define RTORRENT_UTILS_GZIP_H
 
 #include <functional>
+#include <vector>
 
 namespace utils {
 

test/Makefile.am

@@ -51,8 +51,10 @@ rtorrent_Test_Rpc_SOURCES = $(rtorrent_Test_Common) \
 rtorrent_Test_Src_SOURCES = $(rtorrent_Test_Common) \
 	src/test_command_dynamic.cc \
 	src/test_command_dynamic.h \
-	src/test_command_local.cc \
-	src/test_command_local.h \
+	src/test_command_ip.cc \
+	src/test_command_ip.h \
+	src/test_command_system.cc \
+	src/test_command_system.h \
 	src/test_command_path.cc \
 	src/test_command_path.h \
 	src/test_command_string.cc \

test/src/test_command_ip.cc

@@ -0,0 +1,55 @@
+#include "config.h"
+
+#include "test/src/test_command_ip.h"
+
+#include <cstdint>
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestCommandIp);
+
+bool ipv4_range_parse(const char* address, uint32_t* address_start, uint32_t* address_end);
+
+static uint32_t
+ipv4(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
+  return (a << 24) | (b << 16) | (c << 8) | d;
+}
+
+#define RANGE_ASSERT(address, expected_start, expected_end)             \
+  {                                                                     \
+    uint32_t start = 0;                                                 \
+    uint32_t end = 0;                                                   \
+                                                                        \
+    CPPUNIT_ASSERT(ipv4_range_parse(address, &start, &end));            \
+    CPPUNIT_ASSERT_EQUAL(expected_start, start);                        \
+    CPPUNIT_ASSERT_EQUAL(expected_end, end);                            \
+  }
+
+void
+TestCommandIp::test_single_address() {
+  RANGE_ASSERT("10.1.2.3", ipv4(10, 1, 2, 3), ipv4(10, 1, 2, 3));
+}
+
+void
+TestCommandIp::test_explicit_range() {
+  RANGE_ASSERT("10.1.2.3-10.1.2.9", ipv4(10, 1, 2, 3), ipv4(10, 1, 2, 9));
+}
+
+void
+TestCommandIp::test_cidr() {
+  RANGE_ASSERT("10.0.0.0/8", ipv4(10, 0, 0, 0), ipv4(10, 255, 255, 255));
+  RANGE_ASSERT("10.1.2.0/24", ipv4(10, 1, 2, 0), ipv4(10, 1, 2, 255));
+  RANGE_ASSERT("10.1.2.128/25", ipv4(10, 1, 2, 128), ipv4(10, 1, 2, 255));
+  RANGE_ASSERT("10.1.2.3/31", ipv4(10, 1, 2, 2), ipv4(10, 1, 2, 3));
+}
+
+void
+TestCommandIp::test_cidr_zero_mask() {
+  RANGE_ASSERT("0.0.0.0/0", ipv4(0, 0, 0, 0), ipv4(255, 255, 255, 255));
+  RANGE_ASSERT("10.1.2.3/0", ipv4(0, 0, 0, 0), ipv4(255, 255, 255, 255));
+}
+
+void
+TestCommandIp::test_cidr_full_mask() {
+  RANGE_ASSERT("10.1.2.3/32", ipv4(10, 1, 2, 3), ipv4(10, 1, 2, 3));
+  RANGE_ASSERT("0.0.0.0/32", ipv4(0, 0, 0, 0), ipv4(0, 0, 0, 0));
+  RANGE_ASSERT("255.255.255.255/32", ipv4(255, 255, 255, 255), ipv4(255, 255, 255, 255));
+}

test/src/test_command_ip.h

@@ -0,0 +1,25 @@
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+// ipv4_range_parse is a pure function, so this does not use test_fixture and
+// the mock and logging setup that comes with it.
+class TestCommandIp : public CppUnit::TestFixture {
+  CPPUNIT_TEST_SUITE(TestCommandIp);
+
+  CPPUNIT_TEST(test_single_address);
+  CPPUNIT_TEST(test_explicit_range);
+
+  CPPUNIT_TEST(test_cidr);
+  CPPUNIT_TEST(test_cidr_zero_mask);
+  CPPUNIT_TEST(test_cidr_full_mask);
+
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void test_single_address();
+  void test_explicit_range();
+
+  void test_cidr();
+  void test_cidr_zero_mask();
+  void test_cidr_full_mask();
+};

test/src/test_command_system.cc

@@ -1,6 +1,6 @@
 #include "config.h"
 
-#include "test/src/test_command_local.h"
+#include "test/src/test_command_system.h"
 
 #include <torrent/torrent.h>
 #include <torrent/runtime/socket_manager.h>
@@ -10,12 +10,12 @@
 #include "globals.h"
 #include "rpc/parse_commands.h"
 
-CPPUNIT_TEST_SUITE_REGISTRATION(TestCommandLocal);
+CPPUNIT_TEST_SUITE_REGISTRATION(TestCommandSystem);
 
-void initialize_command_local();
+void initialize_command_system();
 
 void
-TestCommandLocal::setUp() {
+TestCommandSystem::setUp() {
   torrent::initialize_main_thread();
   torrent::initialize();
 
@@ -23,16 +23,16 @@ TestCommandLocal::setUp() {
     control = new Control;
 
   if (!rpc::commands.has("system.sockets.size"))
-    initialize_command_local();
+    initialize_command_system();
 }
 
 void
-TestCommandLocal::tearDown() {
+TestCommandSystem::tearDown() {
   torrent::cleanup();
 }
 
 void
-TestCommandLocal::test_socket_category_commands() {
+TestCommandSystem::test_socket_category_commands() {
   for (uint32_t i = 0; i < torrent::runtime::SocketManager::category_count; ++i) {
     auto category = static_cast<torrent::runtime::socket_manager_category_t>(i);
     auto name     = "system.sockets." + torrent::option_to_str_or_throw(torrent::OPTION_SOCKET_CATEGORY, i);

test/src/test_command_system.h

@@ -1,7 +1,7 @@
 #include "test/helpers/test_fixture.h"
 
-class TestCommandLocal : public test_fixture {
-  CPPUNIT_TEST_SUITE(TestCommandLocal);
+class TestCommandSystem : public test_fixture {
+  CPPUNIT_TEST_SUITE(TestCommandSystem);
 
   CPPUNIT_TEST(test_socket_category_commands);