Tagged release 0.16.14.

LUA_OK was introduced in Lua 5.2. Define it as 0 for compatibility
with Lua 5.1 and LuaJIT (which is based on Lua 5.1).

configure.ac

@@ -1,6 +1,6 @@
 m4_pattern_allow([PKG_CHECK_EXISTS])
 
-AC_INIT([rtorrent],[0.16.13],[sundell.software@gmail.com])
+AC_INIT([rtorrent],[0.16.14],[sundell.software@gmail.com])
 
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_MACRO_DIRS([scripts])
@@ -10,15 +10,11 @@ AM_PROG_AR
 LT_INIT
 
 AC_PROG_CXX
-
-AC_DEFINE([API_VERSION], [21], [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)
-
 AX_CXX_COMPILE_STDCXX(20, noext, mandatory)
 
-AC_SYS_LARGEFILE
+PKG_PROG_PKG_CONFIG
+
+AC_DEFINE([API_VERSION], [22], [api version])
 
 RAK_CHECK_CFLAGS
 RAK_CHECK_CXXFLAGS
@@ -26,9 +22,6 @@ RAK_ENABLE_DEBUG
 RAK_ENABLE_EXTRA_DEBUG
 RAK_ENABLE_WERROR
 
-TORRENT_ENABLE_ARCH
-TORRENT_WITH_SYSROOT
-
 AC_ARG_ENABLE(execinfo,
   AS_HELP_STRING([--disable-execinfo],
     [disable libexecinfo [[default=enable]]]),
@@ -54,7 +47,7 @@ fi
 
 PKG_CHECK_MODULES([CPPUNIT], [cppunit],, [no_cppunit="yes"])
 PKG_CHECK_MODULES([ZLIB], [zlib])
-PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.13])
+PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.14])
 
 AC_LANG_PUSH(C++)
 TORRENT_WITH_XMLRPC_C
@@ -80,7 +73,6 @@ CFLAGS="$CFLAGS $PTHREAD_CFLAGS $CURSES_CFLAGS $ZLIB_CFLAGS $DEPENDENCIES_CFLAGS
 CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS $CURSES_CFLAGS $ZLIB_CFLAGS $DEPENDENCIES_CFLAGS"
 
 TORRENT_CHECK_CACHELINE
-TORRENT_CHECK_POPCOUNT
 
 AC_CONFIG_FILES([
   Makefile

scripts/checks.m4

@@ -1,48 +1,3 @@
-AC_DEFUN([TORRENT_CHECK_XFS], [
-  AC_MSG_CHECKING(for XFS support)
-
-  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
-      #include <xfs/libxfs.h>
-      #include <sys/ioctl.h>
-      int main() {
-        struct xfs_flock64 l;
-        ioctl(0, XFS_IOC_RESVSP64, &l);
-        return 0;
-      }
-      ])],
-    [
-      AC_DEFINE(USE_XFS, 1, Use XFS filesystem stuff.)
-      AC_MSG_RESULT(yes)
-    ], [
-      AC_MSG_RESULT(no)
-    ])
-])
-
-
-AC_DEFUN([TORRENT_WITHOUT_XFS], [
-  AC_ARG_WITH(xfs,
-    AS_HELP_STRING([--without-xfs],[do not check for XFS filesystem support]),
-    [
-       if test "$withval" = "yes"; then
-        TORRENT_CHECK_XFS
-      fi
-    ], [
-        TORRENT_CHECK_XFS
-    ])
-])
-
-
-AC_DEFUN([TORRENT_WITH_XFS], [
-  AC_ARG_WITH(xfs,
-    AS_HELP_STRING([--with-xfs],[check for XFS filesystem support]),
-    [
-      if test "$withval" = "yes"; then
-        TORRENT_CHECK_XFS
-      fi
-    ])
-])
-
-
 AC_DEFUN([TORRENT_CHECK_EPOLL], [
   AC_MSG_CHECKING(for epoll support)
 
@@ -122,158 +77,9 @@ AC_DEFUN([TORRENT_WITHOUT_KQUEUE], [
 ])
 
 
-AC_DEFUN([TORRENT_CHECK_FALLOCATE], [
-  AC_MSG_CHECKING(for fallocate)
-
-  AC_LINK_IFELSE([AC_LANG_PROGRAM([[#define _GNU_SOURCE
-               #include <fcntl.h>
-              ]], [[ fallocate(0, FALLOC_FL_KEEP_SIZE, 0, 0); return 0;
-              ]])],[
-      AC_DEFINE(USE_FALLOCATE, 1, Linux's fallocate supported.)
-      AC_MSG_RESULT(yes)
-    ],[
-      AC_MSG_RESULT(no)
-    ])
-])
-
-
-AC_DEFUN([TORRENT_CHECK_POSIX_FALLOCATE], [
-  AC_MSG_CHECKING(for posix_fallocate)
-
-  AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <fcntl.h>
-              ]], [[ posix_fallocate(0, 0, 0);
-              ]])],[
-      AC_DEFINE(USE_POSIX_FALLOCATE, 1, posix_fallocate supported.)
-      AC_MSG_RESULT(yes)
-    ],[
-      AC_MSG_RESULT(no)
-    ])
-])
-
-
-AC_DEFUN([TORRENT_WITH_POSIX_FALLOCATE], [
-  AC_ARG_WITH(posix-fallocate,
-    AS_HELP_STRING([--with-posix-fallocate],[check for and use posix_fallocate to allocate files]),
-    [
-      if test "$withval" = "yes"; then
-        TORRENT_CHECK_POSIX_FALLOCATE
-      fi
-    ])
-])
-
-AC_DEFUN([TORRENT_CHECK_STATVFS], [
-  AC_CHECK_HEADERS(sys/vfs.h sys/statvfs.h sys/statfs.h)
-
-  AC_MSG_CHECKING(for statvfs)
-
-  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-      #if HAVE_SYS_VFS_H
-      #include <sys/vfs.h>
-      #endif
-      #if HAVE_SYS_STATVFS_H
-      #include <sys/statvfs.h>
-      #endif
-      #if HAVE_SYS_STATFS_H
-      #include <sys/statfs.h>
-      #endif
-    ]], [[
-      struct statvfs s; fsblkcnt_t c;
-      statvfs("", &s);
-      fstatvfs(0, &s);
-    ]])],[
-      AC_DEFINE(FS_STAT_FD, [fstatvfs(fd, &m_stat) == 0], Function to determine filesystem stats from fd)
-      AC_DEFINE(FS_STAT_FN, [statvfs(fn, &m_stat) == 0], Function to determine filesystem stats from filename)
-      AC_DEFINE(FS_STAT_STRUCT, [struct statvfs], Type of second argument to statfs function)
-      AC_DEFINE(FS_STAT_SIZE_TYPE, [unsigned long], Type of block size member in stat struct)
-      AC_DEFINE(FS_STAT_COUNT_TYPE, [fsblkcnt_t], Type of block count member in stat struct)
-      AC_DEFINE(FS_STAT_BLOCK_SIZE, [(m_stat.f_frsize)], Determine the block size)
-      AC_MSG_RESULT(ok)
-      have_stat_vfs=yes
-    ],[
-      AC_MSG_RESULT(no)
-      have_stat_vfs=no
-    ])
-])
-
-AC_DEFUN([TORRENT_CHECK_STATFS], [
-  AC_CHECK_HEADERS(sys/statfs.h)
-
-  AC_MSG_CHECKING(for statfs)
-
-  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-      #if HAVE_SYS_STATFS_H
-      #include <sys/statfs.h>
-      #endif
-    ]], [[
-      struct statfs s;
-      statfs("", &s);
-      fstatfs(0, &s);
-    ]])],[
-      AC_DEFINE(FS_STAT_FD, [fstatfs(fd, &m_stat) == 0], Function to determine filesystem stats from fd)
-      AC_DEFINE(FS_STAT_FN, [statfs(fn, &m_stat) == 0], Function to determine filesystem stats from filename)
-      AC_DEFINE(FS_STAT_STRUCT, [struct statfs], Type of second argument to statfs function)
-      AC_DEFINE(FS_STAT_SIZE_TYPE, [long], Type of block size member in stat struct)
-      AC_DEFINE(FS_STAT_COUNT_TYPE, [long], Type of block count member in stat struct)
-      AC_DEFINE(FS_STAT_BLOCK_SIZE, [(m_stat.f_bsize)], Determine the block size)
-      AC_MSG_RESULT(ok)
-      have_stat_vfs=yes
-    ],[
-      AC_MSG_RESULT(no)
-      have_stat_vfs=no
-    ])
-])
-
-AC_DEFUN([TORRENT_DISABLED_STATFS], [
-      AC_DEFINE(FS_STAT_FD, [(errno = ENOSYS) == 0], Function to determine filesystem stats from fd)
-      AC_DEFINE(FS_STAT_FN, [(errno = ENOSYS) == 0], Function to determine filesystem stats from filename)
-      AC_DEFINE(FS_STAT_STRUCT, [struct {blocksize_type  f_bsize; blockcount_type f_bavail;}], Type of second argument to statfs function)
-      AC_DEFINE(FS_STAT_SIZE_TYPE, [int], Type of block size member in stat struct)
-      AC_DEFINE(FS_STAT_COUNT_TYPE, [int], Type of block count member in stat struct)
-      AC_DEFINE(FS_STAT_BLOCK_SIZE, [(4096)], Determine the block size)
-      AC_MSG_RESULT(No filesystem stats available)
-])
-
-AC_DEFUN([TORRENT_WITHOUT_STATVFS], [
-  AC_ARG_WITH(statvfs,
-    AS_HELP_STRING([--without-statvfs],[don't try to use statvfs to find free diskspace]),
-    [
-      if test "$withval" = "yes"; then
-        TORRENT_CHECK_STATVFS
-      else
-        have_stat_vfs=no
-      fi
-    ],
-    [
-      TORRENT_CHECK_STATVFS
-    ])
-])
-
-AC_DEFUN([TORRENT_WITHOUT_STATFS], [
-  AC_ARG_WITH(statfs,
-    AS_HELP_STRING([--without-statfs],[don't try to use statfs to find free diskspace]),
-    [
-      if test "$have_stat_vfs" = "no"; then
-        if test "$withval" = "yes"; then
-          TORRENT_CHECK_STATFS
-        else
-          TORRENT_DISABLED_STATFS
-        fi
-      fi
-    ],
-    [
-      if test "$have_stat_vfs" = "no"; then
-        TORRENT_CHECK_STATFS
-        if test "$have_stat_vfs" = "no"; then
-          TORRENT_DISABLED_STATFS
-        fi
-      fi
-    ])
-])
-
-
 AC_DEFUN([TORRENT_WITH_ADDRESS_SPACE], [
   AC_ARG_WITH(address-space,
-    AS_HELP_STRING([--with-address-space=MB],[change the default address space size [[default=1024mb]]]),
+    AS_HELP_STRING([--with-address-space=MB],[change the default address space size [default=1024mb-or-32768mb]]),
     [
       if test ! -z $withval -a "$withval" != "yes" -a "$withval" != "no"; then
         AC_DEFINE_UNQUOTED(DEFAULT_ADDRESS_SPACE_SIZE, [$withval])
@@ -285,51 +91,48 @@ AC_DEFUN([TORRENT_WITH_ADDRESS_SPACE], [
       AC_CHECK_SIZEOF(long)
 
       if test $ac_cv_sizeof_long = 8; then
-        AC_DEFINE(DEFAULT_ADDRESS_SPACE_SIZE, 4096, Default address space size.)
+        AC_DEFINE(DEFAULT_ADDRESS_SPACE_SIZE, 32768, Default address space size.)
       else
         AC_DEFINE(DEFAULT_ADDRESS_SPACE_SIZE, 1024, Default address space size.)
       fi
     ])
 ])
 
-AC_DEFUN([TORRENT_WITH_FASTCGI], [
-  AC_ARG_WITH(fastcgi,
-    AS_HELP_STRING([--with-fastcgi=PATH],[enable FastCGI RPC support (DO NOT USE)]),
+
+AC_DEFUN([TORRENT_CHECK_ATOMIC], [
+  AC_MSG_CHECKING([whether 64-bit atomic operations require -latomic])
+  AC_LANG_PUSH(C++)
+
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <cstdint>
+                                    #include <atomic>]],
+                                    [[std::atomic<uint64_t> x(0);
+                                    return x.load();]])],
     [
-      AC_MSG_CHECKING([for FastCGI (DO NOT USE)])
+      AC_MSG_RESULT([no])
+      ATOMIC_LIBS=""
+    ],
+    [
+      save_LIBS="$LIBS"
+      LIBS="$LIBS -latomic"
 
-      if test "$withval" = "no"; then
-        AC_MSG_RESULT(no)
-
-      elif test "$withval" = "yes"; then
-        CXXFLAGS="$CXXFLAGS"
-	LIBS="$LIBS -lfcgi"
-
-        AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include <fcgiapp.h>
-        ]], [[ FCGX_Init(); ]])],[
-          AC_MSG_RESULT(ok)
-        ],[
-          AC_MSG_RESULT(not found)
-          AC_MSG_ERROR(Could not compile FastCGI test.)
+      AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <cstdint>
+                                        #include <atomic>]],
+                                        [[std::atomic<uint64_t> x(0);
+                                        return x.load();]])],
+        [
+          AC_MSG_RESULT([yes])
+          ATOMIC_LIBS="-latomic"
+        ],
+        [
+          AC_MSG_RESULT([unsupported])
+          AC_MSG_ERROR([Compiler target lacks proper 64-bit atomic support.])
         ])
 
-        AC_DEFINE(HAVE_FASTCGI, 1, Support for FastCGI.)
-
-      else
-        CXXFLAGS="$CXXFLAGS -I$withval/include"
-	LIBS="$LIBS -lfcgi -L$withval/lib"
-
-        AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include <fcgiapp.h>
-        ]], [[ FCGX_Init(); ]])],[
-          AC_MSG_RESULT(ok)
-        ],[
-          AC_MSG_RESULT(not found)
-          AC_MSG_ERROR(Could not compile FastCGI test.)
-        ])
-
-        AC_DEFINE(HAVE_FASTCGI, 1, Support for FastCGI.)
-      fi
+      LIBS="$save_LIBS"
     ])
