Stuff.

SocketManager throws internal_error for category_generic, aborting rtorrent over RPC.

.github/workflows/commit-lint.yml

@@ -0,0 +1,65 @@
+name: "Lint Commit Message Size"
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  check-commit-bounds:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Validate Line Count, Width, and Spacing
+        run: |
+          # Fetch commit hashes unique to this PR branch
+          COMMITS=$(git log --no-merges --pretty=format:"%H" origin/${{ github.base_ref }}..HEAD)
+
+          MAX_LINES=3
+          MAX_CHARS=90
+          FAILED=0
+
+          for commit in $COMMITS; do
+            SUBJECT=$(git log --format="%s" -n 1 $commit)
+
+            # Extract clean commit message, trimming trailing blank lines
+            RAW_MSG=$(git log --format="%B" -n 1 $commit)
+            CLEAN_MSG=$(echo "$RAW_MSG" | awk '{msg[NR]=$0} END {while(NR>0 && msg[NR]=="") NR--; for(i=1;i<=NR;i++) print msg[i]}')
+
+            # 1. Check total line count
+            LINE_COUNT=$(echo "$CLEAN_MSG" | wc -l)
+            if [ "$LINE_COUNT" -gt "$MAX_LINES" ]; then
+              echo "❌ Error: Commit message has too many lines ($LINE_COUNT/$MAX_LINES)."
+              echo "   Commit: '$SUBJECT'"
+              FAILED=1
+            fi
+
+            # 2. Check for multiple consecutive blank lines
+            # This regex looks for 2 or more empty lines anywhere in the message
+            if echo "$CLEAN_MSG" | grep -pz '(\r?\n){3,}'; then
+              echo "❌ Error: Commit message contains multiple consecutive line breaks."
+              echo "   Commit: '$SUBJECT'"
+              FAILED=1
+            fi
+
+            # 3. Check maximum width of any individual line
+            while IFS= read -r line; do
+              LINE_LENGTH=${#line}
+              if [ "$LINE_LENGTH" -gt "$MAX_CHARS" ]; then
+                echo "❌ Error: Line length exceeds limit ($LINE_LENGTH / $MAX_CHARS chars)."
+                echo "   Offending line: '$line'"
+                FAILED=1
+              fi
+            done <<< "$CLEAN_MSG"
+
+          done
+
+          # Fail the job if any check failed
+          if [ "$FAILED" -ne 0 ]; then
+            exit 1
+          fi
+
+          echo "✅ All commit messages passed style rules!"

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.19],[sundell.software@gmail.com])
 
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_MACRO_DIRS([scripts])
@@ -14,7 +14,7 @@ AX_CXX_COMPILE_STDCXX(20, noext, mandatory)
 
 PKG_PROG_PKG_CONFIG
 
-AC_DEFINE([API_VERSION], [23], [api version])
+AC_DEFINE([API_VERSION], [24], [api version])
 
 RAK_CHECK_CFLAGS
 RAK_CHECK_CXXFLAGS
@@ -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.19])
 
 AC_LANG_PUSH(C++)
 TORRENT_WITH_XMLRPC_C

src/Makefile.am

@@ -174,6 +174,8 @@ libsub_root_a_SOURCES = \
 	utils/list_focus.h \
 	utils/lockfile.cc \
 	utils/lockfile.h \
+	utils/waitpid_queue.cc \
+	utils/waitpid_queue.h \
 	utils/watch_ready_queue.cc \
 	utils/watch_ready_queue.h \
 	\

src/command_download.cc

@@ -974,6 +974,7 @@ 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,6 +444,8 @@ 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); });
@@ -470,6 +472,8 @@ 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

@@ -117,7 +117,7 @@ group_insert(const torrent::Object::list_type& args) {
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.enable", "simple",
                                                               "schedule=group." + name + ".ratio,5,60,on_ratio=" + name));
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.disable", "simple",
-                                                              "schedule_remove=group." + name + ".ratio"));
+                                                              "schedule.remove=group." + name + ".ratio"));
   rpc::commands.call("method.insert", rpc::create_object_list("group."  + name + ".ratio.command", "simple",
                                                               "d.try_close= ;d.ignore_commands.set=1"));
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".view", "string", view));
@@ -250,12 +250,12 @@ initialize_command_local() {
 
     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); });
