Tagged release 0.16.9.

Remove unneeded MSG_NOSIGNAL.
Whitelist additional read-only getters for untrusted connections
2026-08-06 02:02:30 +00:00 · 2026-04-06 15:19:27 +02:00 · 2026-04-06 10:48:35 +02:00 · 2026-03-30 11:55:24 +02:00 · 2026-03-27 17:48:13 +01:00 · 2026-03-27 17:48:13 +01:00
76 changed files with 2371 additions and 1643 deletions
@@ -9,9 +9,6 @@ nobase_dist_pkgdata_DATA = \
 EXTRA_DIST= \
 	rak/address_info.h \
 	rak/algorithm.h \
-	rak/error_number.h \
-	rak/file_stat.h \
-	rak/path.h \
 	rak/partial_queue.h \
 	rak/regex.h \
 	rak/string_manip.h \
@@ -1,6 +1,6 @@
 m4_pattern_allow([PKG_CHECK_EXISTS])

-AC_INIT([rtorrent],[0.16.4],[sundell.software@gmail.com])
+AC_INIT([rtorrent],[0.16.9],[sundell.software@gmail.com])

 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_MACRO_DIRS([scripts])
@@ -11,7 +11,7 @@ LT_INIT

 AC_PROG_CXX

-AC_DEFINE([API_VERSION], [18], [api version])
+AC_DEFINE([API_VERSION], [19], [api version])

 # Filter out unwanted flags added by autoconf on some systems, e.g. MacOS.
 TORRENT_REMOVE_UNWANTED(CXX, $CXX, -std=c++11 -std=gnu++11)
@@ -48,7 +48,7 @@ if test "x$ax_cv_ncursesw" != xyes && test "x$ax_cv_ncurses" != xyes; then
 fi

 PKG_CHECK_MODULES([CPPUNIT], [cppunit],, [no_cppunit="yes"])
-PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.4])
+PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.9])

 AC_LANG_PUSH(C++)
 TORRENT_WITH_XMLRPC_C
@@ -56,6 +56,7 @@ AC_LANG_POP(C++)

 TORRENT_WITH_LUA
 TORRENT_WITH_TINYXML2
+TORRENT_WITH_SYSTEMD

 if test ${with_xmlrpc_c+y} && test ${with_xmlrpc_tinyxml2+y}; then
  AC_MSG_ERROR([--with-xmlrpc-c and --with-xmlrpc-tinyxml2 cannot be used together. Please choose only one])
@@ -0,0 +1 @@
+valgrind --leak-check=full --track-origins=yes --show-reachable=yes --suppressions=/Users/rakshasa/projects/rtorrent/doc/valgrind.suppression --gen-suppressions=all --log-file=valgrind.log /usr/local/bin/rtorrent
@@ -1,85 +0,0 @@
-// rak - Rakshasa's toolbox
-// Copyright (C) 2005-2007, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-#ifndef RAK_ERROR_NUMBER_H
-#define RAK_ERROR_NUMBER_H
-
-#include <cerrno>
-#include <cstring>
-
-namespace rak {
-
-class error_number {
-public:
-  static const int e_access      = EACCES;
-  static const int e_again       = EAGAIN;
-  static const int e_connreset   = ECONNRESET;
-  static const int e_connaborted = ECONNABORTED;
-  static const int e_deadlk      = EDEADLK;
-
-  static const int e_noent       = ENOENT;
-  static const int e_nodev       = ENODEV;
-  static const int e_nomem       = ENOMEM;
-  static const int e_notdir      = ENOTDIR;
-  static const int e_isdir       = EISDIR;
-  
-  static const int e_intr        = EINTR;
-
-  error_number() : m_errno(0) {}
-  error_number(int e) : m_errno(e) {}
-
-  bool                is_valid() const             { return m_errno != 0; }
-
-  int                 value() const                { return m_errno; }
-  const char*         c_str() const                { return std::strerror(m_errno); }
-
-  bool                is_blocked_momentary() const { return m_errno == e_again || m_errno == e_intr; }
-  bool                is_blocked_prolonged() const { return m_errno == e_deadlk; }
-
-  bool                is_closed() const            { return m_errno == e_connreset || m_errno == e_connaborted; }
-
-  bool                is_bad_path() const          { return m_errno == e_noent || m_errno == e_notdir || m_errno == e_access; }
-
-  static error_number current()                    { return errno; }
-  static void         clear_global()               { errno = 0; }
-  static void         set_global(error_number err) { errno = err.m_errno; }
-
-  bool operator == (const error_number& e) const   { return m_errno == e.m_errno; }
-
-private:
-  int                 m_errno;
-};
-
-}
-
-#endif
@@ -1,75 +0,0 @@
-// rak - Rakshasa's toolbox
-// Copyright (C) 2005-2007, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
-#ifndef RAK_FILE_STAT_H
-#define RAK_FILE_STAT_H
-
-#include <string>
-#include <cinttypes>
-#include <sys/stat.h>
-
-namespace rak {
-
-class file_stat {
-public:
-  // Consider storing rak::error_number.
-
-  bool                update(int fd)                        { return fstat(fd, &m_stat) == 0; }
-  bool                update(const char* filename)          { return stat(filename, &m_stat) == 0; }
-  bool                update(const std::string& filename)   { return update(filename.c_str()); }
-
-  bool                update_link(const char* filename)        { return lstat(filename, &m_stat) == 0; }
-  bool                update_link(const std::string& filename) { return update_link(filename.c_str()); }
-
-  bool                is_regular() const                    { return S_ISREG(m_stat.st_mode); }
-  bool                is_directory() const                  { return S_ISDIR(m_stat.st_mode); }
-  bool                is_character() const                  { return S_ISCHR(m_stat.st_mode); }
-  bool                is_block() const                      { return S_ISBLK(m_stat.st_mode); }
-  bool                is_fifo() const                       { return S_ISFIFO(m_stat.st_mode); }
-  bool                is_link() const                       { return S_ISLNK(m_stat.st_mode); }
-  bool                is_socket() const                     { return S_ISSOCK(m_stat.st_mode); }
-
-  off_t               size() const                          { return m_stat.st_size; }
-
-  time_t              access_time() const                   { return m_stat.st_atime; }
-  time_t              change_time() const                   { return m_stat.st_ctime; }
-  time_t              modified_time() const                 { return m_stat.st_mtime; }
-
-private:
-  struct stat         m_stat;
-};
-
-}
-
-#endif
@@ -1,105 +0,0 @@
-// rak - Rakshasa's toolbox
-// Copyright (C) 2005-2007, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
-// Various functions for manipulating file paths. Also consider making
-// a directory iterator.
-
-#ifndef RAK_PATH_H
-#define RAK_PATH_H
-
-#include <cstdlib>
-#include <string>
-
-namespace rak {
-
-inline std::string
-path_expand(const std::string& path) {
-  if (path.empty() || path[0] != '~')
-    return path;
-
-  char* home = std::getenv("HOME");
-
-  if (home == NULL)
-    return path;
-  
-  return home + path.substr(1);
-}
-
-// Don't inline this...
-//
-// Same strlcpy as found in *bsd.
-inline size_t
-strlcpy(char *dest, const char *src, size_t size) {
-  size_t n = size;
-  const char* first = src;
-
-  if (n != 0) {
-    while (--n != 0)
-      if ((*dest++ = *src++) == '\0')
-        break;
-  }
-
-  if (n == 0) {
-    if (size != 0)
-      *dest = '\0';
-    
-    while (*src++)
-      ;
-  }
-
-  return src - first - 1;
-}
-
-inline char*
-path_expand(const char* src, char* first, char* last) {
-  if (*src == '~') {
-    char* home = std::getenv("HOME");
-
-    if (home == NULL)
-      return first;
-
-    first += strlcpy(first, home, std::distance(first, last));
-
-    if (first > last)
-      return last;
-
-    src++;
-  }
-
-  return std::min(first + strlcpy(first, src, std::distance(first, last)), last);
-}
-
-}
-
-#endif
@@ -358,3 +358,20 @@ AC_DEFUN([TORRENT_DISABLE_PTHREAD_SETNAME_NP], [
    ]
  )
 ])
+
+
+AC_DEFUN([TORRENT_WITH_SYSTEMD], [
+  AC_ARG_WITH(systemd,
+    AS_HELP_STRING([--with-systemd],[enable systemd socket activation support [[default=no]]]),
+    [
+      if test "$withval" = "yes"; then
+        PKG_CHECK_MODULES([SYSTEMD], [libsystemd],
+          [
+            CXXFLAGS="$CXXFLAGS $SYSTEMD_CFLAGS"
+            LIBS="$LIBS $SYSTEMD_LIBS"
+            AC_DEFINE(HAVE_SYSTEMD, 1, [Support for systemd socket activation.])
+          ],
+          [AC_MSG_ERROR([libsystemd not found. Install libsystemd-dev (or the equivalent for your distribution).])])
+      fi
+    ])
+])
@@ -13,8 +13,6 @@ libsub_root_a_SOURCES = \
 	core/download_factory.h \
 	core/download_list.cc \
 	core/download_list.h \
-	core/download_store.cc \
-	core/download_store.h \
 	core/http_queue.cc \
 	core/http_queue.h \
 	core/manager.cc \
@@ -125,6 +123,16 @@ libsub_root_a_SOURCES = \
 	rpc/tinyxml2/tinyxml2.cc \
 	rpc/nlohmann/json.h \
 	\
+	scgi/thread_scgi.cc \
+	scgi/thread_scgi.h \
+	\
+	session/download_storer.cc \
+	session/download_storer.h \
+	session/session_manager.cc \
+	session/session_manager.h \
+	session/thread_session.cc \
+	session/thread_session.h \
+	\
 	ui/download.cc \
 	ui/download.h \
 	ui/download_list.cc \
@@ -164,8 +172,6 @@ libsub_root_a_SOURCES = \
 	utils/list_focus.h \
 	utils/lockfile.cc \
 	utils/lockfile.h \
-	utils/socket_fd.cc \
-	utils/socket_fd.h \
 	\
 	command_download.cc \
 	command_dynamic.cc \
@@ -190,9 +196,7 @@ libsub_root_a_SOURCES = \
 	option_parser.cc \
 	option_parser.h \
 	signal_handler.cc \
-	signal_handler.h \
-	thread_worker.cc \
-	thread_worker.h
+	signal_handler.h


 AM_CPPFLAGS = -I$(srcdir) -I$(top_srcdir) -DPACKAGE_DATADIR=\"$(pkgdatadir)\"
@@ -5,8 +5,6 @@
 #include <functional>
 #include <netdb.h>
 #include <unistd.h>
-#include <rak/file_stat.h>
-#include <rak/path.h>
 #include <rak/string_manip.h>
 #include <rak/regex.h>
 #include <torrent/rate.h>
@@ -21,13 +19,14 @@
 #include <torrent/net/types.h>
 #include <torrent/peer/connection_list.h>
 #include <torrent/peer/peer_list.h>
+#include <torrent/utils/file_stat.h>
 #include <torrent/utils/log.h>
 #include <torrent/utils/option_strings.h>

 #include "core/download.h"
-#include "core/download_store.h"
 #include "core/manager.h"
 #include "rpc/parse.h"
+#include "session/session_manager.h"

 #include "globals.h"
 #include "control.h"