+
+  AC_LANG_POP(C++)
+  AC_SUBST([ATOMIC_LIBS])
 ])
 
 
@@ -374,6 +177,7 @@ AC_DEFUN([TORRENT_WITH_XMLRPC_C], [
   ])
 ])
 
+
 AC_DEFUN([TORRENT_WITH_TINYXML2], [
   AC_MSG_CHECKING(for tinyxml2)
 
@@ -387,6 +191,7 @@ AC_DEFUN([TORRENT_WITH_TINYXML2], [
   ])
 ])
 
+
 AC_DEFUN([TORRENT_WITH_LUA], [
   AC_ARG_WITH(lua,
     AS_HELP_STRING([--with-lua],[enable LUA support]),
@@ -441,6 +246,7 @@ AC_DEFUN([TORRENT_WITH_INOTIFY], [
   AC_LANG_POP(C++)
 ])
 
+
 AC_DEFUN([TORRENT_CHECK_PTHREAD_SETNAME_NP], [
   AC_CHECK_HEADERS(pthread.h)
 
@@ -472,6 +278,7 @@ AC_DEFUN([TORRENT_CHECK_PTHREAD_SETNAME_NP], [
   ])
 ])
 
+
 AC_DEFUN([TORRENT_DISABLE_PTHREAD_SETNAME_NP], [
   AC_MSG_CHECKING([for pthread_setname_no])
 

scripts/common.m4

@@ -1,67 +1,3 @@
-AC_DEFUN([TORRENT_WITH_SYSROOT], [
-  AC_ARG_WITH(sysroot,
-    AS_HELP_STRING([--with-sysroot=PATH],
-      [compile and link with a specific sysroot]),
-    [
-      AC_MSG_CHECKING(for sysroot)
-
-      if test "$withval" = "no"; then
-        AC_MSG_RESULT(no)
-
-      elif test "$withval" = "yes"; then
-        AC_MSG_RESULT(not a path)
-        AC_MSG_ERROR(The sysroot option must point to a directory, like f.ex "/Developer/SDKs/MacOSX10.4u.sdk".)
-      else
-        AC_MSG_RESULT($withval)
-
-        CXXFLAGS="$CXXFLAGS -isysroot $withval"
-        LDFLAGS="$LDFLAGS -Wl,-syslibroot,$withval"
-      fi
-    ])
-])
-
-
-AC_DEFUN([TORRENT_REMOVE_UNWANTED],
-[
-  AC_REQUIRE([AC_PROG_GREP])
-  values_to_check=`for i in $2; do echo $i; done`
-  unwanted_values=`for i in $3; do echo $i; done`
-  if test -z "${unwanted_values}"; then
-    $1="$2"
-  else
-    result=`echo "${values_to_check}" | $GREP -Fvx -- "${unwanted_values}" | $GREP -v '^$'`
-    # join with spaces, squeeze repeats, and trim trailing space
-    $1=$(printf '%s\n' "$result" | tr '\n' ' ' | sed 's/  */ /g; s/ *$//')
-  fi
-])
-
-
-AC_DEFUN([TORRENT_ENABLE_ARCH], [
-  AC_ARG_ENABLE(arch,
-    AS_HELP_STRING([--enable-arch=ARCH],
-      [comma seprated list of architectures to compile for]),
-    [
-      AC_MSG_CHECKING(for target architectures)
-
-      if test "$enableval" = "yes"; then
-        AC_MSG_ERROR(no arch supplied)
-
-      elif test "$enableval" = "no"; then
-        AC_MSG_RESULT(using default)
-
-      else
-        AC_MSG_RESULT($enableval)
-
-        for i in `IFS=,; echo $enableval`; do
-          CFLAGS="$CFLAGS -march=$i"
-          CXXFLAGS="$CXXFLAGS -march=$i"
-          LDFLAGS="$LDFLAGS -march=$i"
-        done
-      fi
-    ])
-])
-
-
 AC_DEFUN([TORRENT_MINCORE_SIGNEDNESS], [
   AC_LANG_PUSH(C++)
   AC_MSG_CHECKING(signedness of mincore parameter)
@@ -90,7 +26,7 @@ AC_DEFUN([TORRENT_MINCORE_SIGNEDNESS], [
           AC_MSG_RESULT(signed)
         ],
         [
-          AC_MSG_ERROR([failed, do *not* attempt fix this with --disable-mincore unless you are running Win32.])
+          AC_MSG_ERROR([failed, do *not* attempt fix this with --disable-mincore unless you are running Win32 or OpenBSD.])
       ])
   ])
 
@@ -144,20 +80,6 @@ AC_DEFUN([TORRENT_CHECK_POSIX_FADVISE], [
   ])
 ])
 
-AC_DEFUN([TORRENT_CHECK_POPCOUNT], [
-  AC_MSG_CHECKING(for __builtin_popcount)
-
-  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
-      int f() { return __builtin_popcount(0); }
-    ])],
-    [
-      AC_MSG_RESULT(yes)
-      AC_DEFINE(USE_BUILTIN_POPCOUNT, 1, Use __builtin_popcount.)
-    ], [
-      AC_MSG_RESULT(no)
-  ])
-])
-
 AC_DEFUN([TORRENT_CHECK_CACHELINE], [
   AC_REQUIRE([AC_CANONICAL_HOST])
   AC_MSG_CHECKING([for target cacheline size])
@@ -227,74 +149,119 @@ AC_DEFUN([TORRENT_CHECK_CACHELINE], [
   esac
 ])
 
-AC_DEFUN([TORRENT_CHECK_ALIGNED], [
-  AC_MSG_CHECKING(the byte alignment)
 
-  AC_RUN_IFELSE([AC_LANG_SOURCE([
-      #include <inttypes.h>
-      int main() {
-        char buf@<:@8@:>@ = { 0, 0, 0, 0, 1, 0, 0, 0 };
-	int i;
-        for (i = 1; i < 4; ++i)
-	  if (*(uint32_t*)(buf + i) == 0) return -1;
-	return 0;
-	}
+AC_DEFUN([TORRENT_CHECK_CUSTOM_ENDIAN64], [
+  AC_CHECK_HEADERS([endian.h sys/endian.h libkern/OSByteOrder.h])
+  AC_C_BIGENDIAN
+
+  AH_TEMPLATE([CUSTOM_ENDIAN_HEADER], [The system header to include for endian conversions.])
+  AH_TEMPLATE([custom_ntohll], [Convert 64-bit integer from network to host byte order.])
+  AH_TEMPLATE([custom_htonll], [Convert 64-bit integer from host to network byte order.])
+
+  dnl 1. Initialize our header variable tracking
+  endian_header_file='<stdint.h>'
+
+  dnl 2. Test if native be64toh works natively via <endian.h> (Standard Linux/glibc)
+  AC_MSG_CHECKING([for native be64toh via endian.h])
+  AC_LINK_IFELSE([AC_LANG_SOURCE([
+      #include <stdint.h>
+      #ifdef HAVE_ENDIAN_H
+      #  include <endian.h>
+      #endif
+      int main() { uint64_t x = be64toh(1); return 0; }
+    ])],
+    [has_native_be64=yes; endian_header_file='<endian.h>'],
+    [has_native_be64=no]
+  )
+  AC_MSG_RESULT([$has_native_be64])
+
+  dnl 3. If missing, test if it works via <sys/endian.h> (True BSD systems like FreeBSD)
+  if test "$has_native_be64" = "no"; then
+    AC_MSG_CHECKING([for native be64toh via sys/endian.h])
+    AC_LINK_IFELSE([AC_LANG_SOURCE([
+        #include <stdint.h>
+        #ifdef HAVE_SYS_ENDIAN_H
+        #  include <sys/endian.h>
+        #endif
+        int main() { uint64_t x = be64toh(1); return 0; }
       ])],
-    [
-      AC_MSG_RESULT(none needed)
-    ], [
-      AC_DEFINE(USE_ALIGNED, 1, Require byte alignment)
-      AC_MSG_RESULT(required)
-  ])
+      [has_native_be64=yes; endian_header_file='<sys/endian.h>'],
+      [has_native_be64=no]
+    )
+    AC_MSG_RESULT([$has_native_be64])
+  fi
+
+  dnl 4. Route definitions cleanly based on actual testing results
+  if test "$has_native_be64" = "yes"; then
+    dnl Linux or true BSD environment
+    AC_DEFINE_UNQUOTED([CUSTOM_ENDIAN_HEADER], [$endian_header_file], [The header containing native endian macros.])
+    AC_DEFINE([custom_ntohll(x)], [(be64toh(x))], [Use native platform be64toh])
+    AC_DEFINE([custom_htonll(x)], [(htobe64(x))], [Use native platform htobe64])
+  else
+    dnl Fallback block: Check if we are on macOS using Apple's optimized hardware libraries
+    if test "$ac_cv_header_libkern_OSByteOrder_h" = "yes"; then
+      AC_DEFINE([CUSTOM_ENDIAN_HEADER], [<libkern/OSByteOrder.h>], [The header containing native endian macros.])
+      AC_DEFINE([custom_ntohll(x)], [(OSSwapBigToHostInt64(x))], [Map missing be64toh to macOS native swap])
+      AC_DEFINE([custom_htonll(x)], [(OSSwapHostToBigInt64(x))], [Map missing htobe64 to macOS native swap])
+    else
+      dnl Fallback for platforms with no built-in architecture macros (compiler built-ins)
+      AC_DEFINE([CUSTOM_ENDIAN_HEADER], [<stdint.h>], [The header containing native endian macros.])
+      if test "$ac_cv_c_bigendian" = "yes"; then
+        AC_DEFINE([custom_ntohll(x)], [((uint64_t)(x))], [Fallback 64-bit conversion.])
+        AC_DEFINE([custom_htonll(x)], [((uint64_t)(x))], [Fallback 64-bit conversion.])
+      else
+        AC_DEFINE([custom_ntohll(x)], [(__builtin_bswap64((uint64_t)(x)))], [Fallback 64-bit conversion.])
+        AC_DEFINE([custom_htonll(x)], [(__builtin_bswap64((uint64_t)(x)))], [Fallback 64-bit conversion.])
+      fi
+    fi
+  fi
 ])
 
 
-AC_DEFUN([TORRENT_ENABLE_ALIGNED], [
-  AC_ARG_ENABLE(aligned,
-    AS_HELP_STRING([--enable-aligned],
-      [enable alignment safe code [[default=check]]]),
-    [
-        if test "$enableval" = "yes"; then
-          AC_DEFINE(USE_ALIGNED, 1, Require byte alignment)
-        fi
-    ],[
-        TORRENT_CHECK_ALIGNED
-  ])
-])
-
-
-AC_DEFUN([TORRENT_DISABLE_INSTRUMENTATION], [
+AC_DEFUN([TORRENT_ENABLE_INSTRUMENTATION], [
   AC_MSG_CHECKING([if instrumentation should be included])
 
   AC_ARG_ENABLE(instrumentation,
-    AS_HELP_STRING([--disable-instrumentation],
-      [disable instrumentation [[default=enabled]]]),
+    AS_HELP_STRING([--enable-instrumentation],
+      [enable instrumentation [[default=disabled]]]),
     [
       if test "$enableval" = "yes"; then
         AC_DEFINE(LT_INSTRUMENTATION, 1, enable instrumentation)
-	AC_MSG_RESULT(yes)
+        AC_MSG_RESULT(yes)
       else
-	AC_MSG_RESULT(no)
+        AC_MSG_RESULT(no)
       fi
     ],[
-      AC_DEFINE(LT_INSTRUMENTATION, 1, enable instrumentation)
-      AC_MSG_RESULT(yes)
+      AC_MSG_RESULT(no)
     ])
 ])
 
 
-AC_DEFUN([TORRENT_ENABLE_INTERRUPT_SOCKET], [
-  AC_ARG_ENABLE(interrupt-socket,
-    AS_HELP_STRING([--enable-interrupt-socket],
-      [enable interrupt socket [[default=no]]]),
-    [
-      if test "$enableval" = "yes"; then
-        AC_DEFINE(USE_INTERRUPT_SOCKET, 1, Use interrupt socket instead of pthread_kill)
-      fi
-    ]
-  )
+AC_DEFUN([TORRENT_ENABLE_CUSTOM_STACK_SIZE], [
+  AC_ARG_ENABLE([pthread-setstacksize],
+    [AS_HELP_STRING([--enable-pthread-setstacksize], [explicitly set pthread stack size (auto-enabled for musl)])],
+    [enable_pthread_setstacksize=$enableval],
+    [enable_pthread_setstacksize=auto])
+
+  AC_CANONICAL_HOST
+  if test "x$enable_pthread_setstacksize" = "xauto"; then
+    case "$host" in
+      *-musl*)
+        enable_pthread_setstacksize=yes
+        ;;
+      *)
+        enable_pthread_setstacksize=no
+        ;;
+    esac
+  fi
+
+  if test "x$enable_pthread_setstacksize" = "xyes"; then
+    AC_DEFINE([USE_PTHREAD_SETSTACKSIZE], [1], [Use explicit pthread stack size])
+    AC_DEFINE([DEFAULT_PTHREAD_STACKSIZE], [(8 * 1024 * 1024)], [Default pthread stack size in bytes])
+  fi
 ])
 
+
 AC_DEFUN([TORRENT_DISABLE_IPV6], [
   AC_ARG_ENABLE(ipv6,
     AS_HELP_STRING([--enable-ipv6],

src/command_download.cc

@@ -9,7 +9,6 @@
 #include <torrent/rate.h>
 #include <torrent/throttle.h>
 #include <torrent/tracker/tracker.h>
-#include <torrent/connection_manager.h>
 #include <torrent/data/download_data.h>
 #include <torrent/data/file.h>
 #include <torrent/data/file_list.h>
@@ -164,8 +163,8 @@ apply_d_connection_type(core::Download* download, const std::string& name) {
 
 torrent::Object
 apply_d_choke_heuristics(core::Download* download, const std::string& name, bool is_down) {
-  torrent::Download::HeuristicType t =
-    (torrent::Download::HeuristicType)torrent::option_find_string(torrent::OPTION_CHOKE_HEURISTICS, name.c_str());
+  torrent::heuristics_enum t =
+    static_cast<torrent::heuristics_enum>(torrent::option_find_string(torrent::OPTION_CHOKE_HEURISTICS, name.c_str()));
 
   if (is_down)
     download->download()->set_download_choke_heuristic(t);

src/command_events.cc

@@ -329,42 +329,40 @@ directory_watch_ready(const torrent::Object::list_type& args) {
 
 void
 initialize_command_events() {
-  CMD2_ANY_STRING  ("on_ratio",        std::bind(&apply_on_ratio, std::placeholders::_2));
+  CMD2_ANY_STRING  ("on_ratio",                   [](auto, auto& args) { return apply_on_ratio(args); });
 
-  CMD2_ANY         ("start_tied",      std::bind(&apply_start_tied));
-  CMD2_ANY         ("stop_untied",     std::bind(&apply_stop_untied));
-  CMD2_ANY         ("close_untied",    std::bind(&apply_close_untied));
-  CMD2_ANY         ("remove_untied",   std::bind(&apply_remove_untied));
+  CMD2_ANY         ("start_tied",                 [](auto, auto) { return apply_start_tied(); });
+  CMD2_ANY         ("stop_untied",                [](auto, auto) { return apply_stop_untied(); });
+  CMD2_ANY         ("close_untied",               [](auto, auto) { return apply_close_untied(); });
+  CMD2_ANY         ("remove_untied",              [](auto, auto) { return apply_remove_untied(); });
 
-  // TODO: Deprecate schedule2 in the future.
-  CMD2_ANY_LIST    ("schedule",         std::bind(&apply_schedule, std::placeholders::_2));
-  CMD2_ANY_LIST    ("schedule2",        std::bind(&apply_schedule, std::placeholders::_2));
-  CMD2_ANY_STRING_V("schedule.remove",  std::bind(&rpc::CommandScheduler::erase_str, control->command_scheduler(), std::placeholders::_2));
-  CMD2_ANY_STRING_V("schedule_remove2", std::bind(&rpc::CommandScheduler::erase_str, control->command_scheduler(), std::placeholders::_2));
+  CMD2_ANY_LIST    ("schedule",                   [](auto, auto& args) { return apply_schedule(args); });
+  CMD2_ANY_STRING_V("schedule.remove",            [](auto, auto& str) { return control->command_scheduler()->erase_str(str); });
 
-  CMD2_ANY_STRING_V("import",          std::bind(&apply_import, std::placeholders::_2));
-  CMD2_ANY_STRING_V("try_import",      std::bind(&apply_try_import, std::placeholders::_2));
+  CMD2_ANY_STRING_V("import",                     [](auto, auto& str) { return apply_import(str); });
+  CMD2_ANY_STRING_V("try_import",                 [](auto, auto& str) { return apply_try_import(str); });
 
-  CMD2_ANY_LIST    ("load.normal",        std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_tied));
-  CMD2_ANY_LIST    ("load.verbose",       std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied));
-  CMD2_ANY_LIST    ("load.start",         std::bind(&apply_load, std::placeholders::_2,
-                                                         core::Manager::create_quiet | core::Manager::create_tied | core::Manager::create_start));
-  CMD2_ANY_LIST    ("load.start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied  | core::Manager::create_start));
-  CMD2_ANY_LIST    ("load.raw",           std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_raw_data));
-  CMD2_ANY_LIST    ("load.raw_verbose",   std::bind(&apply_load, std::placeholders::_2, core::Manager::create_raw_data));
-  CMD2_ANY_LIST    ("load.raw_start",     std::bind(&apply_load, std::placeholders::_2,
-                                                         core::Manager::create_quiet | core::Manager::create_start | core::Manager::create_raw_data));
-  CMD2_ANY_LIST    ("load.raw_start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_start | core::Manager::create_raw_data));
+  CMD2_ANY_LIST    ("load.normal",                [](auto, auto& args) { return apply_load(args, core::Manager::create_quiet | core::Manager::create_tied); });
+  CMD2_ANY_LIST    ("load.verbose",               [](auto, auto& args) { return apply_load(args, core::Manager::create_tied); });
+  CMD2_ANY_LIST    ("load.start",                 [](auto, auto& args) { return apply_load(args, core::Manager::create_quiet | core::Manager::create_tied | core::Manager::create_start); });
+  CMD2_ANY_LIST    ("load.start_verbose",         [](auto, auto& args) { return apply_load(args, core::Manager::create_tied | core::Manager::create_start); });
+  CMD2_ANY_LIST    ("load.raw",                   [](auto, auto& args) { return apply_load(args, core::Manager::create_quiet | core::Manager::create_raw_data); });
+  CMD2_ANY_LIST    ("load.raw_verbose",           [](auto, auto& args) { return apply_load(args, core::Manager::create_raw_data); });
+  CMD2_ANY_LIST    ("load.raw_start",             [](auto, auto& args) { return apply_load(args, core::Manager::create_quiet | core::Manager::create_start | core::Manager::create_raw_data); });
+  CMD2_ANY_LIST    ("load.raw_start_verbose",     [](auto, auto& args) { return apply_load(args, core::Manager::create_start | core::Manager::create_raw_data); });
 
-  CMD2_ANY_VALUE   ("close_low_diskspace",        std::bind(&apply_close_low_diskspace, std::placeholders::_2, 99));
-  CMD2_ANY_VALUE   ("close_low_diskspace.normal", std::bind(&apply_close_low_diskspace, std::placeholders::_2, 3));
+  CMD2_ANY_VALUE   ("close_low_diskspace",        [](auto, auto& arg) { return apply_close_low_diskspace(arg, 99); });
+  CMD2_ANY_VALUE   ("close_low_diskspace.normal", [](auto, auto& arg) { return apply_close_low_diskspace(arg, 3); });
 
-  CMD2_ANY_LIST    ("download_list",       std::bind(&apply_download_list, std::placeholders::_2));
-  CMD2_ANY_LIST    ("d.multicall2",        std::bind(&d_multicall, std::placeholders::_2));
-  CMD2_ANY_LIST    ("d.multicall.filtered", std::bind(&d_multicall_filtered, std::placeholders::_2));
+  CMD2_ANY_LIST    ("download_list",              [](auto, auto& args) { return apply_download_list(args); });
 
-  CMD2_ANY_LIST    ("directory.watch.added", std::bind(&directory_watch_added, std::placeholders::_2));
-  CMD2_ANY_LIST    ("directory.watch.ready", std::bind(&directory_watch_ready, std::placeholders::_2));
+  // TODO: Deprecate d.multicall2. (6/2026)
+  CMD2_ANY_LIST    ("d.multicall",                [](auto, auto& args) { return d_multicall(args); });
+  CMD2_ANY_LIST    ("d.multicall2",               [](auto, auto& args) { return d_multicall(args); });
+  CMD2_ANY_LIST    ("d.multicall.filtered",       [](auto, auto& args) { return d_multicall_filtered(args); });
+
+  CMD2_ANY_LIST    ("directory.watch.added",      [](auto, auto& args) { return directory_watch_added(args); });
+  CMD2_ANY_LIST    ("directory.watch.ready",      [](auto, auto& args) { return directory_watch_ready(args); });
 
   rpc::rpc.mark_safe("start_tied");
   rpc::rpc.mark_safe("stop_untied");
@@ -374,6 +372,7 @@ initialize_command_events() {
   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.multicall");
   rpc::rpc.mark_safe("d.multicall2");
   rpc::rpc.mark_safe("d.multicall.filtered");
 }

src/command_groups.cc

@@ -186,8 +186,8 @@ apply_cg_insert(const std::string& arg) {
   cg_list_hack.push_back(new torrent::choke_group());
   cg_list_hack.back()->set_name(arg);
 
-  cg_list_hack.back()->up_queue()->set_heuristics(torrent::choke_queue::HEURISTICS_UPLOAD_LEECH);
-  cg_list_hack.back()->down_queue()->set_heuristics(torrent::choke_queue::HEURISTICS_DOWNLOAD_LEECH);
+  cg_list_hack.back()->up_queue()->set_heuristics(torrent::HEURISTICS_UPLOAD_LEECH);
+  cg_list_hack.back()->down_queue()->set_heuristics(torrent::HEURISTICS_DOWNLOAD_LEECH);
 
   return torrent::Object();
 }

src/command_local.cc

@@ -114,9 +114,9 @@ group_insert(const torrent::Object::list_type& args) {
   const std::string& view = check_name(post_increment(itr, last)->as_string());
 
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.enable", "simple",
-                                                              "schedule2=group." + name + ".ratio,5,60,on_ratio=" + name));
+                                                              "schedule=group." + name + ".ratio,5,60,on_ratio=" + name));
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.disable", "simple",
-                                                              "schedule_remove2=group." + name + ".ratio"));
+                                                              "schedule_remove=group." + name + ".ratio"));
   rpc::commands.call("method.insert", rpc::create_object_list("group."  + name + ".ratio.command", "simple",
                                                               "d.try_close= ;d.ignore_commands.set=1"));
   rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".view", "string", view));
@@ -133,19 +133,6 @@ group_insert(const torrent::Object::list_type& args) {
   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:
-
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".view",             "group." + name + ".view");
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".view.set",         "group." + name + ".view.set");
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".ratio.min",        "group." + name + ".ratio.min");
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".ratio.min.set",    "group." + name + ".ratio.min.set");
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".ratio.max",        "group." + name + ".ratio.max");
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".ratio.max.set",    "group." + name + ".ratio.max.set");
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".ratio.upload",     "group." + name + ".ratio.upload");
-    CMD2_REDIRECT_MUTABLE("group2." + name + ".ratio.upload.set", "group." + name + ".ratio.upload.set");
-  }
-
   return name;
 }
 
