Parse multicall commands once per call

Keep the change to d, f, p and t multicalls. Parse each column lazily on first use and evaluate it through rpc::call_object, preserving per-target argument expansion.

Compared unpatched and patched builds on macOS: output was byte-identical across the test harness, including an erase-mid-call check.

configure.ac

@@ -1,6 +1,6 @@
 m4_pattern_allow([PKG_CHECK_EXISTS])
 
-AC_INIT([rtorrent],[0.16.24],[sundell.software@gmail.com])
+AC_INIT([rtorrent],[0.16.25],[sundell.software@gmail.com])
 
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_MACRO_DIRS([scripts])
@@ -14,7 +14,7 @@ AX_CXX_COMPILE_STDCXX(20, noext, mandatory)
 
 PKG_PROG_PKG_CONFIG
 
-AC_DEFINE([API_VERSION], [28], [api version])
+AC_DEFINE([API_VERSION], [29], [api version])
 
 RAK_CHECK_CFLAGS
 RAK_CHECK_CXXFLAGS
@@ -49,7 +49,7 @@ fi
 
 PKG_CHECK_MODULES([CPPUNIT], [cppunit],, [no_cppunit="yes"])
 PKG_CHECK_MODULES([ZLIB], [zlib])
-PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.24])
+PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.16.25])
 
 AC_LANG_PUSH(C++)
 TORRENT_WITH_XMLRPC_C

src/command_download.cc