@@ -77,23 +76,23 @@ apply_d_change_link(core::Download* download, const torrent::Object::list_type&

  if (type == "base_path") {
    target = rpc::call_command_string("d.base_path", rpc::make_target(download));
-    link = rak::path_expand(prefix + rpc::call_command_string("d.base_path", rpc::make_target(download)) + postfix);
+    link   = expand_path(prefix + rpc::call_command_string("d.base_path", rpc::make_target(download)) + postfix);

  } else if (type == "base_filename") {
    target = rpc::call_command_string("d.base_path", rpc::make_target(download));
-    link = rak::path_expand(prefix + rpc::call_command_string("d.base_filename", rpc::make_target(download)) + postfix);
+    link   = expand_path(prefix + rpc::call_command_string("d.base_filename", rpc::make_target(download)) + postfix);

 //   } else if (type == "directory_path") {
 //     target = rpc::call_command_string("d.directory", rpc::make_target(download));
 //     link = rak::path_expand(prefix + rpc::call_command_string("d.base_path", rpc::make_target(download)) + postfix);

  } else if (type == "tied") {
-    link = rak::path_expand(rpc::call_command_string("d.tied_to_file", rpc::make_target(download)));
+    link = expand_path(rpc::call_command_string("d.tied_to_file", rpc::make_target(download)));

    if (link.empty())
      return torrent::Object();

-    link = rak::path_expand(prefix + link + postfix);
+    link = expand_path(prefix + link + postfix);
    target = rpc::call_command_string("d.base_path", rpc::make_target(download));

  } else {
@@ -109,7 +108,7 @@ apply_d_change_link(core::Download* download, const torrent::Object::list_type&

  case 1:
  {
-    rak::file_stat fileStat;
+    torrent::utils::FileStat fileStat;
    errno = 0;

    if (!fileStat.update_link(link) || !fileStat.is_link() || unlink(link.c_str()) == -1)
@@ -131,7 +130,7 @@ apply_d_delete_tied(core::Download* download) {
  if (tie.empty())
    return torrent::Object();

-  if (::unlink(rak::path_expand(tie).c_str()) == -1)
+  if (::unlink(expand_path(tie).c_str()) == -1)
    control->core()->push_log_std("Could not unlink tied file: " + std::string(std::strerror(errno)));

  rpc::call_command("d.tied_to_file.set", std::string(), rpc::make_target(download));
@@ -302,7 +301,7 @@ apply_d_add_peer(core::Download* download, const std::string& arg) {
  if (port < 1 || port > 65535)
    throw torrent::input_error("Invalid port number.");

-  assert(std::this_thread::get_id() == torrent::main_thread::thread()->thread_id());
+  assert(std::this_thread::get_id() == torrent::main_thread::thread_id());

  // Currently discarding SOCK_STREAM.
  torrent::this_thread::resolver()->resolve_preferred(NULL, host, AF_UNSPEC, AF_INET, [download, port](torrent::c_sa_shared_ptr sa, int err) {
@@ -495,6 +494,19 @@ download_get_variable(core::Download* download, const char* first_key, const cha
  return download->bencode()->get_key(first_key).get_key(second_key);
 }

+torrent::Object
+download_get_value_or_zero(core::Download* download, const char* first_key, const char* second_key = NULL) {
+  auto object = download_get_variable(download, first_key, second_key);
+
+  if (object.is_empty())
+    return int64_t(0);
+
+  if (!object.is_value())
+    throw torrent::bencode_error("Download variable is not a value.");
+
+  return object;
+}
+
 torrent::Object
 download_set_variable(core::Download* download, const torrent::Object& rawArgs, const char* first_key, const char* second_key = NULL) {
  if (second_key == NULL)
@@ -600,12 +612,16 @@ d_list_remove(core::Download* download, const torrent::Object& rawArgs, const ch

 #define CMD2_DL_TIMESTAMP(key, first_key, second_key)                   \
  CMD2_DL(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \
-  CMD2_DL_VALUE_P(key ".set", std::bind(&download_set_variable_value, \
-                                             std::placeholders::_1, std::placeholders::_2, \
-                                             first_key, second_key)); \
+  CMD2_DL_VALUE_P(key ".set", std::bind(&download_set_variable_value,   \
+                                        std::placeholders::_1, std::placeholders::_2, \
+                                        first_key, second_key));        \
  CMD2_DL_VALUE_P(key ".set_if_z", std::bind(&download_set_variable_value_ifz, \
                                             std::placeholders::_1, std::placeholders::_2, \
                                             first_key, second_key));   \
+  CMD2_DL(key ".or_zero", [](core::Download* download, auto) {          \
+      return download_get_value_or_zero(download, first_key, second_key); }); \
+  CMD2_DL_VALUE(key ".elapsed", [](core::Download* download, auto value) { \
+      return download_get_value_or_zero(download, first_key, second_key).as_value() > value; });

 #define CMD2_DL_VAR_STRING(key, first_key, second_key)                   \
  CMD2_DL(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \
@@ -683,8 +699,8 @@ initialize_command_download() {
  CMD2_DL_V       ("d.erase",      std::bind(&core::DownloadList::erase_ptr, control->core()->download_list(), std::placeholders::_1));
  CMD2_DL_V       ("d.check_hash", std::bind(&core::DownloadList::check_hash, control->core()->download_list(), std::placeholders::_1));

-  CMD2_DL         ("d.save_resume",       std::bind(&core::DownloadStore::save_resume, control->core()->download_store(), std::placeholders::_1));
-  CMD2_DL         ("d.save_full_session", std::bind(&core::DownloadStore::save_full, control->core()->download_store(), std::placeholders::_1));
+  CMD2_DL_V       ("d.save_resume",       [](core::Download* download, auto) { session_thread::manager()->save_resume_download(download); });
+  CMD2_DL_V       ("d.save_full_session", [](core::Download* download, auto) { session_thread::manager()->save_full_download(download); });

  CMD2_DL_V       ("d.update_priorities", CMD2_ON_DL(update_priorities));

@@ -868,4 +884,91 @@ initialize_command_download() {
  CMD2_DL_LIST    ("t.multicall", std::bind(&t_multicall, std::placeholders::_1, std::placeholders::_2));

  CMD2_ANY_LIST   ("p.call_target", std::bind(&p_call_target, std::placeholders::_2));
+
+  rpc::rpc.mark_safe("add_peer");
+  rpc::rpc.mark_safe("d.hash");
+  rpc::rpc.mark_safe("d.local_id");
+  rpc::rpc.mark_safe("d.local_id_html");
+  rpc::rpc.mark_safe("d.bitfield");
+  rpc::rpc.mark_safe("d.base_path");
+  rpc::rpc.mark_safe("d.base_filename");
+  rpc::rpc.mark_safe("d.name");
+  rpc::rpc.mark_safe("d.directory");
+  rpc::rpc.mark_safe("d.directory_base");
+  rpc::rpc.mark_safe("d.creation_date");
+  rpc::rpc.mark_safe("d.load_date");
+  rpc::rpc.mark_safe("d.up.rate");
+  rpc::rpc.mark_safe("d.up.total");
+  rpc::rpc.mark_safe("d.down.rate");
+  rpc::rpc.mark_safe("d.down.total");
+  rpc::rpc.mark_safe("d.skip.rate");
+  rpc::rpc.mark_safe("d.skip.total");
+  rpc::rpc.mark_safe("d.is_open");
+  rpc::rpc.mark_safe("d.is_active");
+  rpc::rpc.mark_safe("d.is_hash_checked");
+  rpc::rpc.mark_safe("d.is_hash_checking");
+  rpc::rpc.mark_safe("d.is_multi_file");
+  rpc::rpc.mark_safe("d.is_private");
+  rpc::rpc.mark_safe("d.is_pex_active");
+  rpc::rpc.mark_safe("d.is_partially_done");
+  rpc::rpc.mark_safe("d.is_not_partially_done");
+  rpc::rpc.mark_safe("d.is_meta");
+  rpc::rpc.mark_safe("d.peer_exchange");
+  rpc::rpc.mark_safe("d.resume");
+  rpc::rpc.mark_safe("d.pause");
+  rpc::rpc.mark_safe("d.open");
+  rpc::rpc.mark_safe("d.close");
+  rpc::rpc.mark_safe("d.close.directly");
+  rpc::rpc.mark_safe("d.erase");
+  rpc::rpc.mark_safe("d.check_hash");
+  rpc::rpc.mark_safe("d.save_resume");
+  rpc::rpc.mark_safe("d.save_full_session");
+  rpc::rpc.mark_safe("d.update_priorities");
+  rpc::rpc.mark_safe("d.custom");
+  rpc::rpc.mark_safe("d.custom1");
+  rpc::rpc.mark_safe("d.custom2");
+  rpc::rpc.mark_safe("d.custom3");
+  rpc::rpc.mark_safe("d.custom4");
+  rpc::rpc.mark_safe("d.custom5");
+  rpc::rpc.mark_safe("d.size_bytes");
+  rpc::rpc.mark_safe("d.size_chunks");
+  rpc::rpc.mark_safe("d.size_pex");
+  rpc::rpc.mark_safe("d.completed_bytes");
+  rpc::rpc.mark_safe("d.bytes_done");
+  rpc::rpc.mark_safe("d.peers_accounted");
+  rpc::rpc.mark_safe("d.chunks_hashed");
+  rpc::rpc.mark_safe("d.tracker_size");
+  rpc::rpc.mark_safe("d.completed_chunks");
+  rpc::rpc.mark_safe("d.left_bytes");
+  rpc::rpc.mark_safe("d.chunk_size");
+  rpc::rpc.mark_safe("d.priority");
+  rpc::rpc.mark_safe("d.priority_str");
+  rpc::rpc.mark_safe("d.state");
+  rpc::rpc.mark_safe("d.state_changed");
+  rpc::rpc.mark_safe("d.state_counter");
+  rpc::rpc.mark_safe("d.connection_current");
+  rpc::rpc.mark_safe("d.connection_leech");
+  rpc::rpc.mark_safe("d.connection_seed");
+  rpc::rpc.mark_safe("d.throttle_name");
+  rpc::rpc.mark_safe("d.uploads_max");
+  rpc::rpc.mark_safe("d.downloads_max");
+  rpc::rpc.mark_safe("d.peers_min");
+  rpc::rpc.mark_safe("d.peers_max");
+  rpc::rpc.mark_safe("d.peers_connected");
+  rpc::rpc.mark_safe("d.peers_not_connected");
+  rpc::rpc.mark_safe("d.peers_complete");
+  rpc::rpc.mark_safe("d.tracker_numwant");
+  rpc::rpc.mark_safe("d.tracker_focus");
+  rpc::rpc.mark_safe("d.message");
+  rpc::rpc.mark_safe("d.hashing");
+  rpc::rpc.mark_safe("d.hashing_failed");
+  rpc::rpc.mark_safe("d.free_diskspace");
+  rpc::rpc.mark_safe("d.views");
+  rpc::rpc.mark_safe("d.views.remove");
+  rpc::rpc.mark_safe("d.views.push_back_unique");
+  rpc::rpc.mark_safe("d.ratio");
+  rpc::rpc.mark_safe("f.multicall");
+  rpc::rpc.mark_safe("p.multicall");
+  rpc::rpc.mark_safe("p.call_target");
+  rpc::rpc.mark_safe("t.multicall");
 }
@@ -455,4 +455,27 @@ initialize_command_dynamic() {
  CMD2_ANY         ("strings.tracker_event",             std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_EVENT));
  CMD2_ANY         ("strings.tracker_mode",              std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_MODE));
  // clang-format on
+
+#ifdef HAVE_XMLRPC_TINYXML2
+  rpc::rpc.mark_safe("system.listMethods");
+#endif
+
+  rpc::rpc.mark_safe("method.use_deprecated");
+  rpc::rpc.mark_safe("method.const");
+  rpc::rpc.mark_safe("method.has_key");
+  rpc::rpc.mark_safe("method.list_keys");
+  rpc::rpc.mark_safe("method.get");
+  rpc::rpc.mark_safe("method.rlookup");
+  rpc::rpc.mark_safe("catch");
+
+  rpc::rpc.mark_safe("strings.choke_heuristics");
+  rpc::rpc.mark_safe("strings.choke_heuristics.upload");
+  rpc::rpc.mark_safe("strings.choke_heuristics.download");
+  rpc::rpc.mark_safe("strings.connection_type");
+  rpc::rpc.mark_safe("strings.encryption");
+  rpc::rpc.mark_safe("strings.ip_filter");
+  rpc::rpc.mark_safe("strings.ip_tos");
+  rpc::rpc.mark_safe("strings.log_group");
+  rpc::rpc.mark_safe("strings.tracker_event");
+  rpc::rpc.mark_safe("strings.tracker_mode");
 }
@@ -2,14 +2,12 @@

 #include <functional>
 #include <cstdio>
-#include <rak/error_number.h>
-#include <rak/file_stat.h>
-#include <rak/path.h>
 #include <rak/string_manip.h>
 #include <torrent/rate.h>
 #include <torrent/hash_string.h>
 #include <torrent/utils/log.h>
 #include <torrent/utils/directory_events.h>
+#include <torrent/utils/file_stat.h>

 #include "globals.h"
 #include "control.h"
@@ -67,10 +65,10 @@ apply_start_tied() {
    if (rpc::call_command_value("d.state", rpc::make_target(download)) == 1)
      continue;

-    rak::file_stat fs;
+    torrent::utils::FileStat fs;
    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(download));

-    if (!tied_to_file.empty() && fs.update(rak::path_expand(tied_to_file)))
+    if (!tied_to_file.empty() && fs.update(expand_path(tied_to_file)))
      rpc::parse_command_single(rpc::make_target(download), "d.try_start=");
  }

@@ -83,10 +81,10 @@ apply_stop_untied() {
    if (rpc::call_command_value("d.state", rpc::make_target(download)) == 0)
      continue;

-    rak::file_stat fs;
+    torrent::utils::FileStat fs;
    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(download));

-    if (!tied_to_file.empty() && !fs.update(rak::path_expand(tied_to_file)))
+    if (!tied_to_file.empty() && !fs.update(expand_path(tied_to_file)))
      rpc::parse_command_single(rpc::make_target(download), "d.try_stop=");
  }

@@ -96,10 +94,10 @@ apply_stop_untied() {
 torrent::Object
 apply_close_untied() {
  for (const auto& download : *control->core()->download_list()) {
-    rak::file_stat fs;
+    torrent::utils::FileStat fs;
    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(download));

-    if (rpc::call_command_value("d.ignore_commands", rpc::make_target(download)) == 0 && !tied_to_file.empty() && !fs.update(rak::path_expand(tied_to_file)))
+    if (rpc::call_command_value("d.ignore_commands", rpc::make_target(download)) == 0 && !tied_to_file.empty() && !fs.update(expand_path(tied_to_file)))
      rpc::parse_command_single(rpc::make_target(download), "d.try_close=");
  }

@@ -109,10 +107,10 @@ apply_close_untied() {
 torrent::Object
 apply_remove_untied() {
  for (auto itr = control->core()->download_list()->begin(); itr != control->core()->download_list()->end(); ) {
-    rak::file_stat fs;
+    torrent::utils::FileStat fs;
    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(*itr));

-    if (!tied_to_file.empty() && !fs.update(rak::path_expand(tied_to_file))) {
+    if (!tied_to_file.empty() && !fs.update(expand_path(tied_to_file))) {
      // Need to clear tied_to_file so it doesn't try to delete it.
      rpc::call_command("d.tied_to_file.set", std::string(), rpc::make_target(*itr));

@@ -301,7 +299,7 @@ directory_watch_added(const torrent::Object::list_type& args) {
  auto& command = args.back().as_string();

  if (!control->directory_events()->open())
-    throw torrent::input_error("Could not open inotify:" + std::string(rak::error_number::current().c_str()));
+    throw torrent::input_error("Could not open inotify:" + std::string(std::strerror(errno)));

  control->directory_events()->notify_on(path.c_str(),
                                         torrent::directory_events::flag_on_added | torrent::directory_events::flag_on_updated,
@@ -346,4 +344,15 @@ initialize_command_events() {
  CMD2_ANY_LIST    ("d.multicall.filtered", std::bind(&d_multicall_filtered, std::placeholders::_2));

  CMD2_ANY_LIST    ("directory.watch.added", std::bind(&directory_watch_added, std::placeholders::_2));
+
+  rpc::rpc.mark_safe("start_tied");
+  rpc::rpc.mark_safe("stop_untied");
+  rpc::rpc.mark_safe("close_untied");
+  rpc::rpc.mark_safe("remove_untied");
+
+  rpc::rpc.mark_safe("close_low_diskspace");
+  rpc::rpc.mark_safe("close_low_diskspace.normal");
+  rpc::rpc.mark_safe("download_list");
+  rpc::rpc.mark_safe("d.multicall2");
+  rpc::rpc.mark_safe("d.multicall.filtered");
 }
@@ -1,41 +1,5 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

-#include <rak/error_number.h>
-#include <rak/path.h>
 #include <torrent/data/file.h>
 #include <torrent/data/file_list.h>
 #include <torrent/data/file_list_iterator.h>
@@ -139,4 +103,32 @@ initialize_command_file() {

  CMD2_FILEITR("fi.filename_last",      std::bind(&apply_fi_filename_last, std::placeholders::_1));
  CMD2_FILEITR("fi.is_file",            std::bind(&torrent::FileListIterator::is_file, std::placeholders::_1));
+
+  rpc::rpc.mark_safe("f.path");
+  rpc::rpc.mark_safe("f.path_components");
+  rpc::rpc.mark_safe("f.path_depth");
+  rpc::rpc.mark_safe("f.frozen_path");
+  rpc::rpc.mark_safe("f.offset");
+  rpc::rpc.mark_safe("f.size_bytes");
+  rpc::rpc.mark_safe("f.size_chunks");
+  rpc::rpc.mark_safe("f.completed_chunks");
+  rpc::rpc.mark_safe("f.range_first");
+  rpc::rpc.mark_safe("f.range_second");
+  rpc::rpc.mark_safe("f.priority");
+  rpc::rpc.mark_safe("f.priority.set");
+  rpc::rpc.mark_safe("f.is_created");
+  rpc::rpc.mark_safe("f.is_open");
+  rpc::rpc.mark_safe("f.is_create_queued");
+  rpc::rpc.mark_safe("f.is_resize_queued");
+  rpc::rpc.mark_safe("f.prioritize_first");
+  rpc::rpc.mark_safe("f.prioritize_first.enable");
+  rpc::rpc.mark_safe("f.prioritize_first.disable");
+  rpc::rpc.mark_safe("f.prioritize_last");
+  rpc::rpc.mark_safe("f.prioritize_last.enable");
+  rpc::rpc.mark_safe("f.prioritize_last.disable");
+  rpc::rpc.mark_safe("f.last_touched");
+  rpc::rpc.mark_safe("f.match_depth_prev");
+  rpc::rpc.mark_safe("f.match_depth_next");
+  rpc::rpc.mark_safe("fi.filename_last");
+  rpc::rpc.mark_safe("fi.is_file");
 }
@@ -385,4 +385,24 @@ initialize_command_groups() {
  CMD2_ANY         ("choke_group.down.heuristics",     std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS,
                                                                 std::bind(&torrent::choke_queue::heuristics, CHOKE_GROUP(&torrent::choke_group::down_queue))));
  CMD2_ANY_LIST    ("choke_group.down.heuristics.set", std::bind(&apply_cg_heuristics_set, std::placeholders::_2, false));
+
+  rpc::rpc.mark_safe("choke_group.list");
+  rpc::rpc.mark_safe("choke_group.size");
+  rpc::rpc.mark_safe("choke_group.index_of");
+  rpc::rpc.mark_safe("choke_group.general.size");
+  rpc::rpc.mark_safe("choke_group.tracker.mode");
+  rpc::rpc.mark_safe("choke_group.up.rate");
+  rpc::rpc.mark_safe("choke_group.down.rate");
+  rpc::rpc.mark_safe("choke_group.up.max");
+  rpc::rpc.mark_safe("choke_group.up.max.unlimited");
+  rpc::rpc.mark_safe("choke_group.up.total");
+  rpc::rpc.mark_safe("choke_group.up.queued");
+  rpc::rpc.mark_safe("choke_group.up.unchoked");
+  rpc::rpc.mark_safe("choke_group.up.heuristics");
+  rpc::rpc.mark_safe("choke_group.down.max");
+  rpc::rpc.mark_safe("choke_group.down.max.unlimited");
+  rpc::rpc.mark_safe("choke_group.down.total");
+  rpc::rpc.mark_safe("choke_group.down.queued");
+  rpc::rpc.mark_safe("choke_group.down.unchoked");
+  rpc::rpc.mark_safe("choke_group.down.heuristics");
 }
@@ -1,54 +1,18 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

 #include <fstream>
-#include <rak/path.h>
-#include <torrent/peer/peer_list.h>
-#include <torrent/utils/log.h>
-#include <torrent/utils/option_strings.h>
-
-#include "globals.h"
-#include "command_helpers.h"
-
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
+#include <torrent/peer/peer_list.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/option_strings.h>
+
+#include "globals.h"
+#include "command_helpers.h"

 bool ipv4_range_parse(const char* address, uint32_t* address_start, uint32_t* address_end);

@@ -89,7 +53,7 @@ apply_ip_tables_get(const torrent::Object::list_type& args) {
  if (table_itr == ip_tables.end())
    throw torrent::input_error("Could not find ip table.");

-  if (!ipv4_range_parse(address.c_str(), &address_start, &address_end)) 
+  if (!ipv4_range_parse(address.c_str(), &address_start, &address_end))
    throw torrent::input_error("Invalid address format.");

  if(!table_itr->table.defined(address_start, address_end))
@@ -298,7 +262,7 @@ apply_ipv4_filter_get(const std::string& args) {
  uint32_t address_start;
  uint32_t address_end;

-  if (!ipv4_range_parse(args.c_str(), &address_start, &address_end)) 
+  if (!ipv4_range_parse(args.c_str(), &address_start, &address_end))
    throw torrent::input_error("Invalid address format.");

  if(!torrent::PeerList::ipv4_filter()->defined(address_start, address_end))
@@ -326,8 +290,8 @@ apply_ipv4_filter_load(const torrent::Object::list_type& args) {
  std::string value_name = args.back().as_string();
  int value = torrent::option_find_string(torrent::OPTION_IP_FILTER, value_name.c_str());

-  std::fstream file(rak::path_expand(filename).c_str(), std::ios::in);
-  
+  std::fstream file(expand_path(filename).c_str(), std::ios::in);
+
  if (!file.is_open())
    throw torrent::input_error("Could not open ip filter file: " + filename);

@@ -1,11 +1,10 @@
 #include "config.h"

+#include <cerrno>
 #include <fcntl.h>
 #include <functional>
 #include <stdio.h>
 #include <unistd.h>
-#include <rak/path.h>
-#include <rak/error_number.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <torrent/torrent.h>
@@ -17,11 +16,11 @@

 #include "core/download.h"
 #include "core/download_list.h"
-#include "core/download_store.h"
 #include "core/manager.h"
 #include "rak/string_manip.h"
 #include "rpc/parse_commands.h"
 #include "rpc/scgi.h"
+#include "session/session_manager.h"
 #include "utils/file_status_cache.h"

 #include "globals.h"
@@ -121,6 +120,15 @@ group_insert(const torrent::Object::list_type& args) {
  rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.max", "value", (int64_t)300));
  rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.upload", "value", (int64_t)20 << 20));

+  rpc::rpc.mark_safe("group." + name + ".view");
+  rpc::rpc.mark_safe("group." + name + ".view.set");
+  rpc::rpc.mark_safe("group." + name + ".ratio.min");
+  rpc::rpc.mark_safe("group." + name + ".ratio.min.set");
+  rpc::rpc.mark_safe("group." + name + ".ratio.max");
+  rpc::rpc.mark_safe("group." + name + ".ratio.max.set");
+  rpc::rpc.mark_safe("group." + name + ".ratio.upload");
+  rpc::rpc.mark_safe("group." + name + ".ratio.upload.set");
+
  if (rpc::call_command_value("method.use_intermediate") == 3) {
    // Cleaned up in 0.16.1:

@@ -171,12 +179,16 @@ cmd_file_append(const torrent::Object::list_type& args) {

  FILE* output = fopen(args.front().as_string().c_str(), "a");

-  if (output == NULL)
-    throw torrent::input_error("Could not append to file '" + args.front().as_string() + "': " + rak::error_number::current().c_str());
+  if (output == nullptr)
+    throw torrent::input_error("Could not append to file '" + args.front().as_string() + "': " + std::strerror(errno));

-  file_print_list(++args.begin(), args.end(), output, file_print_delim_space);
-
-  fprintf(output, "\n");
+  try {
+    file_print_list(++args.begin(), args.end(), output, file_print_delim_space);
+    fprintf(output, "\n");
+  } catch (...) {
+    fclose(output);
+    throw;
+  }
  fclose(output);
  return torrent::Object();
 }
@@ -184,7 +196,6 @@ cmd_file_append(const torrent::Object::list_type& args) {
 void
 initialize_command_local() {
  core::DownloadList*    dList = control->core()->download_list();
-  core::DownloadStore*   dStore = control->core()->download_store();
  torrent::ChunkManager* chunkManager = torrent::chunk_manager();
  torrent::FileManager*  fileManager = torrent::file_manager();

@@ -212,7 +223,8 @@ initialize_command_local() {
  CMD2_ANY_VALUE_V ("system.files.advise_random.set",         std::bind(&FM_t::set_advise_random, fileManager, std::placeholders::_2));
  CMD2_ANY         ("system.files.advise_random.hashing",     std::bind(&FM_t::advise_random_hashing, fileManager));
  CMD2_ANY_VALUE_V ("system.files.advise_random.hashing.set", std::bind(&FM_t::set_advise_random_hashing, fileManager, std::placeholders::_2));
-  CMD2_VAR_BOOL    ("system.files.session.fdatasync",         true);
+  CMD2_ANY         ("system.files.session.fdatasync",         [](auto, auto)        { return session_thread::manager()->use_fsyncdisk(); });
+  CMD2_ANY_VALUE_V ("system.files.session.fdatasync.set",     [](auto, auto& value) { return session_thread::manager()->set_use_fsyncdisk(value); });

  CMD2_ANY         ("system.files.opened_counter",     std::bind(&FM_t::files_opened_counter, fileManager));
  CMD2_ANY         ("system.files.closed_counter",     std::bind(&FM_t::files_closed_counter, fileManager));
@@ -270,22 +282,25 @@ initialize_command_local() {
  CMD2_ANY         ("pieces.hash.queue_size",          std::bind(&torrent::main_thread::hash_queue_size));
  CMD2_VAR_BOOL    ("pieces.hash.on_completion",       true);

-  CMD2_VAR_STRING  ("directory.default",       "./");
+  CMD2_VAR_STRING  ("directory.default",               "./");

-  CMD2_VAR_STRING  ("session.name",            "");
-  CMD2_VAR_BOOL    ("session.use_lock",        true);
-  CMD2_VAR_BOOL    ("session.on_completion",   true);
+  CMD2_VAR_STRING  ("session.name",                    "");
+  CMD2_ANY         ("session.path",                    [](auto, auto)        { return session_thread::manager()->path(); });
+  CMD2_ANY_STRING_V("session.path.set",                [](auto, auto& str)   { return session_thread::manager()->set_path(str); });
+  CMD2_ANY         ("session.use_lock",                [](auto, auto)        { return session_thread::manager()->use_lock(); });
+  CMD2_ANY_VALUE_V ("session.use_lock.set",            [](auto, auto& value) { return session_thread::manager()->set_use_lock(value); });
+  CMD2_VAR_BOOL    ("session.on_completion",           true);

-  CMD2_ANY         ("session.path",            std::bind(&core::DownloadStore::path, dStore));
-  CMD2_ANY_STRING_V("session.path.set",        std::bind(&core::DownloadStore::set_path, dStore, std::placeholders::_2));
+  CMD2_ANY_V       ("session.save",                    [dList](auto, auto)   { return dList->session_save(); });

-  CMD2_ANY_V       ("session.save",            std::bind(&core::DownloadList::session_save, dList));
+  CMD2_ANY         ("magnet.path",                     [](auto, auto)        { return control->core()->magnet_path(); });
+  CMD2_ANY_STRING_V("magnet.path.set",                 [](auto, auto& str)   { return control->core()->set_magnet_path(str); });

 #ifdef HAVE_LUA
  rpc::LuaEngine* lua_engine = control->lua_engine();

-  CMD2_ANY         ("lua.execute",            std::bind(&rpc::execute_lua, lua_engine, std::placeholders::_1, std::placeholders::_2, 0));
-  CMD2_ANY         ("lua.execute.str",        std::bind(&rpc::execute_lua, lua_engine, std::placeholders::_1, std::placeholders::_2, rpc::LuaEngine::flag_string));
+  CMD2_ANY         ("lua.execute",                    std::bind(&rpc::execute_lua, lua_engine, std::placeholders::_1, std::placeholders::_2, 0));
+  CMD2_ANY         ("lua.execute.str",                std::bind(&rpc::execute_lua, lua_engine, std::placeholders::_1, std::placeholders::_2, rpc::LuaEngine::flag_string));
 #endif

 #define CMD2_EXECUTE(key, flags)                                        \
@@ -317,4 +332,25 @@ initialize_command_local() {
  CMD2_ANY_P("argument.3", std::bind(&rpc::command_base::argument_ref, 3));

  CMD2_ANY_LIST  ("group.insert", std::bind(&group_insert, std::placeholders::_2));
+
+  rpc::rpc.mark_safe("system.api_version");
+  rpc::rpc.mark_safe("system.client_version");
+  rpc::rpc.mark_safe("system.library_version");
+  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("directory.default");
+  rpc::rpc.mark_safe("session.path");
+  rpc::rpc.mark_safe("session.use_lock");
+  rpc::rpc.mark_safe("session.on_completion");
+
+  rpc::rpc.mark_safe("pieces.sync.always_safe");
+  rpc::rpc.mark_safe("pieces.sync.timeout");
+  rpc::rpc.mark_safe("pieces.sync.timeout_safe");
+  rpc::rpc.mark_safe("pieces.preload.type");
+  rpc::rpc.mark_safe("pieces.preload.min_size");
+  rpc::rpc.mark_safe("pieces.preload.min_rate");
+  rpc::rpc.mark_safe("pieces.memory.max");
+  rpc::rpc.mark_safe("pieces.hash.on_completion");
 }
@@ -8,19 +8,18 @@
 #include <torrent/utils/log.h>
 #include <torrent/utils/option_strings.h>

-#include "core/download.h"
-#include "core/download_list.h"
-#include "core/manager.h"
-#include "rak/path.h"
-#include "rpc/parse_commands.h"
-
 #include "globals.h"
 #include "control.h"
 #include "command_helpers.h"
+#include "core/download.h"
+#include "core/download_list.h"
+#include "core/manager.h"
+#include "rpc/parse_commands.h"

 static const int log_flag_use_gz = 0x1;
 static const int log_flag_append_pid = 0x2;
 static const int log_flag_append_file = 0x4;
+static const int log_flag_flush = 0x8;

 void
 log_add_group_output_str(const char* group_name, const char* output_id) {
@@ -35,8 +34,8 @@ apply_log_open(int output_flags, const torrent::Object::list_type& args) {

  torrent::Object::list_const_iterator itr = args.begin();

-  std::string output_id = (itr++)->as_string();
-  std::string file_name = rak::path_expand((itr++)->as_string());
+  auto output_id = (itr++)->as_string();
+  auto file_name = expand_path((itr++)->as_string());

  if ((output_flags & log_flag_append_pid)) {
    char buffer[32];
@@ -46,11 +45,12 @@ apply_log_open(int output_flags, const torrent::Object::list_type& args) {
  }

  bool append = (output_flags & log_flag_append_file);
+  bool flush = (output_flags & log_flag_flush);

  if ((output_flags & log_flag_use_gz))
    torrent::log_open_gz_file_output(output_id.c_str(), file_name.c_str(), append);
  else
-    torrent::log_open_file_output(output_id.c_str(), file_name.c_str(), append);
+    torrent::log_open_file_output(output_id.c_str(), file_name.c_str(), append, flush);

  while (itr != args.end())
    log_add_group_output_str((itr++)->as_string().c_str(), output_id.c_str());
@@ -62,7 +62,7 @@ torrent::Object
 apply_log_add_output(const torrent::Object::list_type& args) {
  if (args.size() != 2)
    throw torrent::input_error("Invalid number of arguments.");
-  
+
  log_add_group_output_str(args.front().as_string().c_str(),
                           args.back().as_string().c_str());

@@ -86,7 +86,7 @@ apply_log(const torrent::Object::string_type& arg, int logType) {
  }

  if (!arg.empty()) {
-    int logFd = open(rak::path_expand(arg).c_str(), O_WRONLY | O_APPEND | O_CREAT, 0644);
+    int logFd = open(expand_path(arg).c_str(), O_WRONLY | O_APPEND | O_CREAT, 0644);

    if (logFd < 0)
      throw torrent::input_error("Could not open execute log file.");
@@ -128,19 +128,22 @@ log_vmmap_dump(const std::string& str) {

 void
 initialize_command_logging() {
-  CMD2_ANY_LIST    ("log.open_file",        std::bind(&apply_log_open, 0, std::placeholders::_2));
-  CMD2_ANY_LIST    ("log.open_gz_file",     std::bind(&apply_log_open, log_flag_use_gz, std::placeholders::_2));
-  CMD2_ANY_LIST    ("log.open_file_pid",    std::bind(&apply_log_open, log_flag_append_pid, std::placeholders::_2));
-  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_gz_file",   std::bind(&apply_log_open, log_flag_append_file, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_file",          std::bind(&apply_log_open, 0, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_file.flush",    std::bind(&apply_log_open, log_flag_flush, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_gz_file",       std::bind(&apply_log_open, log_flag_use_gz, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_file_pid",      std::bind(&apply_log_open, log_flag_append_pid, std::placeholders::_2));
+  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_STRING_V("log.close",      std::bind(&torrent::log_close_output_str, std::placeholders::_2));
+  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.add_output",       std::bind(&apply_log_add_output, 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));
-  CMD2_ANY_STRING_V("log.rpc",        std::bind(&ThreadWorker::set_rpc_log, worker_thread, std::placeholders::_2));
-  CMD2_REDIRECT    ("log.xmlrpc",     "log.rpc"); // For backwards compatibility
+  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));
+  CMD2_ANY_STRING_V("log.rpc",              [](const auto&, const auto& str) { scgi_thread::set_rpc_log(str); });
+
+  CMD2_REDIRECT    ("log.xmlrpc", "log.rpc"); // For backwards compatibility
 }
@@ -3,20 +3,25 @@
 #include <functional>
 #include <cstdio>
 #include <unistd.h>
+#ifdef HAVE_SYSTEMD
+#include <sys/socket.h>
+#include <systemd/sd-daemon.h>
+#endif
 #include <rak/address_info.h>
-#include <rak/path.h>
 #include <torrent/torrent.h>
 #include <torrent/rate.h>
 #include <torrent/data/file_manager.h>
 #include <torrent/download/resource_manager.h>
 #include <torrent/net/http_stack.h>
 #include <torrent/net/network_config.h>
-#include <torrent/net/network_manager.h>
 #include <torrent/net/socket_address.h>
 #include <torrent/tracker/tracker.h>
 #include <torrent/utils/log.h>
 #include <torrent/utils/option_strings.h>

+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
 #include "core/download.h"
 #include "core/manager.h"
 #include "rpc/scgi.h"
@@ -24,10 +29,6 @@
 #include "rpc/parse.h"
 #include "rpc/parse_commands.h"

-#include "globals.h"
-#include "control.h"
-#include "command_helpers.h"
-
 torrent::Object
 apply_encryption(const torrent::Object::list_type& args) {
  uint32_t options_mask = torrent::net::NetworkConfig::encryption_none;
@@ -79,7 +80,7 @@ initialize_rpc_handlers() {

 torrent::Object
 apply_scgi(const std::string& arg, int type) {
-  if (worker_thread->scgi() != NULL)
+  if (scgi_thread::scgi() != nullptr)
    throw torrent::input_error("SCGI already enabled.");

  initialize_rpc_handlers();
@@ -126,7 +127,7 @@ apply_scgi(const std::string& arg, int type) {

    case 2:
    default:
-      path = rak::path_expand(arg);
+      path = expand_path(arg);

      unlink(path.c_str());
      scgi->open_named(path);
@@ -142,10 +143,64 @@ apply_scgi(const std::string& arg, int type) {
    throw torrent::input_error(e.what());
  }

-  worker_thread->set_scgi(scgi);
+  scgi_thread::set_scgi(scgi);
  return torrent::Object();
 }

+torrent::Object
+apply_scgi_systemd() {
+#ifdef HAVE_SYSTEMD
+  if (scgi_thread::scgi() != nullptr)
+    throw torrent::input_error("SCGI already enabled.");
+
+  int n = sd_listen_fds(0);
+  if (n < 1)
+    throw torrent::input_error("No systemd socket(s) provided (sd_listen_fds returned " +
+                               std::to_string(n) + ").");
+
+  // Iterate over all provided fds. Use the first listening stream socket;
+  // close the rest. The systemd docs say unused fds should be closed.
+  int selected_fd = -1;
+  for (int i = 0; i < n; i++) {
+    int fd = SD_LISTEN_FDS_START + i;
+
+    if (selected_fd != -1) {
+      ::close(fd);
+      continue;
+    }
+
+    auto err = sd_is_socket(fd, AF_UNSPEC, SOCK_STREAM, 1);
+
+    if (err < 0) {
+      // Safe to ignore errors here - we just skip it and move on.
+      ::close(fd);
+      continue;
+    }
+
+    if (err == 0) {
+      // Not the socket we're looking for.
+      ::close(fd);
+      continue;
+    }
+
+    selected_fd = fd;
+  }
+
+  if (selected_fd == -1)
+    throw torrent::input_error("No listening stream socket found among systemd-provided fds.");
+
+  initialize_rpc_handlers();
+
+  rpc::SCgi* scgi = new rpc::SCgi;
+  scgi->open_fd(selected_fd);
+
+  scgi_thread::set_scgi(scgi);
+  return torrent::Object();
+#else
+  throw torrent::input_error("Systemd SCGI endpoint is not supported.");
+#endif
+}
+
 torrent::Object
 apply_xmlrpc_dialect(const std::string& arg) {
  int value;
@@ -169,7 +224,6 @@ initialize_command_network() {
  auto file_manager = torrent::file_manager();
  auto http_stack = torrent::net_thread::http_stack();
  auto nw_config = torrent::config::network_config();
-  auto nw_manager = torrent::runtime::network_manager();

  CMD2_ANY_STRING  ("encoding.add", std::bind(&apply_encoding_list, std::placeholders::_2));

@@ -178,12 +232,12 @@ initialize_command_network() {
  CMD2_VAR_BOOL    ("network.port_random", true);
  CMD2_VAR_STRING  ("network.port_range",  "6881-6999");

-  CMD2_ANY         ("network.listen.port",        [nw_manager](auto, auto)       { return nw_manager->listen_port(); });
+  CMD2_ANY         ("network.listen.port",        [](auto, auto)                 { return torrent::runtime::listen_port(); });
  CMD2_ANY         ("network.listen.backlog",     [nw_config](auto, auto)        { return nw_config->listen_backlog(); });
  CMD2_ANY_VALUE_V ("network.listen.backlog.set", [nw_config](auto, auto& value) { return nw_config->set_listen_backlog(value); });

  CMD2_VAR_BOOL    ("protocol.pex",               true);
-  CMD2_ANY_LIST    ("protocol.encryption.set",    [](auto, auto& args)            { return apply_encryption(args); });
+  CMD2_ANY_LIST    ("protocol.encryption.set",    [](auto, auto& args)           { return apply_encryption(args); });

  CMD2_VAR_STRING  ("protocol.connection.leech",            "leech");
  CMD2_VAR_STRING  ("protocol.connection.seed",             "seed");
@@ -247,6 +301,7 @@ initialize_command_network() {
  CMD2_ANY_STRING  ("network.scgi.open_port",        std::bind(&apply_scgi, std::placeholders::_2, 1));
  CMD2_ANY_STRING  ("network.scgi.open_local",       std::bind(&apply_scgi, std::placeholders::_2, 2));
  CMD2_VAR_BOOL    ("network.scgi.dont_route",       false);
+  CMD2_ANY         ("network.scgi.open_systemd",     [](auto, auto) { return apply_scgi_systemd(); });

  CMD2_ANY_STRING  ("network.xmlrpc.dialect.set",    [](const auto&, const auto& arg) { return apply_xmlrpc_dialect(arg); })
  CMD2_ANY         ("network.xmlrpc.size_limit",     [](const auto&, const auto&)     { return rpc::rpc.size_limit(); });
@@ -265,4 +320,36 @@ initialize_command_network() {
  CMD2_ANY_VALUE_V ("network.block.outgoing.set",    [nw_config](auto, auto& value) { return nw_config->set_block_outgoing(value); });
  CMD2_ANY         ("network.prefer.ipv6",           [nw_config](auto, auto)        { return nw_config->is_prefer_ipv6(); });
  CMD2_ANY_VALUE_V ("network.prefer.ipv6.set",       [nw_config](auto, auto& value) { return nw_config->set_prefer_ipv6(value); });
+
+  rpc::rpc.mark_safe("network.port_open");
+  rpc::rpc.mark_safe("network.port_random");
+  rpc::rpc.mark_safe("network.port_range");
+  rpc::rpc.mark_safe("network.listen.port");
+  rpc::rpc.mark_safe("network.listen.backlog");
+
+  rpc::rpc.mark_safe("network.http.current_open");
+  rpc::rpc.mark_safe("network.http.max_cache_connections");
+  rpc::rpc.mark_safe("network.http.max_host_connections");
+  rpc::rpc.mark_safe("network.http.max_total_connections");
+
+  rpc::rpc.mark_safe("network.open_files");
+  rpc::rpc.mark_safe("network.max_open_files");
+  rpc::rpc.mark_safe("network.max_open_sockets");
+  rpc::rpc.mark_safe("network.total_handshakes");
+
+  rpc::rpc.mark_safe("network.send_buffer.size");
+  rpc::rpc.mark_safe("network.receive_buffer.size");
+  rpc::rpc.mark_safe("network.bind_address");
+  rpc::rpc.mark_safe("network.local_address");
+  rpc::rpc.mark_safe("network.xmlrpc.size_limit");
+  rpc::rpc.mark_safe("network.open_sockets");
+  rpc::rpc.mark_safe("network.http.cacert");
+  rpc::rpc.mark_safe("network.http.capath");
+  rpc::rpc.mark_safe("network.http.proxy_address");
+  rpc::rpc.mark_safe("network.proxy_address");
+  rpc::rpc.mark_safe("network.scgi.dont_route");
+  rpc::rpc.mark_safe("protocol.pex");
+
+  rpc::rpc.mark_safe("network.rpc.use_xmlrpc");
+  rpc::rpc.mark_safe("network.rpc.use_jsonrpc");
 }
@@ -60,6 +60,8 @@ retrieve_p_options_str(torrent::Peer* peer) {

 torrent::Object
 retrieve_p_completed_percent(torrent::Peer* peer) {
+  if (peer->bitfield()->size_bits() == 0)
+    return int64_t(0);
  return (100 * peer->bitfield()->size_set()) / peer->bitfield()->size_bits();
 }

@@ -98,4 +100,30 @@ initialize_command_peer() {

  CMD2_PEER_V("p.disconnect",         std::bind(&torrent::Peer::disconnect, std::placeholders::_1, 0));
  CMD2_PEER_V("p.disconnect_delayed", std::bind(&torrent::Peer::disconnect, std::placeholders::_1, torrent::ConnectionList::disconnect_delayed));
+
+  rpc::rpc.mark_safe("p.address");
+  rpc::rpc.mark_safe("p.port");
+  rpc::rpc.mark_safe("p.client_version");
+  rpc::rpc.mark_safe("p.options_str");
+  rpc::rpc.mark_safe("p.id");
+  rpc::rpc.mark_safe("p.id_html");
+  rpc::rpc.mark_safe("p.up_rate");
+  rpc::rpc.mark_safe("p.up_total");
+  rpc::rpc.mark_safe("p.down_rate");
+  rpc::rpc.mark_safe("p.down_total");
+  rpc::rpc.mark_safe("p.peer_rate");
+  rpc::rpc.mark_safe("p.peer_total");
+  rpc::rpc.mark_safe("p.is_encrypted");
+  rpc::rpc.mark_safe("p.is_incoming");
+  rpc::rpc.mark_safe("p.is_obfuscated");
+  rpc::rpc.mark_safe("p.is_snubbed");
+  rpc::rpc.mark_safe("p.is_unwanted");
+  rpc::rpc.mark_safe("p.is_preferred");
+  rpc::rpc.mark_safe("p.snubbed");
+  rpc::rpc.mark_safe("p.snubbed.set");
+  rpc::rpc.mark_safe("p.banned");
+  rpc::rpc.mark_safe("p.banned.set");
+  rpc::rpc.mark_safe("p.completed_percent");
+  rpc::rpc.mark_safe("p.disconnect");
+  rpc::rpc.mark_safe("p.disconnect_delayed");
 }
@@ -199,4 +199,60 @@ initialize_command_throttle() {
  CMD2_ANY_STRING  ("throttle.up.rate",   std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_rate));
  CMD2_ANY_STRING  ("throttle.down.max",  std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_max));
  CMD2_ANY_STRING  ("throttle.down.rate", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_rate));
+
+  rpc::rpc.mark_safe("throttle.unchoked_uploads");
+  rpc::rpc.mark_safe("throttle.max_unchoked_uploads");
+  rpc::rpc.mark_safe("throttle.unchoked_downloads");
+  rpc::rpc.mark_safe("throttle.max_unchoked_downloads");
+
+  rpc::rpc.mark_safe("throttle.min_peers.normal");
+  rpc::rpc.mark_safe("throttle.min_peers.normal.set");
+  rpc::rpc.mark_safe("throttle.max_peers.normal");
+  rpc::rpc.mark_safe("throttle.max_peers.normal.set");
+  rpc::rpc.mark_safe("throttle.min_peers.seed");
+  rpc::rpc.mark_safe("throttle.min_peers.seed.set");
+  rpc::rpc.mark_safe("throttle.max_peers.seed");
+  rpc::rpc.mark_safe("throttle.max_peers.seed.set");
+
+  rpc::rpc.mark_safe("throttle.min_uploads");
+  rpc::rpc.mark_safe("throttle.min_uploads.set");
+  rpc::rpc.mark_safe("throttle.max_uploads");
+  rpc::rpc.mark_safe("throttle.max_uploads.set");
+  rpc::rpc.mark_safe("throttle.min_downloads");
+  rpc::rpc.mark_safe("throttle.min_downloads.set");
+  rpc::rpc.mark_safe("throttle.max_downloads");
+  rpc::rpc.mark_safe("throttle.max_downloads.set");
+
+  rpc::rpc.mark_safe("throttle.max_uploads.div");
+  rpc::rpc.mark_safe("throttle.max_uploads.div.set");
+  rpc::rpc.mark_safe("throttle.max_uploads.div._val");
+  rpc::rpc.mark_safe("throttle.max_uploads.div._val.set");
+  rpc::rpc.mark_safe("throttle.max_uploads.global");
+  rpc::rpc.mark_safe("throttle.max_uploads.global.set");
+  rpc::rpc.mark_safe("throttle.max_uploads.global._val");
+  rpc::rpc.mark_safe("throttle.max_uploads.global._val.set");
+  rpc::rpc.mark_safe("throttle.max_downloads.div");
+  rpc::rpc.mark_safe("throttle.max_downloads.div.set");
+  rpc::rpc.mark_safe("throttle.max_downloads.div._val");
+  rpc::rpc.mark_safe("throttle.max_downloads.div._val.set");
+  rpc::rpc.mark_safe("throttle.max_downloads.global");
+  rpc::rpc.mark_safe("throttle.max_downloads.global.set");
+  rpc::rpc.mark_safe("throttle.max_downloads.global._val");
+  rpc::rpc.mark_safe("throttle.max_downloads.global._val.set");
+
+  rpc::rpc.mark_safe("throttle.global_up.rate");
+  rpc::rpc.mark_safe("throttle.global_up.total");
+  rpc::rpc.mark_safe("throttle.global_up.max_rate");
+  rpc::rpc.mark_safe("throttle.global_up.max_rate.set");
+  rpc::rpc.mark_safe("throttle.global_up.max_rate.set_kb");
+  rpc::rpc.mark_safe("throttle.global_down.rate");
+  rpc::rpc.mark_safe("throttle.global_down.total");
+  rpc::rpc.mark_safe("throttle.global_down.max_rate");
+  rpc::rpc.mark_safe("throttle.global_down.max_rate.set");
+  rpc::rpc.mark_safe("throttle.global_down.max_rate.set_kb");
+
+  rpc::rpc.mark_safe("throttle.up.max");
+  rpc::rpc.mark_safe("throttle.up.rate");
+  rpc::rpc.mark_safe("throttle.down.max");
+  rpc::rpc.mark_safe("throttle.down.rate");
 }
@@ -4,8 +4,8 @@
 #include <cstdio>
 #include <netdb.h>
 #include <torrent/net/network_config.h>
-#include <torrent/net/network_manager.h>
 #include <torrent/net/resolver.h>
+#include <torrent/runtime/network_manager.h>
 #include <torrent/tracker/dht_controller.h>
 #include <torrent/tracker/tracker.h>
 #include <torrent/utils/log.h>
@@ -28,9 +28,6 @@ tracker_set_enabled(torrent::tracker::Tracker* tracker, bool state) {

 torrent::Object
 apply_dht_add_node(const std::string& arg) {
-  if (!torrent::runtime::network_manager()->is_dht_valid())
-    throw torrent::input_error("DHT not enabled.");
-
  int port;
  char dummy;
  char host[1024];
@@ -45,7 +42,7 @@ apply_dht_add_node(const std::string& arg) {
  if (port < 1 || port > 65535)
    throw torrent::input_error("Invalid port number.");

-  assert(std::this_thread::get_id() == torrent::main_thread::thread()->thread_id());
+  assert(std::this_thread::get_id() == torrent::main_thread::thread_id());

  auto host_str = std::string(host);

@@ -59,7 +56,7 @@ apply_dht_add_node(const std::string& arg) {
      }

      lt_log_print(torrent::LOG_DHT_CONTROLLER, "dht.add_node : %s", host_str.c_str());
-      torrent::runtime::network_manager()->dht_add_peer_node(sa.get(), port);
+      torrent::runtime::network_manager()->dht_add_bootstrap_node(host_str.c_str(), port);
  });

  return torrent::Object();
@@ -154,4 +151,35 @@ initialize_command_tracker() {

  CMD2_ANY_STRING     ("dht.add_node",          std::bind(&apply_dht_add_node, std::placeholders::_2));
  CMD2_ANY            ("dht.statistics",        std::bind(&core::DhtManager::dht_statistics, dht_manager));
+
+  rpc::rpc.mark_safe("t.url");
+  rpc::rpc.mark_safe("t.group");
+  rpc::rpc.mark_safe("t.id");
+  rpc::rpc.mark_safe("t.type");
+  rpc::rpc.mark_safe("t.is_usable");
+  rpc::rpc.mark_safe("t.is_busy");
+  rpc::rpc.mark_safe("t.is_enabled");
+  rpc::rpc.mark_safe("t.is_enabled.set");
+  rpc::rpc.mark_safe("t.is_extra_tracker");
+  rpc::rpc.mark_safe("t.is_open");
+  rpc::rpc.mark_safe("t.normal_interval");
+  rpc::rpc.mark_safe("t.scrape_time_last");
+  rpc::rpc.mark_safe("t.scrape_counter");
+  rpc::rpc.mark_safe("t.success_time_last");
+  rpc::rpc.mark_safe("t.success_counter");
+  rpc::rpc.mark_safe("t.failed_time_last");
+  rpc::rpc.mark_safe("t.failed_counter");
+  rpc::rpc.mark_safe("t.activity_time_last");
+  rpc::rpc.mark_safe("t.activity_time_next");
+  rpc::rpc.mark_safe("t.scrape_complete");
+  rpc::rpc.mark_safe("t.scrape_incomplete");
+  rpc::rpc.mark_safe("t.scrape_downloaded");
+
+  rpc::rpc.mark_safe("dht.mode.set");
+  rpc::rpc.mark_safe("dht.port");
+  rpc::rpc.mark_safe("dht.override_port");
+  rpc::rpc.mark_safe("dht.add_node");
+  rpc::rpc.mark_safe("dht.statistics");
+  rpc::rpc.mark_safe("trackers.numwant");
+  rpc::rpc.mark_safe("trackers.use_udp");
 }
@@ -888,4 +888,28 @@ initialize_command_ui() {
      return control->object_storage()->get_str(display::color_vars[color_id]);
    });
  }
+
+  rpc::rpc.mark_safe("view.set_visible");
+  rpc::rpc.mark_safe("view.set_not_visible");
+
+  rpc::rpc.mark_safe("cat");
+  rpc::rpc.mark_safe("if");
+  rpc::rpc.mark_safe("branch");
+  rpc::rpc.mark_safe("and");
+  rpc::rpc.mark_safe("or");
+  rpc::rpc.mark_safe("not");
+  rpc::rpc.mark_safe("value");
+  rpc::rpc.mark_safe("compare");
+  rpc::rpc.mark_safe("elapsed.less");
+  rpc::rpc.mark_safe("elapsed.greater");
+
+  rpc::rpc.mark_safe("convert.gm_time");
+  rpc::rpc.mark_safe("convert.gm_date");
+  rpc::rpc.mark_safe("convert.time");
+  rpc::rpc.mark_safe("convert.date");
+  rpc::rpc.mark_safe("convert.elapsed_time");
+  rpc::rpc.mark_safe("convert.kb");
+  rpc::rpc.mark_safe("convert.mb");
+  rpc::rpc.mark_safe("convert.xb");
+  rpc::rpc.mark_safe("convert.throttle");
 }
@@ -5,11 +5,10 @@
 #include <unistd.h>
 #include <sys/stat.h>
 #include <torrent/net/http_stack.h>
-#include <torrent/net/network_manager.h>
+#include <torrent/runtime/network_manager.h>
 #include <torrent/utils/directory_events.h>

 #include "core/dht_manager.h"
-#include "core/download_store.h"
 #include "core/http_queue.h"
 #include "core/manager.h"
 #include "core/view_manager.h"
@@ -26,6 +25,7 @@
 #include "rpc/lua.h"
 #include "rpc/parse_commands.h"
 #include "rpc/object_storage.h"
+#include "session/session_manager.h"
 #include "ui/root.h"

 Control::Control()
@@ -58,7 +58,8 @@ Control::~Control() {

 void
 Control::initialize() {
-  worker_thread->start_thread();
+  session_thread::thread()->start_thread();
+  scgi_thread::thread()->start_thread();

  display::Canvas::initialize();
  display::Window::slot_schedule([this](display::Window* w, std::chrono::microseconds t) { m_display->schedule(w, t); });
@@ -68,7 +69,6 @@ Control::initialize() {
  torrent::net_thread::http_stack()->set_user_agent(USER_AGENT);

  m_core->listen_open();
-  m_core->download_store()->enable(rpc::call_command_value("session.use_lock"));
  m_core->set_hashing_view(*m_view_manager->find_throw("hashing"));

  m_ui->init(this);
@@ -86,7 +86,12 @@ Control::cleanup() {
  if(!display::Canvas::daemon())
    m_inputStdin->remove(torrent::this_thread::poll());

-  m_core->download_store()->disable();
+  if (scgi_thread::thread()->is_active())
+    scgi_thread::thread()->stop_thread_wait();
+
+  // Wait for all session files to be written.
+  session_thread::manager()->flush_all_pending_builds();
+  session_thread::thread()->stop_thread_wait();

  m_ui->cleanup();
  m_core->cleanup();
@@ -104,7 +109,7 @@ Control::cleanup_exception() {

 bool
 Control::is_shutdown_completed() {
-  if (!m_shutdownQuick || worker_thread->is_active())
+  if (!m_shutdownQuick)
    return false;

  // Tracker requests can be disowned, so wait for these to
@@ -123,10 +128,10 @@ void
 Control::handle_shutdown() {
  rpc::commands.call_catch("event.system.shutdown", rpc::make_target(), "shutdown", "System shutdown event action failed: ");

-  if (!m_shutdownQuick) {
-    if (worker_thread->is_active())
-      worker_thread->stop_thread_wait();
+  if (scgi_thread::thread()->is_active())
+    scgi_thread::thread()->stop_thread_wait();

+  if (!m_shutdownQuick) {
    torrent::runtime::network_manager()->listen_close();

    m_directory_events->close();
@@ -136,9 +141,6 @@ Control::handle_shutdown() {
      torrent::this_thread::scheduler()->wait_for_ceil_seconds(&m_task_shutdown, 5s);

  } else {
-    if (worker_thread->is_active())
-      worker_thread->stop_thread_wait();
-
    m_core->shutdown(true);
  }

@@ -6,17 +6,17 @@
 #include <sstream>
 #include <torrent/object.h>
 #include <torrent/object_stream.h>
-#include <torrent/net/network_manager.h>
 #include <torrent/rate.h>
+#include <torrent/runtime/network_manager.h>
 #include <torrent/tracker/dht_controller.h>
 #include <torrent/utils/log.h>

 #include "control.h"
 #include "download.h"
-#include "download_store.h"
 #include "globals.h"
 #include "manager.h"
 #include "rpc/parse_commands.h"
+#include "session/session_manager.h"

 #define LT_LOG(log_fmt, ...)                                            \
  lt_log_print_subsystem(torrent::LOG_DHT_CONTROLLER, "dht_manager", log_fmt, __VA_ARGS__);
@@ -35,13 +35,13 @@ DhtManager::~DhtManager() {

 void
 DhtManager::load_dht_cache() {
-  if (m_start == dht_disable || !control->core()->download_store()->is_enabled()) {
+  if (m_start == dht_disable || !session_thread::manager()->is_used()) {
    LT_LOG("ignoring cache file", 0);
    return;
  }

-  std::string cache_filename = control->core()->download_store()->path() + "rtorrent.dht_cache";
-  std::fstream cache_stream(cache_filename.c_str(), std::ios::in | std::ios::binary);
+  auto cache_filename = session_thread::manager()->path() + "rtorrent.dht_cache";
+  auto cache_stream   = std::fstream(cache_filename.c_str(), std::ios::in | std::ios::binary);

  torrent::Object cache = torrent::Object::create_map();

@@ -115,14 +115,15 @@ DhtManager::stop_dht() {

 void
 DhtManager::save_dht_cache() {
-  if (!control->core()->download_store()->is_enabled())
+  if (!session_thread::manager()->is_used())
    return;
+
  if (!torrent::runtime::network_manager()->is_dht_valid())
    return;

-  std::string filename = control->core()->download_store()->path() + "rtorrent.dht_cache";
-  std::string filename_tmp = filename + ".new";
-  std::fstream cache_file(filename_tmp.c_str(), std::ios::out | std::ios::trunc);
+  auto filename     = session_thread::manager()->path() + "rtorrent.dht_cache";
+  auto filename_tmp = filename + ".new";
+  auto cache_file   = std::fstream(filename_tmp.c_str(), std::ios::out | std::ios::trunc);

  if (!cache_file.is_open())
    return;
@@ -1,25 +1,25 @@
 #include "config.h"

+#include "core/download.h"
+
 #include <list>
-#include <rak/file_stat.h>
-#include <rak/path.h>
 #include <torrent/exceptions.h>
 #include <torrent/rate.h>
 #include <torrent/torrent.h>
 #include <torrent/tracker/tracker.h>
 #include <torrent/data/file.h>
 #include <torrent/data/file_list.h>
+#include <torrent/utils/file_stat.h>

 #include "rpc/parse_commands.h"

 #include "control.h"
-#include "download.h"
-#include "manager.h"
+#include "core/manager.h"

 namespace core {

-Download::Download(download_type d) :
-    m_download(d) {
+Download::Download(download_type d)
+  : m_download(d) {

  m_download.info()->signal_tracker_success().push_back(std::bind(&Download::receive_tracker_msg, this, ""));
  m_download.info()->signal_tracker_failed().push_back(std::bind(&Download::receive_tracker_msg, this, std::placeholders::_1));
@@ -118,13 +118,14 @@ void
 Download::set_root_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.
-  // 
+  //
  // This should ensure that no one tries to set the destination
  // directory 'after' moving files. In cases where the user wants to
  // override this behavior the download must first be closed or
  // 'd.directory_base.set' may be used.
-  rak::file_stat file_stat;
-  torrent::FileList* file_list = m_download.file_list();
+
+  torrent::utils::FileStat file_stat;
+  torrent::FileList*       file_list = m_download.file_list();

  if (is_hash_checked() && file_list->completed_chunks() != 0 &&

@@ -136,11 +137,11 @@ Download::set_root_directory(const std::string& path) {
    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 atter the files have been moved.");
+    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);
-  file_list->set_root_dir(rak::path_expand(path));
+  file_list->set_root_dir(expand_path(path));

  bencode()->get_key("rtorrent").insert_key("directory", path);
 }
@@ -7,7 +7,6 @@
 #include <functional>
 #include <sstream>
 #include <stdexcept>
-#include <rak/path.h>
 #include <torrent/utils/log.h>
 #include <torrent/utils/resume.h>
 #include <torrent/object.h>
@@ -20,7 +19,6 @@
 #include "control.h"
 #include "globals.h"
 #include "core/download.h"
-#include "core/download_store.h"
 #include "core/http_queue.h"
 #include "core/manager.h"
 #include "rpc/parse_commands.h"
@@ -124,7 +122,7 @@ DownloadFactory::receive_load() {
    receive_loaded();

  } else {
-    std::fstream stream(rak::path_expand(m_uri).c_str(), std::ios::in | std::ios::binary);
+    std::fstream stream(expand_path(m_uri).c_str(), std::ios::in | std::ios::binary);

    if (!stream.is_open())
      return receive_failed("Could not open file");
@@ -159,8 +157,8 @@ DownloadFactory::receive_commit() {

 void
 DownloadFactory::receive_success() {
-  auto rtorrent_object = download_factory_load_stream((rak::path_expand(m_uri) + ".rtorrent").c_str());
-  auto libtorrent_resume_object = download_factory_load_stream((rak::path_expand(m_uri) + ".libtorrent_resume").c_str());
+  auto rtorrent_object          = download_factory_load_stream((expand_path(m_uri) + ".rtorrent").c_str());
+  auto libtorrent_resume_object = download_factory_load_stream((expand_path(m_uri) + ".libtorrent_resume").c_str());

  uint32_t tracker_key;

@@ -255,11 +253,21 @@ DownloadFactory::receive_success() {
                            rpc::call_command_value("system.file.split_size"),
                            rpc::call_command_string("system.file.split_suffix"));

-  if (!rtorrent->has_key_string("directory"))
-    rpc::call_command("d.directory.set", m_variables["directory"], rpc::make_target(download));
-  else
+  if (rtorrent->has_key_string("directory")) {
    rpc::call_command("d.directory_base.set", rtorrent->get_key("directory"), rpc::make_target(download));

+  } else if (download->download()->info()->is_meta_download()) {
+    auto& metadata_path = control->core()->magnet_path();
+
+    if (!metadata_path.empty())
+      rpc::call_command("d.directory.set", metadata_path, rpc::make_target(download));
+    else
+      rpc::call_command("d.directory.set", session_thread::session_path(), rpc::make_target(download));
+
+  } else {
+    rpc::call_command("d.directory.set", m_variables["directory"], rpc::make_target(download));
+  }
+
  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));

@@ -22,10 +22,10 @@
 #include "view.h"
 #include "view_manager.h"

-#include "dht_manager.h"
-#include "download.h"
-#include "download_list.h"
-#include "download_store.h"
+#include "core/dht_manager.h"
+#include "core/download.h"
+#include "core/download_list.h"
+#include "session/session_manager.h"
 #include "ui/root.h"

 #define DL_TRIGGER_EVENT(download, event_name) \
@@ -68,10 +68,8 @@ DownloadList::clear() {

 void
 DownloadList::session_save() {
-  unsigned int c = std::count_if(begin(), end(), [&](Download* d) { return control->core()->download_store()->save_resume(d); });
-
-  if (c != size())
-    lt_log_print(torrent::LOG_ERROR, "Failed to save session torrents.");
+  for (auto& download : *this)
+    session_thread::manager()->save_resume_download(download);

  control->dht_manager()->save_dht_cache();
  control->ui()->save_input_history();
@@ -199,10 +197,10 @@ DownloadList::erase(iterator itr) {
  (*itr)->set_hash_failed(true);

  close(*itr);
-
-  control->core()->download_store()->remove(*itr);
+  session_thread::manager()->remove_download(*itr);

  DL_TRIGGER_EVENT(*itr, "event.download.erased");
+
  for (auto v : *control->view_manager())
    v->erase(*itr);

@@ -639,10 +637,8 @@ DownloadList::confirm_finished(Download* download) {
  // the download.
  //
  // Obsolete.
-  if (!download->is_active() && rpc::call_command_value("session.on_completion") != 0) {
-    //    torrent::resume_save_progress(*download->download(), download->download()->bencode()->get_key("libtorrent_resume"));
-    control->core()->download_store()->save_resume(download);
-  }
+  if (!download->is_active() && rpc::call_command_value("session.on_completion") != 0)
+    session_thread::manager()->save_resume_download(download);

  // Send the completed request before resuming so we don't reset the
  // up/downloaded baseline.
@@ -655,7 +651,7 @@ DownloadList::confirm_finished(Download* download) {

  if (find(infohash) == end())
    return;
-      
+
 //   if (download->resume_flags() != ~uint32_t())
 //     throw torrent::internal_error("DownloadList::confirm_finished(...) download->resume_flags() != ~uint32_t().");

@@ -1,205 +0,0 @@
-// DownloadStore handles the saving and listing of session torrents.
-
-#include "config.h"
-
-#include <fstream>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <rak/error_number.h>
-#include <rak/path.h>
-#include <rak/string_manip.h>
-#include <torrent/utils/resume.h>
-#include <torrent/object.h>
-#include <torrent/exceptions.h>
-#include <torrent/torrent.h>
-#include <torrent/rate.h>
-#include <torrent/object_stream.h>
-
-#include "utils/directory.h"
-
-#include "download.h"
-#include "download_store.h"
-#include "rpc/parse_commands.h"
-
-namespace core {
-
-void
-DownloadStore::enable(bool lock) {
-  if (is_enabled())
-    throw torrent::input_error("Session directory already enabled.");
-
-  if (m_path.empty())
-    return;
-
-  if (lock)
-    m_lockfile.set_path(m_path + "rtorrent.lock");
-  else
-    m_lockfile.set_path(std::string());
-
-  if (!m_lockfile.try_lock()) {
-    if (rak::error_number::current().is_bad_path())
-      throw torrent::input_error("Could not lock session directory: \"" + m_path + "\", " + rak::error_number::current().c_str());
-    else
-      throw torrent::input_error("Could not lock session directory: \"" + m_path + "\", held by \"" + m_lockfile.locked_by_as_string() + "\".");
-  }
-}
-
-void
-DownloadStore::disable() {
-  if (!is_enabled())
-    return;
-
-  m_lockfile.unlock();
-}
-
-void
-DownloadStore::set_path(const std::string& path) {
-  if (is_enabled())
-    throw torrent::input_error("Tried to change session directory while it is enabled.");
-
-  if (!path.empty() && *path.rbegin() != '/')
-    m_path = rak::path_expand(path + '/');
-  else
-    m_path = rak::path_expand(path);
-}
-
-bool
-DownloadStore::write_bencode(const std::string& filename, const torrent::Object& obj, uint32_t skip_mask) {
-  int fd;
-  torrent::Object tmp;
-  std::fstream output(filename.c_str(), std::ios::out | std::ios::trunc);
-
-  if (!output.is_open())
-    goto download_store_save_error;
-
-  torrent::object_write_bencode(&output, &obj, skip_mask);
-
-  if (!output.good())
-    goto download_store_save_error;
-
-  output.close();
-
-  // Test the new file, to ensure it is a valid bencode string.
-  output.open(filename.c_str(), std::ios::in);
-  output >> tmp;
-
-  if (!output.good())
-    goto download_store_save_error;
-
-  output.close();
-
-  // Ensure that the new file is actually written to the disk
-  fd = ::open(filename.c_str(), O_WRONLY);
-  if (fd < 0)
-    goto download_store_save_error;
-
-  if (rpc::call_command_value("system.files.session.fdatasync")) {
-#ifdef __APPLE__
-    fsync(fd);
-#else
-    fdatasync(fd);
-#endif
-  }
-
-  ::close(fd);
-
-  return true;
-
-download_store_save_error:
-  output.close();
-  return false;
-}
-
-bool
-DownloadStore::save(Download* d, int flags) {
-  if (!is_enabled())
-    return true;
-
-  torrent::Object* resume_base   = &d->download()->bencode()->get_key("libtorrent_resume");
-  torrent::Object* rtorrent_base = &d->download()->bencode()->get_key("rtorrent");
-
-  // Move this somewhere else?
-  rtorrent_base->insert_key("chunks_done",    d->download()->file_list()->completed_chunks());
-  rtorrent_base->insert_key("chunks_wanted",  d->download()->data()->wanted_chunks());
-  rtorrent_base->insert_key("total_uploaded", d->info()->up_rate()->total());
-  rtorrent_base->insert_key("total_downloaded", d->info()->down_rate()->total());
-
-  // Don't save for completed torrents when we've cleared the uncertain_pieces.
-  torrent::resume_save_progress(*d->download(), *resume_base);
-  torrent::resume_save_uncertain_pieces(*d->download(), *resume_base);
-
-  torrent::resume_save_addresses(*d->download(), *resume_base);
-  torrent::resume_save_file_priorities(*d->download(), *resume_base);
-  torrent::resume_save_tracker_settings(*d->download(), *resume_base);
-
-  // Temp fixing of all flags, move to a better place:
-  resume_base->set_flags(torrent::Object::flag_session_data);
-  rtorrent_base->set_flags(torrent::Object::flag_session_data);
-
-  std::string base_filename = create_filename(d);
-
-  if (!write_bencode(base_filename + ".libtorrent_resume.new", *resume_base, 0) ||
-      !write_bencode(base_filename + ".rtorrent.new", *rtorrent_base, 0))
-    return false;
-
-  ::rename((base_filename + ".libtorrent_resume.new").c_str(), (base_filename + ".libtorrent_resume").c_str());
-  ::rename((base_filename + ".rtorrent.new").c_str(), (base_filename + ".rtorrent").c_str());
-
-  if (!(flags & flag_skip_static) &&
-      write_bencode(base_filename + ".new", *d->bencode(), torrent::Object::flag_session_data))
-    ::rename((base_filename + ".new").c_str(), base_filename.c_str());
-
-  return true;
-}
-
-void
-DownloadStore::remove(Download* d) {
-  if (!is_enabled())
-    return;
-
-  ::unlink((create_filename(d) + ".libtorrent_resume").c_str());
-  ::unlink((create_filename(d) + ".rtorrent").c_str());
-  ::unlink(create_filename(d).c_str());
-}
-
-// This also needs to check that it isn't a directory.
-bool
-not_correct_format(const utils::directory_entry& entry) {
-  return !DownloadStore::is_correct_format(entry.s_name);
-}
-
-utils::Directory
-DownloadStore::get_formated_entries() {
-  if (!is_enabled())
-    return utils::Directory();
-
-  utils::Directory d(m_path);
-
-  if (!d.update(utils::Directory::update_hide_dot))
-    throw torrent::storage_error("core::DownloadStore::update() could not open directory \"" + m_path + "\"");
-
-  d.erase(std::remove_if(d.begin(), d.end(), [&](const utils::directory_entry& entry) { return not_correct_format(entry); }), d.end());
-
-  return d;
-}
-
-bool
-DownloadStore::is_correct_format(const std::string& f) {
-  if (f.size() != 48 || f.substr(40) != ".torrent")
-    return false;
-
-  for (std::string::const_iterator itr = f.begin(); itr != f.end() - 8; ++itr)
-    if (!(*itr >= '0' && *itr <= '9') &&
-        !(*itr >= 'A' && *itr <= 'F'))
-      return false;
-
-  return true;
-}
-
-std::string
-DownloadStore::create_filename(Download* d) {
-  return m_path + rak::transform_hex(d->info()->hash().begin(), d->info()->hash().end()) + ".torrent";
-}
-
-}
@@ -1,49 +0,0 @@
-#ifndef RTORRENT_CORE_DOWNLOAD_STORE_H
-#define RTORRENT_CORE_DOWNLOAD_STORE_H
-
-#include <string>
-
-#include "utils/lockfile.h"
-
-namespace utils {
-  class Directory;
-}
-
-namespace core {
-
-class Download;
-
-class DownloadStore {
-public:
-  static const int flag_skip_static = 0x1;
-
-  bool                is_enabled()                            { return m_lockfile.is_locked(); }
-
-  void                enable(bool lock);
-  void                disable();
-
-  const std::string&  path() const                            { return m_path; }
-  void                set_path(const std::string& path);
-
-  bool                save(Download* d, int flags);
-  bool                save_full(Download* d)   { return save(d, 0); }
-  bool                save_resume(Download* d) { return save(d, flag_skip_static); }
-  void                remove(Download* d);
-
-  // Currently shows all entries in the correct format.
-  utils::Directory    get_formated_entries();
-
-  static bool         is_correct_format(const std::string& f);
-
-private:
-  std::string         create_filename(Download* d);
-
-  bool                write_bencode(const std::string& filename, const torrent::Object& obj, uint32_t skip_mask);
-
-  std::string         m_path;
-  utils::Lockfile     m_lockfile;
-};
-
-}
-
-#endif
@@ -1,5 +1,7 @@
 #include "config.h"

+#include "core/manager.h"
+
 #include <cstdio>
 #include <cstring>
 #include <fstream>
@@ -8,7 +10,6 @@
 #include <sys/select.h>
 #include <rak/address_info.h>
 #include <rak/regex.h>
-#include <rak/path.h>
 #include <rak/string_manip.h>
 #include <torrent/utils/resume.h>
 #include <torrent/object.h>
@@ -19,8 +20,8 @@
 #include <torrent/throttle.h>
 #include <torrent/net/http_stack.h>
 #include <torrent/net/network_config.h>
-#include <torrent/net/network_manager.h>
 #include <torrent/net/socket_address.h>
+#include <torrent/runtime/network_manager.h>
 #include <torrent/utils/log.h>

 #include "rpc/parse_commands.h"
@@ -32,9 +33,7 @@
 #include "control.h"
 #include "core/download.h"
 #include "core/download_factory.h"
-#include "core/download_store.h"
 #include "core/http_queue.h"
-#include "core/manager.h"
 #include "core/view.h"

 namespace core {
@@ -50,11 +49,10 @@ Manager::push_log(const char* msg) {
  m_log_complete->lock_and_push_log(msg, strlen(msg), 0);
 }

-Manager::Manager() :
-    m_log_important(torrent::log_open_log_buffer("important")),
+Manager::Manager()
+  : m_log_important(torrent::log_open_log_buffer("important")),
    m_log_complete(torrent::log_open_log_buffer("complete")) {

-  m_download_store    = std::make_unique<DownloadStore>();
  m_download_list     = std::make_unique<DownloadList>();
  m_file_status_cache = std::make_unique<FileStatusCache>();
  m_http_queue        = std::make_unique<HttpQueue>();
@@ -134,6 +132,16 @@ Manager::retrieve_throttle_value(const torrent::Object::string_type& name, bool
  }
 }

+void
+Manager::set_magnet_path(const std::string& path) {
+  if (path.empty())
+    m_magnet_path.clear();
+  else if (path.back() == '/')
+    m_magnet_path = path;
+  else
+    m_magnet_path = path + '/';
+}
+
 void
 Manager::cleanup() {
  // Need to disconnect log signals? Not really since we won't receive
@@ -249,7 +257,7 @@ Manager::try_create_download(const std::string& uri, int flags, const command_li
      !is_network_uri(uri) &&
      !is_magnet_uri(uri) &&
      !is_data_uri(uri) &&
-      !file_status_cache()->insert(uri, 0))
+      !file_status_cache()->insert(uri))
    return;

  // Adding download.
@@ -21,7 +21,6 @@ class FileStatusCache;

 namespace core {

-class DownloadStore;
 class HttpQueue;

 typedef std::map<std::string, torrent::ThrottlePair> ThrottleMap;
@@ -37,7 +36,6 @@ public:
  ~Manager();

  DownloadList*       download_list()                     { return m_download_list.get(); }
-  DownloadStore*      download_store()                    { return m_download_store.get(); }
  FileStatusCache*    file_status_cache()                 { return m_file_status_cache.get(); }

  HttpQueue*          http_queue()                        { return m_http_queue.get(); }
@@ -63,6 +61,9 @@ public:

  void                set_proxy_address(const std::string& addr);

+  const std::string&  magnet_path();
+  void                set_magnet_path(const std::string& path);
+
  void                shutdown(bool force);

  void                push_log(const char* msg);
@@ -95,7 +96,6 @@ private:
  void                receive_hashing_changed();

  std::unique_ptr<DownloadList>    m_download_list;
-  std::unique_ptr<DownloadStore>   m_download_store;
  std::unique_ptr<FileStatusCache> m_file_status_cache;
  std::unique_ptr<HttpQueue>       m_http_queue;

@@ -106,11 +106,15 @@ private:

  torrent::log_buffer_ptr m_log_important;
  torrent::log_buffer_ptr m_log_complete;
+
+  std::string         m_magnet_path;
 };

 // Meh, cleanup.
 extern void receive_tracker_dump(const std::string& url, const char* data, size_t size);

+inline const std::string& Manager::magnet_path() { return m_magnet_path; }
+
 }

 #endif
@@ -361,7 +361,7 @@ Frame::balance_row(uint32_t x, uint32_t y, uint32_t width, uint32_t height) {
    (*itr)->balance(x, y, m_width, std::min((*itr)->m_height, height));

    y += (*itr)->m_height;
-    height -= (*itr)->m_height;
+    height -= std::min(height, (*itr)->m_height);
  }
 }

@@ -436,7 +436,7 @@ Frame::balance_column(uint32_t x, uint32_t y, uint32_t width, uint32_t height) {
    (*itr)->balance(x, y, std::min((*itr)->m_width, width), m_height);

    x += (*itr)->m_width;
-    width -= (*itr)->m_width;
+    width -= std::min(width, (*itr)->m_width);
  }
 }

@@ -55,6 +55,7 @@ Manager::receive_update() {
    m_force_redraw = false;

    display::Canvas::resize_term(display::Canvas::term_size());
+    keypad(stdscr, TRUE);
    Canvas::redraw_std();

    adjust_layout();
@@ -17,7 +17,6 @@
 #include <torrent/download/resource_manager.h>
 #include <torrent/net/http_stack.h>
 #include <torrent/net/network_config.h>
-#include <torrent/net/network_manager.h>
 #include <torrent/net/socket_address.h>
 #include <torrent/peer/client_info.h>

@@ -151,7 +150,7 @@ print_download_status(char* first, char* last, core::Download* d) {

  if (d->is_hash_checking()) {
    first = print_buffer(first, last, "Checking hash [%2i%%]",
-                         (d->download()->chunks_hashed() * 100) / d->download()->file_list()->size_chunks());
+                         d->download()->file_list()->size_chunks() != 0 ? (d->download()->chunks_hashed() * 100) / d->download()->file_list()->size_chunks() : 0);

  } else if (d->tracker_controller().has_active_trackers_not_scrape()) {
    auto tracker = d->tracker_controller().find_if([](const auto& t) {
@@ -209,7 +208,7 @@ print_download_info_compact(char* first, char* last, core::Download* d) {
  if (d->is_done())
    first = print_buffer(first, last, " 100%% ");
  else if (d->is_open())
-    first = print_buffer(first, last, "  %2u%% ",(d->download()->file_list()->completed_chunks() * 100) / d->download()->file_list()->size_chunks());
+    first = print_buffer(first, last, "  %2u%% ", d->download()->file_list()->size_chunks() != 0 ? (d->download()->file_list()->completed_chunks() * 100) / d->download()->file_list()->size_chunks() : 0);
  else
    first = print_buffer(first, last, "      ");

@@ -261,7 +260,7 @@ print_download_percentage_done(char* first, char* last, core::Download* d) {
    //return print_buffer(first, last, "[--%%]");
    return print_buffer(first, last, "     ");
  else
-    return print_buffer(first, last, "[%2u%%]", (d->download()->file_list()->completed_chunks() * 100) / d->download()->file_list()->size_chunks());
+    return print_buffer(first, last, "[%2u%%]", d->download()->file_list()->size_chunks() != 0 ? (d->download()->file_list()->completed_chunks() * 100) / d->download()->file_list()->size_chunks() : 0);
 }

 char*
@@ -375,8 +374,7 @@ print_status_info(char* first, char* last) {
    first = print_status_throttle_rate(first, last, false, throttle_down_names, global_downrate);

  first = print_buffer(first, last, " KB]");
-
-  first = print_buffer(first, last, " [Port: %i]", (unsigned int)torrent::runtime::network_manager()->listen_port());
+  first = print_buffer(first, last, " [Port: %i]", (unsigned int)torrent::runtime::listen_port());

  auto local_address = torrent::config::network_config()->local_address_best_match();

@@ -19,7 +19,7 @@ WindowHttpQueue::WindowHttpQueue(core::HttpQueue* q) :
  set_active(false);

  m_conn_insert = m_queue->signal_insert().insert(m_queue->signal_insert().end(), [this](auto h) { receive_insert(h); });
-  m_conn_erase  = m_queue->signal_erase().insert(m_queue->signal_insert().end(), [this](auto h) { receive_erase(h); });
+  m_conn_erase  = m_queue->signal_erase().insert(m_queue->signal_erase().end(), [this](auto h) { receive_erase(h); });

  m_task_deactivate.slot() = [this] {
      if (!m_container.empty())
@@ -12,7 +12,7 @@ WindowInput::redraw() {
  m_canvas->erase();
  m_canvas->print(0, 0, "%s> %s", m_title.c_str(), m_input != NULL ? m_input->c_str() : "<NULL>");

-  if (m_focus)
+  if (m_focus && m_input != NULL)
    m_canvas->set_attr(m_input->get_pos() + 2 + m_title.size(), 0, 1, A_REVERSE, COLOR_PAIR(0));
 }

@@ -2,7 +2,28 @@

 #include "globals.h"

+#include <torrent/exceptions.h>
+
 rpc::ip_table_list ip_tables;

 Control*           control{};
-ThreadWorker*      worker_thread{};
+
+std::string
+expand_path(const std::string& path) {
+  if (path.empty())
+    return std::string();
+
+  if (path[0] == '~') {
+    if (path.size() < 2 || path[1] != '/')
+      throw torrent::input_error("Could not expand ~ in session path, only ~/<path> is supported.");
+
+    const char* home = std::getenv("HOME");
+
+    if (home == nullptr || *home == '\0')
+      throw torrent::input_error("Could not expand ~ in session path, HOME environment variable not set.");
+
+    return home + path.substr(1);
+  }
+
+  return path;
+}
@@ -1,14 +1,53 @@
 #ifndef TORRENT_GLOBALS_H
 #define TORRENT_GLOBALS_H

-#include "thread_worker.h"
+#include <torrent/common.h>
+
 #include "rpc/ip_table_list.h"

 class Control;

-extern rpc::ip_table_list          ip_tables;
+extern rpc::ip_table_list ip_tables;
+extern Control*           control;

-extern Control*      control;
-extern ThreadWorker* worker_thread;
+std::string expand_path(const std::string& path);
+
+namespace rpc {
+class SCgi;
+}
+
+namespace session {
+class SessionManager;
+}
+
+namespace scgi_thread {
+
+torrent::utils::Thread* thread();
+std::thread::id         thread_id();
+
+void                    callback(void* target, std::function<void ()>&& fn);
+void                    cancel_callback(void* target);
+void                    cancel_callback_and_wait(void* target);
+
+rpc::SCgi*              scgi();
+void                    set_scgi(rpc::SCgi* scgi);
+void                    set_rpc_log(const std::string& filename);
+
+} // namespace torrent::scgi_thread
+
+
+namespace session_thread {
+
+torrent::utils::Thread* thread();
+std::thread::id         thread_id();
+
+void                    callback(void* target, std::function<void ()>&& fn);
+void                    cancel_callback(void* target);
+void                    cancel_callback_and_wait(void* target);
+
+session::SessionManager* manager();
+std::string              session_path();
+
+} // namespace torrent::session_thread

 #endif
@@ -14,12 +14,14 @@ public:

  InputEvent(int fd) { m_fileDesc = fd; }

+  const char*         type_name() const override { return "input"; }
+
  void                insert(torrent::net::Poll* p);
  void                remove(torrent::net::Poll* p);

-  void                event_read();
-  void                event_write();
-  void                event_error();
+  void                event_read() override;
+  void                event_write() override;
+  void                event_error() override;

  void                slot_pressed(slot_int s) { m_slotPressed = s; }

@@ -1,42 +1,7 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

 #include <functional>
 #include <rak/algorithm.h>
-#include <rak/path.h>

 #include <dirent.h>
 #include <sys/stat.h>
@@ -73,7 +38,7 @@ PathInput::receive_do_complete() {
  size_type dirEnd = find_last_delim();

  utils::Directory dir(dirEnd != 0 ? str().substr(0, dirEnd) : "./");
-  
+
  if (!dir.update(utils::Directory::update_sort | utils::Directory::update_hide_dot) || dir.empty()) {
    mark_dirty();

@@ -13,7 +13,6 @@
 #include <torrent/net/fd.h>
 #include <torrent/utils/chrono.h>
 #include <torrent/utils/log.h>
-#include <rak/error_number.h>

 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
@@ -22,17 +21,19 @@
 #include "core/dht_manager.h"
 #include "core/download.h"
 #include "core/download_factory.h"
-#include "core/download_store.h"
 #include "core/manager.h"
 #include "display/canvas.h"
 #include "display/window.h"
 #include "display/manager.h"
 #include "input/bindings.h"
-#include "ui/root.h"
-
 #include "rpc/command_scheduler.h"
 #include "rpc/command_scheduler_item.h"
 #include "rpc/parse_commands.h"
+#include "scgi/thread_scgi.h"
+#include "session/download_storer.h"
+#include "session/thread_session.h"
+#include "session/session_manager.h"
+#include "ui/root.h"
 #include "utils/directory.h"

 #include "control.h"
@@ -41,8 +42,6 @@
 #include "signal_handler.h"
 #include "option_parser.h"

-#include "thread_worker.h"
-
 #define LT_LOG(log_fmt, ...)                                    \
  lt_log_print(torrent::LOG_SYSTEM, "system: " log_fmt, __VA_ARGS__);

@@ -113,7 +112,7 @@ initialize_rpc_slots() {

 void
 load_session_torrents() {
-  utils::Directory entries = control->core()->download_store()->get_formated_entries();
+  utils::Directory entries = session::DownloadStorer::get_formated_entries(session_thread::manager()->path());

  for (const auto& entry : entries) {
    // We don't really support session torrents that are links. These
@@ -215,9 +214,8 @@ main(int argc, char** argv) {
    torrent::initialize();
    torrent::set_main_thread_slots(std::bind(&client_perform));

-    // TODO: Move to controller.
-    worker_thread = new ThreadWorker();
-    worker_thread->init_thread();
+    scgi::ThreadScgi::create_thread();
+    session::ThreadSession::create_thread();

    // Initialize option handlers after libtorrent to ensure
    // torrent::ConnectionManager* are valid etc.
@@ -421,6 +419,7 @@ main(int argc, char** argv) {
    // Deprecate:

    CMD2_VAR_STRING("dht.throttle.name",   "deprecated");
+    rpc::rpc.mark_safe("dht.throttle.name");

    CMD2_REDIRECT("network.http.max_open",     "network.http.max_total_connections");
    CMD2_REDIRECT("network.http.max_open.set", "network.http.max_total_connections.set");
@@ -530,13 +529,13 @@ main(int argc, char** argv) {
    return -1;
  }

-  torrent::log_cleanup();
-
  delete control;
  control = nullptr;

-  delete worker_thread;
-  worker_thread = nullptr;
+  scgi::ThreadScgi::destroy_thread();
+  session::ThreadSession::destroy_thread();
+
+  torrent::log_cleanup();

  return 0;
 }
@@ -565,7 +564,7 @@ handle_sigbus(int signum, siginfo_t* sa, [[maybe_unused]] void* ptr) {
 #else
  output << "Stack dump not enabled." << std::endl;
 #endif
-  output << std::endl << "Error: " << rak::error_number(sa->si_errno).c_str() << std::endl;
+  output << std::endl << "Error: " << std::strerror(sa->si_errno) << std::endl;

  const char* signal_reason;

@@ -1,37 +1,3 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

 #include <algorithm>
@@ -137,8 +103,11 @@ void
 OptionParser::call_int_pair(slot_int_pair slot, const std::string& arg) {
  int a, b;

-  if (std::sscanf(arg.c_str(), "%u-%u", &a, &b) != 2)
+  if (std::sscanf(arg.c_str(), "%d-%d", &a, &b) != 2)
    throw std::runtime_error("Invalid argument, \"" + arg + "\" should be \"a-b\"");

+  if (a < 0 || b < 0)
+    throw std::runtime_error("Invalid argument, \"" + arg + "\" should be positive numbers");
+  
  slot(a, b);
 }
@@ -98,11 +98,17 @@ CommandMap::call_command(const key_type& key, const mapped_type& arg, const targ
  if (itr == base_type::end())
    throw torrent::input_error("Command \"" + std::string(key) + "\" does not exist.");

+  if (!rpc.is_trusted() && !(itr->second.m_flags & flag_untrusted_safe))
+    throw untrusted_error("Command \"" + std::string(key) + "\" is not allowed for untrusted connections.");
+
  return itr->second.m_anySlot(&itr->second.m_variable, target, arg);
 }

 const CommandMap::mapped_type
 CommandMap::call_command(iterator itr, const mapped_type& arg, const target_type& target) {
+  if (!rpc.is_trusted() && !(itr->second.m_flags & flag_untrusted_safe))
+    throw untrusted_error("Command \"" + itr->first + "\" is not allowed for untrusted connections.");
+
  return itr->second.m_anySlot(&itr->second.m_variable, target, arg);
 }

@@ -56,6 +56,8 @@ public:
  static const int flag_file_target    = 0x100;
  static const int flag_tracker_target = 0x200;

+  static const int flag_untrusted_safe = 0x400;
+
  CommandMap() = default;

  bool                has(const std::string& key) const { return base_type::find(key) != base_type::end(); }
@@ -5,7 +5,6 @@
 #include <fcntl.h>
 #include <string>
 #include <unistd.h>
-#include <rak/path.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <torrent/utils/thread.h>
@@ -42,8 +41,13 @@ ExecFile::execute(const char* file, char* const* argv, int flags) {

  pid_t childPid = fork();

-  if (childPid == -1)
+  if (childPid == -1) {
+    if (flags & flag_capture) {
+      ::close(pipeFd[0]);
+      ::close(pipeFd[1]);
+    }
    throw torrent::input_error("ExecFile::execute(...) Fork failed.");
+  }

  if (childPid == 0) {
    if (flags & flag_background) {
@@ -133,9 +133,12 @@ jsonrpc_call_command(const std::string& method, const json& params) {

  params_object_list.erase(params_object_list.begin());

-  const auto& result = rpc::commands.call_command(itr, params_object, target);
-
-  return object_to_json(result);
+  try {
+    const auto& result = rpc::commands.call_command(itr, params_object, target);
+    return object_to_json(result);
+  } catch (untrusted_error& e) {
+    throw rpc_error(JSONRPC_METHOD_NOT_FOUND_ERROR, e.what());
+  }
 }

 json
@@ -1,5 +1,6 @@
 #include "config.h"

+#include <cerrno>
 #include <fstream>
 #include <string>
 #include <sys/stat.h>
@@ -10,8 +11,6 @@
 #include <lua.hpp>
 #endif

-#include <rak/error_number.h>
-#include <rak/path.h>
 #include <rak/string_manip.h>
 #include <torrent/object.h>

@@ -266,8 +265,10 @@ object_to_lua(lua_State* l_state, torrent::Object const& object) {
    lua_createtable(l_state, 0, static_cast<int>(object_map.size()));
    int table_idx = lua_gettop(l_state);
    for (const auto& itr : object_map) {
-      object_to_lua(l_state, itr.second);
+      // lua_rawset requires the value to be on top of the stack, with the
+      // key below it.
      lua_pushlstring(l_state, itr.first.c_str(), itr.first.size());
+      object_to_lua(l_state, itr.second);
      lua_rawset(l_state, table_idx);
    }
    break;
@@ -417,12 +418,16 @@ execute_lua(LuaEngine* engine, rpc::target_type target_type, torrent::Object con
 }

 #else
+
 torrent::Object
-execute_lua(LuaEngine* engine, torrent::Object const& rawArgs, int flags) {
+execute_lua([[maybe_unused]] LuaEngine* engine, [[maybe_unused]] torrent::Object const& rawArgs, [[maybe_unused]] int flags) {
  throw torrent::input_error("Lua support not enabled");
  return torrent::Object();
 }
+
 LuaEngine::LuaEngine() {}
 LuaEngine::~LuaEngine() {}
+
 #endif
+
 } // namespace rpc
@@ -1,45 +1,11 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

 #include <cstring>
 #include <cstdio>
 #include <locale>
-#include <rak/path.h>
 #include <torrent/exceptions.h>

+#include "globals.h"
 #include "parse.h"

 namespace rpc {
@@ -90,7 +56,7 @@ parse_string(const char* first, const char* last, std::string* dest, bool (*deli

      dest->push_back(*first++);
    }
-  
+
    return first;
  }
 }
@@ -100,7 +66,7 @@ parse_whole_string(const char* first, const char* last, std::string* dest) {
  first = parse_skip_wspace(first, last);
  first = parse_string(first, last, dest);
  first = parse_skip_wspace(first, last);
-   
+
  if (first != last)
    throw torrent::input_error("Junk at end of input.");
 }
@@ -154,11 +120,17 @@ parse_value_nothrow(const char* src, int64_t* value, int base, int unit) {
  case 'b':
  case 'B': ++last; break;
  case 'k':
-  case 'K': *value = *value << 10; ++last; break;
+  case 'K':
+    if (*value > (int64_t)0x1FFFFFFFFFFFFF) return src; // overflow guard
+    *value = *value << 10; ++last; break;
  case 'm':
-  case 'M': *value = *value << 20; ++last; break;
+  case 'M':
+    if (*value > (int64_t)0x7FFFFFFFFFF) return src; // overflow guard
+    *value = *value << 20; ++last; break;
  case 'g':
-  case 'G': *value = *value << 30; ++last; break;
+  case 'G':
+    if (*value > (int64_t)0x1FFFFFFFF) return src; // overflow guard
+    *value = *value << 30; ++last; break;
 //   case ' ':
 //   case '\0': *value = *value * unit; break;
 //   default: throw torrent::input_error("Could not parse value.");
@@ -175,7 +147,7 @@ parse_object(const char* first, const char* last, torrent::Object* dest, bool (*
    *dest = torrent::Object::create_list();
    first = parse_list(first + 1, last, dest, &parse_is_delim_block);
    first = parse_skip_wspace(first, last);
-    
+
    if (first == last || *first != '}')
      throw torrent::input_error("Could not find closing '}'.");

@@ -238,7 +210,7 @@ parse_list(const char* first, const char* last, torrent::Object* dest, bool (*de
    first = parse_skip_wspace(first, last);

    dest->as_list().push_back(tmp);
-    
+
    if (first == last || !parse_is_seperator(*first))
      break;

@@ -284,12 +256,12 @@ convert_to_string(const torrent::Object& rawSrc) {

    if (src.as_raw_bencode().is_raw_string())
      return src.as_raw_bencode().as_raw_string().as_string();
-    
+
    if (src.as_raw_bencode().is_value())
      return src.as_raw_bencode().as_value_string();

  default: throw torrent::input_error("Not a string.");
-  }  
+  }
 }

 std::string
@@ -341,9 +313,9 @@ convert_list_to_command(torrent::Object::list_const_iterator first,
  if (first == last)
    throw torrent::input_error("Too few arguments.");

-  std::string dest = (first++)->as_string();
-  std::string::size_type quoteItr = dest.find('=');
-  
+  auto dest     = (first++)->as_string();
+  auto quoteItr = dest.find('=');
+
  if (quoteItr == std::string::npos)
    throw torrent::input_error("Could not find '=' in command.");

@@ -419,7 +391,7 @@ convert_to_value_nothrow(const torrent::Object& src, int64_t* value, int base, i
  default:
    return false;
  }
-  
+
  return true;
 }

@@ -430,20 +402,23 @@ print_object(char* first, char* last, const torrent::Object* src, int flags) {
  {
    const std::string& str = src->as_string();

+    if (first == last)
+      return first;
+
    if ((flags & print_expand_tilde) && *str.c_str() == '~') {
-      return rak::path_expand(str.c_str(), first, last);
+      auto expanded = expand_path(str);

-    } else {
-      if (first == last)
-        return first;
-
-      size_t n = std::min<size_t>(str.size(), std::distance(first, last) - 1);
-
-      std::memcpy(first, str.c_str(), n);
+      size_t n = std::min<size_t>(expanded.size(), std::distance(first, last) - 1);
+      std::memcpy(first, expanded.c_str(), n);
      *(first += n) = '\0';

-      return first;
+    } else {
+      size_t n = std::min<size_t>(str.size(), std::distance(first, last) - 1);
+      std::memcpy(first, str.c_str(), n);
+      *(first += n) = '\0';
    }
+
+    return first;
  }

  case torrent::Object::TYPE_VALUE:
@@ -480,7 +455,7 @@ print_object_std(std::string* dest, const torrent::Object* src, int flags) {
    const std::string& str = src->as_string();

    if ((flags & print_expand_tilde) && *str.c_str() == '~')
-      *dest += rak::path_expand(str);
+      *dest += expand_path(str);
    else
      *dest += str;

@@ -4,9 +4,9 @@
 #include <fstream>
 #include <string>
 #include <functional>
-#include <rak/path.h>
 #include <torrent/exceptions.h>

+#include "globals.h"
 #include "rpc/parse.h"
 #include "rpc/parse_commands.h"
 #include "rpc/rpc_manager.h"
@@ -140,7 +140,7 @@ parse_command_multiple(target_type target, const char* first, const char* last)

 bool
 parse_command_file(const std::string& path) {
-  std::fstream file(rak::path_expand(path).c_str(), std::ios::in);
+  std::fstream file(expand_path(path).c_str(), std::ios::in);

  if (!file.is_open())
    return false;
@@ -156,9 +156,10 @@ parse_command_file(const std::string& path) {

      if (file.gcount() == 0)
        throw torrent::internal_error("parse_command_file(...) file.gcount() == 0.");
+
      int lineLength = file.gcount() - 1;
      // In case we are at the end of the file and the last character is
-      // not a line feed, we'll just increase the read character count so 
+      // not a line feed, we'll just increase the read character count so
      // that the last would also be included in option line.
      if (file.eof() && file.get() != '\n')
        lineLength++;
@@ -13,6 +13,19 @@ CommandMap commands;
 RpcManager rpc;
 ExecFile   execFile;

+// Trusted/untrusted XMLRPC connection model.
+//
+// The trust state is set per-request by the SCGI layer based on the
+// UNTRUSTED_CONNECTION header. Commands without flag_untrusted_safe
+// are blocked for untrusted connections. The check is in
+// CommandMap::call_command(), which catches all command execution
+// including nested calls through argument expansion.
+
+bool
+RpcManager::is_trusted() const {
+  return m_trusted;
+}
+
 void
 RpcManager::object_to_target(const torrent::Object& obj, int call_flags, rpc::target_type* target, std::function<void()>* deleter) {
  if (!obj.is_string())
@@ -124,6 +137,21 @@ RpcManager::process(RPCType type, const char* in_buffer, uint32_t length, slot_r
  }
 }

+bool
+RpcManager::process_untrusted(RPCType type, const char* in_buffer, uint32_t length, slot_response_callback callback) {
+  bool previous = m_trusted;
+  m_trusted = false;
+
+  try {
+    bool result = process(type, in_buffer, length, callback);
+    m_trusted = previous;
+    return result;
+  } catch (...) {
+    m_trusted = previous;
+    throw;
+  }
+}
+
 void
 RpcManager::initialize_handlers() {
  if (m_handlers_initialized)
@@ -175,4 +203,14 @@ RpcManager::insert_command(const char* name, const char* parm, const char* doc)
  m_jsonrpc.insert_command(name, parm, doc);
 }

+void
+RpcManager::mark_safe(const std::string& key) {
+  auto itr = commands.find(key);
+
+  if (itr == commands.end())
+    return;
+
+  itr->second.m_flags |= CommandMap::flag_untrusted_safe;
+}
+
 } // namespace rpc
@@ -4,6 +4,7 @@
 #include <cstdint>
 #include <functional>
 #include <torrent/common.h>
+#include <torrent/exceptions.h>

 #include "rpc/command.h"
 #include "rpc/command_map.h"
@@ -34,6 +35,12 @@ private:
  std::string m_msg;
 };

+class untrusted_error : public torrent::input_error {
+public:
+  using torrent::input_error::input_error;
+  virtual ~untrusted_error() throw() = default;
+};
+
 class RpcManager {
 public:
  using slot_download          = std::function<core::Download*(const char*)>;
@@ -63,17 +70,26 @@ public:
  void           set_type_enabled(RPCType type, bool enabled);

  bool           process(RPCType type, const char* in_buffer, uint32_t length, slot_response_callback callback);
+  bool           process_untrusted(RPCType type, const char* in_buffer, uint32_t length, slot_response_callback callback);

  void           insert_command(const char* name, const char* parm, const char* doc);
+  void           mark_safe(const std::string& key);

  slot_download& slot_find_download() { return m_slot_find_download; }
  slot_file&     slot_find_file()     { return m_slot_find_file; }
  slot_tracker&  slot_find_tracker()  { return m_slot_find_tracker; }
  slot_peer&     slot_find_peer()     { return m_slot_find_peer; }

+  // Trusted/untrusted XMLRPC connection model.
+  // When an SCGI request includes the UNTRUSTED_CONNECTION header,
+  // commands without flag_untrusted_safe are blocked.
+  bool           is_trusted() const;
+
  static void    object_to_target(const torrent::Object& obj, int callFlags, rpc::target_type* target, std::function<void()>* deleter);

 private:
+  bool          m_trusted{true};
+
  XmlRpc        m_xmlrpc;
  JsonRpc       m_jsonrpc;

@@ -1,6 +1,9 @@
 #include "config.h"

+#include <algorithm>
 #include <cassert>
+#include <fcntl.h>
+#include <unistd.h>
 #include <sys/un.h>
 #include <torrent/connection_manager.h>
 #include <torrent/torrent.h>
@@ -8,42 +11,47 @@
 #include <torrent/net/fd.h>
 #include <torrent/net/poll.h>
 #include <torrent/net/socket_address.h>
+#include <torrent/runtime/socket_manager.h>

 #include "control.h"
 #include "globals.h"
 #include "rpc/scgi_task.h"
-#include "utils/socket_fd.h"

 // TODO: Figure out why moving this to the top causes a build error.
 #include "rpc/scgi.h"

 namespace rpc {

+SCgi::SCgi() {
+  std::generate(m_tasks.begin(), m_tasks.end(), []() { return std::make_unique<SCgiTask>(); });
+
+  m_current = m_tasks.begin();
+}
+
 SCgi::~SCgi() {
-  if (!get_fd().is_valid())
-    return;
-
-  for (SCgiTask* itr = m_task, *last = m_task + max_tasks; itr != last; ++itr)
-    if (itr->is_open())
-      itr->close();
-
-  deactivate();
-  torrent::connection_manager()->dec_socket_count();
-
-  get_fd().close();
-  get_fd().clear();
-
-  if (!m_path.empty())
-    ::unlink(m_path.c_str());
+  assert(!is_open() && "SCgi::~SCgi() called while open");
 }

 void
-SCgi::open_port(void* sa, unsigned int length, bool dontRoute) {
-  if (!get_fd().open_stream() ||
-      (dontRoute && !get_fd().set_dont_route(true)))
-    throw torrent::resource_error("Could not open socket for listening: " + std::string(std::strerror(errno)));
+SCgi::open_port(sockaddr* sa, unsigned int length, bool dont_route) {
+  torrent::runtime::socket_manager()->open_event_or_throw(this, [&]() {
+      int fd = torrent::fd_open_family(torrent::fd_flag_stream | torrent::fd_flag_nonblock | torrent::fd_flag_reuse_address,
+                                       sa->sa_family);

-  open(sa, length);
+      if (fd == -1)
+        throw torrent::resource_error("Could not open socket for listening: " + std::string(std::strerror(errno)));
+
+      if (dont_route && !torrent::fd_set_dont_route(fd, true)) {
+        torrent::fd_close(fd);
+        throw torrent::resource_error("Could not set socket option IP_DONTROUTE: " + std::string(std::strerror(errno)));
+      }
+
+      set_file_descriptor(fd);
+
+      open(reinterpret_cast<sockaddr*>(sa), length);
+    });
+
+  torrent::connection_manager()->inc_socket_count();
 }

 void
@@ -51,81 +59,141 @@ SCgi::open_named(const std::string& filename) {
  if (filename.empty() || filename.size() > 4096)
    throw torrent::resource_error("Invalid filename length.");

-  auto buffer = std::make_unique<char[]>(sizeof(sockaddr_un) + filename.size());
+  auto buffer = std::make_unique<char[]>(sizeof(sockaddr_un) + filename.size() + 1);
+
  sockaddr_un* sa = reinterpret_cast<sockaddr_un*>(buffer.get());
-
-#ifdef __sun__
-  sa->sun_family = AF_UNIX;
-#else
  sa->sun_family = AF_LOCAL;
-#endif
-
  std::memcpy(sa->sun_path, filename.c_str(), filename.size() + 1);

-  if (!get_fd().open_local())
-    throw torrent::resource_error("Could not open socket for listening.");
+  torrent::runtime::socket_manager()->open_event_or_throw(this, [&]() {
+      int fd = torrent::fd_open_local(torrent::fd_flag_stream | torrent::fd_flag_nonblock | torrent::fd_flag_reuse_address);
+
+      if (fd == -1)
+        throw torrent::resource_error("Could not open socket for listening: " + std::string(std::strerror(errno)));
+
+      set_file_descriptor(fd);
+
+      open(reinterpret_cast<sockaddr*>(sa), offsetof(struct sockaddr_un, sun_path) + filename.size() + 1);
+    });
+
+  torrent::connection_manager()->inc_socket_count();

-  open(sa, offsetof(struct sockaddr_un, sun_path) + filename.size() + 1);
  m_path = filename;
 }

 void
-SCgi::open(void* sa, unsigned int length) {
+SCgi::open_fd(int fd) {
+  torrent::runtime::socket_manager()->open_event_or_throw(this, [&]() {
+      if (!torrent::fd_set_nonblock(fd))
+        throw torrent::resource_error("Could not set non-blocking on systemd fd: " +
+                                      std::string(std::strerror(errno)));
+      set_file_descriptor(fd);
+      // fd is already bound and listening; no bind()/listen() needed.
+    });
+
+  torrent::connection_manager()->inc_socket_count();
+}
+
+void
+SCgi::open(sockaddr* sa, unsigned int length) {
  try {
-    if (!get_fd().set_nonblock() ||
-        !get_fd().set_reuse_address(true) ||
-        !get_fd().bind_sa(reinterpret_cast<sockaddr*>(sa), length) ||
-        !get_fd().listen(max_tasks))
+    if (::bind(file_descriptor(), sa, length) == -1)
+      throw torrent::resource_error("Could not bind socket for listening: " + std::string(std::strerror(errno)));
+
+    if (!torrent::fd_listen(file_descriptor(), max_tasks))
      throw torrent::resource_error("Could not prepare socket for listening: " + std::string(std::strerror(errno)));

-    torrent::connection_manager()->inc_socket_count();
-
  } catch (torrent::resource_error& e) {
-    get_fd().close();
-    get_fd().clear();
-
-    throw e;
+    torrent::fd_close(file_descriptor());
+    set_file_descriptor(-1);
+    throw;
  }
 }

-// TODO: Verify this is run in correct thread, also only ever call poll methods from thread_self.
-
 void
 SCgi::activate() {
-  assert(std::this_thread::get_id() == worker_thread->thread_id() && "SCgi::activate() must be called from the worker thread.");
+  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()->insert_error(this);
 }

+// TODO: This should close the fd to avoid reuse.
 void
-SCgi::deactivate() {
-  assert(std::this_thread::get_id() == worker_thread->thread_id() && "SCgi::deactivate() must be called from the worker thread.");
+SCgi::stop() {
+  assert(torrent::this_thread::thread() == scgi_thread::thread());

-  torrent::this_thread::poll()->remove_and_close(this);
+  if (!is_open())
+    return;
+
+  for (auto& itr : m_tasks) {
+    if (itr->is_open())
+      itr->close();
+  }
+
+  torrent::runtime::socket_manager()->close_event_or_throw(this, [this]() {
+      torrent::this_thread::poll()->remove_and_close(this);
+
+      torrent::fd_close(file_descriptor());
+      set_file_descriptor(-1);
+    });
+
+  torrent::connection_manager()->dec_socket_count();
+
+  if (!m_path.empty())
+    ::unlink(m_path.c_str());
 }

 void
 SCgi::event_read() {
+  if (m_current < m_tasks.begin() || m_current >= m_tasks.end())
+    throw torrent::internal_error("SCgi::event_read() m_current is out of bounds");
+
  while (true) {
-    int fd = torrent::fd_accept(get_fd().get_fd());
+    // TODO: Optimize this by keeping track of count.
+    auto prev = m_current;

-    if (fd == -1) {
-      if (errno == EAGAIN || errno == EWOULDBLOCK)
-        break;
+    m_current = std::find_if(m_current + 1, m_tasks.end(), [](const auto& task) { return !task->is_open(); });

-      throw torrent::resource_error("Listener port accept() failed: " + std::string(std::strerror(errno)));
-    }
+    if (m_current == m_tasks.end())
+      m_current = std::find_if(m_tasks.begin(), prev, [](const auto& task) { return !task->is_open(); });

-    SCgiTask* task = std::find_if(m_task, m_task + max_tasks, std::mem_fn(&SCgiTask::is_available));
+    if (m_current == prev) {
+      // TODO: Currently just close, although we should remove ourselves from read.
+      int fd = torrent::fd_accept(file_descriptor());
+
+      if (fd != -1)
+        torrent::fd_close(fd);

-    if (task == m_task + max_tasks) {
-      torrent::fd_close(fd);
      continue;
    }

-    task->open(this, fd);
+    auto open_func = [this, task = m_current->get()]() {
+        int fd = torrent::fd_accept(file_descriptor());
+
+        if (fd == -1) {
+          if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
+            return;
+
+          // Force a new event_read() call just to be sure we don't enter an infinite loop.
+          if (errno == ECONNABORTED)
+            return;
+
+          throw torrent::resource_error("Listener port accept() failed: " + std::string(std::strerror(errno)));
+        }
+
+        task->open(this, fd);
+      };
+
+    auto cleanup_func = [task = m_current->get()]() {
+        task->cancel_open();
+      };
+
+    bool result = torrent::runtime::socket_manager()->open_event_or_cleanup(m_current->get(), open_func, cleanup_func);
+
+    if (!result)
+      break;
  }
 }

@@ -1,15 +1,12 @@
 #ifndef RTORRENT_RPC_SCGI_H
 #define RTORRENT_RPC_SCGI_H

+#include <array>
 #include <functional>
+#include <memory>
 #include <torrent/event.h>

 #include "rpc/scgi_task.h"
-#include "utils/socket_fd.h"
-
-namespace utils {
-  class SocketFd;
-}

 namespace rpc {

@@ -17,15 +14,18 @@ class SCgi : public torrent::Event {
 public:
  static const int max_tasks = 100;

+  SCgi();
  ~SCgi() override;

  const char*         type_name() const override { return "scgi"; }

-  void                open_port(void* sa, unsigned int length, bool dontRoute);
+  void                open_port(sockaddr* sa, unsigned int length, bool dont_route);
  void                open_named(const std::string& filename);
+  void                open_fd(int fd);

  void                activate();
-  void                deactivate();
+
+  void                stop();

  const std::string&  path() const { return m_path; }

@@ -36,14 +36,16 @@ public:
  void                event_write() override;
  void                event_error() override;

-  utils::SocketFd&    get_fd()            { return *reinterpret_cast<utils::SocketFd*>(&m_fileDesc); }
-
 private:
-  void                open(void* sa, unsigned int length);
+  using task_list = std::array<std::unique_ptr<SCgiTask>, max_tasks>;
+
+  void                open(sockaddr* sa, unsigned int length);

  std::string         m_path;
  int                 m_logFd{-1};
-  SCgiTask            m_task[max_tasks];
+
+  task_list           m_tasks;
+  task_list::iterator m_current;
 };

 }
@@ -2,14 +2,16 @@

 #include "rpc/scgi_task.h"

-#include <rak/error_number.h>
 #include <cstdio>
+#include <unistd.h>
 #include <vector>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <torrent/exceptions.h>
 #include <torrent/torrent.h>
+#include <torrent/net/fd.h>
 #include <torrent/net/poll.h>
+#include <torrent/runtime/socket_manager.h>
 #include <torrent/utils/log.h>
 #include <torrent/utils/thread.h>

@@ -17,49 +19,62 @@
 #include "globals.h"
 #include "scgi.h"
 #include "rpc/parse_commands.h"
-#include "utils/socket_fd.h"

 namespace rpc {

 void
 SCgiTask::open(SCgi* parent, int fd) {
+  set_file_descriptor(fd);
+
+  m_buffer.reset(new char[default_buffer_size + 1]);
+
  m_parent      = parent;
-  m_fileDesc    = fd;
-  m_buffer      = new char[default_buffer_size + 1];
  m_buffer_size = default_buffer_size;
-  m_position    = m_buffer;
-  m_body        = NULL;
+  m_position    = m_buffer.get();
+  m_body        = nullptr;

  torrent::this_thread::poll()->open(this);
  torrent::this_thread::poll()->insert_read(this);
  torrent::this_thread::poll()->insert_error(this);
 }

+void
+SCgiTask::cancel_open() {
+  if (!is_open())
+    return;
+
+  torrent::this_thread::poll()->remove_and_close(this);
+
+  torrent::fd_close(file_descriptor());
+  set_file_descriptor(-1);
+};
+
 void
 SCgiTask::close() {
-  if (!get_fd().is_valid())
+  if (!is_open())
    return;

  torrent::main_thread::thread()->cancel_callback_and_wait(this);
  torrent::utils::Thread::self()->cancel_callback(this);

-  torrent::this_thread::poll()->remove_and_close(this);
+  torrent::runtime::socket_manager()->close_event_or_throw(this, [this]() {
+      torrent::this_thread::poll()->remove_and_close(this);

-  get_fd().close();
-  get_fd().clear();
+      torrent::fd_close(file_descriptor());
+      set_file_descriptor(-1);
+    });

  auto lock = std::lock_guard<std::mutex>(m_result_mutex);

-  delete[] m_buffer;
-  m_buffer = NULL;
+  m_buffer = nullptr;
 }

 void
 SCgiTask::event_read() {
-  int bytes = ::recv(m_fileDesc, m_position, m_buffer_size - (m_position - m_buffer), 0);
+  int bytes = ::recv(m_fileDesc, m_position, m_buffer_size - (m_position - m_buffer.get()), 0);

  if (bytes <= 0) {
-    if (bytes == 0 || !rak::error_number::current().is_blocked_momentary())
+    if (bytes == 0 || !(errno == EAGAIN || errno == EINTR))
      close();

    return;
@@ -74,14 +89,14 @@ SCgiTask::event_read() {
    // receive all the data we need the first time.
    char* current;

-    int   header_size = strtol(m_buffer, &current, 0);
+    int   header_size = strtol(m_buffer.get(), &current, 0);

    if (current == m_position)
      return;

    // If the request doesn't start with an integer or if it didn't
    // end in ':', then close the connection.
-    if (current == m_buffer || *current != ':' || header_size < 17 || header_size > max_header_size)
+    if (current == m_buffer.get() || *current != ':' || header_size < 17 || header_size > max_header_size)
      goto event_read_failed;

    if (std::distance(++current, m_position) < header_size + 1)
@@ -96,6 +111,9 @@ SCgiTask::event_read() {
    size_t      content_length = 0;
    const char* header_end     = current + header_size;

+    // Assume trusted until we find the UNTRUSTED_CONNECTION header.
+    m_trusted = true;
+
    // Parse out the null-terminated header keys and values, with
    // checks to ensure it doesn't scan beyond the limits of the
    // header
@@ -126,6 +144,8 @@ SCgiTask::event_read() {
          goto event_read_failed;
      } else if (strcmp(key, "CONTENT_TYPE") == 0) {
        content_type = value;
+      } else if (strcmp(key, "UNTRUSTED_CONNECTION") == 0 && strcmp(value, "1") == 0) {
+        m_trusted = false;
      }
    }

@@ -136,7 +156,7 @@ SCgiTask::event_read() {
      goto event_read_failed;

    m_body      = current + 1;
-    header_size = std::distance(m_buffer, m_body);
+    header_size = std::distance(m_buffer.get(), m_body);

    if (!detect_content_type(content_type))
      goto event_read_failed;
@@ -147,19 +167,19 @@ SCgiTask::event_read() {
    } else if ((unsigned int)content_length <= default_buffer_size) {
      m_buffer_size = content_length;

-      std::memmove(m_buffer, m_body, std::distance(m_body, m_position));
-      m_position = m_buffer + std::distance(m_body, m_position);
-      m_body     = m_buffer;
+      std::memmove(m_buffer.get(), m_body, std::distance(m_body, m_position));
+      m_position = m_buffer.get() + std::distance(m_body, m_position);
+      m_body     = m_buffer.get();

    } else {
      realloc_buffer((m_buffer_size = content_length) + 1, m_body, std::distance(m_body, m_position));

-      m_position = m_buffer + std::distance(m_body, m_position);
-      m_body     = m_buffer;
+      m_position = m_buffer.get() + std::distance(m_body, m_position);
+      m_body     = m_buffer.get();
    }
  }

-  if ((unsigned int)std::distance(m_buffer, m_position) != m_buffer_size)
+  if ((unsigned int)std::distance(m_buffer.get(), m_position) != m_buffer_size)
    return;

  torrent::this_thread::poll()->remove_read(this);
@@ -169,13 +189,13 @@ SCgiTask::event_read() {

    // Clean up logging, this is just plain ugly...
    //    write(m_logFd, "\n---\n", sizeof("\n---\n"));
-    result = write(m_parent->log_fd(), m_buffer, m_buffer_size);
-    result = write(m_parent->log_fd(), "\n---\n", sizeof("\n---\n"));
+    result = ::write(m_parent->log_fd(), m_buffer.get(), m_buffer_size);
+    result = ::write(m_parent->log_fd(), "\n---\n", sizeof("\n---\n"));
  }

-  lt_log_print_dump(torrent::LOG_RPC_DUMP, m_body, m_buffer_size - std::distance(m_buffer, m_body), "scgi", "RPC read.", 0);
+  lt_log_print_dump(torrent::LOG_RPC_DUMP, m_body, m_buffer_size - std::distance(m_buffer.get(), m_body), "scgi", "RPC read.", 0);

-  receive_call(m_body, m_buffer_size - std::distance(m_buffer, m_body));
+  receive_call(m_body, m_buffer_size - std::distance(m_buffer.get(), m_body));
  return;

 event_read_failed:
@@ -185,16 +205,10 @@ event_read_failed:

 void
 SCgiTask::event_write() {
-// Apple and Solaris do not support MSG_NOSIGNAL,
-// so disable this fix until we find a better solution
-#if defined(__APPLE__) || defined(__sun__)
  int bytes = ::send(m_fileDesc, m_position, m_buffer_size, 0);
-#else
-  int bytes = ::send(m_fileDesc, m_position, m_buffer_size, MSG_NOSIGNAL);
-#endif

  if (bytes == -1) {
-    if (!rak::error_number::current().is_blocked_momentary())
+    if (!(errno == EAGAIN || errno == EINTR))
      close();

    return;
@@ -249,11 +263,11 @@ SCgiTask::detect_content_type(const std::string& content_type) {
 // If bufferSize is zero then memcpy won't do anything.
 void
 SCgiTask::realloc_buffer(uint32_t size, const char* buffer, uint32_t bufferSize) {
-  char* tmp = new char[size];
+  auto tmp = new char[size];

  std::memcpy(tmp, buffer, bufferSize);
-  ::free(m_buffer);
-  m_buffer = tmp;
+
+  m_buffer.reset(tmp);
 }

 void
@@ -261,11 +275,12 @@ SCgiTask::receive_call(const char* buffer, uint32_t length) {
  // TODO: Rewrite RpcManager.process to pass the result buffer instead of having to copy it.

  auto scgi_thread = torrent::utils::Thread::self();
+  bool trusted = m_trusted;

  auto result_callback = [this, scgi_thread](const char* b, uint32_t l) {
      receive_write(b, l);

-      scgi_thread->callback_interrupt_pollling(this, [this]() {
+      scgi_thread->callback_interrupt_polling(this, [this]() {
          // Only need to lock once here as a memory barrier.
          m_result_mutex.lock();
          m_result_mutex.unlock();
@@ -276,30 +291,30 @@ SCgiTask::receive_call(const char* buffer, uint32_t length) {

  auto lock = std::lock_guard<std::mutex>(m_result_mutex);

+  RpcManager::RPCType rpc_type;
+
  switch (content_type()) {
  case rpc::SCgiTask::ContentType::JSON:
-    torrent::main_thread::thread()->callback_interrupt_pollling(this, [buffer, length, result_callback]() {
-        rpc.process(RpcManager::RPCType::JSON, buffer, length,
-                    [result_callback](const char* b, uint32_t l) {
-                      result_callback(b, l);
-                      return true;
-                    });
-      });
+    rpc_type = RpcManager::RPCType::JSON;
    break;
-
  case rpc::SCgiTask::ContentType::XML:
-    torrent::main_thread::thread()->callback_interrupt_pollling(this, [buffer, length, result_callback]() {
-        rpc.process(RpcManager::RPCType::XML, buffer, length,
-                    [result_callback](const char* b, uint32_t l) {
-                      result_callback(b, l);
-                      return true;
-                    });
-      });
+    rpc_type = RpcManager::RPCType::XML;
    break;
-
  default:
    throw torrent::internal_error("SCgiTask::receive_call(...) received bad input.");
  }
+
+  torrent::main_thread::thread()->callback_interrupt_polling(this, [buffer, length, result_callback, trusted, rpc_type]() {
+      auto callback = [result_callback](const char* b, uint32_t l) {
+          result_callback(b, l);
+          return true;
+        };
+
+      if (trusted)
+        rpc.process(rpc_type, buffer, length, callback);
+      else
+        rpc.process_untrusted(rpc_type, buffer, length, callback);
+    });
 }

 void
@@ -318,20 +333,20 @@ SCgiTask::receive_write(const char* buffer, uint32_t length) {
                        : "Status: 200 OK\r\nContent-Type: text/xml\r\nContent-Length: %i\r\n\r\n";

  // Who ever bothers to check the return value?
-  int headerSize = snprintf(m_buffer, m_buffer_size, header, length);
+  int headerSize = snprintf(m_buffer.get(), m_buffer_size, header, length);

-  m_position   = m_buffer;
+  m_position    = m_buffer.get();
  m_buffer_size = length + headerSize;

-  std::memcpy(m_buffer + headerSize, buffer, length);
+  std::memcpy(m_buffer.get() + headerSize, buffer, length);

  if (m_parent->log_fd() >= 0) {
    [[maybe_unused]] int result;
-    result = write(m_parent->log_fd(), m_buffer, m_buffer_size);
+    result = write(m_parent->log_fd(), m_buffer.get(), m_buffer_size);
    result = write(m_parent->log_fd(), "\n---\n", sizeof("\n---\n"));
  }

-  lt_log_print_dump(torrent::LOG_RPC_DUMP, m_buffer, m_buffer_size, "scgi", "RPC write.", 0);
+  lt_log_print_dump(torrent::LOG_RPC_DUMP, m_buffer.get(), m_buffer_size, "scgi", "RPC write.", 0);
 }

 } // namespace rpc
@@ -5,10 +5,6 @@
 #include <mutex>
 #include <torrent/event.h>

-namespace utils {
-  class SocketFd;
-}
-
 namespace rpc {

 class SCgi;
@@ -23,19 +19,21 @@ public:

  SCgiTask() { m_fileDesc = -1; }

+  const char*         type_name() const override { return "scgi-task"; }
+
  bool                is_open() const      { return m_fileDesc != -1; }
  bool                is_available() const { return m_fileDesc == -1; }

  void                open(SCgi* parent, int fd);
+  void                cancel_open();
+
  void                close();

  ContentType         content_type() const { return m_content_type; }

-  virtual void        event_read();
-  virtual void        event_write();
-  virtual void        event_error();
-
-  utils::SocketFd&    get_fd()             { return *reinterpret_cast<utils::SocketFd*>(&m_fileDesc); }
+  void                event_read() override;
+  void                event_write() override;
+  void                event_error() override;

 private:
  bool                detect_content_type(const std::string& content_type);
@@ -44,17 +42,18 @@ private:
  void                receive_call(const char* buffer, uint32_t length);
  void                receive_write(const char* buffer, uint32_t length);

-  SCgi*               m_parent;
+  SCgi*               m_parent{};

  std::mutex          m_result_mutex;

-  char*               m_buffer{nullptr};
-  char*               m_position{nullptr};
-  char*               m_body{nullptr};
+  std::unique_ptr<char[]> m_buffer;
+  char*                   m_position{};
+  char*                   m_body{};

  unsigned int        m_buffer_size{0};

  ContentType         m_content_type{ XML };
+  bool                m_trusted{true};
 };

 }
@@ -385,6 +385,10 @@ xmlrpc_call_command(xmlrpc_env* env, xmlrpc_value* args, void* voidServerInfo) {

    return object_to_xmlrpc(env, rpc::commands.call_command(itr, object, target));

+  } catch (untrusted_error& e) {
+    xmlrpc_env_set_fault(env, XMLRPC_REQUEST_REFUSED_ERROR, e.what());
+    return NULL;
+
  } catch (xmlrpc_error_c& e) {
    xmlrpc_env_set_fault(env, e.type(), e.what());
    return NULL;
@@ -31,7 +31,7 @@ const int XMLRPC_PARSE_ERROR                  = -503;
 // const int XMLRPC_NETWORK_ERROR                = -504;
 // const int XMLRPC_TIMEOUT_ERROR                = -505;
 const int XMLRPC_NO_SUCH_METHOD_ERROR         = -506;
-// const int XMLRPC_REQUEST_REFUSED_ERROR        = -507;
+const int XMLRPC_REQUEST_REFUSED_ERROR        = -507;
 // const int XMLRPC_INTROSPECTION_DISABLED_ERROR = -508;
 const int XMLRPC_LIMIT_EXCEEDED_ERROR         = -509;
 // const int XMLRPC_INVALID_UTF8_ERROR           = -510;
@@ -238,7 +238,11 @@ execute_command(std::string method_name, const tinyxml2::XMLElement* params_elem
    throw rpc_error(XMLRPC_TYPE_ERROR, "invalid parameters: too few");
  }

-  return rpc::commands.call_command(cmd_itr, params_raw, target);
+  try {
+    return rpc::commands.call_command(cmd_itr, params_raw, target);
+  } catch (untrusted_error& e) {
+    throw rpc_error(XMLRPC_REQUEST_REFUSED_ERROR, e.what());
+  }
 }

 void
@@ -0,0 +1,141 @@
+#include "config.h"
+
+#include "scgi/thread_scgi.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <torrent/exceptions.h>
+#include <torrent/utils/log.h>
+
+#include "globals.h"
+#include "rpc/scgi.h"
+
+namespace scgi {
+
+class ThreadScgiInternal {
+public:
+  static ThreadScgi* thread_scgi() { return ThreadScgi::internal_thread_scgi(); }
+};
+
+ThreadScgi* ThreadScgi::m_thread_scgi{};
+
+void
+ThreadScgi::create_thread() {
+  auto thread = new ThreadScgi;
+
+  m_thread_scgi          = thread;
+  m_thread_scgi->m_state = STATE_INITIALIZED;
+}
+
+void
+ThreadScgi::destroy_thread() {
+  delete m_thread_scgi;
+  m_thread_scgi = nullptr;
+}
+
+ThreadScgi*
+ThreadScgi::thread_scgi() {
+  return m_thread_scgi;
+}
+
+void
+ThreadScgi::cleanup_thread() {
+  if (m_scgi != nullptr)
+    m_scgi.load()->stop();
+}
+
+rpc::SCgi*
+ThreadScgi::scgi() {
+  return m_scgi;
+}
+
+// TODO: Disable changing SCGI once set?
+
+bool
+ThreadScgi::set_scgi(rpc::SCgi* scgi) {
+  rpc::SCgi* expected = nullptr;
+
+  if (!m_scgi.compare_exchange_strong(expected, scgi))
+    return false;
+
+  change_rpc_log();
+
+  callback(nullptr, [this]() {
+      if (m_scgi == nullptr)
+        throw torrent::internal_error("Tried to start SCGI but object was not present.");
+
+      m_scgi.load()->activate();
+    });
+
+  return true;
+}
+
+void
+ThreadScgi::set_rpc_log(const std::string& filename) {
+  callback(nullptr, [this, filename]() {
+      m_rpc_log_filename = filename;
+      change_rpc_log();
+    });
+}
+
+void
+ThreadScgi::change_rpc_log() {
+  if (scgi() == nullptr)
+    return;
+
+  if (scgi()->log_fd() != -1) {
+    ::close(scgi()->log_fd());
+    scgi()->set_log_fd(-1);
+
+    lt_log_print(torrent::LOG_NOTICE, "Closed RPC log.", 0);
+  }
+
+  if (m_rpc_log_filename.empty())
+    return;
+
+  scgi()->set_log_fd(open(expand_path(m_rpc_log_filename).c_str(), O_WRONLY | O_APPEND | O_CREAT, 0644));
+
+  if (scgi()->log_fd() == -1) {
+    lt_log_print(torrent::LOG_NOTICE, "Could not open RPC log file '%s'.", m_rpc_log_filename.c_str());
+    return;
+  }
+
+  lt_log_print(torrent::LOG_NOTICE, "Logging RPC events to '%s'.", m_rpc_log_filename.c_str());
+}
+
+void
+ThreadScgi::call_events() {
+  if ((m_flags & flag_do_shutdown)) {
+    if ((m_flags & flag_did_shutdown))
+      throw torrent::internal_error("Already trigged shutdown.");
+
+    m_flags |= flag_did_shutdown;
+    throw torrent::shutdown_exception();
+  }
+
+  process_callbacks();
+}
+
+std::chrono::microseconds
+ThreadScgi::next_timeout() {
+  // TODO: This leads to kqueue crash?
+  // return std::chrono::microseconds(1h);
+  return std::chrono::microseconds(10min);
+}
+
+} // namespace scgi
+
+namespace scgi_thread {
+
+torrent::utils::Thread* thread()                         { return scgi::ThreadScgiInternal::thread_scgi(); }
+std::thread::id         thread_id()                      { return scgi::ThreadScgiInternal::thread_scgi()->thread_id(); }
+
+void callback(void* target, std::function<void ()>&& fn) { scgi::ThreadScgiInternal::thread_scgi()->callback(target, std::move(fn)); }
+void cancel_callback(void* target)                       { scgi::ThreadScgiInternal::thread_scgi()->cancel_callback(target); }
+void cancel_callback_and_wait(void* target)              { scgi::ThreadScgiInternal::thread_scgi()->cancel_callback_and_wait(target); }
+
+rpc::SCgi*  scgi()                                       { return scgi::ThreadScgiInternal::thread_scgi()->scgi(); }
+void        set_scgi(rpc::SCgi* scgi)                    { scgi::ThreadScgiInternal::thread_scgi()->set_scgi(scgi); }
+void        set_rpc_log(const std::string& filename)     { scgi::ThreadScgiInternal::thread_scgi()->set_rpc_log(filename); }
+
+} // namespace scgi_thread
@@ -0,0 +1,54 @@
+#ifndef RTORRENT_SCGI_THREAD_SCGI_H
+#define RTORRENT_SCGI_THREAD_SCGI_H
+
+#include <atomic>
+#include <string>
+#include <torrent/utils/thread.h>
+
+namespace rpc {
+class SCgi;
+}
+
+namespace scgi {
+
+class ThreadScgiInternal;
+
+class ThreadScgi : public torrent::utils::Thread {
+public:
+
+  static void         create_thread();
+  static void         destroy_thread();
+  static ThreadScgi*  thread_scgi();
+
+  const char*         name() const override  { return "rtorrent-scgi"; }
+
+  rpc::SCgi*          scgi();
+  bool                set_scgi(rpc::SCgi* scgi);
+
+  void                set_rpc_log(const std::string& filename);
+
+protected:
+  friend class ThreadScgiInternal;
+
+  ThreadScgi() = default;
+
+  static auto         internal_thread_scgi() { return m_thread_scgi; }
+
+  void                cleanup_thread() override;
+
+  void                      call_events() override;
+  std::chrono::microseconds next_timeout() override;
+
+private:
+  void                task_touch_log();
+  void                change_rpc_log();
+
+  static ThreadScgi*  m_thread_scgi;
+
+  std::atomic<rpc::SCgi*> m_scgi{nullptr};
+  std::string             m_rpc_log_filename;
+};
+
+} // namespace scgi
+
+#endif // RTORRENT_SCGI_THREAD_SCGI_H
@@ -0,0 +1,193 @@
+#include "config.h"
+
+#include "download_storer.h"
+
+#include <fcntl.h>
+#include <fstream>
+#include <unistd.h>
+#include <torrent/exceptions.h>
+#include <torrent/object.h>
+#include <torrent/object_stream.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/resume.h>
+
+#include "globals.h"
+#include "core/download.h"
+#include "utils/directory.h"
+
+namespace session {
+
+DownloadStorer::DownloadStorer(core::Download* download)
+  : m_download(download) {
+}
+
+void
+DownloadStorer::build_streams(bool skip_static) {
+  auto* download = m_download->download();
+
+  auto& resume_base   = download->bencode()->get_key("libtorrent_resume");
+  auto& rtorrent_base = download->bencode()->get_key("rtorrent");
+
+  rtorrent_base.insert_key("chunks_done",      download->file_list()->completed_chunks());
+  rtorrent_base.insert_key("chunks_wanted",    download->data()->wanted_chunks());
+  rtorrent_base.insert_key("total_uploaded",   m_download->info()->up_rate()->total());
+  rtorrent_base.insert_key("total_downloaded", m_download->info()->down_rate()->total());
+
+  // Don't save for completed torrents when we've cleared the uncertain_pieces.
+  torrent::resume_save_progress(*download, resume_base);
+  torrent::resume_save_uncertain_pieces(*download, resume_base);
+
+  torrent::resume_save_addresses(*download, resume_base);
+  torrent::resume_save_file_priorities(*download, resume_base);
+  torrent::resume_save_tracker_settings(*download, resume_base);
+
+  // Temp fixing of all flags, move to a better place:
+  resume_base.set_flags(torrent::Object::flag_session_data);
+  rtorrent_base.set_flags(torrent::Object::flag_session_data);
+
+  auto torrent_stream  = std::unique_ptr<std::stringstream>();
+  auto resume_stream   = std::make_unique<std::stringstream>();
+  auto rtorrent_stream = std::make_unique<std::stringstream>();
+
+  if (!skip_static) {
+    torrent_stream = std::make_unique<std::stringstream>();
+    torrent::object_write_bencode(&*torrent_stream, m_download->bencode(), torrent::Object::flag_session_data);
+
+    if (!torrent_stream->good())
+      throw torrent::internal_error("DownloadStorer::build_streams() failed to write torrent stream.");
+  }
+
+  torrent::object_write_bencode(&*resume_stream, &resume_base, 0);
+
+  if (!resume_stream->good())
+    throw torrent::internal_error("DownloadStorer::build_streams() failed to write resume stream.");
+
+  torrent::object_write_bencode(&*rtorrent_stream, &rtorrent_base, 0);
+
+  if (!rtorrent_stream->good())
+    throw torrent::internal_error("DownloadStorer::build_streams() failed to write rtorrent stream.");
+
+  m_torrent_stream    = std::move(torrent_stream);
+  m_rtorrent_stream   = std::move(rtorrent_stream);
+  m_libtorrent_stream = std::move(resume_stream);
+}
+
+std::string
+DownloadStorer::build_path(const std::string& session_path) {
+  auto info_hash = m_download->info()->info_hash();
+
+  if (session_path.empty())
+    throw torrent::internal_error("DownloadStorer::build_path() called with empty session path.");
+
+  if (session_path.back() != '/')
+    throw torrent::internal_error("DownloadStorer::build_path() session path missing trailing slash.");
+
+  return session_path + torrent::hash_string_to_hex_str(info_hash) + ".torrent";
+}
+
+void
+DownloadStorer::unlink_files(const std::string& session_path) {
+  auto base_path = build_path(session_path);
+
+  auto torrent_path    = base_path;
+  auto libtorrent_path = base_path + ".libtorrent_resume";
+  auto rtorrent_path   = base_path + ".rtorrent";
+  auto metadata_path   = base_path + ".meta";
+
+  ::unlink(libtorrent_path.c_str());
+  ::unlink(rtorrent_path.c_str());
+  ::unlink(torrent_path.c_str());
+  ::unlink(metadata_path.c_str());
+}
+
+namespace {
+
+bool
+is_correct_format(const std::string& f) {
+  if (f.size() != 48 || f.substr(40) != ".torrent")
+    return false;
+
+  for (std::string::const_iterator itr = f.begin(); itr != f.end() - 8; ++itr)
+    if (!(*itr >= '0' && *itr <= '9') &&
+        !(*itr >= 'A' && *itr <= 'F'))
+      return false;
+
+  return true;
+}
+
+void
+save_stream(const std::string& path, bool use_fsyncdisk, const std::stringstream& stream) {
+  std::fstream output(path.c_str(), std::ios::out | std::ios::trunc);
+
+  // TODO: If we cannot open more files, wait for some to finish and try again.
+  if (!output.is_open())
+    throw torrent::storage_error("failed to open file for writing : " + path);
+
+  output << stream.rdbuf();
+
+  if (!output.good())
+    throw torrent::storage_error("failed to write stream to file : " + path);
+
+  output.close();
+
+  // Ensure that the new file is actually written to the disk
+  int fd = ::open(path.c_str(), O_WRONLY);
+
+  if (fd < 0)
+    throw torrent::storage_error("failed to open file descriptor for fsync : " + path);
+
+  if (use_fsyncdisk) {
+#ifdef __APPLE__
+    ::fsync(fd);
+#else
+    ::fdatasync(fd);
+#endif
+  }
+
+  ::close(fd);
+}
+
+} // namespace anonymous
+
+void
+DownloadStorer::save_and_move_streams(const std::string& path, bool use_fsyncdisk,
+                                       const std::stringstream* torrent_stream,
+                                       const std::stringstream* rtorrent_stream,
+                                       const std::stringstream* libtorrent_stream) {
+  auto torrent_path    = path;
+  auto libtorrent_path = path + ".libtorrent_resume";
+  auto rtorrent_path   = path + ".rtorrent";
+
+  if (torrent_stream)
+    save_stream(torrent_path + ".new", use_fsyncdisk, *torrent_stream);
+
+  save_stream(libtorrent_path + ".new", use_fsyncdisk, *libtorrent_stream);
+  save_stream(rtorrent_path + ".new", use_fsyncdisk, *rtorrent_stream);
+
+  if (torrent_stream) {
+    if (::rename((torrent_path + ".new").c_str(), torrent_path.c_str()) == -1)
+      throw torrent::storage_error("failed to rename torrent file : " + torrent_path);
+  }
+
+  if (::rename((libtorrent_path + ".new").c_str(), libtorrent_path.c_str()) == -1)
+    throw torrent::storage_error("failed to rename libtorrent resume file : " + libtorrent_path);
+
+  if (::rename((rtorrent_path + ".new").c_str(), rtorrent_path.c_str()) == -1)
+    throw torrent::storage_error("failed to rename rtorrent resume file : " + rtorrent_path);
+}
+
+utils::Directory
+DownloadStorer::get_formated_entries(const std::string& session_path) {
+  if (session_path.empty())
+    return utils::Directory();
+
+  utils::Directory d(session_path);
+
+  if (!d.update(utils::Directory::update_hide_dot))
+    throw torrent::storage_error("session::DownloadStorer::update() could not open session directory: " + session_path);
+
+  d.erase(std::remove_if(d.begin(), d.end(), [](auto& entry) { return !is_correct_format(entry.s_name); }), d.end());
+  return d;
+}
+
+} // namespace session
@@ -0,0 +1,55 @@
+#ifndef RTORRENT_SESSION_DOWNLOAD_STORER_H
+#define RTORRENT_SESSION_DOWNLOAD_STORER_H
+
+#include <memory>
+#include <sstream>
+#include <string>
+#include <torrent/common.h>
+
+namespace core {
+class Download;
+}
+
+namespace utils {
+class Directory;
+}
+
+namespace session {
+
+class DownloadStorer {
+public:
+  DownloadStorer(core::Download* download);
+
+  core::Download*     download() const { return m_download; }
+
+  std::string         build_path(const std::string& session_path);
+
+  void                build_full_streams()   { build_streams(false); }
+  void                build_resume_streams() { build_streams(true); }
+
+  void                unlink_files(const std::string& session_path);
+
+  auto                torrent_stream()       { return std::move(m_torrent_stream); }
+  auto                rtorrent_stream()      { return std::move(m_rtorrent_stream); }
+  auto                libtorrent_stream()    { return std::move(m_libtorrent_stream); }
+
+  static void         save_and_move_streams(const std::string& path, bool use_fsyncdisk,
+                                            const std::stringstream* torrent_stream,
+                                            const std::stringstream* rtorrent_stream,
+                                            const std::stringstream* libtorrent_stream);
+
+  static utils::Directory get_formated_entries(const std::string& session_path);
+
+private:
+  void                build_streams(bool skip_static);
+
+  core::Download*     m_download;
+
+  std::unique_ptr<std::stringstream> m_torrent_stream;
+  std::unique_ptr<std::stringstream> m_rtorrent_stream;
+  std::unique_ptr<std::stringstream> m_libtorrent_stream;
+};
+
+} // namespace session
+
+#endif // RTORRENT_SESSION_DOWNLOAD_STORER_H
@@ -0,0 +1,515 @@
+#include "config.h"
+
+#include "session/session_manager.h"
+
+#include <cassert>
+#include <cstdlib>
+#include <torrent/exceptions.h>
+#include <torrent/utils/log.h>
+
+#include "globals.h"
+#include "session/download_storer.h"
+#include "utils/lockfile.h"
+
+#define LT_LOG(log_fmt, ...)                                            \
+  lt_log_print(torrent::LOG_SESSION_EVENTS, "session-events: " log_fmt, __VA_ARGS__);
+
+namespace session {
+
+SessionManager::SessionManager(torrent::utils::Thread* thread)
+  : m_thread(thread),
+    m_lockfile(std::make_unique<utils::Lockfile>()) {
+}
+
+SessionManager::~SessionManager() = default;
+
+void
+SessionManager::set_path(std::string path) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  if (m_freeze_info)
+    throw torrent::input_error("Session path cannot be changed after startup.");
+
+  path = expand_path(path);
+
+  if (path.empty() || path.back() == '/')
+    m_path = path;
+  else
+    m_path = path + '/';
+}
+
+void
+SessionManager::set_use_fsyncdisk(bool use_fsyncdisk) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  if (m_freeze_info)
+    throw torrent::input_error("Session fsyncdisk option cannot be changed after startup.");
+
+  m_use_fsyncdisk = use_fsyncdisk;
+}
+
+void
+SessionManager::set_use_lock(bool use_lock) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  if (m_freeze_info)
+    throw torrent::input_error("Session lock option cannot be changed after startup.");
+
+  m_use_lock = use_lock;
+}
+
+void
+SessionManager::save_resume_download(core::Download* download) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  if (m_path.empty())
+    return;
+
+  {
+    std::unique_lock<std::mutex> lock(m_pending_builds_mutex);
+
+    if (!m_active)
+      throw torrent::internal_error("SessionManager::save_resume_download() called while not active.");
+
+    if (std::find(m_pending_builds.begin(), m_pending_builds.end(), download) != m_pending_builds.end()) {
+      LT_LOG("download already in pending build of resume save : download:%p", download);
+      return;
+    }
+
+    if (m_pending_builds.empty())
+      torrent::main_thread::callback(this, [this]() { process_pending_resume_builds(false); });
+
+    m_pending_builds.push_back(download);
+
+    LT_LOG("build of resume save data queued : download:%p", download);
+  }
+}
+
+void
+SessionManager::save_full_download(core::Download* download) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  if (m_path.empty())
+    return;
+
+  DownloadStorer storer(download);
+
+  storer.build_full_streams();
+
+  auto save_request = SaveRequest{
+    download,
+    storer.build_path(m_path),
+    storer.torrent_stream(),
+    storer.rtorrent_stream(),
+    storer.libtorrent_stream()
+  };
+
+  {
+    std::unique_lock<std::mutex> lock(m_mutex);
+
+    LT_LOG("requesting save : download:%p path:%s", download, save_request.path.c_str());
+
+    if (!m_active)
+      throw torrent::internal_error("SessionManager::save_download() called while not active.");
+
+    if (replace_save_request_unsafe(save_request)) {
+      LT_LOG("updated pending save request with full save data : download:%p", download);
+      return;
+    }
+
+    m_save_requests.push_back(std::move(save_request));
+    m_save_request_counter = m_save_requests.size();
+
+    LT_LOG("queued new full save request : download:%p", download);
+  }
+
+  if (!m_processing_saves_callback_scheduled.exchange(true))
+    session_thread::callback(this, [this]() { process_save_request(); });
+}
+
+void
+SessionManager::remove_download(core::Download* download) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  if (m_path.empty())
+    return;
+
+  std::unique_lock<std::mutex> lock(m_mutex);
+
+  if (!m_active)
+    throw torrent::internal_error("SessionManager::remove_download() called while not active.");
+
+  if (remove_completely_unsafe(download, lock))
+    LT_LOG("canceled pending save request : download:%p", download);
+
+  DownloadStorer(download).unlink_files(m_path);
+
+  LT_LOG("removed session files : download:%p", download);
+}
+
+void
+SessionManager::start() {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  std::unique_lock<std::mutex> lock(m_mutex);
+
+  if (m_active || m_freeze_info)
+    throw torrent::internal_error("SessionManager::start() called while already started.");
+
+  m_active      = true;
+  m_freeze_info = true;
+
+  if (m_path.empty()) {
+    LT_LOG("session manager started with empty path, disabling session management", 0);
+    return;
+  }
+
+  LT_LOG("starting session manager with path: %s", m_path.c_str());
+
+  if (m_use_lock) {
+    m_lockfile->set_path(m_path + "rtorrent.lock");
+
+    if (!m_lockfile->try_lock()) {
+      if (errno == ENOENT || errno == ENOTDIR || errno == EACCES)
+        throw torrent::input_error("Could not lock session directory: " + std::string(std::strerror(errno)) + " : " + m_path);
+      else
+        throw torrent::input_error("Could not lock session directory, held by: " + m_lockfile->locked_by_as_string() + " : " + m_path);
+    }
+
+    LT_LOG("locked session directory: %s", m_path.c_str());
+  }
+}
+
+void
+SessionManager::cleanup() {
+  assert(m_thread == torrent::this_thread::thread());
+
+  std::unique_lock<std::mutex> lock(m_mutex);
+
+  if (!m_active)
+    throw torrent::internal_error("SessionManager::cleanup() called while not active.");
+
+  {
+    std::unique_lock<std::mutex> pending_lock(m_pending_builds_mutex);
+
+    if (!m_pending_builds.empty())
+      throw torrent::internal_error("SessionManager::cleanup() called with pending builds.");
+  }
+
+  m_active = false;
+
+  if (m_path.empty()) {
+    LT_LOG("session manager cleanup called with empty path, skipping", 0);
+    return;
+  }
+
+  LT_LOG("cleaning up session manager with path: %s", m_path.c_str());
+
+  flush_all_and_wait_unsafe(lock);
+
+  if (m_use_lock) {
+    if (!m_lockfile->unlock())
+      LT_LOG("could not unlock session directory: %s", m_path.c_str());
+
+    LT_LOG("unlocked session directory: %s", m_path.c_str());
+  }
+
+  LT_LOG("session manager cleaned up", 0);
+
+  session_thread::cancel_callback(this);
+  torrent::main_thread::cancel_callback(this);
+}
+
+void
+SessionManager::process_pending_resume_builds(bool is_flushing) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  std::vector<SaveRequest> requests;
+
+  // Only main thread is allowed to process pending builds or remove downloads, as such it is safe
+  // to unlock before adding them to save requests.
+  {
+    std::unique_lock<std::mutex> lock(m_pending_builds_mutex);
+
+    while (!m_pending_builds.empty()) {
+      if (!is_flushing && m_save_request_counter + requests.size() >= max_concurrent_requests)
+        break;
+
+      auto* download = m_pending_builds.front();
+      m_pending_builds.pop_front();
+
+      LT_LOG("processing pending resume save : download:%p", download);
+
+      DownloadStorer storer(download);
+
+      storer.build_resume_streams();
+
+      auto save_request = SaveRequest{
+        download,
+        storer.build_path(m_path),
+        nullptr,
+        storer.rtorrent_stream(),
+        storer.libtorrent_stream()
+      };
+
+      requests.push_back(std::move(save_request));
+    }
+  }
+
+  if (requests.empty())
+    return;
+
+  {
+    std::unique_lock<std::mutex> save_lock(m_mutex);
+
+    if (!m_active)
+      throw torrent::internal_error("SessionManager::process_pending_builds() called while not active.");
+
+    for (auto& save_request : requests) {
+      if (replace_save_request_unsafe(save_request)) {
+        LT_LOG("updated pending resume save request : download:%p", save_request.download);
+        continue;
+      }
+
+      m_save_requests.push_back(std::move(save_request));
+
+      LT_LOG("queued new resume save request : download:%p", save_request.download);
+    }
+
+    m_save_request_counter = m_save_requests.size();
+  }
+
+  if (!is_flushing && !m_processing_saves_callback_scheduled.exchange(true))
+    session_thread::callback(this, [this]() { process_save_request_with_pending_callback(); });
+}
+
+void
+SessionManager::process_save_request() {
+  assert(m_thread == torrent::this_thread::thread());
+
+  if (m_path.empty())
+    throw torrent::internal_error("SessionManager::process_save_request() called with empty path.");
+
+  std::unique_lock<std::mutex> lock(m_mutex);
+
+  if (!m_active)
+    throw torrent::internal_error("SessionManager::process_save_request() called while not active.");
+
+  while (!m_save_requests.empty() && m_processing_saves.size() < max_concurrent_requests)
+    process_next_save_request_unsafe();
+
+  m_processing_saves_callback_scheduled = false;
+}
+
+void
+SessionManager::process_save_request_with_pending_callback() {
+  process_save_request();
+
+  std::unique_lock<std::mutex> lock(m_pending_builds_mutex);
+
+  if (!m_pending_builds.empty())
+    torrent::main_thread::callback(this, [this]() { process_pending_resume_builds(false); });
+}
+
+void
+SessionManager::process_next_save_request_unsafe() {
+  auto request = std::move(m_save_requests.front());
+
+  m_save_requests.pop_front();
+  m_save_request_counter = m_save_requests.size();
+
+  auto itr = m_processing_saves.insert(m_processing_saves.end(), ProcessingSave{});
+
+  itr->second = std::move(request);
+  itr->first = std::async(std::launch::async, [this, itr]() {
+      auto cleanup_fn = [this, itr]() {
+          std::unique_lock<std::mutex> lock(m_mutex);
+
+          if (m_finished_saves.empty())
+            session_thread::callback(this, [this]() { process_finished_saves(); });
+
+          m_finished_saves.push_back(std::move(*itr));
+          m_finished_condition.notify_all();
+
+          m_processing_saves.erase(itr);
+        };
+
+      try {
+        DownloadStorer::save_and_move_streams(itr->second.path, m_use_fsyncdisk,
+                                              itr->second.torrent_stream.get(),
+                                              itr->second.rtorrent_stream.get(),
+                                              itr->second.libtorrent_stream.get());
+      } catch (...) {
+        cleanup_fn();
+        throw;
+      }
+
+      cleanup_fn();
+    });
+}
+
+void
+SessionManager::process_finished_saves() {
+  assert(m_thread == torrent::this_thread::thread());
+
+  std::unique_lock<std::mutex> lock(m_mutex);
+
+  if (!m_active)
+    throw torrent::internal_error("SessionManager::process_finished_saves() called while not active.");
+
+  for (auto& request : m_finished_saves) {
+    try {
+      request.first.get();
+
+    } catch (torrent::storage_error& e) {
+      LT_LOG("error saving download : storage error :download:%p path:%s : %s", request.second.download, request.second.path.c_str(), e.what());
+
+      if (m_last_storage_error_message + std::chrono::minutes(5) > torrent::this_thread::cached_time()) {
+        m_ignored_storage_error_count++;
+        continue;
+      }
+
+      lt_log_print(torrent::LOG_ERROR, "Storage errors saving session data for download: ignored:%u : %s", m_ignored_storage_error_count, e.what());
+
+      m_last_storage_error_message = torrent::this_thread::cached_time();
+      m_ignored_storage_error_count = 0;
+      continue;
+
+    } catch (torrent::internal_error& e) {
+      LT_LOG("error saving download : internal error : download:%p path:%s : %s", request.second.download, request.second.path.c_str(), e.what());
+      throw;
+
+    } catch (...) {
+      LT_LOG("error saving download : unknown error : download:%p path:%s", request.second.download, request.second.path.c_str());
+      throw;
+    }
+
+    LT_LOG("finished saving download : download:%p path:%s", request.second.download, request.second.path.c_str());
+  }
+
+  m_finished_saves.clear();
+}
+
+void
+SessionManager::flush_all_and_wait_unsafe(std::unique_lock<std::mutex>& lock) {
+  LT_LOG("flushing all pending saves", 0);
+
+  while (!m_save_requests.empty()) {
+    if (m_processing_saves.size() >= max_cleanup_processing) {
+      m_finished_condition.wait(lock);
+      continue;
+    }
+
+    process_next_save_request_unsafe();
+  }
+
+  while (!m_processing_saves.empty())
+    m_finished_condition.wait(lock);
+
+  for (auto& request : m_finished_saves)
+    LT_LOG("finished saving download : download:%p path:%s", request.second.download, request.second.path.c_str());
+
+  m_finished_saves.clear();
+
+  LT_LOG("flushed all pending saves", 0);
+}
+
+bool
+SessionManager::replace_save_request_unsafe(SaveRequest& save_request) {
+  // Can be run in any thread.
+
+  auto itr = std::find_if(m_save_requests.begin(), m_save_requests.end(), [download = save_request.download](auto& req) {
+      return req.download == download;
+    });
+
+  if (itr == m_save_requests.end())
+    return false;
+
+  if (itr->path != save_request.path)
+    throw torrent::internal_error("SessionManager::replace_save_request_unsafe() path mismatch on replace: " + itr->path + " != " + save_request.path);
+
+  // If the existing request is a full save (created during torrent initialization),
+  // keep its torrent_stream but update the resume streams with newer data.
+  // Otherwise, replace all streams.
+  if (itr->torrent_stream != nullptr) {
+    // Keep existing full-save torrent stream, only update resume streams
+    if (save_request.rtorrent_stream != nullptr)
+      itr->rtorrent_stream = std::move(save_request.rtorrent_stream);
+    
+    if (save_request.libtorrent_stream != nullptr)
+      itr->libtorrent_stream = std::move(save_request.libtorrent_stream);
+  } else {
+    // No full save pending, replace everything
+    itr->torrent_stream    = std::move(save_request.torrent_stream);
+    itr->rtorrent_stream   = std::move(save_request.rtorrent_stream);
+    itr->libtorrent_stream = std::move(save_request.libtorrent_stream);
+  }
+
+  return true;
+}
+
+bool
+SessionManager::remove_completely_unsafe(core::Download* download, std::unique_lock<std::mutex>& lock) {
+  assert(torrent::this_thread::thread() == torrent::main_thread::thread());
+
+  auto remove_requests = [this, download]() {
+    auto itr = std::remove_if(m_save_requests.begin(), m_save_requests.end(), [download](auto& req) {
+        return req.download == download;
+      });
+
+    if (itr == m_save_requests.end())
+      return false;
+
+    m_save_requests.erase(itr, m_save_requests.end());
+    return true;
+  };
+
+  auto remove_pending = [this, download]() {
+    std::unique_lock<std::mutex> pending_lock(m_pending_builds_mutex);
+
+    auto itr = std::remove_if(m_pending_builds.begin(), m_pending_builds.end(), [download](auto* req) {
+        return req == download;
+      });
+
+    if (itr == m_pending_builds.end())
+      return false;
+
+    m_pending_builds.erase(itr, m_pending_builds.end());
+    return true;
+  };
+
+  bool removed_something = false;
+
+  if (remove_pending())
+    removed_something = true;
+
+  if (remove_requests())
+    removed_something = true;
+
+  // This may block for a relatively long time if fdatasync is in use, however this is necessary.
+  while (true) {
+    auto itr = std::find_if(m_processing_saves.begin(), m_processing_saves.end(), [download](auto& req) {
+        return req.second.download == download;
+      });
+
+    if (itr == m_processing_saves.end())
+      break;
+
+    m_finished_condition.wait(lock);
+  }
+
+  // Since we're the main thread, no more requests for this download can be added.
+
+  // Checking active after remove_save_request_unsafe to ensure we're calling this after shutdown.
+  if (!m_active)
+    throw torrent::internal_error("SessionManager::remove_completely_unsafe() called while not active.");
+
+  return removed_something;
+}
+
+// TODO: Properly handle errors.
+// TODO: If no more sockets can be opened, wait for a job to finish. if all is finished, use a
+// timeout and try again.
+
+}  // namespace session
+
@@ -0,0 +1,126 @@
+#ifndef RTORRENT_SESSION_SESSION_MANAGER_H
+#define RTORRENT_SESSION_SESSION_MANAGER_H
+
+#include <condition_variable>
+#include <deque>
+#include <future>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <torrent/common.h>
+
+class Control;
+
+namespace core {
+class Download;
+}
+
+namespace utils {
+class Lockfile;
+}
+
+namespace session {
+
+class ThreadSession;
+
+struct SaveRequest {
+  core::Download*                    download;
+  std::string                        path;
+  std::unique_ptr<std::stringstream> torrent_stream;
+  std::unique_ptr<std::stringstream> rtorrent_stream;
+  std::unique_ptr<std::stringstream> libtorrent_stream;
+};
+
+class SessionManager {
+public:
+  typedef std::unique_ptr<std::stringstream> stream_ptr;
+
+  // TODO: This should depend on max open sockets / be configurable.
+
+  constexpr static int max_concurrent_requests   = 16;
+  constexpr static int max_concurrent_processing = 16;
+  constexpr static int max_cleanup_processing    = 64;
+
+  SessionManager(torrent::utils::Thread* thread);
+  ~SessionManager();
+
+  bool                is_used() const;
+
+  std::string         path() const;
+  void                set_path(std::string path);
+
+  bool                use_fsyncdisk() const;
+  void                set_use_fsyncdisk(bool use_fsyncdisk);
+
+  bool                use_lock() const;
+  void                set_use_lock(bool use_lock);
+
+  void                save_full_download(core::Download* download);
+  void                save_resume_download(core::Download* download);
+  void                remove_download(core::Download* download);
+
+protected:
+  friend class ::Control;
+  friend class ThreadSession;
+
+  void                save_download(core::Download* download, bool skip_static);
+
+  void                start();
+  void                cleanup();
+
+  void                flush_all_pending_builds();
+
+private:
+  void                process_pending_resume_builds(bool is_flushing);
+  void                process_save_request();
+  void                process_save_request_with_pending_callback();
+  void                process_next_save_request_unsafe();
+  void                process_finished_saves();
+
+  // Requires a higher number of open sockets, and should only be used during shutdown.
+  void                flush_all_and_wait_unsafe(std::unique_lock<std::mutex>& lock);
+
+  bool                replace_save_request_unsafe(SaveRequest& download);
+  bool                remove_completely_unsafe(core::Download* download, std::unique_lock<std::mutex>& lock);
+
+  torrent::utils::Thread* m_thread;
+
+  bool                m_freeze_info{};
+  std::string         m_path;
+  bool                m_use_fsyncdisk{true};
+  bool                m_use_lock{true};
+
+  std::mutex          m_mutex;
+  bool                m_active{};
+
+  typedef std::pair<std::future<void>, SaveRequest> ProcessingSave;
+
+  std::deque<SaveRequest>     m_save_requests;
+  std::atomic<size_t>         m_save_request_counter{};
+  std::list<ProcessingSave>   m_processing_saves;
+  std::atomic<bool>           m_processing_saves_callback_scheduled{};
+  std::condition_variable     m_finished_condition;
+  std::vector<ProcessingSave> m_finished_saves;
+
+  std::unique_ptr<utils::Lockfile> m_lockfile;
+
+  std::chrono::microseconds   m_last_storage_error_message{};
+  unsigned int                m_ignored_storage_error_count{};
+
+  // Pending builds are only ever locked by main thread.
+  std::mutex                  m_pending_builds_mutex;
+  std::deque<core::Download*> m_pending_builds;
+};
+
+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_lock() const           { return m_use_lock; }
+inline void        SessionManager::flush_all_pending_builds() { process_pending_resume_builds(true); }
+
+} // namespace session
+
+#endif // RTORRENT_SESSION_SESSION_MANAGER_H
@@ -0,0 +1,87 @@
+#include "config.h"
+
+#include "thread_session.h"
+
+#include <torrent/exceptions.h>
+
+#include "session/session_manager.h"
+
+namespace session {
+
+class ThreadSessionInternal {
+public:
+  static ThreadSession* thread_session() { return ThreadSession::internal_thread_session(); }
+};
+
+ThreadSession* ThreadSession::m_thread_session{nullptr};
+
+void
+ThreadSession::create_thread() {
+  auto thread = new ThreadSession;
+
+  thread->m_manager = std::make_unique<SessionManager>(thread);
+
+  m_thread_session          = thread;
+  m_thread_session->m_state = STATE_INITIALIZED;
+}
+
+void
+ThreadSession::destroy_thread() {
+  delete m_thread_session;
+  m_thread_session = nullptr;
+}
+
+ThreadSession*
+ThreadSession::thread_session() {
+  return m_thread_session;
+}
+
+void
+ThreadSession::init_thread_pre_start() {
+  m_manager->start();
+}
+
+// TODO: Make sure we trigger session save before main thread exits, that it adds all required
+// downloads to the queue.
+void
+ThreadSession::cleanup_thread() {
+  m_manager->cleanup();
+}
+
+void
+ThreadSession::call_events() {
+  // lt_log_print_locked(torrent::LOG_THREAD_NOTICE, "Got thread_disk tick.");
+
+  process_callbacks();
+
+  if ((m_flags & flag_do_shutdown)) {
+    if ((m_flags & flag_did_shutdown))
+      throw torrent::internal_error("Already trigged shutdown.");
+
+    m_flags |= flag_did_shutdown;
+    throw torrent::shutdown_exception();
+  }
+}
+
+std::chrono::microseconds
+ThreadSession::next_timeout() {
+  // TODO: This leads to kqueue crash?
+  // return std::chrono::microseconds(1h);
+  return std::chrono::microseconds(10min);
+}
+
+} // namespace session
+
+namespace session_thread {
+
+torrent::utils::Thread* thread()                         { return session::ThreadSessionInternal::thread_session(); }
+std::thread::id         thread_id()                      { return session::ThreadSessionInternal::thread_session()->thread_id(); }
+
+void callback(void* target, std::function<void ()>&& fn) { session::ThreadSessionInternal::thread_session()->callback(target, std::move(fn)); }
+void cancel_callback(void* target)                       { session::ThreadSessionInternal::thread_session()->cancel_callback(target); }
+void cancel_callback_and_wait(void* target)              { session::ThreadSessionInternal::thread_session()->cancel_callback_and_wait(target); }
+
+session::SessionManager* manager()                       { return session::ThreadSessionInternal::thread_session()->manager(); }
+std::string              session_path()                  { return session::ThreadSessionInternal::thread_session()->manager()->path(); }
+
+} // namespace session_thread
@@ -0,0 +1,43 @@
+#ifndef RTORRENT_SESSION_THREAD_SESSION_H
+#define RTORRENT_SESSION_THREAD_SESSION_H
+
+#include <torrent/utils/thread.h>
+
+namespace session {
+
+class SessionManager;
+class ThreadSessionInternal;
+
+class ThreadSession : public torrent::utils::Thread {
+public:
+
+  static void           create_thread();
+  static void           destroy_thread();
+  static ThreadSession* thread_session();
+
+  const char*         name() const override     { return "rtorrent-session"; }
+
+  SessionManager*     manager() const           { return m_manager.get(); }
+
+protected:
+  friend class ThreadSessionInternal;
+
+  ThreadSession() = default;
+
+  static auto         internal_thread_session() { return m_thread_session; }
+
+  void                init_thread_pre_start() override;
+  void                cleanup_thread() override;
+
+  void                      call_events() override;
+  std::chrono::microseconds next_timeout() override;
+
+private:
+  static ThreadSession*   m_thread_session;
+
+  std::unique_ptr<SessionManager> m_manager;
+};
+
+} // namespace session
+
+#endif // RTORRENT_SESSION_THREAD_SESSION_H
@@ -1,44 +1,11 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

+#include <cerrno>
+#include <cstring>
 #include <signal.h>
 #include <stdexcept>
 #include <string>

-#include "rak/error_number.h"
 #include "signal_handler.h"

 #ifdef __sun__
@@ -80,7 +47,7 @@ SignalHandler::set_handler(unsigned int signum, slot_void slot) {
  sa.sa_handler = &SignalHandler::caught;

  if (sigaction(signum, &sa, NULL) == -1)
-    throw std::logic_error("Could not set sigaction: " + std::string(rak::error_number::current().c_str()));
+    throw std::logic_error("Could not set sigaction: " + std::string(std::strerror(errno)));
  else
    m_handlers[signum] = slot;
 }
@@ -97,7 +64,7 @@ SignalHandler::set_sigaction_handler(unsigned int signum, handler_slot slot) {
  sigemptyset(&sa.sa_mask);

  if (sigaction(signum, &sa, NULL) == -1)
-    throw std::logic_error("Could not set sigaction: " + std::string(rak::error_number::current().c_str()));
+    throw std::logic_error("Could not set sigaction: " + std::string(std::strerror(errno)));
 }

 void
@@ -1,97 +0,0 @@
-#include "config.h"
-
-#include "thread_worker.h"
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <cassert>
-#include <rak/path.h>
-#include <torrent/exceptions.h>
-
-#include "globals.h"
-#include "control.h"
-#include "core/manager.h"
-#include "rpc/scgi.h"
-#include "rpc/parse_commands.h"
-
-ThreadWorker::~ThreadWorker() = default;
-
-void
-ThreadWorker::init_thread() {
-  m_state = STATE_INITIALIZED;
-}
-
-void
-ThreadWorker::cleanup_thread() {
-  if (m_scgi != nullptr)
-    m_scgi.load()->deactivate();
-}
-
-bool
-ThreadWorker::set_scgi(rpc::SCgi* scgi) {
-  rpc::SCgi* expected = nullptr;
-
-  if (!m_scgi.compare_exchange_strong(expected, scgi))
-    return false;
-
-  change_rpc_log();
-
-  callback(nullptr, [this]() {
-      if (m_scgi == NULL)
-        throw torrent::internal_error("Tried to start SCGI but object was not present.");
-
-      m_scgi.load()->activate();
-    });
-
-  return true;
-}
-
-void
-ThreadWorker::set_rpc_log(const std::string& filename) {
-  callback(nullptr, [this, filename]() {
-      m_rpc_log_filename = filename;
-      change_rpc_log();
-    });
-}
-
-void
-ThreadWorker::change_rpc_log() {
-  if (scgi() == NULL)
-    return;
-
-  if (scgi()->log_fd() != -1) {
-    ::close(scgi()->log_fd());
-    scgi()->set_log_fd(-1);
-    control->core()->push_log("Closed RPC log.");
-  }
-
-  if (m_rpc_log_filename.empty())
-    return;
-
-  scgi()->set_log_fd(open(rak::path_expand(m_rpc_log_filename).c_str(), O_WRONLY | O_APPEND | O_CREAT, 0644));
-
-  if (scgi()->log_fd() == -1) {
-    control->core()->push_log_std("Could not open RPC log file '" + m_rpc_log_filename + "'.");
-    return;
-  }
-
-  control->core()->push_log_std("Logging RPC events to '" + m_rpc_log_filename + "'.");
-}
-
-void
-ThreadWorker::call_events() {
-  if ((m_flags & flag_do_shutdown)) {
-    if ((m_flags & flag_did_shutdown))
-      throw torrent::internal_error("Already trigged shutdown.");
-
-    m_flags |= flag_did_shutdown;
-    throw torrent::shutdown_exception();
-  }
-
-  process_callbacks();
-}
-
-std::chrono::microseconds
-ThreadWorker::next_timeout() {
-  return std::chrono::microseconds(10min);
-}
@@ -1,38 +0,0 @@
-#ifndef RTORRENT_THREAD_WORKER_H
-#define RTORRENT_THREAD_WORKER_H
-
-#include <atomic>
-#include <string>
-#include <torrent/utils/thread.h>
-
-namespace rpc {
-class SCgi;
-}
-
-class ThreadWorker : public torrent::utils::Thread {
-public:
-  ThreadWorker() = default;
-  ~ThreadWorker();
-
-  const char*         name() const override      { return "rtorrent scgi"; }
-
-  void                init_thread() override;
-  void                cleanup_thread() override;
-
-  rpc::SCgi*          scgi()                     { return m_scgi; }
-  bool                set_scgi(rpc::SCgi* scgi);
-
-  void                set_rpc_log(const std::string& filename);
-
-private:
-  void                task_touch_log();
-  void                change_rpc_log();
-
-  void                      call_events() override;
-  std::chrono::microseconds next_timeout() override;
-
-  std::atomic<rpc::SCgi*>   m_scgi{nullptr};
-  std::string               m_rpc_log_filename;
-};
-
-#endif
@@ -167,6 +167,8 @@ ElementDownloadList::receive_home() {

 void
 ElementDownloadList::receive_end() {
+  if (m_view->size_visible() == 0)
+    return;
  m_view->set_focus(m_view->end_visible() - 1);
  m_view->set_last_changed();
 }
@@ -221,10 +223,10 @@ ElementDownloadList::receive_change_view(const std::string& name) {

  std::string old_name = view() ? view()->name() : "";
  if (!old_name.empty())
-    rpc::commands.call_catch("event.view.hide", rpc::make_target(), name, "View hide event action failed: ");
+    rpc::commands.call_catch("event.view.hide", rpc::make_target(), old_name, "View hide event action failed: ");
  set_view(*itr);
-  if (!old_name.empty())
-    rpc::commands.call_catch("event.view.show", rpc::make_target(), old_name, "View show event action failed: ");
+  if (!name.empty())
+    rpc::commands.call_catch("event.view.show", rpc::make_target(), name, "View show event action failed: ");
 }

 void
@@ -1,5 +1,7 @@
 #include "config.h"

+#include "ui/root.h"
+
 #include <fstream>
 #include <stdexcept>
 #include <string.h>
@@ -9,6 +11,8 @@
 #include <torrent/download/resource_manager.h>
 #include <torrent/utils/log.h>

+#include "control.h"
+#include "core/download_list.h"
 #include "core/manager.h"
 #include "display/frame.h"
 #include "display/window_http_queue.h"
@@ -18,12 +22,7 @@
 #include "input/manager.h"
 #include "input/text_input.h"
 #include "rpc/parse_commands.h"
-
-#include "control.h"
-#include "download_list.h"
-#include "core/download_store.h"
-
-#include "root.h"
+#include "session/session_manager.h"

 namespace ui {

@@ -378,13 +377,13 @@ Root::set_input_history_size(int size) {

 void
 Root::load_input_history() {
-  if (m_control == nullptr || !m_control->core()->download_store()->is_enabled()) {
+  if (m_control == nullptr || !session_thread::manager()->is_used()) {
    lt_log_print(torrent::LOG_DEBUG, "ignoring input history file");
    return;
  }

-  std::string history_filename = m_control->core()->download_store()->path() + "rtorrent.input_history";
-  std::fstream history_file(history_filename.c_str(), std::ios::in);
+  auto history_filename = session_thread::manager()->path() + "rtorrent.input_history";
+  auto history_file     = std::fstream(history_filename.c_str(), std::ios::in);

  if (history_file.is_open()) {
    // Create a temp object of the content since size of history categories can be smaller than this.
@@ -446,12 +445,12 @@ Root::load_input_history() {

 void
 Root::save_input_history() {
-  if (m_control == nullptr || !m_control->core()->download_store()->is_enabled())
+  if (m_control == nullptr || !session_thread::manager()->is_used())
    return;

-  std::string history_filename = m_control->core()->download_store()->path() + "rtorrent.input_history";
-  std::string history_filename_tmp = history_filename + ".new";
-  std::fstream history_file(history_filename_tmp.c_str(), std::ios::out | std::ios::trunc);
+  auto history_filename     = session_thread::manager()->path() + "rtorrent.input_history";
+  auto history_filename_tmp = history_filename + ".new";
+  auto history_file         = std::fstream(history_filename_tmp.c_str(), std::ios::out | std::ios::trunc);

  if (!history_file.is_open()) {
    lt_log_print(torrent::LOG_DEBUG, "could not open input history file for writing (path:%s)", history_filename.c_str());
@@ -497,13 +496,13 @@ Root::set_keymap_style(const std::string& style) {
  } else if (style == "emacs") {
    m_keymap = emacs_keymap;
  } else {
-    throw torrent::input_error("Root::set_keymap_style() -> ui.keymap.style is configured with unknown keymap style: " + m_keymap_style);
+    throw torrent::input_error("Root::set_keymap_style() -> ui.keymap.style is configured with unknown keymap style: " + style);
  }

  m_keymap_style = style;
 }

-const int
+int
 Root::navigation_key(NavigationKeymap key) {
  return m_keymap[key];
 }
@@ -98,7 +98,8 @@ public:

  const std::string&  keymap_style()                          { return m_keymap_style; }
  void                set_keymap_style(const std::string& style);
-  const int           navigation_key(NavigationKeymap key);
+
+  int                 navigation_key(NavigationKeymap key);

 private:
  void                setup_keys();
@@ -1,48 +1,14 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

-#include <algorithm>
-#include <functional>
+#include "utils/directory.h"

+#include <algorithm>
 #include <dirent.h>
+#include <functional>
 #include <sys/stat.h>
-#include <rak/path.h>
 #include <torrent/exceptions.h>

-#include "directory.h"
+#include "globals.h"

 namespace utils {

@@ -52,7 +18,7 @@ Directory::is_valid() const {
  if (m_path.empty())
    return false;

-  DIR* d = opendir(rak::path_expand(m_path).c_str());
+  DIR* d = opendir(expand_path(m_path).c_str());
  closedir(d);

  return d;
@@ -63,7 +29,7 @@ Directory::update(int flags) {
  if (m_path.empty())
    throw torrent::input_error("Directory::update() tried to open an empty path.");

-  DIR* d = opendir(rak::path_expand(m_path).c_str());
+  DIR* d = opendir(expand_path(m_path).c_str());

  if (d == NULL)
    return false;
@@ -1,55 +1,22 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #include "config.h"

-#include <rak/file_stat.h>
-#include <rak/path.h>
-#include <torrent/exceptions.h>
+#include "utils/file_status_cache.h"

-#include "file_status_cache.h"
+#include <torrent/exceptions.h>
+#include <torrent/utils/file_stat.h>
+
+#include "globals.h"

 namespace utils {

 bool
-FileStatusCache::insert(const std::string& path, int flags) {
-  rak::file_stat fs;
+FileStatusCache::insert(const std::string& path) {
+  torrent::utils::FileStat fs;

  // Should we expand somewhere else? Problem is it adds a lot of junk
  // to the start of the paths added to the cache, causing more work
  // during search, etc.
-  if (!fs.update(rak::path_expand(path)))
+  if (!fs.update(expand_path(path)))
    return false;

  std::pair<iterator, bool> result = base_type::insert(value_type(path, file_status()));
@@ -71,10 +38,10 @@ FileStatusCache::prune() {
  iterator itr = begin();

  while (itr != end()) {
-    rak::file_stat fs;
+    torrent::utils::FileStat fs;
    iterator tmp = itr++;

-    if (!fs.update(rak::path_expand(tmp->first)) || tmp->second.m_mtime != (uint32_t)fs.modified_time())
+    if (!fs.update(expand_path(tmp->first)) || tmp->second.m_mtime != (uint32_t)fs.modified_time())
      base_type::erase(tmp);
  }
 }
@@ -1,42 +1,9 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 #ifndef RTORRENT_UTILS_FILE_STATUS_CACHE_H
 #define RTORRENT_UTILS_FILE_STATUS_CACHE_H

 #include <map>
 #include <string>
+#include <cinttypes>

 namespace utils {

@@ -65,11 +32,9 @@ public:

  using base_type::erase;

-  //  static int flag_
-
  // Insert and return true if the entry does not exist or the new
  // file's mtime is more recent.
-  bool                insert(const std::string& path, int flags);
+  bool                insert(const std::string& path);

  // Add a function for pruning a sorted list of paths.

@@ -1,37 +1,3 @@
-// rTorrent - BitTorrent client
-// Copyright (C) 2005-2011, Jari Sundell
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-// 
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-// 
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-// In addition, as a special exception, the copyright holders give
-// permission to link the code of portions of this program with the
-// OpenSSL library under certain conditions as described in each
-// individual source file, and distribute linked combinations
-// including the two.
-//
-// You must obey the GNU General Public License in all respects for
-// all of the code used other than OpenSSL.  If you modify file(s)
-// with this exception, you may extend this exception to your version
-// of the file(s), but you are not obligated to do so.  If you do not
-// wish to do so, delete this exception statement from your version.
-// If you delete this exception statement from all source files in the
-// program, then also delete it here.
-//
-// Contact:  Jari Sundell <sundell.software@gmail.com>
-
-
 // A simple, and not guaranteed atomic, lockfile implementation. It
 // saves the hostname and pid in the lock file, which may be accessed
 // by Lockfile::locked_by(). If the path is an empty string then no
@@ -1,159 +0,0 @@
-#include "config.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <arpa/inet.h>
-#include <net/if.h>
-#include <netinet/in.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <torrent/exceptions.h>
-#include <torrent/net/socket_address.h>
-
-#include "socket_fd.h"
-
-namespace utils {
-
-inline void
-SocketFd::check_valid() const {
-  if (!is_valid())
-    throw torrent::internal_error("SocketFd function called on an invalid fd.");
-}
-
-bool
-SocketFd::set_nonblock() {
-  check_valid();
-
-  return fcntl(m_fd, F_SETFL, O_NONBLOCK) == 0;
-}
-
-bool
-SocketFd::set_priority(priority_type p) {
-  check_valid();
-  int opt = p;
-
-  if (m_ipv6_socket)
-    return setsockopt(m_fd, IPPROTO_IPV6, IPV6_TCLASS, &opt, sizeof(opt)) == 0;
-  else
-    return setsockopt(m_fd, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) == 0;
-}
-
-bool
-SocketFd::set_reuse_address(bool state) {
-  check_valid();
-  int opt = state;
-
-  return setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == 0;
-}
-
-bool
-SocketFd::set_dont_route(bool state) {
-  check_valid();
-  int opt = state;
-
-  return setsockopt(m_fd, SOL_SOCKET, SO_DONTROUTE, &opt, sizeof(opt)) == 0;
-}
-
-// bool
-// SocketFd::set_bind_to_device(const char* device) {
-//   check_valid();
-//   struct ifreq ifr;
-//   strlcpy(ifr.ifr_name, device, IFNAMSIZ);
-
-//   return setsockopt(m_fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) == 0;
-// }
-
-bool
-SocketFd::set_send_buffer_size(uint32_t s) {
-  check_valid();
-  int opt = s;
-
-  return setsockopt(m_fd, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) == 0;
-}
-
-bool
-SocketFd::set_receive_buffer_size(uint32_t s) {
-  check_valid();
-  int opt = s;
-
-  return setsockopt(m_fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) == 0;
-}
-
-int
-SocketFd::get_error() const {
-  check_valid();
-
-  int err;
-  socklen_t length = sizeof(err);
-
-  if (getsockopt(m_fd, SOL_SOCKET, SO_ERROR, &err, &length) == -1)
-    throw torrent::internal_error("SocketFd::get_error() could not get error");
-
-  return err;
-}
-
-bool
-SocketFd::open_stream() {
-  m_fd = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
-
-  if (m_fd == -1) {
-    m_ipv6_socket = false;
-    return (m_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) != -1;
-  }
-
-  m_ipv6_socket = true;
-
-  int zero = 0;
-  return setsockopt(m_fd, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero)) != -1;
-}
-
-bool
-SocketFd::open_datagram() {
-  m_fd = socket(AF_INET6, SOCK_DGRAM, 0);
-  if (m_fd == -1) {
-    m_ipv6_socket = false;
-    return (m_fd = socket(AF_INET, SOCK_DGRAM, 0)) != -1;
-  }
-  m_ipv6_socket = true;
-
-  int zero = 0;
-  return setsockopt(m_fd, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero)) != -1;
-}
-
-bool
-SocketFd::open_local() {
-  return (m_fd = socket(AF_LOCAL, SOCK_STREAM, 0)) != -1;
-}
-
-void
-SocketFd::close() {
-  if (::close(m_fd) && errno == EBADF)
-    throw torrent::internal_error("SocketFd::close() called on an invalid file descriptor");
-}
-
-bool
-SocketFd::bind_sa(const sockaddr* sa, unsigned int length) {
-  check_valid();
-
-  if (m_ipv6_socket && sa->sa_family == AF_INET) {
-    if (length < sizeof(sockaddr_in))
-      throw torrent::input_error("SocketFd::bind_sa: invalid sockaddr length for AF_INET");
-
-    auto mapped_sa = torrent::sin6_to_v4mapped_in(reinterpret_cast<const sockaddr_in*>(sa));
-    return !::bind(m_fd, reinterpret_cast<const sockaddr*>(mapped_sa.get()), sizeof(sockaddr_in6));
-  }
-
-  return !::bind(m_fd, sa, length);
-}
-
-bool
-SocketFd::listen(int size) {
-  check_valid();
-
-  return !::listen(m_fd, size);
-}
-
-}
@@ -1,55 +0,0 @@
-#ifndef RTORRENT_UTILS_SOCKET_FD_H
-#define RTORRENT_UTILS_SOCKET_FD_H
-
-#include <cinttypes>
-#include <unistd.h>
-#include <sys/socket.h>
-
-namespace utils {
-
-class SocketFd {
-public:
-  typedef uint8_t priority_type;
-
-  SocketFd() : m_fd(-1) {}
-  explicit SocketFd(int fd) : m_fd(fd) {}
-
-  bool                is_valid() const                        { return m_fd >= 0; }
-
-  int                 get_fd() const                          { return m_fd; }
-  void                set_fd(int fd)                          { m_fd = fd; }
-
-  bool                set_nonblock();
-  bool                set_reuse_address(bool state);
-  bool                set_dont_route(bool state);
-
-  bool                set_bind_to_device(const char* device);
-
-  bool                set_priority(priority_type p);
-
-  bool                set_send_buffer_size(uint32_t s);
-  bool                set_receive_buffer_size(uint32_t s);
-
-  int                 get_error() const;
-
-  bool                open_stream();
-  bool                open_datagram();
-  bool                open_local();
-  void                close();
-
-  void                clear()                                 { m_fd = -1; }
-
-  bool                bind_sa(const sockaddr* sa, unsigned int length);
-
-  bool                listen(int size);
-
-private:
-  inline void         check_valid() const;
-
-  int                 m_fd;
-  bool                m_ipv6_socket;
-};
-
-}
-
-#endif
Author	SHA1	Message	Date
rakshasa	b78fd9aef5	Tagged release 0.16.9.	2026-04-06 15:19:27 +02:00
rakshasa	21e399d099	Remove unneeded MSG_NOSIGNAL.	2026-04-06 10:48:35 +02:00
Xirvik	08a907b547	Whitelist additional read-only getters for untrusted connections ruTorrent queries these commands for its settings and status pages. They are all read-only getters with no side effects, safe to expose for untrusted SCGI connections. Tested against ruTorrent with both httprpc and multirpc plugins on servers with active torrents — all modes (list, settings, totals, open connections) work with zero blocked commands.	2026-03-30 11:55:24 +02:00
zqmfb	a0b8702895	Address additional review feedback	2026-03-27 17:48:13 +01:00
zqmfb	ad3c31862e	Further clarify systemd socket selection	2026-03-27 17:48:13 +01:00
zqmfb	2711e4c044	Use libtorrent's fd_set_nonblock helper	2026-03-27 17:48:13 +01:00
zqmfb	8d50aee96f	Add `network.scgi.open_systemd` command unconditionally	2026-03-27 17:48:13 +01:00
zqmfb	71bb51c3fd	Clarify systemd socket selection logic	2026-03-27 17:48:13 +01:00
zqmfb	63ea08bde6	Add support for SCGI systemd socket activation Add a new command, `network.scgi.open_systemd`, that binds to a file descriptor passed in via systemd socket activation.	2026-03-27 17:48:13 +01:00
Xirvik Support	a82bdf22ac	Review fix: remove method.use_deprecated.set from untrusted whitelist	2026-03-23 15:11:07 +01:00
Xirvik	9f6731b4e2	Address review: tighten untrusted safelist and remove set_trusted	2026-03-23 15:11:07 +01:00
Xirvik	d935e0ffe9	Address review feedback: explicit mark_safe whitelist and rpc trust flow	2026-03-23 15:11:07 +01:00
Xirvik	ba239bc8c5	Address code review: fix setter exposure and narrow catch blocks 1. network.rpc.use_xmlrpc and network.rpc.use_jsonrpc: change from CMD2_VAR_BOOL_U (getter+setter both safe) to CMD2_VAR_BOOL_U_GET (getter safe, setter trusted-only). Untrusted callers could previously disable RPC transports entirely. 2. Remove broad catch(std::exception&) and catch(...) from xmlrpc_c.cc that masked real defects and altered fault semantics. 3. Revert SCGI callback catch-all to re-throw instead of swallowing exceptions with a generic error response.	2026-03-23 15:11:07 +01:00
Xirvik	ea16276773	Fix crash on untrusted XMLRPC connections Root cause: network.rpc.use_xmlrpc and network.rpc.use_jsonrpc were not marked as untrusted-safe, but RpcManager::process() calls them before dispatching to the protocol handler. When an untrusted request arrived, call_command() threw untrusted_error for these gatekeepers, which escaped the callback_interrupt_pollling callback and crashed rtorrent. Fix: Mark network.rpc.use_xmlrpc/jsonrpc as safe (CMD2_VAR_BOOL_U). Also harden exception safety: - SCGI callback catch-all now sends a generic error response instead of re-throwing, since the callback infrastructure may not support exception propagation. - xmlrpc_c.cc now has catch(std::exception&) and catch(...) safety nets after the specific exception handlers.	2026-03-23 15:11:07 +01:00
Xirvik	f767053297	Mark safe commands with flag_untrusted_safe for whitelist enforcement Annotate all commands that web UIs (ruTorrent) need for normal torrent management with _U macro variants, which set flag_untrusted_safe. Commands not marked are blocked by default for untrusted connections. Safe commands include: - d.* download getters, state, priorities, custom fields, start/stop - f.* file getters, priority control - p.* peer getters, disconnect, ban/snub - t.* tracker getters, enable/disable - throttle.* rate getters/setters, peer limits - network.* read-only queries (getters safe, setters blocked) - view.list, view.size, view.filter_all, ui.current_view - load., download_list, d.multicall2, d.multicall.filtered - convert., branch/if/and/or/not/cat/value/print - system.* version/time/status queries (read-only) - choke_group.* read-only queries - method.has_key, method.const, method.list_keys, method.get, strings.* - group..view, group..ratio.min/max/upload (dynamic, via flag propagation) Blocked by default (not marked): - execute, method.insert/set/redirect, schedule, import - log., file.append, network.scgi.open_, view.filter/sort/event_* - system.shutdown, system.env, group.insert, choke_group.insert - All user-defined commands (via method.insert)	2026-03-23 15:11:07 +01:00
Xirvik	598914908f	Add untrusted connection security infrastructure (v3) Replace the v2 blacklist approach with a per-command flag system. Commands must opt in to being available for untrusted connections via flag_untrusted_safe (0x400), checked in call_command() which catches all execution paths including nested commands. Infrastructure changes: - Add flag_untrusted_safe to CommandMap - Add untrusted_error exception type for proper error codes - Enforce trust check in both call_command() overloads - Add catch blocks in xmlrpc_c, xmlrpc_tinyxml2, and jsonrpc handlers - Port SCGI trust state management from v2 (thread_local, header parsing) - Add _U macro variants in command_helpers.h for safe command registration - Add CMD2_VAR__U and CMD2_VAR__U_GET variants for variables	2026-03-23 15:11:07 +01:00
rakshasa	38fc815d52	Fix display/UI crash and correctness bugs (@sirus20x6)	2026-03-16 16:08:52 +01:00
Jari Sundell	674ae767aa	Validate parsed int pair arguments for positivity	2026-03-16 13:56:43 +01:00
sirus20x6	0aaa470053	Fix resource leaks and minor issues - Close pipe fds on fork failure in ExecFile::execute - Add exception-safe fclose in cmd_file_append via try/catch - Add overflow guards before K/M/G bit shifts in parse_whole_value - Fix %u format for int* in sscanf (change to %d) - Fix typo "atter"→"after" in error message	2026-03-16 13:56:43 +01:00
PiloUnk	6f27159627	Refactor full save scheduling with early return	2026-03-16 13:29:33 +01:00
PiloUnk	de163293ab	Avoid missing save scheduling after full save update	2026-03-16 13:29:33 +01:00
PiloUnk	fb4e775689	Fix coalescing resume saves with pending full save	2026-03-16 13:29:33 +01:00
rakshasa	39f186e523	Tagged release 0.16.8.	2026-03-15 15:43:32 +01:00
Jari Sundell	70e6964823	Fixed various SCGI issues.	2026-03-10 23:25:28 +09:00
rakshasa	7ead88448b	Removed rak/error_number.h from Makefile.am.	2026-03-04 11:39:25 +01:00
rakshasa	650f0299b5	Tagged release 0.16.7.	2026-03-04 10:47:30 +01:00
rakshasa	5dfb2ae938	Allow dht bootstrap nodes to be added when dht is off.	2026-03-02 09:45:09 +01:00
Jorge Israel Peña	f05a2ae520	Re-send smkx on SIGWINCH to fix arrow keys after terminal reattach	2026-02-19 16:06:42 +01:00
Miroslav Marchev	ecefdba734	dht_add_peer_node is empty, use dht_add_bootstrap_node instead After a refactor dht_add_peer_node became empty function. Replace with dht_add_bootstrap_node to make adding bootstrap nodes work.	2026-02-14 14:32:48 +01:00
Jari Sundell	87666199b3	Added SocketManager to handle reuse of uninterested fd's by the kernel.	2026-01-29 04:00:31 +09:00
Jari Sundell	9489793dcb	Created torrent/runtime include directory.	2026-01-27 08:21:05 +09:00
Jari Sundell	2fa7568165	Remove obsolete SocketFd class.	2026-01-26 19:13:03 +09:00
fffe	f4b718f685	add separate commands for unbuffered logs	2026-01-16 16:10:02 +01:00
Jari Sundell	b233e24465	Deprecated rak::path_expand.	2026-01-08 23:27:53 +09:00
Jari Sundell	289ab046bf	Expand '~/' to $HOME in session path.	2026-01-06 20:44:40 +09:00
Jari Sundell	a8b6a47054	Removed deprecated rak errno and file headers.	2026-01-04 03:22:02 +09:00
Zoltan Celedes	110591d5c1	Fix key/value pairs in Lua Previously, the keys and values were swapped in d.custom.items()	2026-01-03 12:20:08 +01:00
rakshasa	ae14baa357	Tagged release 0.16.6.	2026-01-02 15:22:29 +01:00
rakshasa	0b0c824b4b	Changed magnet metadata handling and added 'magnet.path.set'.	2025-12-31 21:57:52 +01:00
Jari Sundell	def6551488	Properly propagate errors from download session save.	2025-12-30 22:00:34 +09:00
Jari Sundell	787738e36a	Make sure pending builds of session resume get processed.	2025-12-29 09:55:32 +09:00
Jari Sundell	40c2d90c45	Fixed dereferencing of potentially nullptr in SessionManager.	2025-12-25 23:05:08 +09:00
Jari Sundell	4a37fbde0b	Session saving of resume data is added to a pre-queue.	2025-12-23 03:04:47 +09:00
Jari Sundell	4bdeb58eb6	Run multiple session save requests in parallel.	2025-12-22 06:26:35 +09:00
Jari Sundell	5dbb0020dc	Replace ThreadWorker with scgi::ThreadScgi.	2025-12-18 07:43:43 +09:00
Jari Sundell	8f644e65dd	Use separate thread for saving session data.	2025-12-18 06:42:44 +09:00
Jari Sundell	16ff32b88c	Added missing Event::type_name() functions.	2025-12-13 19:06:02 +09:00
Jari Sundell	8806c06f9f	Added timestamp helper commands.	2025-12-10 22:29:42 +09:00
rakshasa	60cfcd37c4	Release 0.16.5.	2025-12-02 17:51:26 +01:00
				`@@ -0,0 +1 @@`
				`valgrind --leak-check=full --track-origins=yes --show-reachable=yes --suppressions=/Users/rakshasa/projects/rtorrent/doc/valgrind.suppression --gen-suppressions=all --log-file=valgrind.log /usr/local/bin/rtorrent`