@@ -203,6 +190,10 @@ initialize_command_local() {
   torrent::ChunkManager* chunkManager = torrent::chunk_manager();
   torrent::FileManager*  fileManager = torrent::file_manager();
 
+  if (rpc::call_command_value("method.use_deprecated") == 1) {
+    CMD2_ANY_LIST    ("file.append",    std::bind(&cmd_file_append, std::placeholders::_2));
+  }
+
   CMD2_ANY         ("system.hostname", std::bind(&system_hostname));
   CMD2_ANY         ("system.pid",      std::bind(&getpid));
 
@@ -310,8 +301,7 @@ initialize_command_local() {
 #define CMD2_EXECUTE(key, flags)                                        \
   CMD2_ANY(key, std::bind(&rpc::ExecFile::execute_object, &rpc::execFile, std::placeholders::_2, flags));
 
-  CMD2_EXECUTE     ("execute",                rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw);
-  CMD2_EXECUTE     ("execute2",                rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw);
+  CMD2_EXECUTE     ("execute",                 rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw);
   CMD2_EXECUTE     ("execute.throw",           rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw);
   CMD2_EXECUTE     ("execute.throw.bg",        rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw | rpc::ExecFile::flag_background);
   CMD2_EXECUTE     ("execute.nothrow",         rpc::ExecFile::flag_expand_tilde);
@@ -323,8 +313,6 @@ initialize_command_local() {
   CMD2_EXECUTE     ("execute.capture",         rpc::ExecFile::flag_throw | rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_capture);
   CMD2_EXECUTE     ("execute.capture_nothrow", rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_capture);
 
-  CMD2_ANY_LIST    ("file.append",    std::bind(&cmd_file_append, std::placeholders::_2));
-
   // TODO: Convert to new command types:
   *rpc::command_base::argument(0) = "placeholder.0";
   *rpc::command_base::argument(1) = "placeholder.1";

src/command_network.cc

@@ -61,8 +61,6 @@ apply_tos(const torrent::Object::string_type& arg) {
   return torrent::Object();
 }
 
-torrent::Object apply_encoding_list(const std::string& arg) { torrent::encoding_list()->push_back(arg); return torrent::Object(); }
-
 void
 initialize_rpc_handlers() {
   rpc::rpc.initialize_handlers();
@@ -221,8 +219,6 @@ initialize_command_network() {
   auto http_stack     = torrent::net_thread::http_stack();
   auto nw_config      = torrent::runtime::network_config();
 
-  CMD2_ANY_STRING  ("encoding.add", std::bind(&apply_encoding_list, std::placeholders::_2));
-
   // Isn't port_open used?
   CMD2_VAR_BOOL    ("network.port_open",   true);
   CMD2_VAR_BOOL    ("network.port_random", true);

src/command_throttle.cc

@@ -70,33 +70,35 @@ parse_address_range(const torrent::Object::list_type& args, torrent::Object::lis
 
 torrent::Object
 apply_throttle(const torrent::Object::list_type& args, bool up) {
-  torrent::Object::list_const_iterator argItr = args.begin();
+  auto arg_itr = args.begin();
 
-  if (argItr == args.end())
+  if (arg_itr == args.end())
     throw torrent::input_error("Missing throttle name.");
 
-  const std::string& name = argItr->as_string();
+  const std::string& name = arg_itr->as_string();
   if (name.empty() || name == "NULL")
     throw torrent::input_error("Invalid throttle name '" + name + "'.");
 
-  if (++argItr == args.end() || argItr->as_string().empty())
+  if (++arg_itr == args.end() || arg_itr->as_string().empty())
     throw torrent::input_error("Missing throttle rate for '" + name + "'.");
 
   int64_t rate;
-  rpc::parse_whole_value_nothrow(argItr->as_string().c_str(), &rate);
+  rpc::parse_whole_value_nothrow(arg_itr->as_string().c_str(), &rate);
 
   if (rate < 0)
     throw torrent::input_error("Throttle rate must be non-negative.");
 
-  core::ThrottleMap::iterator itr = control->core()->throttles().find(name);
-  if (itr == control->core()->throttles().end())
-    itr = control->core()->throttles().insert(std::make_pair(name, torrent::ThrottlePair(NULL, NULL))).first;
+  auto itr = control->core()->throttles().find(name);
 
-  torrent::Throttle*& throttle = up ? itr->second.first : itr->second.second;
-  if (rate != 0 && throttle == NULL)
+  if (itr == control->core()->throttles().end())
+    itr = control->core()->throttles().insert(std::make_pair(name, core::ThrottlePair(nullptr, nullptr))).first;
+
+  auto*& throttle = up ? itr->second.first : itr->second.second;
+
+  if (rate != 0 && throttle == nullptr)
     throttle = (up ? torrent::up_throttle_global() : torrent::down_throttle_global())->create_slave();
 
-  if (throttle != NULL)
+  if (throttle != nullptr)
     throttle->set_max_rate(rate * 1024);
 
   return torrent::Object();
@@ -109,10 +111,10 @@ static const int throttle_info_rate = (1 << 3);
 
 torrent::Object
 retrieve_throttle_info(const torrent::Object::string_type& name, int flags) {
-  core::ThrottleMap::iterator itr = control->core()->throttles().find(name);
-  torrent::ThrottlePair throttles = itr == control->core()->throttles().end() ? torrent::ThrottlePair(NULL, NULL) : itr->second;
-  torrent::Throttle* throttle = flags & throttle_info_down ? throttles.second : throttles.first;
-  torrent::Throttle* global = flags & throttle_info_down ? torrent::down_throttle_global() : torrent::up_throttle_global();
+  auto  itr       = control->core()->throttles().find(name);
+  auto  throttles = (itr == control->core()->throttles().end()) ? core::ThrottlePair(nullptr, nullptr) : itr->second;
+  auto* throttle  = flags & throttle_info_down ? throttles.second : throttles.first;
+  auto* global    = flags & throttle_info_down ? torrent::down_throttle_global() : torrent::up_throttle_global();
 
   if (throttle == NULL && name.empty())
     throttle = global;
@@ -127,20 +129,6 @@ retrieve_throttle_info(const torrent::Object::string_type& name, int flags) {
     return (int64_t)throttle->max_rate();
 }
 
-torrent::Object
-apply_address_throttle(const torrent::Object::list_type& args) {
-  if (args.size() < 2 || args.size() > 3)
-    throw torrent::input_error("Incorrect number of arguments.");
-
-  std::pair<uint32_t, uint32_t> range = parse_address_range(args, ++args.begin());
-  core::ThrottleMap::iterator throttleItr = control->core()->throttles().find(args.begin()->as_string().c_str());
-  if (throttleItr == control->core()->throttles().end())
-    throw torrent::input_error("Throttle not found.");
-
-  control->core()->set_address_throttle(range.first, range.second, throttleItr->second);
-  return torrent::Object();
-}
-
 torrent::Object
 throttle_update(const char* variable, int64_t value) {
   rpc::commands.call_command(variable, value);
@@ -198,7 +186,6 @@ initialize_command_throttle() {
   // than kB.
   CMD2_ANY_LIST    ("throttle.up",                          std::bind(&apply_throttle, std::placeholders::_2, true));
   CMD2_ANY_LIST    ("throttle.down",                        std::bind(&apply_throttle, std::placeholders::_2, false));
-  CMD2_ANY_LIST    ("throttle.ip",                          std::bind(&apply_address_throttle, std::placeholders::_2));
 
   CMD2_ANY_STRING  ("throttle.up.max",    std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_max));
   CMD2_ANY_STRING  ("throttle.up.rate",   std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_rate));

src/command_tracker.cc

@@ -81,73 +81,71 @@ apply_enable_trackers(int64_t arg) {
 
 void
 initialize_command_tracker() {
-  CMD2_TRACKER        ("t.is_busy",           std::bind(&torrent::tracker::Tracker::is_requesting, std::placeholders::_1));
-  CMD2_TRACKER        ("t.is_enabled",        std::bind(&torrent::tracker::Tracker::is_enabled, std::placeholders::_1));
-  CMD2_TRACKER        ("t.is_extra_tracker",  std::bind(&torrent::tracker::Tracker::is_extra_tracker, std::placeholders::_1));
-  CMD2_TRACKER        ("t.is_open",           std::bind(&torrent::tracker::Tracker::is_requesting, std::placeholders::_1));
-  CMD2_TRACKER        ("t.is_scrapable",      std::bind(&torrent::tracker::Tracker::is_scrapable, std::placeholders::_1));
-  CMD2_TRACKER        ("t.is_usable",         std::bind(&torrent::tracker::Tracker::is_usable, std::placeholders::_1));
+  CMD2_TRACKER        ("t.is_busy",            [](auto* tracker, auto) { return tracker->is_requesting(); });
+  CMD2_TRACKER        ("t.is_enabled",         [](auto* tracker, auto) { return tracker->is_enabled(); });
+  CMD2_TRACKER        ("t.is_extra_tracker",   [](auto* tracker, auto) { return tracker->is_extra_tracker(); });
+  CMD2_TRACKER        ("t.is_open",            [](auto* tracker, auto) { return tracker->is_requesting(); });
+  CMD2_TRACKER        ("t.is_scrapable",       [](auto* tracker, auto) { return tracker->is_scrapable(); });
+  CMD2_TRACKER        ("t.is_usable",          [](auto* tracker, auto) { return tracker->is_usable(); });
 
   // TODO: Deprecate.
-  CMD2_TRACKER        ("t.can_scrape",        std::bind(&torrent::tracker::Tracker::is_scrapable, std::placeholders::_1));
+  CMD2_TRACKER        ("t.can_scrape",         [](auto* tracker, auto) { return tracker->is_scrapable(); });
 
-  CMD2_TRACKER_V      ("t.enable",            std::bind(&torrent::tracker::Tracker::enable, std::placeholders::_1));
-  CMD2_TRACKER_V      ("t.disable",           std::bind(&torrent::tracker::Tracker::disable, std::placeholders::_1));
+  CMD2_TRACKER_V      ("t.enable",             [](auto* tracker, auto) { tracker->enable(); });
+  CMD2_TRACKER_V      ("t.disable",            [](auto* tracker, auto) { tracker->disable(); });
 
-  CMD2_TRACKER_VALUE_V("t.is_enabled.set",    std::bind(&tracker_set_enabled, std::placeholders::_1, std::placeholders::_2));
+  CMD2_TRACKER_VALUE_V("t.is_enabled.set",     [](auto* tracker, auto& value) { return tracker_set_enabled(tracker, value); });
 
-  CMD2_TRACKER        ("t.url",               std::bind(&torrent::tracker::Tracker::url, std::placeholders::_1));
-  CMD2_TRACKER        ("t.group",             std::bind(&torrent::tracker::Tracker::group, std::placeholders::_1));
-  CMD2_TRACKER        ("t.type",              std::bind(&torrent::tracker::Tracker::type, std::placeholders::_1));
-  CMD2_TRACKER        ("t.id",                std::bind(&torrent::tracker::Tracker::tracker_id, std::placeholders::_1));
+  CMD2_TRACKER        ("t.url",                [](auto* tracker, auto) { return tracker->url(); });
+  CMD2_TRACKER        ("t.group",              [](auto* tracker, auto) { return tracker->group(); });
+  CMD2_TRACKER        ("t.type",               [](auto* tracker, auto) { return tracker->type(); });
+  CMD2_TRACKER        ("t.id",                 [](auto* tracker, auto) { return tracker->tracker_id(); });
 
-  CMD2_TRACKER        ("t.latest_event",      [](auto* tracker, auto) { return tracker->state().latest_event(); });
-  CMD2_TRACKER        ("t.latest_new_peers",  [](auto* tracker, auto) { return tracker->state().latest_new_peers(); });
-  CMD2_TRACKER        ("t.latest_sum_peers",  [](auto* tracker, auto) { return tracker->state().latest_sum_peers(); });
+  CMD2_TRACKER        ("t.latest_event",       [](auto* tracker, auto) { return tracker->state().latest_event(); });
+  CMD2_TRACKER        ("t.latest_new_peers",   [](auto* tracker, auto) { return tracker->state().latest_new_peers(); });
+  CMD2_TRACKER        ("t.latest_sum_peers",   [](auto* tracker, auto) { return tracker->state().latest_sum_peers(); });
 
-  CMD2_TRACKER        ("t.normal_interval",   [](auto* tracker, auto) { return tracker->state().normal_interval(); });
-  CMD2_TRACKER        ("t.min_interval",      [](auto* tracker, auto) { return tracker->state().min_interval(); });
+  CMD2_TRACKER        ("t.normal_interval",    [](auto* tracker, auto) { return tracker->state().normal_interval().count(); });
+  CMD2_TRACKER        ("t.min_interval",       [](auto* tracker, auto) { return tracker->state().min_interval().count(); });
 
-  CMD2_TRACKER        ("t.activity_time_next", [](auto* tracker, auto) { return tracker->state().activity_time_next(); });
-  CMD2_TRACKER        ("t.activity_time_last", [](auto* tracker, auto) { return tracker->state().activity_time_last(); });
+  CMD2_TRACKER        ("t.activity_time_next", [](auto* tracker, auto) { return tracker->state().activity_time_next().count(); });
+  CMD2_TRACKER        ("t.activity_time_last", [](auto* tracker, auto) { return tracker->state().activity_time_last().count(); });
 
-  CMD2_TRACKER        ("t.success_time_next", [](auto* tracker, auto) { return tracker->state().success_time_next(); });
-  CMD2_TRACKER        ("t.success_time_last", [](auto* tracker, auto) { return tracker->state().success_time_last(); });
-  CMD2_TRACKER        ("t.success_counter",   [](auto* tracker, auto) { return tracker->state().success_counter(); });
+  CMD2_TRACKER        ("t.success_time_next",  [](auto* tracker, auto) { return tracker->state().success_time_next().count(); });
+  CMD2_TRACKER        ("t.success_time_last",  [](auto* tracker, auto) { return tracker->state().success_time_last().count(); });
+  CMD2_TRACKER        ("t.success_counter",    [](auto* tracker, auto) { return tracker->state().success_counter(); });
 
-  CMD2_TRACKER        ("t.failed_time_next",  [](auto* tracker, auto) { return tracker->state().failed_time_next(); });
-  CMD2_TRACKER        ("t.failed_time_last",  [](auto* tracker, auto) { return tracker->state().failed_time_last(); });
-  CMD2_TRACKER        ("t.failed_counter",    [](auto* tracker, auto) { return tracker->state().failed_counter(); });
+  CMD2_TRACKER        ("t.failed_time_next",   [](auto* tracker, auto) { return tracker->state().failed_time_next().count(); });
+  CMD2_TRACKER        ("t.failed_time_last",   [](auto* tracker, auto) { return tracker->state().failed_time_last().count(); });
+  CMD2_TRACKER        ("t.failed_counter",     [](auto* tracker, auto) { return tracker->state().failed_counter(); });
 
-  CMD2_TRACKER        ("t.scrape_time_last",  [](auto* tracker, auto) { return tracker->state().scrape_time_last(); });
-  CMD2_TRACKER        ("t.scrape_counter",    [](auto* tracker, auto) { return tracker->state().scrape_counter(); });
+  CMD2_TRACKER        ("t.scrape_time_last",   [](auto* tracker, auto) { return tracker->state().scrape_time_last().count(); });
+  CMD2_TRACKER        ("t.scrape_counter",     [](auto* tracker, auto) { return tracker->state().scrape_counter(); });
 
-  CMD2_TRACKER        ("t.scrape_complete",   [](auto* tracker, auto) { return tracker->state().scrape_complete(); });
-  CMD2_TRACKER        ("t.scrape_incomplete", [](auto* tracker, auto) { return tracker->state().scrape_incomplete(); });
-  CMD2_TRACKER        ("t.scrape_downloaded", [](auto* tracker, auto) { return tracker->state().scrape_downloaded(); });
+  CMD2_TRACKER        ("t.scrape_complete",    [](auto* tracker, auto) { return tracker->state().scrape_complete(); });
+  CMD2_TRACKER        ("t.scrape_incomplete",  [](auto* tracker, auto) { return tracker->state().scrape_incomplete(); });
+  CMD2_TRACKER        ("t.scrape_downloaded",  [](auto* tracker, auto) { return tracker->state().scrape_downloaded(); });
 
-  CMD2_ANY_VALUE      ("trackers.enable",     std::bind(&apply_enable_trackers, int64_t(1)));
-  CMD2_ANY_VALUE      ("trackers.disable",    std::bind(&apply_enable_trackers, int64_t(0)));
+  CMD2_ANY_VALUE      ("trackers.enable",      [](auto, auto)          { return apply_enable_trackers(1); });
+  CMD2_ANY_VALUE      ("trackers.disable",     [](auto, auto)          { return apply_enable_trackers(0); });
   CMD2_VAR_BOOL       ("trackers.delay_scrape", false);
-  CMD2_VAR_VALUE      ("trackers.numwant",    -1);
+  CMD2_VAR_VALUE      ("trackers.numwant",      -1);
 
   CMD2_ANY            ("trackers.use_udp",     [](auto, auto) { return true; });
   CMD2_ANY_VALUE_V    ("trackers.use_udp.set", [](auto, auto) {
       lt_log_print(torrent::LOG_ERROR, "trackers.use_udp.set is no longer supported", 0);
     })
 
-  auto dht_manager = control->dht_manager();
-
-  CMD2_ANY_STRING_V   ("dht.mode.set",          std::bind(&core::DhtManager::set_mode, control->dht_manager(), std::placeholders::_2));
-  CMD2_ANY            ("dht.port",              [](auto, auto) { return torrent::runtime::network_manager()->dht_controller()->port(); });
+  CMD2_ANY_STRING_V   ("dht.mode.set",          [](auto, auto& str) { return control->dht_manager()->set_mode_by_user(str); });
+  CMD2_ANY            ("dht.port",              [](auto, auto)      { return torrent::runtime::network_manager()->dht_controller()->port(); });
   CMD2_ANY_VALUE_V    ("dht.port.set",          [](auto, auto) {
       lt_log_print(torrent::LOG_DHT_ERROR, "dht.port.set is no longer supported, use dht.override_port.set", 0);
     });
-  CMD2_ANY            ("dht.override_port",     std::bind(&torrent::runtime::NetworkConfig::override_dht_port, torrent::runtime::network_config()));
-  CMD2_ANY_VALUE_V    ("dht.override_port.set", std::bind(&torrent::runtime::NetworkConfig::set_override_dht_port, torrent::runtime::network_config(), std::placeholders::_2));
+  CMD2_ANY            ("dht.override_port",     [](auto, auto)        { return torrent::runtime::network_config()->override_dht_port(); });
+  CMD2_ANY_VALUE_V    ("dht.override_port.set", [](auto, auto& value) { return torrent::runtime::network_config()->set_override_dht_port(value); });
 
-  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));
+  CMD2_ANY_STRING     ("dht.add_node",          [](auto, auto& str)   { return apply_dht_add_node(str); });
+  CMD2_ANY            ("dht.statistics",        [](auto, auto)        { return control->dht_manager()->dht_statistics(); });
 
   rpc::rpc.mark_safe("t.url");
   rpc::rpc.mark_safe("t.group");

src/command_ui.cc

@@ -795,61 +795,59 @@ apply_set_color(int color_id, const torrent::Object::string_type& color_str) {
 
 void
 initialize_command_ui() {
-  CMD2_VAR_STRING("keys.layout", "qwerty");
+  CMD2_VAR_STRING  ("keys.layout", "qwerty");
 
-  CMD2_ANY_STRING("view.add", object_convert_void(std::bind(&core::ViewManager::insert_throw, control->view_manager(), std::placeholders::_2)));
+  CMD2_ANY_STRING  ("view.add", object_convert_void(std::bind(&core::ViewManager::insert_throw, control->view_manager(), std::placeholders::_2)));
 
-  CMD2_ANY_L   ("view.list",          std::bind(&apply_view_list));
-  CMD2_ANY_LIST("view.set",           std::bind(&apply_view_set, std::placeholders::_2));
+  CMD2_ANY_L       ("view.list",          std::bind(&apply_view_list));
+  CMD2_ANY_LIST    ("view.set",           std::bind(&apply_view_set, std::placeholders::_2));
 
-  CMD2_ANY_LIST  ("view.filter",      std::bind(&apply_view_event, &core::ViewManager::set_filter, std::placeholders::_2));
-  CMD2_ANY_LIST  ("view.filter_on",   std::bind(&apply_view_filter_on, std::placeholders::_2));
-  CMD2_ANY_LIST  ("view.filter.temp", std::bind(&apply_view_event, &core::ViewManager::set_filter_temp, std::placeholders::_2));
-  CMD2_VAR_STRING("view.filter.temp.excluded", "default,started,stopped");
-  CMD2_VAR_BOOL  ("view.filter.temp.log", 0);
+  CMD2_ANY_LIST    ("view.filter",      std::bind(&apply_view_event, &core::ViewManager::set_filter, std::placeholders::_2));
+  CMD2_ANY_LIST    ("view.filter_on",   std::bind(&apply_view_filter_on, std::placeholders::_2));
+  CMD2_ANY_LIST    ("view.filter.temp", std::bind(&apply_view_event, &core::ViewManager::set_filter_temp, std::placeholders::_2));
+  CMD2_VAR_STRING  ("view.filter.temp.excluded", "default,started,stopped");
+  CMD2_VAR_BOOL    ("view.filter.temp.log", 0);
 
-  CMD2_ANY_LIST("view.sort",          std::bind(&apply_view_sort, std::placeholders::_2));
-  CMD2_ANY_LIST("view.sort_new",      std::bind(&apply_view_event, &core::ViewManager::set_sort_new, std::placeholders::_2));
-  CMD2_ANY_LIST("view.sort_current",  std::bind(&apply_view_event, &core::ViewManager::set_sort_current, std::placeholders::_2));
+  CMD2_ANY_LIST    ("view.sort",          std::bind(&apply_view_sort, std::placeholders::_2));
+  CMD2_ANY_LIST    ("view.sort_new",      std::bind(&apply_view_event, &core::ViewManager::set_sort_new, std::placeholders::_2));
+  CMD2_ANY_LIST    ("view.sort_current",  std::bind(&apply_view_event, &core::ViewManager::set_sort_current, std::placeholders::_2));
 
-  CMD2_ANY_LIST("view.event_added",   std::bind(&apply_view_event, &core::ViewManager::set_event_added, std::placeholders::_2));
-  CMD2_ANY_LIST("view.event_removed", std::bind(&apply_view_event, &core::ViewManager::set_event_removed, std::placeholders::_2));
+  CMD2_ANY_LIST    ("view.event_added",   std::bind(&apply_view_event, &core::ViewManager::set_event_added, std::placeholders::_2));
+  CMD2_ANY_LIST    ("view.event_removed", std::bind(&apply_view_event, &core::ViewManager::set_event_removed, std::placeholders::_2));
 
-  // Cleanup and add . to view.
-
-  CMD2_ANY_STRING("view.size",              std::bind(&cmd_view_size, std::placeholders::_2));
-  CMD2_ANY_STRING("view.size_not_visible",  std::bind(&cmd_view_size_not_visible, std::placeholders::_2));
-  CMD2_ANY_STRING("view.persistent",        std::bind(&cmd_view_persistent, std::placeholders::_2));
+  CMD2_ANY_STRING  ("view.size",              std::bind(&cmd_view_size, std::placeholders::_2));
+  CMD2_ANY_STRING  ("view.size_not_visible",  std::bind(&cmd_view_size_not_visible, std::placeholders::_2));
+  CMD2_ANY_STRING  ("view.persistent",        std::bind(&cmd_view_persistent, std::placeholders::_2));
 
   CMD2_ANY_STRING_V("view.filter_all",      std::bind(&core::View::filter, std::bind(&core::ViewManager::find_ptr_throw, control->view_manager(), std::placeholders::_2)));
 
-  CMD2_DL_STRING ("view.filter_download", std::bind(&cmd_view_filter_download, std::placeholders::_1, std::placeholders::_2));
-  CMD2_DL_STRING ("view.set_visible",     std::bind(&cmd_view_set_visible,     std::placeholders::_1, std::placeholders::_2));
-  CMD2_DL_STRING ("view.set_not_visible", std::bind(&cmd_view_set_not_visible, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_STRING   ("view.filter_download", std::bind(&cmd_view_filter_download, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_STRING   ("view.set_visible",     std::bind(&cmd_view_set_visible,     std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_STRING   ("view.set_not_visible", std::bind(&cmd_view_set_not_visible, std::placeholders::_1, std::placeholders::_2));
 
   // Commands that affect the default rtorrent UI.
-  CMD2_DL        ("ui.unfocus_download",   std::bind(&cmd_ui_unfocus_download, std::placeholders::_1));
-  CMD2_ANY       ("ui.current_view",       std::bind(&cmd_ui_current_view));
-  CMD2_ANY_STRING("ui.current_view.set",   std::bind(&cmd_ui_set_view, std::placeholders::_2));
+  CMD2_DL          ("ui.unfocus_download",   std::bind(&cmd_ui_unfocus_download, std::placeholders::_1));
+  CMD2_ANY         ("ui.current_view",       std::bind(&cmd_ui_current_view));
+  CMD2_ANY_STRING  ("ui.current_view.set",   std::bind(&cmd_ui_set_view, std::placeholders::_2));
 
-  CMD2_ANY        ("ui.input.history.size",     std::bind(&ui::Root::get_input_history_size, control->ui()));
-  CMD2_ANY_VALUE_V("ui.input.history.size.set", std::bind(&ui::Root::set_input_history_size, control->ui(), std::placeholders::_2));
-  CMD2_ANY_V      ("ui.input.history.clear",    std::bind(&ui::Root::clear_input_history, control->ui()));
+  CMD2_ANY         ("ui.input.history.size",     std::bind(&ui::Root::get_input_history_size, control->ui()));
+  CMD2_ANY_VALUE_V ("ui.input.history.size.set", std::bind(&ui::Root::set_input_history_size, control->ui(), std::placeholders::_2));
+  CMD2_ANY_V       ("ui.input.history.clear",    std::bind(&ui::Root::clear_input_history, control->ui()));
 
-  CMD2_VAR_VALUE ("ui.throttle.global.step.small",  5);
-  CMD2_VAR_VALUE ("ui.throttle.global.step.medium", 50);
-  CMD2_VAR_VALUE ("ui.throttle.global.step.large",  500);
+  CMD2_VAR_VALUE   ("ui.throttle.global.step.small",  5);
+  CMD2_VAR_VALUE   ("ui.throttle.global.step.medium", 50);
+  CMD2_VAR_VALUE   ("ui.throttle.global.step.large",  500);
 
-  CMD2_VAR_VALUE ("ui.focus.page_size", 0);
+  CMD2_VAR_VALUE   ("ui.focus.page_size", 0);
 
-  CMD2_ANY_LIST  ("ui.status.throttle.up.set",   std::bind(&cmd_status_throttle_names, true, std::placeholders::_2));
-  CMD2_ANY_LIST  ("ui.status.throttle.down.set", std::bind(&cmd_status_throttle_names, false, std::placeholders::_2));
+  CMD2_ANY_LIST    ("ui.status.throttle.up.set",   std::bind(&cmd_status_throttle_names, true, std::placeholders::_2));
+  CMD2_ANY_LIST    ("ui.status.throttle.down.set", std::bind(&cmd_status_throttle_names, false, std::placeholders::_2));
 
   CMD2_ANY         ("ui.keymap.style",     std::bind(&ui::Root::keymap_style, control->ui()));
   CMD2_ANY_STRING_V("ui.keymap.style.set", std::bind(&ui::Root::set_keymap_style, control->ui(), std::placeholders::_2));
 
   // TODO: Add 'option_string' for rtorrent-specific options.
-  CMD2_VAR_STRING("ui.torrent_list.layout", "full");
+  CMD2_VAR_STRING  ("ui.torrent_list.layout", "full");
 
   // Move.
   CMD2_ANY("print", &apply_print);

src/core/dht_manager.cc

@@ -140,24 +140,43 @@ DhtManager::save_dht_cache() {
 }
 
 void
-DhtManager::set_mode(const std::string& arg) {
-  int i;
-  for (i = 0; i < dht_settings_num; i++) {
+DhtManager::set_mode_by_user(const std::string& arg) {
+  for (int i = 0; i < dht_settings_num; i++) {
     if (arg == dht_settings[i]) {
-      m_start = i;
-      break;
+      m_set_by_user = true;
+      return set_mode_directly(i);
     }
   }
+}
 
-  if (i == dht_settings_num)
+void
+DhtManager::set_mode_directly(unsigned int mode) {
+  if (mode >= dht_settings_num)
     throw torrent::input_error("Invalid argument.");
 
+  m_start = mode;
+
   if (m_start == dht_off)
     stop_dht();
   else if (m_start == dht_on)
     start_dht();
 }
 
+void
+DhtManager::set_auto_if_untouched_and_has_session() {
+  if (m_set_by_user)
+    return;
+
+  if (rpc::call_command_string("session.path").empty()) {
+    LT_LOG("DHT auto-start disabled, session path not set.", 0);
+    return;
+  }
+
+  set_mode_directly(dht_auto);
+
+  LT_LOG("DHT auto-start enabled.", 0);
+}
+
 void
 DhtManager::update() {
   if (!torrent::runtime::network_manager()->is_dht_active())

src/core/dht_manager.h

@@ -8,6 +8,11 @@ namespace core {
 
 class DhtManager {
 public:
+  static constexpr int dht_disable = 0;
+  static constexpr int dht_off     = 1;
+  static constexpr int dht_auto    = 2;
+  static constexpr int dht_on      = 3;
+
   ~DhtManager();
 
   void                load_dht_cache();
@@ -18,16 +23,14 @@ public:
   void                stop_dht();
   void                auto_start()                 { if (m_start == dht_auto) start_dht(); }
 
-  void                set_mode(const std::string& arg);
+  void                set_mode_by_user(const std::string& arg);
+  void                set_mode_directly(unsigned int mode);
+
+  void                set_auto_if_untouched_and_has_session();
 
 private:
-  static const int    dht_disable = 0;
-  static const int    dht_off     = 1;
-  static const int    dht_auto    = 2;
-  static const int    dht_on      = 3;
-
-  static const int    dht_settings_num = 4;
-  static const char*  dht_settings[dht_settings_num];
+  static constexpr int dht_settings_num = 4;
+  static const char*   dht_settings[dht_settings_num];
 
   void                update();
   bool                log_statistics(bool force);
@@ -43,6 +46,7 @@ private:
   torrent::utils::SchedulerEntry m_stop_timeout;
 
   bool                m_warned{};
+  bool                m_set_by_user{};
   int                 m_start{dht_off};
 };
 

src/core/download.cc

@@ -88,15 +88,16 @@ Download::distributed_copies() const {
 }
 
 void
-Download::set_throttle_name(const std::string& throttleName) {
+Download::set_throttle_name(const std::string& name) {
   if (m_download.info()->is_active())
     throw torrent::input_error("Cannot set throttle on active download.");
 
-  torrent::ThrottlePair throttles = control->core()->get_throttle(throttleName);
+  auto throttles = control->core()->get_throttle(name);
+
   m_download.set_upload_throttle(throttles.first);
   m_download.set_download_throttle(throttles.second);
 
-  m_download.bencode()->get_key("rtorrent").insert_key("throttle_name", throttleName);
+  m_download.bencode()->get_key("rtorrent").insert_key("throttle_name", name);
 }
 
 void

src/core/download.h

@@ -22,6 +22,8 @@ public:
   typedef torrent::ConnectionList       connection_list_type;
   typedef download_type::ConnectionType connection_type;
 
+  static constexpr uint32_t default_resume_flags = ~uint32_t{} & ~torrent::Download::open_enable_fallocate;
+
   static const int variable_hashing_stopped = 0;
   static const int variable_hashing_initial = 1;
   static const int variable_hashing_last    = 2;
@@ -78,7 +80,7 @@ public:
 
   void                set_root_directory(const std::string& path);
 
-  void                set_throttle_name(const std::string& throttleName);
+  void                set_throttle_name(const std::string& name);
 
   bool                operator == (const std::string& str) const;
 
@@ -100,7 +102,7 @@ private:
   download_type       m_download;
   bool                m_hashFailed{};
   std::string         m_message;
-  uint32_t            m_resumeFlags{~uint32_t{}};
+  uint32_t            m_resumeFlags{default_resume_flags};
   unsigned int        m_group{};
 };
 

src/core/download_list.cc

@@ -331,7 +331,7 @@ DownloadList::resume(Download* download, int flags) {
 
     // We need to make sure the flags aren't reset if someone decideds
     // to call resume() while it is hashing, etc.
-    if (download->resume_flags() == ~uint32_t())
+    if (download->resume_flags() == Download::default_resume_flags)
       download->set_resume_flags(flags);
 
     // Manual or end-of-download rehashing clears the resume data so
@@ -404,7 +404,7 @@ DownloadList::resume(Download* download, int flags) {
     download->set_priority(download->priority());
     download->download()->start(download->resume_flags());
 
-    download->set_resume_flags(~uint32_t());
+    download->set_resume_flags(Download::default_resume_flags);
 
     DL_TRIGGER_EVENT(download, "event.download.resumed");
 
@@ -421,7 +421,7 @@ DownloadList::pause(Download* download, int flags) {
 
   try {
 
-    download->set_resume_flags(~uint32_t());
+    download->set_resume_flags(Download::default_resume_flags);
 
     rpc::parse_command_single(rpc::make_target(download), "view.set_not_visible=active");
 
@@ -492,7 +492,11 @@ DownloadList::hash_done(Download* download) {
 
   if (!download->is_hash_checked()) {
     download->set_hash_failed(true);
-    
+
+    auto& msg = download->download()->hash_error_message();
+    if (!msg.empty())
+      download->set_message(msg);
+
     DL_TRIGGER_EVENT(download, "event.download.hash_failed");
     return;
   }
@@ -656,8 +660,8 @@ 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().");
+//   if (download->resume_flags() != Download::default_resume_flags)
+//     throw torrent::internal_error("DownloadList::confirm_finished(...) download->resume_flags() != Download::default_resume_flags.");
 
   // See #1292.
   //
@@ -667,7 +671,7 @@ DownloadList::confirm_finished(Download* download) {
   //
   // TODO: Add a check when setting the flags to see if the torrent is
   // being hashed.
-  download->set_resume_flags(~uint32_t());
+  download->set_resume_flags(Download::default_resume_flags);
 
   if (!download->is_active() && rpc::call_command_value("d.state", rpc::make_target(download)) == 1)
     resume(download,

src/core/manager.cc

@@ -11,7 +11,6 @@
 #include <rak/regex.h>
 #include <torrent/utils/resume.h>
 #include <torrent/object.h>
-#include <torrent/connection_manager.h>
 #include <torrent/exceptions.h>
 #include <torrent/object_stream.h>
 #include <torrent/throttle.h>
@@ -87,10 +86,10 @@ Manager::set_hashing_view(View* v) {
   m_hashingView->signal_changed().push_back(std::bind(&Manager::receive_hashing_changed, this));
 }
 
-torrent::ThrottlePair
+ThrottlePair
 Manager::get_throttle(const std::string& name) {
-  ThrottleMap::const_iterator itr = m_throttles.find(name);
-  torrent::ThrottlePair throttles = (itr == m_throttles.end() ? torrent::ThrottlePair(nullptr, nullptr) : itr->second);
+  auto itr       = m_throttles.find(name);
+  auto throttles = (itr == m_throttles.end() ? ThrottlePair(nullptr, nullptr) : itr->second);
 
   if (throttles.first == nullptr)
     throttles.first = torrent::up_throttle_global();
@@ -101,20 +100,6 @@ Manager::get_throttle(const std::string& name) {
   return throttles;
 }
 
-void
-Manager::set_address_throttle(uint32_t begin, uint32_t end, torrent::ThrottlePair throttles) {
-  m_addressThrottles.set_merge(begin, end, throttles);
-  torrent::connection_manager()->address_throttle() = std::bind(&core::Manager::get_address_throttle, control->core(), std::placeholders::_1);
-}
-
-torrent::ThrottlePair
-Manager::get_address_throttle(const sockaddr* addr) {
-  if (addr->sa_family != AF_INET)
-    return torrent::ThrottlePair(nullptr, nullptr);
-
-  return m_addressThrottles.get(ntohl(reinterpret_cast<const sockaddr_in*>(addr)->sin_addr.s_addr), torrent::ThrottlePair(nullptr, nullptr));
-}
-
 int64_t
 Manager::retrieve_throttle_value(const torrent::Object::string_type& name, bool rate, bool up) {
   ThrottleMap::iterator itr = throttles().find(name);
@@ -513,6 +498,7 @@ Manager::receive_hashing_changed() {
 
       } else {
         (*itr)->set_hash_failed(true);
+        (*itr)->set_message("Hashing failed: " + std::string(e.what()));
         lt_log_print(torrent::LOG_TORRENT_ERROR, "Hashing failed: %s", e.what());
       }
     }

src/core/manager.h

@@ -5,7 +5,6 @@
 #include <memory>
 #include <vector>
 #include <torrent/utils/log_buffer.h>
-#include <torrent/connection_manager.h>
 #include <torrent/object.h>
 
 #include "download_list.h"
@@ -23,7 +22,8 @@ namespace core {
 
 class HttpQueue;
 
-typedef std::map<std::string, torrent::ThrottlePair> ThrottleMap;
+using ThrottlePair = std::pair<torrent::Throttle*, torrent::Throttle*>;
+using ThrottleMap  =  std::map<std::string, ThrottlePair>;
 
 class View;
 
@@ -37,26 +37,22 @@ public:
 
   bool                is_download_shutdown_completed();
 
-  DownloadList*       download_list()                     { return m_download_list.get(); }
-  FileStatusCache*    file_status_cache()                 { return m_file_status_cache.get(); }
+  DownloadList*       download_list()                   { return m_download_list.get(); }
+  FileStatusCache*    file_status_cache()               { return m_file_status_cache.get(); }
 
-  HttpQueue*          http_queue()                        { return m_http_queue.get(); }
+  HttpQueue*          http_queue()                      { return m_http_queue.get(); }
 
-  View*               hashing_view()                      { return m_hashingView; }
+  View*               hashing_view()                    { return m_hashingView; }
   void                set_hashing_view(View* v);
 
-  torrent::log_buffer* log_important()                    { return m_log_important.get(); }
-  torrent::log_buffer* log_complete()                     { return m_log_complete.get(); }
+  auto*               log_important()                   { return m_log_important.get(); }
+  auto*               log_complete()                    { return m_log_complete.get(); }
 
-  ThrottleMap&          throttles()                       { return m_throttles; }
-  torrent::ThrottlePair get_throttle(const std::string& name);
+  ThrottleMap&        throttles()                       { return m_throttles; }
+  ThrottlePair        get_throttle(const std::string& name);
 
   int64_t             retrieve_throttle_value(const torrent::Object::string_type& name, bool rate, bool up);
 
-  // Use custom throttle for the given range of IP addresses.
-  void                  set_address_throttle(uint32_t begin, uint32_t end, torrent::ThrottlePair throttles);
-  torrent::ThrottlePair get_address_throttle(const sockaddr* addr);
-
   void                cleanup();
 
   void                listen_open();
@@ -87,8 +83,6 @@ public:
   void                try_create_download_from_meta_download(torrent::Object* bencode, const std::string& metafile);
 
 private:
-  typedef RangeMap<uint32_t, torrent::ThrottlePair> AddressThrottleMap;
-
   void                create_http(const std::string& uri);
   void                create_final(std::istream* s);
 
@@ -104,7 +98,6 @@ private:
   View*               m_hashingView{};
 
   ThrottleMap         m_throttles;
-  AddressThrottleMap  m_addressThrottles;
 
   torrent::log_buffer_ptr m_log_important;
   torrent::log_buffer_ptr m_log_complete;

src/display/canvas.h

@@ -132,8 +132,7 @@ Canvas::resize_term(std::pair<int, int> dim) {
 
 inline unsigned int
 Canvas::get_x() {
-  int x;
-  [[maybe_unused]] int y;
+  [[maybe_unused]] int x, y;
   if (!m_daemon) {
     getyx(m_window, y, x);
   } else {
@@ -144,7 +143,7 @@ Canvas::get_x() {
 
 inline unsigned int
 Canvas::get_y() {
-  int x, y;
+  [[maybe_unused]] int x, y;
   if (!m_daemon) {
     getyx(m_window, y, x);
   } else {
@@ -155,8 +154,7 @@ Canvas::get_y() {
 
 inline unsigned int
 Canvas::width() {
-  int x;
-  [[maybe_unused]] int y;
+  [[maybe_unused]] int x, y;
   if (!m_daemon) {
     getmaxyx(m_window, y, x);
   } else {
@@ -167,7 +165,7 @@ Canvas::width() {
 
 inline unsigned int
 Canvas::height() {
-  int x, y;
+  [[maybe_unused]] int x, y;
   if (!m_daemon) {
     getmaxyx(m_window, y, x);
   } else {
@@ -257,8 +255,7 @@ Canvas::set_default_attributes(int attr) {
 
 inline int
 Canvas::get_screen_width() {
-  int x;
-  [[maybe_unused]] int y;
+  [[maybe_unused]] int x, y;
   if (!m_daemon) {
     getmaxyx(stdscr, y, x);
   } else {
@@ -269,7 +266,7 @@ Canvas::get_screen_width() {
 
 inline int
 Canvas::get_screen_height() {
-  int x, y;
+  [[maybe_unused]] int x, y;
   if (!m_daemon) {
     getmaxyx(stdscr, y, x);
   } else {

src/display/manager.cc

@@ -80,10 +80,14 @@ Manager::schedule_update(std::chrono::microseconds min_interval) {
     return;
   }
 
-  if (m_task_update.is_scheduled() && m_task_update.time() <= m_scheduler.front()->time())
+  auto cached = torrent::this_thread::cached_time();
+  m_scheduler.external_set_cached_time(cached);
+  auto next = cached + m_scheduler.next_timeout(cached);
+
+  if (m_task_update.is_scheduled() && m_task_update.time_or_zero() <= next)
     return;
 
-  torrent::this_thread::scheduler()->update_wait_until(&m_task_update, std::max(m_scheduler.front()->time(), m_time_last_update + min_interval));
+  torrent::this_thread::scheduler()->update_wait_until(&m_task_update, std::max(next, m_time_last_update + min_interval));
 }
 
 }

src/display/window_log.cc

@@ -26,6 +26,7 @@ WindowLog::WindowLog(torrent::log_buffer* l) :
 }
 
 WindowLog::~WindowLog() {
+  m_log->lock_and_set_update_slot(nullptr);
   torrent::this_thread::scheduler()->erase(&m_task_update);
 }
 

src/main.cc

@@ -281,12 +281,12 @@ main(int argc, char** argv) {
        "view.filter = leeching,((and,((d.state)),((not,((d.complete))))))\n"
        "view.filter_on = leeching,event.download.resumed,event.download.paused,event.download.finished\n"
 
-       "schedule2 = view.main,10,10,((view.sort,main,20))\n"
-       "schedule2 = view.name,10,10,((view.sort,name,20))\n"
+       "schedule = view.main,10,10,((view.sort,main,20))\n"
+       "schedule = view.name,10,10,((view.sort,name,20))\n"
 
-       "schedule2 = session_save,1200,1200,((session.save))\n"
-       "schedule2 = low_diskspace,5,60,((close_low_diskspace,500M))\n"
-       "schedule2 = prune_file_status,3600,86400,((system.file_status_cache.prune))\n"
+       "schedule = session_save,1200,1200,((session.save))\n"
+       "schedule = low_diskspace,5,60,((close_low_diskspace,500M))\n"
+       "schedule = prune_file_status,3600,86400,((system.file_status_cache.prune))\n"
 
        "protocol.encryption.set=allow_incoming,prefer_plaintext,enable_retry\n"
 
@@ -309,7 +309,8 @@ main(int argc, char** argv) {
     CMD2_REDIRECT("ratio.upload.set",      "group.seeding.ratio.upload.set");
 
     CMD2_REDIRECT("encryption",            "protocol.encryption.set");
-    CMD2_REDIRECT("encoding_list",         "encoding.add");
+
+    CMD2_REDIRECT("check_hash",            "pieces.hash.on_completion.set");
 
     CMD2_REDIRECT("connection_leech",      "protocol.connection.leech.set");
     CMD2_REDIRECT("connection_seed",       "protocol.connection.seed.set");
@@ -329,26 +330,11 @@ main(int argc, char** argv) {
     CMD2_REDIRECT("max_downloads_div",     "throttle.max_downloads.div.set");
     CMD2_REDIRECT("max_downloads_global",  "throttle.max_downloads.global.set");
 
-    CMD2_REDIRECT("max_memory_usage",      "pieces.memory.max.set");
-
-    CMD2_REDIRECT("bind",                  "network.bind_address.set");
-    CMD2_REDIRECT("ip",                    "network.local_address.set");
-    CMD2_REDIRECT("port_range",            "network.port_range.set");
-
-    CMD2_REDIRECT("dht",                   "dht.mode.set");
-
-    CMD2_REDIRECT("port_random",           "network.port_random.set");
-    CMD2_REDIRECT("proxy_address",         "network.proxy_address.set");
-
-    CMD2_REDIRECT("scgi_port",             "network.scgi.open_port");
-    CMD2_REDIRECT("scgi_local",            "network.scgi.open_local");
-
     CMD2_REDIRECT("directory",             "directory.default.set");
     CMD2_REDIRECT("session",               "session.path.set");
 
-    CMD2_REDIRECT("check_hash",            "pieces.hash.on_completion.set");
-
-    CMD2_REDIRECT("key_layout",            "keys.layout.set");
+    CMD2_REDIRECT("scgi_port",             "network.scgi.open_port");
+    CMD2_REDIRECT("scgi_local",            "network.scgi.open_local");
 
     CMD2_REDIRECT("to_gm_time",            "convert.gm_time");
     CMD2_REDIRECT("to_gm_date",            "convert.gm_date");
@@ -360,37 +346,53 @@ main(int argc, char** argv) {
     CMD2_REDIRECT("to_xb",                 "convert.xb");
     CMD2_REDIRECT("to_throttle",           "convert.throttle");
 
-    CMD2_REDIRECT("torrent_list_layout",   "ui.torrent_list.layout.set");
-
-    // 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");
-
-    // Deprecated commands. Don't use these anymore.
-    //
-    // It has been so long that we now re-create these commands with the new (old by now) command
-    // call style, where the first argument is the target.
 
     // if (rpc::call_command_value("method.use_intermediate") == 1) {
-    //   CMD2_REDIRECT("execute", "execute2");
-
-    //   CMD2_REDIRECT("schedule", "schedule2");
-    //   CMD2_REDIRECT("schedule_remove", "schedule_remove2");
 
     // } else if (rpc::call_command_value("method.use_intermediate") == 2) {
     //   Allow for use in config files, etc, just don't export it.
-    //   CMD2_REDIRECT_NO_EXPORT("execute", "execute2");
-
-    //   CMD2_REDIRECT_NO_EXPORT("schedule", "schedule2");
-    //   CMD2_REDIRECT_NO_EXPORT("schedule_remove", "schedule_remove2");
     // }
 
-    // if (rpc::call_command_value("method.use_deprecated") == 1) {
-    // }
+    if (rpc::call_command_value("method.use_deprecated") == 1) {
+      CMD2_REDIRECT("execute2",         "execute");
+      CMD2_REDIRECT("schedule2",        "schedule");
+      CMD2_REDIRECT("schedule_remove2", "schedule.remove");
+
+      // TODO: Remove file.append when cleaning these up.
+
+      CMD2_REDIRECT("bind",                  "network.bind_address.set");
+      CMD2_REDIRECT("ip",                    "network.local_address.set");
+      CMD2_REDIRECT("port_range",            "network.port_range.set");
+
+      // TODO: Check if dht is on by default.
+      CMD2_REDIRECT("dht",                   "dht.mode.set");
+
+      CMD2_REDIRECT("port_random",           "network.port_random.set");
+      CMD2_REDIRECT("proxy_address",         "network.proxy_address.set");
+
+      CMD2_REDIRECT("key_layout",            "keys.layout.set");
+
+      CMD2_REDIRECT("torrent_list_layout",   "ui.torrent_list.layout.set");
+
+      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");
+
+      // Users should check their setups to see if they need to modify their use of these options.
+      CMD2_REDIRECT("max_memory_usage",      "pieces.memory.max.set");
+      CMD2_REDIRECT("encoding_list",         "encoding.add");
+
+      CMD2_ANY_STRING_V("encoding.add", [](auto, auto) {
+          lt_log_print(torrent::LOG_WARN, "The 'encoding.add' command is deprecated and does nothing.");
+        });
+
+      CMD2_ANY_LIST ("throttle.ip", []( auto, auto) {
+          lt_log_print(torrent::LOG_WARN, "The 'throttle.ip' command is deprecated and does nothing.");
+          return torrent::Object();
+        });
+    }
 
     {
       auto fd = torrent::fd_open_family(torrent::fd_flag_stream, AF_INET6);
@@ -421,16 +423,16 @@ main(int argc, char** argv) {
     control->initialize();
     control->ui()->load_input_history();
 
-    // Load session torrents and perform scheduled tasks to ensure
-    // session torrents are loaded before arg torrents.
+    // Load session torrents and perform scheduled tasks to ensure session torrents are loaded
+    // before arg torrents.
+    control->dht_manager()->set_auto_if_untouched_and_has_session();
     control->dht_manager()->load_dht_cache();
 
     load_session_torrents(session_thread::manager()->path());
     load_arg_torrents(argv + firstArg, argv + argc);
 
-    // Make sure we update the display before any scheduled tasks can
-    // run, so that loading of torrents doesn't look like it hangs on
-    // startup.
+    // Make sure we update the display before any scheduled tasks can run, so that loading of
+    // torrents doesn't look like it hangs on startup.
     control->display()->adjust_layout();
     control->display()->receive_update();
 

src/rpc/lua.cc

@@ -10,6 +10,10 @@
 
 #ifdef HAVE_LUA
 #include <lua.hpp>
+// LUA_OK was introduced in Lua 5.2; define for Lua 5.1 and LuaJIT2.0.
+#ifndef LUA_OK
+#define LUA_OK 0
+#endif
 #endif
 
 #include <torrent/object.h>

src/rpc/xmlrpc.cc

@@ -1,3 +1,4 @@
+#include <deque>
 #include "config.h"
 
 #include "xmlrpc.h"
@@ -9,7 +10,7 @@
 
 namespace rpc {
 
-std::vector<std::string> XmlRpc::m_command_names;
+std::deque<std::string>  XmlRpc::m_command_names;
 
 const char*
 XmlRpc::store_command_name(const char* name) {

src/rpc/xmlrpc.h

@@ -1,6 +1,7 @@
 #ifndef RTORRENT_RPC_XMLRPC_H
 #define RTORRENT_RPC_XMLRPC_H
 
+#include <deque>
 #include <functional>
 #include <torrent/common.h>
 #include <torrent/hash_string.h>
@@ -61,7 +62,7 @@ public:
 private:
   static const char*  store_command_name(const char* name);
 
-  static std::vector<std::string> m_command_names;
+  static std::deque<std::string>  m_command_names;
 
   slot_download       m_slotFindDownload;
   slot_file           m_slotFindFile;

src/ui/download.cc

@@ -4,7 +4,6 @@
 
 #include <torrent/exceptions.h>
 #include <torrent/chunk_manager.h>
-#include <torrent/connection_manager.h>
 #include <torrent/throttle.h>
 #include <torrent/torrent.h>
 #include <torrent/data/file_list.h>

src/ui/element_log_complete.cc

@@ -26,6 +26,10 @@ ElementLogComplete::ElementLogComplete(torrent::log_buffer* l) :
     });
 }
 
+ElementLogComplete::~ElementLogComplete() {
+  m_log->lock_and_set_update_slot(nullptr);
+}
+
 void
 ElementLogComplete::activate(display::Frame* frame, [[maybe_unused]] bool focus) {
   if (is_active())

src/ui/element_log_complete.h

@@ -18,6 +18,7 @@ public:
   typedef display::WindowLogComplete    WLogComplete;
 
   ElementLogComplete(torrent::log_buffer* l);
+  ~ElementLogComplete() override;
 
   void                activate(display::Frame* frame, bool focus = true);
   void                disable();