@@ -334,6 +334,11 @@ f_multicall(core::Download* download, const torrent::Object::list_type& args) {
 
   bool use_regex = true;
 
+  rpc::preparsed_commands commands([&args](auto& cmds) {
+    for (auto cItr = ++args.begin(); cItr != args.end(); ++cItr)
+      cmds.push_back(rpc::parse_command_object(cItr->as_string()));
+  });
+
   if (args.front().is_list())
     for (const auto& o : args.front().as_list())
       regex_list.push_back(o.as_string_c());
@@ -349,10 +354,10 @@ f_multicall(core::Download* download, const torrent::Object::list_type& args) {
 
     torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
 
-    for (torrent::Object::list_const_iterator cItr = ++args.begin(); cItr != args.end(); cItr++) {
-      const std::string& cmd = cItr->as_string();
-      row.push_back(rpc::parse_command(rpc::make_target(file.get()), cmd.c_str(), cmd.c_str() + cmd.size()).first);
-    }
+    // Defer parsing until a file actually matches the multicall selection.
+    commands.prepare_if_needed();
+    for (auto& itr : commands)
+      row.push_back(rpc::call_object(itr, rpc::make_target(file.get())));
   }
 
   return resultRaw;
@@ -372,6 +377,11 @@ t_multicall(core::Download* download, const torrent::Object::list_type& args) {
   auto  result_raw = torrent::Object::create_list();
   auto& result     = result_raw.as_list();
 
+  rpc::preparsed_commands commands([&args](auto& cmds) {
+    for (auto cItr = ++args.begin(); cItr != args.end(); ++cItr)
+      cmds.push_back(rpc::parse_command_object(cItr->as_string()));
+  });
+
   for (uint32_t idx = 0, last = download->tracker_list_size(); idx < last; idx++) {
     auto& row     = result.insert(result.end(), torrent::Object::create_list())->as_list();
     auto  tracker = download->tracker_controller().at(idx);
@@ -379,11 +389,10 @@ t_multicall(core::Download* download, const torrent::Object::list_type& args) {
     if (!tracker.is_valid())
       continue;
 
-    for (auto cItr = ++args.begin(); cItr != args.end(); cItr++) {
-      auto& cmd = cItr->as_string();
-
-      row.push_back(rpc::parse_command(rpc::make_target(&tracker), cmd.c_str(), cmd.c_str() + cmd.size()).first);
-    }
+    // Do not parse columns when there are no valid tracker targets.
+    commands.prepare_if_needed();
+    for (auto& itr : commands)
+      row.push_back(rpc::call_object(itr, rpc::make_target(&tracker)));
   }
 
   return result_raw;
@@ -405,13 +414,18 @@ p_multicall(core::Download* download, const torrent::Object::list_type& args) {
   auto*      connection_list = download->connection_list();
   const auto change_counter  = connection_list->change_counter();
 
+  rpc::preparsed_commands commands([&args](auto& cmds) {
+    for (auto cItr = ++args.begin(); cItr != args.end(); ++cItr)
+      cmds.push_back(rpc::parse_command_object(cItr->as_string()));
+  });
+
   for (const auto& connection : *connection_list) {
     torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
 
-    for (auto cItr = ++args.begin(); cItr != args.end(); cItr++) {
-      const std::string& cmd = cItr->as_string();
-
-      row.push_back(rpc::parse_command(rpc::make_target(connection), cmd.c_str(), cmd.c_str() + cmd.size()).first);
+    // Prepare only after a peer exists, preserving empty-list laziness.
+    commands.prepare_if_needed();
+    for (auto& itr : commands) {
+      row.push_back(rpc::call_object(itr, rpc::make_target(connection)));
 
       // Erasing a peer frees it and swaps the last element into its place, so
       // neither this peer nor the iteration survives a change to the list.

src/command_events.cc

@@ -247,20 +247,26 @@ d_multicall(const torrent::Object::list_type& args) {
   torrent::Object             resultRaw = torrent::Object::create_list();
   torrent::Object::list_type& result = resultRaw.as_list();
 
+  rpc::preparsed_commands commands([&args](auto& cmds) {
+    for (auto cItr = ++args.begin(); cItr != args.end(); ++cItr)
+      cmds.push_back(rpc::parse_command_object(cItr->as_string()));
+  });
+
   for (const auto& download : dlist) {
     if (download.use_count() == 1)
       continue;
 
     torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
 
-    for (torrent::Object::list_const_iterator cItr = ++args.begin(); cItr != args.end(); cItr++) {
+    // Skip parsing if there are no usable download targets in the view.
+    commands.prepare_if_needed();
+    for (auto& itr : commands) {
       // A command may erase this download, which destroys the torrent object it
       // wraps; the list dropping its reference is what tells us.
       if (download.use_count() == 1)
         break;
 
-      auto& cmd = cItr->as_string();
-      row.push_back(rpc::parse_command(rpc::make_target(download), cmd.c_str(), cmd.c_str() + cmd.size()).first);
+      row.push_back(rpc::call_object(itr, rpc::make_target(download)));
     }
   }
 

src/command_groups.cc

@@ -1,5 +1,6 @@
 #include "config.h"
 
+#include <limits>
 #include <memory>
 
 #include <torrent/download/resource_manager.h>
@@ -232,6 +233,9 @@ apply_cg_max_set(const torrent::Object::list_type& args, bool is_up) {
   int64_t second_arg = 0;
   rpc::parse_whole_value(args.back().as_string().c_str(), &second_arg);
 
+  if (second_arg < -1 || second_arg > std::numeric_limits<uint32_t>::max())
+    throw torrent::input_error("Max unchoked must be between -1 and 4294967295.");
+
   if (is_up)
     cg_get_group(args.front())->up_queue()->set_max_unchoked(second_arg);
   else

src/command_helpers.h

@@ -1,12 +1,25 @@
 #ifndef RTORRENT_UTILS_COMMAND_HELPERS_H
 #define RTORRENT_UTILS_COMMAND_HELPERS_H
 
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <torrent/exceptions.h>
+
 #include "rpc/command.h"
 #include "rpc/parse_commands.h"
 #include "rpc/object_storage.h"
 
 void initialize_commands();
 
+inline uint16_t
+checked_port_value(int64_t value, const char* label) {
+  if (value < 0 || value > std::numeric_limits<uint16_t>::max())
+    throw torrent::input_error(std::string("Invalid ") + label + " port number.");
+
+  return static_cast<uint16_t>(value);
+}
+
 //
 // Aliases with CMD_* for the below
 //

src/command_network.cc

@@ -54,14 +54,6 @@ set_listen_port_range(const std::string& arg) {
   torrent::runtime::client_config()->set_listen_port_range(port_first, port_last);
 }
 
-uint16_t
-checked_local_port_value(int64_t value, const char* label) {
-  if (value < 0 || value > 65535)
-    throw torrent::input_error(std::string("Invalid ") + label + " port number.");
-
-  return static_cast<uint16_t>(value);
-}
-
 torrent::Object
 get_encryption() {
   auto encryption_modes = torrent::runtime::network_config()->encryption_modes();
@@ -325,7 +317,7 @@ initialize_command_network() {
   auto nw_config      = torrent::runtime::network_config();
 
   CMD_ANY         ("network.listen.port",            [](auto, auto)        { return torrent::runtime::network_manager()->listen_port(); });
-  CMD_ANY_VALUE_V ("network.listen.port.set",        [](auto, auto& value) { return torrent::runtime::network_manager()->set_listen_port(value); });
+  CMD_ANY_VALUE_V ("network.listen.port.set",        [](auto, auto& value) { return torrent::runtime::network_manager()->set_listen_port(checked_port_value(value, "listen")); });
   CMD_ANY         ("network.listen.port.random",     [](auto, auto)        { return torrent::runtime::client_config()->listen_port_random(); });
   CMD_ANY_VALUE_V ("network.listen.port.random.set", [](auto, auto& value) { return torrent::runtime::client_config()->set_listen_port_random(value); });
   CMD_ANY         ("network.listen.port.range",      [](auto, auto)        { return listen_port_range(); });
@@ -394,11 +386,11 @@ initialize_command_network() {
   CMD_ANY_STRING_V("network.local_address.ipv6.set",         [nw_config](auto, auto& str)    { return nw_config->set_local_inet6_address(str); });
 
   CMD_ANY         ("network.local_port",                     [nw_config](auto, auto)         { return nw_config->local_port_best_match(); });
-  CMD_ANY_VALUE_V ("network.local_port.set",                 [nw_config](auto, auto& value)  { return nw_config->set_local_port(checked_local_port_value(value, "local")); });
+  CMD_ANY_VALUE_V ("network.local_port.set",                 [nw_config](auto, auto& value)  { return nw_config->set_local_port(checked_port_value(value, "local")); });
   CMD_ANY         ("network.local_port.ipv4",                [nw_config](auto, auto)         { return nw_config->local_inet_port(); });
-  CMD_ANY_VALUE_V ("network.local_port.ipv4.set",            [nw_config](auto, auto& value)  { return nw_config->set_local_inet_port(checked_local_port_value(value, "local ipv4")); });
+  CMD_ANY_VALUE_V ("network.local_port.ipv4.set",            [nw_config](auto, auto& value)  { return nw_config->set_local_inet_port(checked_port_value(value, "local ipv4")); });
   CMD_ANY         ("network.local_port.ipv6",                [nw_config](auto, auto)         { return nw_config->local_inet6_port(); });
-  CMD_ANY_VALUE_V ("network.local_port.ipv6.set",            [nw_config](auto, auto& value)  { return nw_config->set_local_inet6_port(checked_local_port_value(value, "local ipv6")); });
+  CMD_ANY_VALUE_V ("network.local_port.ipv6.set",            [nw_config](auto, auto& value)  { return nw_config->set_local_inet6_port(checked_port_value(value, "local ipv6")); });
 
   CMD_ANY         ("network.proxy.global",                   [](auto, auto)                  { return torrent::runtime::proxy_manager()->proxy_url(); });
   CMD_ANY_STRING_V("network.proxy.global.set",               [](auto, auto& str)             { return torrent::runtime::proxy_manager()->set_proxy_url(str); });

src/command_system.cc

@@ -86,8 +86,10 @@ initialize_command_system() {
   CMD_VAR_VALUE   ("system.file.split_size",       -1);
   CMD_VAR_STRING  ("system.file.split_suffix",     ".part");
 
-  CMD_ANY         ("system.file_name.replace_slash",     [](auto, auto)      { return torrent::runtime::client_config()->file_name_replace_slash(); });
-  CMD_ANY_STRING_V("system.file_name.replace_slash.set", [](auto, auto& str) { return torrent::runtime::client_config()->set_file_name_replace_slash(str); });
+  CMD_ANY         ("system.file_name.replace_slash",         [](auto, auto)        { return torrent::runtime::client_config()->file_name_replace_slash(); });
+  CMD_ANY_STRING_V("system.file_name.replace_slash.set",     [](auto, auto& str)   { return torrent::runtime::client_config()->set_file_name_replace_slash(str); });
+  CMD_ANY         ("system.file_name.allow_legacy_utf8",     [](auto, auto)        { return torrent::runtime::client_config()->file_name_allow_legacy_utf8(); });
+  CMD_ANY_VALUE_V ("system.file_name.allow_legacy_utf8.set", [](auto, auto& value) { return torrent::runtime::client_config()->set_file_name_allow_legacy_utf8(value); });
 
   CMD_ANY         ("system.file_status_cache.size",      [](auto, auto)      { return control->core()->file_status_cache()->size(); });
   CMD_ANY_V       ("system.file_status_cache.prune",     [](auto, auto)      { return control->core()->file_status_cache()->prune(); });
@@ -167,9 +169,13 @@ initialize_command_system() {
   rpc::rpc.mark_safe("system.time");
   rpc::rpc.mark_safe("system.time_seconds");
   rpc::rpc.mark_safe("system.time_usec");
+  rpc::rpc.mark_safe("system.torrent_name.use_sanitized");
+  rpc::rpc.mark_safe("system.file.allocate");
   rpc::rpc.mark_safe("system.file.max_size");
   rpc::rpc.mark_safe("system.file.split_size");
   rpc::rpc.mark_safe("system.file.split_suffix");
+  rpc::rpc.mark_safe("system.file_name.replace_slash");
+  rpc::rpc.mark_safe("system.file_name.allow_legacy_utf8");
 
   rpc::rpc.mark_safe("system.sockets.size");
   rpc::rpc.mark_safe("system.sockets.max_size");

src/command_tracker.cc

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

src/core/download_list.cc

@@ -82,7 +82,7 @@ DownloadList::find(const torrent::HashString& hash) {
 
 DownloadList::iterator
 DownloadList::find_hex(const char* hash) {
-  if (strlen(hash) < 40)
+  if (strlen(hash) != 40)
     return end();
 
   torrent::HashString key;
@@ -709,6 +709,10 @@ DownloadList::confirm_finished(Download* download) {
   if (choke_up.is_string_empty())     choke_up     = rpc::call_command("protocol.choke_heuristics.up.seed", torrent::Object(), rpc::make_target(download));
   if (choke_down.is_string_empty())   choke_down   = rpc::call_command("protocol.choke_heuristics.down.seed", torrent::Object(), rpc::make_target(download));
 
+  // libtorrent refuses initial seeding on an active download.
+  if (download->is_active() && conn_current.as_string() == "initial_seed")
+    conn_current = "seed";
+
   rpc::call_command("d.connection_current.set",    conn_current, rpc::make_target(download));
   rpc::call_command("d.up.choke_heuristics.set",   choke_up, rpc::make_target(download));
   rpc::call_command("d.down.choke_heuristics.set", choke_down, rpc::make_target(download));

src/core/download_list.h

@@ -1,6 +1,7 @@
 #ifndef RTORRENT_CORE_DOWNLOAD_LIST_H
 #define RTORRENT_CORE_DOWNLOAD_LIST_H
 
+#include <cstdint>
 #include <iosfwd>
 #include <list>
 #include <memory>

src/rpc/command.h

@@ -108,7 +108,7 @@ public:
 
     static stack_type* from_data(char* data) { return reinterpret_cast<stack_type*>(data); }
 
-    char buffer[sizeof(torrent::Object) * max_arguments];
+    alignas(optimal_alignment) char buffer[sizeof(torrent::Object) * max_arguments];
   };
 
   command_base() : m_copy_helper(nullptr), m_dest_helper(nullptr) {}

src/rpc/exec_file.cc

@@ -1,5 +1,7 @@
 #include "config.h"
 
+#include <memory>
+
 #include "rpc/exec_file.h"
 
 // #include <cassert>
@@ -81,8 +83,9 @@ ExecFile::execute_object(const torrent::Object& rawArgs, int flags) {
   char*  argsBuffer[max_args];
   char** argsCurrent = argsBuffer;
 
-  // Size of value strings are less than 24.
-  char   valueBuffer[buffer_size+1];
+  // On the heap: a buffer of buffer_size does not belong on the stack of whichever thread runs the command.
+  auto   valueStorage = std::make_unique<char[]>(buffer_size + 1);
+  char*  valueBuffer  = valueStorage.get();
   char*  valueCurrent = valueBuffer;
 
   if (rawArgs.is_list()) {

src/rpc/exec_file.h

@@ -10,7 +10,7 @@ namespace rpc {
 class ExecFile {
 public:
   static constexpr unsigned int max_args    = 128;
-  static constexpr unsigned int buffer_size = 4096;
+  static constexpr unsigned int buffer_size = 128 * 1024;
 
   static constexpr int flag_expand_tilde = 0x1;
   static constexpr int flag_throw        = 0x2;

src/rpc/parse.cc

@@ -1,5 +1,7 @@
 #include "config.h"
 
+#include <cctype>
+#include <charconv>
 #include <cstring>
 #include <cstdio>
 #include <limits>
@@ -113,16 +115,45 @@ parse_value_nothrow(const char* src, int64_t* value, int base, int unit) {
   if (unit <= 0)
     throw torrent::input_error("Command::string_to_value_unit(...) received unit <= 0.");
 
-  char* last;
+  if (base != 0 && base != 8 && base != 10 && base != 16)
+    throw torrent::input_error("Command::string_to_value_unit(...) received invalid base.");
+
+  const char* first = src;
+
+  while (parse_is_space(*src))
+    src++;
+
+  if (src[0] == '+')
+    return first;
+
+  if (src[0] == '-') {
+    if (base == 8 || base == 16)
+      return first;
+
+    if (src[1] == '0')
+      return first;
+  }
+
+  if (base == 10 && src[0] == '0' && (src[1] >= '0' && src[1] <= '9'))
+    return first;
+
+  char* last{};
+
+  errno  = 0;
   *value = strtoll(src, &last, base);
 
+  if (errno == ERANGE)
+    return first;
+
   if (last == src) {
-    if (strcasecmp(src, "no") == 0) { *value = 0; return src + strlen("no"); }
-    if (strcasecmp(src, "yes") == 0) { *value = 1; return src + strlen("yes"); }
-    if (strcasecmp(src, "true") == 0) { *value = 1; return src + strlen("true"); }
+    *value = 0;
+
+    if (strcasecmp(src, "no") == 0)    { *value = 0; return src + strlen("no"); }
+    if (strcasecmp(src, "yes") == 0)   { *value = 1; return src + strlen("yes"); }
+    if (strcasecmp(src, "true") == 0)  { *value = 1; return src + strlen("true"); }
     if (strcasecmp(src, "false") == 0) { *value = 0; return src + strlen("false"); }
 
-    return src;
+    return first;
   }
 
   switch (*last) {
@@ -130,15 +161,15 @@ parse_value_nothrow(const char* src, int64_t* value, int base, int unit) {
   case 'B': ++last; break;
   case 'k':
   case 'K':
-    if (!value_fits_shifted(*value, 10)) return src; // overflow guard
+    if (!value_fits_shifted(*value, 10)) return first; // overflow guard
     *value = *value << 10; ++last; break;
   case 'm':
   case 'M':
-    if (!value_fits_shifted(*value, 20)) return src; // overflow guard
+    if (!value_fits_shifted(*value, 20)) return first; // overflow guard
     *value = *value << 20; ++last; break;
   case 'g':
   case 'G':
-    if (!value_fits_shifted(*value, 30)) return src; // overflow guard
+    if (!value_fits_shifted(*value, 30)) return first; // overflow guard
     *value = *value << 30; ++last; break;
 //   case ' ':
 //   case '\0': *value = *value * unit; break;
@@ -146,7 +177,7 @@ parse_value_nothrow(const char* src, int64_t* value, int base, int unit) {
   default:
     if (*value > std::numeric_limits<int64_t>::max() / unit ||
         *value < std::numeric_limits<int64_t>::min() / unit)
-      return src; // overflow guard
+      return first; // overflow guard
 
     *value = *value * unit;
     break;
@@ -393,7 +424,7 @@ convert_to_value_nothrow(const torrent::Object& src, int64_t* value, int base, i
       == unpacked.as_string().c_str() + unpacked.as_string().size();
 
   case torrent::Object::TYPE_RAW_STRING: {
-    const torrent::raw_string& str = src.as_raw_string();
+    const torrent::raw_string& str = unpacked.as_raw_string();
 
     auto buffer = std::make_unique<char[]>(str.size() + 1);
     std::memcpy(buffer.get(), str.data(), str.size());

src/rpc/parse.h

@@ -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>
-
-
 #ifndef RTORRENT_RPC_PARSE_H
 #define RTORRENT_RPC_PARSE_H
 

src/rpc/parse_commands.cc

@@ -123,6 +123,39 @@ parse_command(target_type target, const char* first, const char* last) {
   return std::make_pair(commands.call_command(key, args, target), first);
 }
 
+torrent::Object
+parse_command_object(const char* first, const char* last) {
+  first = std::find_if(first, last, [&](char c) { return !command_map_is_space(c); });
+
+  if (first == last || *first == '#')
+    return torrent::Object();
+
+  char key[128];
+
+  first = parse_command_name(first, last, key, key + 128);
+  first = std::find_if(first, last, [&](char c) { return !command_map_is_space(c); });
+
+  if (first == last || *first != '=')
+    throw torrent::input_error("Could not find '=' in command '" + std::string(key) + "'.");
+
+  torrent::Object result = torrent::Object::create_dict_key();
+
+  result.as_dict_key() = key;
+
+  first = parse_whole_list(first + 1, last, &result.as_dict_obj(), &parse_is_delim_command);
+
+  // Find the last character that is part of this command, skipping
+  // the whitespace at the end.
+  first = std::find_if(first, last, [&](char c) { return !command_map_is_space(c); });
+
+  // This helper accepts exactly one command and cannot return where a next
+  // command begins, so reject every non-whitespace suffix, including ';'.
+  if (first != last && *first != '\0')
+    throw torrent::input_error("Junk at end of input.");
+
+  return result;
+}
+
 torrent::Object
 parse_command_multiple(target_type target, const char* first, const char* last) {
   parse_command_type result;

src/rpc/parse_commands.h

@@ -37,6 +37,9 @@
 
 #include <string>
 #include <cstring>
+#include <functional>
+#include <utility>
+#include <vector>
 
 #include "xmlrpc.h"
 #include "rpc_manager.h"
@@ -67,6 +70,34 @@ parse_command_single(target_type target, const std::string& cmd) {
   return parse_command(target, cmd.c_str(), cmd.c_str() + cmd.size()).first;
 }
 
+// Parse one RPC command without executing it. Repeated evaluations can use
+// call_object on the result, which handles per-target argument expansion.
+torrent::Object        parse_command_object(const char* first, const char* last);
+
+inline torrent::Object parse_command_object(const std::string& cmd) {
+  return parse_command_object(cmd.c_str(), cmd.c_str() + cmd.size());
+}
+
+// Prepare a multicall's commands once, on the first target that uses them. This
+// keeps empty target lists from parsing commands that would never be evaluated.
+struct preparsed_commands : public std::vector<torrent::Object> {
+  explicit preparsed_commands(std::function<void(preparsed_commands&)> prepare)
+    : m_prepare(std::move(prepare)) {}
+
+  void prepare_if_needed() {
+    if (m_prepare) {
+      // Clear before invoking: the callback may inspect this vector, and a
+      // throwing callback must not be run again against partially added items.
+      auto prepare = std::move(m_prepare);
+      m_prepare = {};
+      prepare(*this);
+    }
+  }
+
+private:
+  std::function<void(preparsed_commands&)> m_prepare;
+};
+
 inline torrent::Object
 parse_command_multiple_std(const std::string& cmd, target_type target = rpc::make_target()) {
   return parse_command_multiple(target, cmd.c_str(), cmd.c_str() + cmd.size());

src/ui/element_menu.cc

@@ -179,7 +179,7 @@ ElementMenu::set_entry(size_type idx, bool triggerSlot) {
   m_entry = idx;
   focus_entry(m_entry);
 
-  if (triggerSlot)
+  if (triggerSlot && m_entry < size())
     base_type::operator[](m_entry).m_slotFocus();
 
   m_window->mark_dirty();

test/Makefile.am

@@ -51,6 +51,8 @@ rtorrent_Test_Rpc_SOURCES = $(rtorrent_Test_Common) \
 	rpc/test_command_slot.h \
 	rpc/test_object_storage.cc \
 	rpc/test_object_storage.h \
+	rpc/test_parse.cc \
+	rpc/test_parse.h \
 	rpc/test_parse_options.cc \
 	rpc/test_parse_options.h \
 	rpc/test_rpc_manager.cc \
@@ -59,6 +61,8 @@ rtorrent_Test_Rpc_SOURCES = $(rtorrent_Test_Common) \
 rtorrent_Test_Src_SOURCES = $(rtorrent_Test_Common) \
 	src/test_command_dynamic.cc \
 	src/test_command_dynamic.h \
+	src/test_command_groups.cc \
+	src/test_command_groups.h \
 	src/test_command_ip.cc \
 	src/test_command_ip.h \
 	src/test_command_system.cc \
@@ -69,6 +73,10 @@ rtorrent_Test_Src_SOURCES = $(rtorrent_Test_Common) \
 	src/test_command_string.h \
 	src/test_command_throttle.cc \
 	src/test_command_throttle.h \
+	src/test_command_tracker.cc \
+	src/test_command_tracker.h \
+	src/test_download_list.cc \
+	src/test_download_list.h \
 	src/test_input_path_input.cc \
 	src/test_input_path_input.h \
 	src/test_session_commit.cc \

test/rpc/test_command.cc

@@ -2,7 +2,10 @@
 
 #include "test/rpc/test_command.h"
 
+#include <torrent/exceptions.h>
+
 #include "rpc/command.h"
+#include "rpc/parse_commands.h"
 
 CPPUNIT_TEST_SUITE_REGISTRATION(TestCommand);
 
@@ -83,3 +86,50 @@ TestCommand::test_stack_double() {
   rpc::command_base::pop_stack(&stack_first, last_stack_first);
   CPPUNIT_ASSERT(command_stack_all_empty());
 }
+
+void
+TestCommand::test_preparsed_commands() {
+  unsigned int prepare_count = 0;
+  rpc::preparsed_commands commands([&prepare_count](auto& prepared) {
+    ++prepare_count;
+    // Reentrant access must not invoke the same callback recursively.
+    prepared.prepare_if_needed();
+    prepared.push_back(rpc::parse_command_object("string.length=abc"));
+  });
+
+  CPPUNIT_ASSERT_EQUAL(0u, prepare_count);
+  CPPUNIT_ASSERT(commands.empty());
+
+  commands.prepare_if_needed();
+  CPPUNIT_ASSERT_EQUAL(1u, prepare_count);
+
+  size_t count = 0;
+  for (auto& itr : commands) {
+    CPPUNIT_ASSERT(itr.is_dict_key());
+    ++count;
+  }
+
+  CPPUNIT_ASSERT_EQUAL(size_t(1), count);
+  CPPUNIT_ASSERT_EQUAL(1u, prepare_count);
+
+  for (auto& itr : commands)
+    CPPUNIT_ASSERT(itr.is_dict_key());
+
+  CPPUNIT_ASSERT_EQUAL(1u, prepare_count);
+}
+
+void
+TestCommand::test_parse_command_object() {
+  auto command = rpc::parse_command_object("\tstring.length=abc  ");
+  CPPUNIT_ASSERT(command.is_dict_key());
+  CPPUNIT_ASSERT_EQUAL(std::string("string.length"), command.as_dict_key());
+
+  // This helper has no way to return the next-command pointer, so it must not
+  // silently accept a multipart command separated by ';'.
+  CPPUNIT_ASSERT_THROW(rpc::parse_command_object("string.length=abc;string.length=def"), torrent::input_error);
+
+  // Unlike parse_command (which parses command files), this helper handles one
+  // multicall command and must reject newline boundaries, including CRLF.
+  CPPUNIT_ASSERT_THROW(rpc::parse_command_object("string.length=abc\nstring.length=def"), torrent::input_error);
+  CPPUNIT_ASSERT_THROW(rpc::parse_command_object("string.length=abc\r\nstring.length=def"), torrent::input_error);
+}

test/rpc/test_command.h

@@ -5,10 +5,14 @@ class TestCommand : public test_fixture {
 
   CPPUNIT_TEST(test_stack);
   CPPUNIT_TEST(test_stack_double);
+  CPPUNIT_TEST(test_preparsed_commands);
+  CPPUNIT_TEST(test_parse_command_object);
 
   CPPUNIT_TEST_SUITE_END();
 
 public:
   void test_stack();
   void test_stack_double();
+  void test_preparsed_commands();
+  void test_parse_command_object();
 };

test/rpc/test_parse.cc

@@ -0,0 +1,95 @@
+#include "config.h"
+
+#include "test/rpc/test_parse.h"
+
+#include <cstdint>
+#include <limits>
+
+#include "rpc/parse.h"
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestParse);
+
+void
+TestParse::test_whole_value_in_range() {
+  int64_t value = 0;
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("9223372036854775807", &value));
+  CPPUNIT_ASSERT_EQUAL(std::numeric_limits<int64_t>::max(), value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("-9223372036854775808", &value));
+  CPPUNIT_ASSERT_EQUAL(std::numeric_limits<int64_t>::min(), value);
+}
+
+void
+TestParse::test_whole_value_out_of_range() {
+  int64_t value = 0;
+
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("9223372036854775808", &value));
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("-9223372036854775809", &value));
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("99999999999999999999999999", &value));
+}
+
+void
+TestParse::test_whole_value_bases() {
+  int64_t value = 0;
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("0x1f", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{31}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("0X1F", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{31}, value);
+
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("-0x1f", &value));
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("0022", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{022}, value);
+
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("0028", &value));
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("+022", &value));
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("-022", &value));
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("22", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{22}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("1f", &value, 16));
+  CPPUNIT_ASSERT_EQUAL(int64_t{31}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("0x1f", &value, 16));
+  CPPUNIT_ASSERT_EQUAL(int64_t{31}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("22", &value, 8));
+  CPPUNIT_ASSERT_EQUAL(int64_t{022}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("022", &value, 8));
+  CPPUNIT_ASSERT_EQUAL(int64_t{022}, value);
+
+  const char* no_digits = "0x";
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow(no_digits, &value));
+  CPPUNIT_ASSERT_EQUAL(no_digits + 1, rpc::parse_value_nothrow(no_digits, &value));
+
+  const char* bad_digits = "0xzz";
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow(bad_digits, &value));
+  CPPUNIT_ASSERT_EQUAL(bad_digits + 1, rpc::parse_value_nothrow(bad_digits, &value));
+}
+
+void
+TestParse::test_whole_value_prefixes() {
+  int64_t value = 0;
+
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("+5", &value));
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("  5  ", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{5}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("5k", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{5120}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("yes", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{1}, value);
+
+  CPPUNIT_ASSERT(rpc::parse_whole_value_nothrow("false", &value));
+  CPPUNIT_ASSERT_EQUAL(int64_t{0}, value);
+
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("junk", &value));
+  CPPUNIT_ASSERT(!rpc::parse_whole_value_nothrow("", &value));
+}

test/rpc/test_parse.h

@@ -0,0 +1,18 @@
+#include "test/helpers/test_fixture.h"
+
+class TestParse : public test_fixture {
+  CPPUNIT_TEST_SUITE(TestParse);
+
+  CPPUNIT_TEST(test_whole_value_in_range);
+  CPPUNIT_TEST(test_whole_value_out_of_range);
+  CPPUNIT_TEST(test_whole_value_bases);
+  CPPUNIT_TEST(test_whole_value_prefixes);
+
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void test_whole_value_in_range();
+  void test_whole_value_out_of_range();
+  void test_whole_value_bases();
+  void test_whole_value_prefixes();
+};

test/src/test_command_groups.cc

@@ -0,0 +1,65 @@
+#include "config.h"
+
+#include "test/src/test_command_groups.h"
+
+#include <torrent/torrent.h>
+
+#include "control.h"
+#include "globals.h"
+#include "rpc/parse_commands.h"
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestCommandGroups);
+
+void initialize_command_groups();
+
+static void
+call_set(const char* value) {
+  torrent::Object::list_type args;
+  args.push_back(torrent::Object(int64_t{0}));
+  args.push_back(torrent::Object(std::string(value)));
+
+  rpc::commands.call_command("choke_group.up.max.set", torrent::Object::create_list_range(args.begin(), args.end()));
+}
+
+static int64_t
+call_get(const char* key) {
+  return rpc::commands.call_command(key, torrent::Object(int64_t{0})).as_value();
+}
+
+void
+TestCommandGroups::setUp() {
+  torrent::initialize_main_thread();
+  torrent::initialize();
+
+  if (control == nullptr)
+    control = new Control;
+
+  if (!rpc::commands.has("choke_group.up.max.set"))
+    initialize_command_groups();
+}
+
+void
+TestCommandGroups::tearDown() {
+  torrent::cleanup();
+}
+
+void
+TestCommandGroups::test_max_unchoked_in_range() {
+  call_set("50");
+  CPPUNIT_ASSERT_EQUAL(int64_t{50}, call_get("choke_group.up.max"));
+  CPPUNIT_ASSERT_EQUAL(int64_t{0}, call_get("choke_group.up.max.unlimited"));
+
+  call_set("-1");
+  CPPUNIT_ASSERT_EQUAL(int64_t{1}, call_get("choke_group.up.max.unlimited"));
+}
+
+void
+TestCommandGroups::test_max_unchoked_out_of_range() {
+  call_set("50");
+
+  CPPUNIT_ASSERT_THROW(call_set("4294967296"), torrent::input_error);
+  CPPUNIT_ASSERT_EQUAL(int64_t{50}, call_get("choke_group.up.max"));
+
+  CPPUNIT_ASSERT_THROW(call_set("-2"), torrent::input_error);
+  CPPUNIT_ASSERT_EQUAL(int64_t{50}, call_get("choke_group.up.max"));
+}

test/src/test_command_groups.h

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

test/src/test_command_tracker.cc

@@ -0,0 +1,73 @@
+#include "config.h"
+
+#include "test/src/test_command_tracker.h"
+
+#include <torrent/runtime/network_config.h>
+#include <torrent/torrent.h>
+
+#include "control.h"
+#include "globals.h"
+#include "command_helpers.h"
+#include "rpc/parse_commands.h"
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestCommandTracker);
+
+void initialize_command_tracker();
+
+static void
+call_set(const char* value) {
+  rpc::commands.call_command("dht.override_port.set", torrent::Object(std::string(value)));
+}
+
+static uint16_t
+override_port() {
+  return torrent::runtime::network_config()->override_dht_port();
+}
+
+void
+TestCommandTracker::setUp() {
+  torrent::initialize_main_thread();
+  torrent::initialize();
+
+  if (control == nullptr)
+    control = new Control;
+
+  if (!rpc::commands.has("dht.override_port.set"))
+    initialize_command_tracker();
+}
+
+void
+TestCommandTracker::tearDown() {
+  torrent::cleanup();
+}
+
+void
+TestCommandTracker::test_dht_override_port_in_range() {
+  call_set("6881");
+  CPPUNIT_ASSERT_EQUAL(uint16_t{6881}, override_port());
+
+  call_set("65535");
+  CPPUNIT_ASSERT_EQUAL(uint16_t{65535}, override_port());
+}
+
+void
+TestCommandTracker::test_dht_override_port_out_of_range() {
+  call_set("6881");
+
+  CPPUNIT_ASSERT_THROW(call_set("70000"), torrent::input_error);
+  CPPUNIT_ASSERT_EQUAL(uint16_t{6881}, override_port());
+
+  CPPUNIT_ASSERT_THROW(call_set("-1"), torrent::input_error);
+  CPPUNIT_ASSERT_EQUAL(uint16_t{6881}, override_port());
+}
+
+void
+TestCommandTracker::test_checked_port_value() {
+  CPPUNIT_ASSERT_EQUAL(uint16_t{0}, checked_port_value(0, "test"));
+  CPPUNIT_ASSERT_EQUAL(uint16_t{6881}, checked_port_value(6881, "test"));
+  CPPUNIT_ASSERT_EQUAL(uint16_t{65535}, checked_port_value(65535, "test"));
+
+  CPPUNIT_ASSERT_THROW(checked_port_value(-1, "test"), torrent::input_error);
+  CPPUNIT_ASSERT_THROW(checked_port_value(65536, "test"), torrent::input_error);
+  CPPUNIT_ASSERT_THROW(checked_port_value(4294967296, "test"), torrent::input_error);
+}

test/src/test_command_tracker.h

@@ -0,0 +1,19 @@
+#include "test/helpers/test_fixture.h"
+
+class TestCommandTracker : public test_fixture {
+  CPPUNIT_TEST_SUITE(TestCommandTracker);
+
+  CPPUNIT_TEST(test_dht_override_port_in_range);
+  CPPUNIT_TEST(test_dht_override_port_out_of_range);
+  CPPUNIT_TEST(test_checked_port_value);
+
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void test_dht_override_port_in_range();
+  void test_dht_override_port_out_of_range();
+  void test_checked_port_value();
+};

test/src/test_download_list.cc

@@ -0,0 +1,68 @@
+#include "config.h"
+
+#include "test/src/test_download_list.h"
+
+#include <cstdio>
+#include <torrent/download.h>
+#include <torrent/download_info.h>
+#include <torrent/hash_string.h>
+#include <torrent/object.h>
+#include <torrent/torrent.h>
+
+#include "control.h"
+#include "core/download.h"
+#include "globals.h"
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TestDownloadList);
+
+static std::string
+insert_download(core::DownloadList* list) {
+  torrent::Object info = torrent::Object::create_map();
+  info.insert_key("name", std::string("test_download_list"));
+  info.insert_key("length", int64_t{16});
+  info.insert_key("piece length", int64_t{262144});
+  info.insert_key("pieces", std::string(20, char(0)));
+
+  auto* object = new torrent::Object(torrent::Object::create_map());
+  object->insert_key("info", info);
+
+  auto download = torrent::download_add(object, 0);
+  list->insert(new core::Download(download));
+
+  char buffer[41];
+
+  for (unsigned int i = 0; i < torrent::HashString::size_data; i++)
+    snprintf(buffer + i * 2, 3, "%02x", static_cast<unsigned char>(download.info()->hash()[i]));
+
+  return std::string(buffer, 40);
+}
+
+void
+TestDownloadList::setUp() {
+  torrent::initialize_main_thread();
+  torrent::initialize();
+
+  if (control == nullptr)
+    control = new Control;
+
+  m_hex = insert_download(&m_list);
+}
+
+void
+TestDownloadList::tearDown() {
+  m_list.clear();
+
+  torrent::cleanup();
+}
+
+void
+TestDownloadList::test_find_hex() {
+  CPPUNIT_ASSERT(m_list.find_hex(m_hex.c_str()) != m_list.end());
+}
+
+void
+TestDownloadList::test_find_hex_wrong_length() {
+  CPPUNIT_ASSERT(m_list.find_hex((m_hex + "f").c_str()) == m_list.end());
+  CPPUNIT_ASSERT(m_list.find_hex((m_hex + m_hex).c_str()) == m_list.end());
+  CPPUNIT_ASSERT(m_list.find_hex(m_hex.substr(0, 39).c_str()) == m_list.end());
+}

test/src/test_download_list.h

@@ -0,0 +1,24 @@
+#include <string>
+
+#include "core/download_list.h"
+#include "test/helpers/test_fixture.h"
+
+class TestDownloadList : public test_fixture {
+  CPPUNIT_TEST_SUITE(TestDownloadList);
+
+  CPPUNIT_TEST(test_find_hex);
+  CPPUNIT_TEST(test_find_hex_wrong_length);
+
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void test_find_hex();
+  void test_find_hex_wrong_length();
+
+private:
+  core::DownloadList m_list;
+  std::string        m_hex;
+};