-    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); });
 
     if (i == 0)
       continue;
 
+    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, value); });
     CMD_ANY_VALUE_V(category_name + ".max_alloc.set", [category](auto, auto& value) { torrent::runtime::socket_manager()->set_category_max_allocation(category, value); });
   }
@@ -354,6 +354,10 @@ initialize_command_local() {
 
     rpc::rpc.mark_safe(category_name + ".size");
     rpc::rpc.mark_safe(category_name + ".max_size");
+
+    if (i == 0)
+      continue;
+
     rpc::rpc.mark_safe(category_name + ".min_alloc");
     rpc::rpc.mark_safe(category_name + ".max_alloc");
   }

src/command_logging.cc

@@ -1,6 +1,7 @@
 #include "config.h"
 
 #include <fcntl.h>
+#include <iterator>
 #include <stdio.h>
 #include <unistd.h>
 #include <torrent/data/chunk_utils.h>
@@ -15,6 +16,7 @@
 #include "core/download.h"
 #include "core/download_list.h"
 #include "core/manager.h"
+#include "rpc/parse.h"
 #include "rpc/parse_commands.h"
 
 torrent::Object
@@ -38,6 +40,32 @@ 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) {
@@ -112,6 +140,7 @@ 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/input/input_event.h

@@ -2,12 +2,11 @@
 #define RTORRENT_INPUT_INPUT_EVENT_H
 
 #include <functional>
-
-#include <torrent/event.h>
+#include <torrent/system/event.h>
 
 namespace input {
 
-class InputEvent : public torrent::Event {
+class InputEvent : public torrent::system::Event {
 public:
   typedef std::function<void (int)> slot_int;
 

src/main.cc

@@ -301,8 +301,6 @@ 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"
     );
 
@@ -346,8 +344,9 @@ main(int argc, char** argv) {
     CMD_REDIRECT("directory",             "directory.default.set");
     CMD_REDIRECT("session",               "session.path.set");
 
-    CMD_REDIRECT("scgi_port",             "network.scgi.open_port");
-    CMD_REDIRECT("scgi_local",            "network.scgi.open_local");
+    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("to_gm_time",            "convert.gm_time");
     CMD_REDIRECT("to_gm_date",            "convert.gm_date");
@@ -391,8 +390,6 @@ 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");

src/rpc/exec_file.cc

@@ -1,23 +1,22 @@
 #include "config.h"
 
-#include <cassert>
-#include <cerrno>
-#include <cstring>
-#include <fcntl.h>
-#include <spawn.h>
-#include <string>
+#include "rpc/exec_file.h"
+
+// #include <cassert>
+// #include <cerrno>
+// #include <cstring>
+// #include <fcntl.h>
+// #include <spawn.h>
+// #include <string>
 #include <unistd.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <torrent/net/fd.h>
+// #include <sys/types.h>
+#include <sys/uio.h>
+// #include <torrent/net/fd.h>
 #include <torrent/system/thread.h>
+#include <torrent/system/spawn_process.h>
 #include <torrent/system/types.h>
 
-#include "exec_file.h"
-#include "parse.h"
-
-// Standard POSIX environment pointer
-extern char** environ;
+#include "rpc/parse.h"
 
 namespace rpc {
 
@@ -25,216 +24,56 @@ namespace rpc {
 
 int
 ExecFile::execute(const char* file, char* const* argv, int flags) {
-  assert(!((flags & flag_capture) && (flags & flag_background)));
+  torrent::system::SpawnProcess spawn_process;
 
-  // Write the executed command and its parameters to the log fd.
-  [[maybe_unused]] int result;
+  spawn_process.set_log_fd(m_log_fd);
+  spawn_process.set_background(flags & flag_background);
+  spawn_process.set_capture_output(flags & flag_capture);
 
   if (m_log_fd != -1) {
-    for (char* const* itr = argv; *itr != NULL; itr++) {
-      if (itr == argv)
-        result = write(m_log_fd, "\n---\n", sizeof("\n---\n"));
-      else
-        result = write(m_log_fd, " ", 1);
+    std::vector<struct iovec> iovecs;
+    iovecs.reserve(32);
+    iovecs.push_back({const_cast<char*>("\n---\n"), 5});
 
-      result = write(m_log_fd, *itr, std::strlen(*itr));
+    for (auto* itr = argv; *itr != nullptr; itr++) {
+      if (itr != argv)
+        iovecs.push_back({const_cast<char*>(" "), 1});
+
+      iovecs.push_back({*itr, std::strlen(*itr)});
     }
 
-    result = write(m_log_fd, "\n---\n", sizeof("\n---\n"));
+    iovecs.push_back({const_cast<char*>("\n---\n"), 5});
+
+    [[maybe_unused]] int result = ::writev(m_log_fd, iovecs.data(), iovecs.size());
   }
 
-  posix_spawn_file_actions_t actions{};
-
-  if (posix_spawn_file_actions_init(&actions) != 0)
-    throw torrent::internal_error("ExecFile::execute(...) posix_spawn_file_actions_init failed.");
-
-  posix_spawnattr_t attr;
-  posix_spawnattr_init(&attr);
-
-  // Try to avoid leaking open fds to the spawned process. Prefer POSIX_SPAWN_CLOEXEC_DEFAULT
-  // (macOS-only) or posix_spawn_file_actions_addclosefrom_np (glibc >= 2.34, FreeBSD >= 13.1).
-  //
-  // Other platforms like musl libc, OpenBSD and NetBSD must rely on explicit O_CLOEXEC.
-
-  // Handle standard input redirection (/dev/null), posix_spawn_file_actions_addopen handles opening
-  // and dup2 natively
-  if (posix_spawn_file_actions_addopen(&actions, 0, "/dev/null", O_RDWR, 0) != 0) {
-    // Fallback if open fails inside action setup
-    posix_spawn_file_actions_addclose(&actions, 0);
-  }
-
-  int pipe_0 = -1;
-  int pipe_1 = -1;
-
-  // Handle standard output redirection
-  if (flags & flag_capture) {
-    torrent::fd_open_pipe(pipe_0, pipe_1);
-
-    posix_spawn_file_actions_adddup2(&actions, pipe_1, 1);
-
-    // Ensure the write end of the pipe is closed in the child after duplicating.
-    posix_spawn_file_actions_addclose(&actions, pipe_0);
-    posix_spawn_file_actions_addclose(&actions, pipe_1);
-
-  } else if (m_log_fd != -1) {
-    posix_spawn_file_actions_adddup2(&actions, m_log_fd, 1);
-
-  } else {
-    posix_spawn_file_actions_addopen(&actions, 1, "/dev/null", O_RDWR, 0);
-  }
-
-  if (m_log_fd != -1) {
-    posix_spawn_file_actions_adddup2(&actions, m_log_fd, 2);
-  } else {
-    posix_spawn_file_actions_addopen(&actions, 2, "/dev/null", O_RDWR, 0);
-  }
-
-  short spawn_flags = 0;
-
-#if defined(POSIX_SPAWN_CLOEXEC_DEFAULT)
-  spawn_flags |= POSIX_SPAWN_CLOEXEC_DEFAULT;
-#elif defined(HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSEFROM_NP)
-  posix_spawn_file_actions_addclosefrom_np(&actions, 3);
-#endif
-
-  if (flags & flag_background) {
-#ifdef POSIX_SPAWN_SETSID
-    spawn_flags |= POSIX_SPAWN_SETSID;
-#else
-    spawn_flags |= POSIX_SPAWN_SETPGROUP;
-    posix_spawnattr_setpgroup(&attr, 0);
-#endif
-  }
-
-  posix_spawnattr_setflags(&attr, spawn_flags);
-
-  pid_t child_pid{};
-  int   spawn_status = posix_spawnp(&child_pid, file, &actions, &attr, argv, environ);
-
-  posix_spawn_file_actions_destroy(&actions);
-  posix_spawnattr_destroy(&attr);
+  int spawn_status = spawn_process.execute(file, argv);
 
   if (spawn_status != 0) {
-    if (pipe_0 != -1)
-      torrent::fd_close(pipe_0);
+    if (m_log_fd != -1) {
+      auto prefix    = "\n--- posix_spawn failed: ";
+      auto errno_str = torrent::system::errno_enum_str(spawn_status) + " ---\n";
 
-    if (pipe_1 != -1)
-      torrent::fd_close(pipe_1);
+      struct iovec iovecs[2] = {
+        {const_cast<char*>(prefix), std::strlen(prefix)},
+        {const_cast<char*>(errno_str.c_str()), errno_str.size()},
+      };
+
+      [[maybe_unused]] int result = ::writev(m_log_fd, iovecs, 2);
+    }
 
     throw torrent::input_error("ExecFile::execute() posix_spawn failed: " + torrent::system::errno_enum_str(spawn_status));
   }
 
-  if (flags & flag_capture) {
-    m_capture = std::string();
-    torrent::fd_close(pipe_1);
-
-    char buffer[4096];
-    ssize_t length;
-
-    do {
-      length = read(pipe_0, buffer, sizeof(buffer));
-
-      if (length > 0)
-        m_capture += std::string(buffer, length);
-
-    } while (length > 0);
-
-    torrent::fd_close(pipe_0);
-
-    if (m_log_fd != -1) {
-      result = write(m_log_fd, "Captured output:\n", sizeof("Captured output:\n"));
-      result = write(m_log_fd, m_capture.data(), m_capture.length());
-    }
-  }
-
   if (flags & flag_background) {
-    if (m_log_fd != -1)
-      result = write(m_log_fd, "\n--- Running in Background ---\n", sizeof("\n--- Running in Background ---\n"));
-
+    m_waitpid_queue.close_pid(spawn_process.child_pid());
     return 0;
   }
 
-  int status;
-
-  while (::waitpid(child_pid, &status, 0) == -1) {
-    switch (errno) {
-    case EINTR:
-      continue;
-    case ECHILD:
-      throw torrent::internal_error("ExecFile::execute(...) waitpid failed with ECHILD, child process not found.");
-    case EINVAL:
-      throw torrent::internal_error("ExecFile::execute(...) waitpid failed with EINVAL.");
-    default:
-      throw torrent::internal_error("ExecFile::execute(...) waitpid failed with unexpected error: " + std::string(std::strerror(errno)));
-    }
-  };
-
-  // Check return value?
-  if (m_log_fd != -1) {
-    if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
-      result = write(m_log_fd, "\n--- Success ---\n", sizeof("\n--- Success ---\n"));
-    else
-      result = write(m_log_fd, "\n--- Error ---\n", sizeof("\n--- Error ---\n"));
-  }
-
-  return status;
-}
-
-torrent::Object
-ExecFile::execute_object(const torrent::Object& rawArgs, int flags) {
-  char*  argsBuffer[max_args];
-  char** argsCurrent = argsBuffer;
-
-  // Size of value strings are less than 24.
-  char   valueBuffer[buffer_size+1];
-  char*  valueCurrent = valueBuffer;
-
-  if (rawArgs.is_list()) {
-    const torrent::Object::list_type& args = rawArgs.as_list();
-
-    if (args.empty())
-      throw torrent::input_error("Too few arguments.");
-
-    for (torrent::Object::list_const_iterator itr = args.begin(), last = args.end(); itr != last; itr++, argsCurrent++) {
-      if (argsCurrent == argsBuffer + max_args - 1)
-        throw torrent::input_error("Too many arguments.");
-
-      if (itr->is_string() && (!(flags & flag_expand_tilde) || *itr->as_string().c_str() != '~')) {
-        *argsCurrent = const_cast<char*>(itr->as_string().c_str());
-
-      } else {
-        *argsCurrent = valueCurrent;
-        valueCurrent = print_object(valueCurrent, valueBuffer + buffer_size, &*itr, flags) + 1;
-
-        if (valueCurrent >= valueBuffer + buffer_size)
-          throw torrent::input_error("Overflowed execute arg buffer.");
-      }
-    }
-
-  } else {
-    const torrent::Object::string_type& args = rawArgs.as_string();
-
-    if ((flags & flag_expand_tilde) && args.c_str()[0] == '~') {
-      *argsCurrent = valueCurrent;
-      valueCurrent = print_object(valueCurrent, valueBuffer + buffer_size, &rawArgs, flags) + 1;
-    } else {
-      *argsCurrent = const_cast<char*>(args.c_str());
-    }
-
-    argsCurrent++;
-  }
-
-  *argsCurrent = NULL;
-
-  int status = execute(argsBuffer[0], argsBuffer, flags);
-
-  if ((flags & flag_throw) && status != 0)
-    throw torrent::input_error("Bad return code.");
-
   if (flags & flag_capture)
-    return m_capture;
+    m_capture = spawn_process.capture_child_output();
 
-  return torrent::Object((int64_t)status);
+  return spawn_process.wait_for_child();
 }
 
-}
+} // namespace rpc

src/rpc/exec_file.h

@@ -3,6 +3,8 @@
 
 #include <torrent/object.h>
 
+#include "utils/waitpid_queue.h"
+
 namespace rpc {
 
 class ExecFile {
@@ -24,6 +26,8 @@ public:
 private:
   int                 m_log_fd{-1};
   std::string         m_capture;
+
+  utils::WaitpidQueue m_waitpid_queue;
 };
 
 }

src/rpc/scgi.h

@@ -3,13 +3,13 @@
 
 #include <array>
 #include <memory>
-#include <torrent/event.h>
+#include <torrent/system/event.h>
 
 #include "rpc/scgi_task.h"
 
 namespace rpc {
 
-class SCgi : public torrent::Event {
+class SCgi : public torrent::system::Event {
 public:
   static const int max_tasks = 100;
 

src/rpc/scgi_task.h

@@ -4,13 +4,13 @@
 #include <memory>
 #include <mutex>
 #include <vector>
-#include <torrent/event.h>
+#include <torrent/system/event.h>
 
 namespace rpc {
 
 class SCgi;
 
-class SCgiTask : public torrent::Event {
+class SCgiTask : public torrent::system::Event {
 public:
   static constexpr int default_buffer_size = 8191;
   static constexpr int max_header_size     = 2000;

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.port_range.set", arg); });
+    optionParser.insert_option('p', [](auto& arg) { rpc::call_command_set_string("network.listen.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); });

src/utils/waitpid_queue.cc

@@ -0,0 +1,115 @@
+#include "config.h"
+
+#include "utils/waitpid_queue.h"
+
+#include <sys/wait.h>
+#include <torrent/exceptions.h>
+
+namespace utils {
+
+WaitpidQueue::WaitpidQueue() {
+  m_worker = std::async(std::launch::async, [this]() {
+      bool is_running = true;
+      auto wait_time  = 50ms;
+
+      while (is_running) {
+        if (!m_queue.empty()) {
+          auto start_time = std::chrono::steady_clock::now();
+
+          while (!m_wakeup_worker.load(std::memory_order_acquire) && !m_should_shutdown) {
+            auto elapsed = std::chrono::steady_clock::now() - start_time;
+
+            if (elapsed >= wait_time)
+              break;
+
+            std::this_thread::sleep_for(50ms);
+          }
+
+        } else {
+          m_wakeup_worker.wait(false, std::memory_order_acquire);
+          std::this_thread::sleep_for(50ms);
+        }
+
+        std::set<pid_t> queue;
+
+        {
+          std::lock_guard<std::mutex> guard(m_mutex);
+
+          if (m_should_shutdown) {
+            if (m_queue.empty())
+              return;
+
+            is_running = false;
+          }
+
+          if (m_queue.empty())
+            throw torrent::internal_error("WaitpidQueue worker thread woke up but queue is empty.");
+
+          queue = m_queue;
+
+          m_wakeup_worker.store(false, std::memory_order_release);
+        }
+
+        wait_time = std::min(10 * 1000ms, wait_time * 2);
+
+        for (auto pid : queue) {
+          if (::waitpid(pid, nullptr, WNOHANG) == 0)
+            continue;
+
+          {
+            std::lock_guard<std::mutex> guard(m_mutex);
+
+            if (m_queue.erase(pid) != 1)
+              throw torrent::internal_error("WaitpidQueue worker thread could not find pid in queue.");
+          }
+
+          wait_time = std::max(50ms, wait_time / 2);
+
+          m_remaining.fetch_sub(1, std::memory_order_release);
+          m_remaining.notify_all();
+        }
+      }
+    });
+}
+
+WaitpidQueue::~WaitpidQueue() {
+  {
+    std::lock_guard<std::mutex> guard(m_mutex);
+    m_should_shutdown = true;
+  }
+
+  m_wakeup_worker.store(true, std::memory_order_release);
+  m_wakeup_worker.notify_all();
+
+  // m_worker.wait();
+}
+
+void
+WaitpidQueue::close_pid(pid_t pid) {
+  if (pid < 0)
+    throw torrent::internal_error("WaitpidQueue::close_pid() called with invalid pid.");
+
+  m_remaining.fetch_add(1, std::memory_order_acquire);
+
+  {
+    std::lock_guard<std::mutex> guard(m_mutex);
+
+    // if (!m_queue.empty()) {
+    //   m_queue.push_back(pid);
+    //   return;
+    // }
+
+    m_queue.insert(pid);
+  }
+
+  m_wakeup_worker.store(true, std::memory_order_release);
+  m_wakeup_worker.notify_all();
+}
+
+void
+WaitpidQueue::wait_for(uint32_t max_remaining) {
+  while (m_remaining.load(std::memory_order_acquire) > max_remaining)
+    m_remaining.wait(max_remaining, std::memory_order_acquire);
+}
+
+} // namespace torrent::utils

src/utils/waitpid_queue.h

@@ -0,0 +1,44 @@
+#ifndef RTORRENT_UTILS_WAITPID_QUEUE_H
+#define RTORRENT_UTILS_WAITPID_QUEUE_H
+
+#include <future>
+#include <set>
+#include <torrent/system/common.h>
+
+namespace utils {
+
+class WaitpidQueue {
+public:
+  WaitpidQueue();
+  ~WaitpidQueue();
+
+  uint32_t            size() const;
+
+  void                close_pid(int pid);
+
+  void                wait_for(uint32_t max_remaining);
+
+private:
+  WaitpidQueue(const WaitpidQueue&) = delete;
+  WaitpidQueue& operator=(const WaitpidQueue&) = delete;
+
+  std::future<void>   m_worker;
+
+  align_cacheline
+
+  std::mutex          m_mutex;
+  std::set<pid_t>     m_queue;
+
+  bool                m_should_shutdown{};
+
+  align_cacheline
+
+  std::atomic<bool>     m_wakeup_worker{};
+  std::atomic<uint32_t> m_remaining{};
+};
+
+inline uint32_t WaitpidQueue::size() const { return m_remaining.load(std::memory_order_acquire); }
+
+} // namespace utils
+
+#endif

test/Makefile.am

@@ -49,6 +49,8 @@ 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_watch_ready_queue.cc \
 	src/test_watch_ready_queue.h
 

test/helpers/mock_compare.h

@@ -2,9 +2,10 @@
 #define LIBTORRENT_HELPERS_MOCK_COMPARE_H
 
 #include <algorithm>
+#include <map>
 #include <type_traits>
-#include <torrent/event.h>
 #include <torrent/net/socket_address.h>
+#include <torrent/system/event.h>
 
 // Compare arguments to mock functions with what is expected. The lhs
 // are the expected arguments, rhs are the ones called with.
@@ -13,13 +14,13 @@ template <typename Arg>
 inline bool mock_compare_arg(Arg lhs, Arg rhs) { return lhs == rhs; }
 
 template <int I, typename A, typename... Args>
-typename std::enable_if<I == 1, int>::type
+std::enable_if_t<I == 1, int>
 mock_compare_tuple(const std::tuple<A, Args...>& lhs, const std::tuple<Args...>& rhs) {
   return mock_compare_arg(std::get<I>(lhs), std::get<I - 1>(rhs)) ? 0 : 1;
 }
 
 template <int I, typename A, typename... Args>
-typename std::enable_if<1 < I, int>::type
+std::enable_if_t<1 < I, int>
 mock_compare_tuple(const std::tuple<A, Args...>& lhs, const std::tuple<Args...>& rhs) {
   auto res = mock_compare_tuple<I - 1>(lhs, rhs);
 
@@ -70,24 +71,37 @@ void mock_compare_add(T* v) {
 // Specialize:
 //
 
+constexpr int mock_compare_gt_two_int = -0xFD30;
+
+template <>
+inline bool mock_compare_arg<int>(int lhs, int rhs) {
+  if (lhs == mock_compare_gt_two_int)
+    return rhs > 2;
+  if (rhs == mock_compare_gt_two_int)
+    return lhs > 2;
+
+  return lhs == rhs;
+}
+
 template <>
 inline bool mock_compare_arg<sockaddr*>(sockaddr* lhs, sockaddr* rhs) {
   return lhs != nullptr && rhs != nullptr && torrent::sa_equal(lhs, rhs);
 }
+
 template <>
 inline bool mock_compare_arg<const sockaddr*>(const sockaddr* lhs, const sockaddr* rhs) {
   return lhs != nullptr && rhs != nullptr && torrent::sa_equal(lhs, rhs);
 }
 
 template <>
-inline bool mock_compare_arg<torrent::Event*>(torrent::Event* lhs, torrent::Event* rhs) {
-  if (mock_compare_map<torrent::Event>::is_key(lhs)) {
-    if (!mock_compare_map<torrent::Event>::has_value(rhs)) {
-      mock_compare_map<torrent::Event>::values[lhs] = rhs;
+inline bool mock_compare_arg<torrent::system::Event*>(torrent::system::Event* lhs, torrent::system::Event* rhs) {
+  if (mock_compare_map<torrent::system::Event>::is_key(lhs)) {
+    if (!mock_compare_map<torrent::system::Event>::has_value(rhs)) {
+      mock_compare_map<torrent::system::Event>::values[lhs] = rhs;
       return true;
     }
 
-    return mock_compare_map<torrent::Event>::has_key(lhs) && mock_compare_map<torrent::Event>::get(lhs) == rhs;
+    return mock_compare_map<torrent::system::Event>::has_key(lhs) && mock_compare_map<torrent::system::Event>::get(lhs) == rhs;
   }
 
   return lhs == rhs;

test/helpers/mock_function.cc

@@ -6,9 +6,9 @@
 #include <iostream>
 #include <unistd.h>
 
-#include "torrent/event.h"
 #include "torrent/net/socket_address.h"
 #include "torrent/net/fd.h"
+#include "torrent/system/event.h"
 #include "torrent/utils/log.h"
 #include "torrent/utils/random.h"
 
@@ -32,7 +32,7 @@ mock_clear(bool ignore_assert) {
   MOCK_CLEANUP_MAP(torrent::random_uniform_uint16);
   MOCK_CLEANUP_MAP(torrent::random_uniform_uint32);
 
-  mock_compare_map<torrent::Event>::values.clear();
+  mock_compare_map<torrent::system::Event>::values.clear();
 }
 } // namespace
 
@@ -55,7 +55,9 @@ mock_redirect_defaults([[maybe_unused]] mock_redirect_flags flags) {
 
   mock_redirect(torrent::fd__close, std::function<int(int fildes)>([](int fildes) { return ::close(fildes); }));
   mock_redirect(torrent::fd__fcntl_int, std::function<int(int fildes, int cmd, int arg)>([](int fildes, int cmd, int arg) { return ::fcntl(fildes, cmd, arg); }));
-  mock_redirect(torrent::fd__setsockopt_int, std::function<int(int socket, int level, int option_name, int option_value)>([](int socket, int level, int option_name, int option_value) { return ::setsockopt(socket, level, option_name, &option_value, sizeof(int)); }));
+  mock_redirect(torrent::fd__setsockopt_int, std::function<int(int socket, int level, int option_name, int option_value)>([](int socket, int level, int option_name, int option_value) {
+      return ::setsockopt(socket, level, option_name, &option_value, sizeof(int));
+    }));
   mock_redirect(torrent::fd__socket, std::function<int(int domain, int type, int protocol)>([](int domain, int type, int protocol) { return ::socket(domain, type, protocol); }));
 }
 
@@ -112,69 +114,6 @@ int fd__socket(int domain, int type, int protocol) {
   return mock_call<int>(__func__, &torrent::fd__socket, domain, type, protocol);
 }
 
-//
-// Mock functions for 'torrent/common.h':
-//
-
-namespace this_thread {
-
-void event_open(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_open, event);
-}
-
-void event_open_and_count(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_open_and_count, event);
-}
-
-void event_close_and_count(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_close_and_count, event);
-}
-
-void event_closed_and_count(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_closed_and_count, event);
-}
-
-void event_insert_read(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_insert_read, event);
-}
-
-void event_insert_write(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_insert_write, event);
-}
-
-void event_insert_error(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_insert_error, event);
-}
-
-void event_remove_read(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_remove_read, event);
-}
-
-void event_remove_write(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_remove_write, event);
-}
-
-void event_remove_error(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_remove_error, event);
-}
-
-void event_remove_and_close(Event* event) {
-  MOCK_LOG("fd:%i type_name:%s", event->file_descriptor(), event->type_name());
-  return mock_call<void>(__func__, &torrent::this_thread::event_remove_and_close, event);
-}
-
-}
-
 //
 // Mock functions for 'torrent/utils/random.h':
 //

test/src/test_command_local.cc

@@ -0,0 +1,54 @@
+#include "config.h"
+
+#include "test/src/test_command_local.h"
+
+#include <torrent/torrent.h>
+#include <torrent/runtime/socket_manager.h>
+#include <torrent/utils/option_strings.h>
+
+#include "control.h"
+#include "globals.h"
+#include "rpc/parse_commands.h"
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestCommandLocal);
+
+void initialize_command_local();
+
+void
+TestCommandLocal::setUp() {
+  torrent::initialize_main_thread();
+  torrent::initialize();
+
+  if (control == nullptr)
+    control = new Control;
+
+  if (!rpc::commands.has("system.sockets.size"))
+    initialize_command_local();
+}
+
+void
+TestCommandLocal::tearDown() {
+  torrent::cleanup();
+}
+
+void
+TestCommandLocal::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);
+
+    for (const auto suffix : {".size", ".max_size", ".min_alloc", ".max_alloc"})
+      if (rpc::commands.has(name + suffix))
+        CPPUNIT_ASSERT_NO_THROW(rpc::commands.call(name + suffix));
+
+    const bool has_allocation = category != torrent::runtime::category_generic;
+
+    CPPUNIT_ASSERT(rpc::commands.has(name + ".size"));
+    CPPUNIT_ASSERT(rpc::commands.has(name + ".max_size"));
+
+    CPPUNIT_ASSERT_EQUAL(has_allocation, rpc::commands.has(name + ".min_alloc"));
+    CPPUNIT_ASSERT_EQUAL(has_allocation, rpc::commands.has(name + ".max_alloc"));
+    CPPUNIT_ASSERT_EQUAL(has_allocation, rpc::commands.has(name + ".min_alloc.set"));
+    CPPUNIT_ASSERT_EQUAL(has_allocation, rpc::commands.has(name + ".max_alloc.set"));
+  }
+}

test/src/test_command_local.h

@@ -0,0 +1,15 @@
+#include "test/helpers/test_fixture.h"
+
+class TestCommandLocal : public test_fixture {
+  CPPUNIT_TEST_SUITE(TestCommandLocal);
+
+  CPPUNIT_TEST(test_socket_category_commands);
+
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void test_socket_category_commands();
+};