Add JSON-RPC capability

src/Makefile.am

@@ -109,6 +109,10 @@ libsub_root_a_SOURCES = \
 	rpc/ip_table_list.h \
 	rpc/lua.h \
 	rpc/lua.cc \
+	rpc/jsonrpc.cc \
+	rpc/jsonrpc.h \
+	rpc/rpc_manager.cc \
+	rpc/rpc_manager.h \
 	rpc/object_storage.cc \
 	rpc/object_storage.h \
 	rpc/parse.cc \
@@ -127,6 +131,7 @@ libsub_root_a_SOURCES = \
 	rpc/xmlrpc_tinyxml2.cc \
 	rpc/tinyxml2/tinyxml2.h \
 	rpc/tinyxml2/tinyxml2.cc \
+	rpc/nlohmann/json.h \
 	\
 	ui/download.cc \
 	ui/download.h \
@@ -157,6 +162,7 @@ libsub_root_a_SOURCES = \
 	ui/root.cc \
 	ui/root.h \
 	\
+	utils/base64.cc \
 	utils/base64.h \
 	utils/directory.cc \
 	utils/directory.h \

src/command_dynamic.cc

@@ -187,7 +187,7 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
   if (!(flags & rpc::object_storage::flag_static))
     cmd_flags |= rpc::CommandMap::flag_modifiable;
   if (!(flags & rpc::object_storage::flag_private))
-    cmd_flags |= rpc::CommandMap::flag_public_xmlrpc;
+    cmd_flags |= rpc::CommandMap::flag_public_rpc;
 
   if ((flags & rpc::object_storage::mask_type) == rpc::object_storage::flag_list_type) {
     torrent::Object             valueList     = torrent::Object::create_list();
@@ -360,7 +360,7 @@ system_method_redirect(const torrent::Object::list_type& args) {
   std::string new_key  = torrent::object_create_string(args.front());
   std::string dest_key = torrent::object_create_string(args.back());
 
-  rpc::commands.create_redirect(new_key, dest_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_modifiable);
+  rpc::commands.create_redirect(new_key, dest_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_modifiable);
 
   return torrent::Object();
 }

src/command_helpers.h

@@ -49,7 +49,7 @@ void initialize_commands();
 
 #define CMD2_A_FUNCTION(key, function, slot, parm, doc)                 \
   rpc::commands.insert_slot<rpc::command_base_is_type<rpc::function>::type>(key, slot, &rpc::function, \
-                            rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, NULL, NULL);
+                            rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_rpc, NULL, NULL);
 
 #define CMD2_A_FUNCTION_PRIVATE(key, function, slot, parm, doc)         \
   rpc::commands.insert_slot<rpc::command_base_is_type<rpc::function>::type>(key, slot, &rpc::function,   \
@@ -137,19 +137,19 @@ void initialize_commands();
                                std::placeholders::_1, std::placeholders::_2));
 
 #define CMD2_REDIRECT(from_key, to_key) \
-  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_dont_delete);
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_dont_delete);
 #define CMD2_REDIRECT_GENERIC(from_key, to_key) \
-  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_dont_delete);
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_dont_delete);
 #define CMD2_REDIRECT_GENERIC_NO_EXPORT(from_key, to_key) \
   rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_dont_delete);
 #define CMD2_REDIRECT_FILE(from_key, to_key) \
-  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_file_target | rpc::CommandMap::flag_dont_delete);
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_file_target | rpc::CommandMap::flag_dont_delete);
 #define CMD2_REDIRECT_TRACKER(from_key, to_key) \
-  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_tracker_target | rpc::CommandMap::flag_dont_delete);
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_tracker_target | rpc::CommandMap::flag_dont_delete);
 
 #define CMD2_REDIRECT_GENERIC_STR(from_key, to_key)                     \
   rpc::commands.create_redirect(from_key, to_key, \
-                                rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_no_target);
+                                rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_no_target);
 
 #define CMD2_REDIRECT_GENERIC_STR_NO_EXPORT(from_key, to_key)                     \
   rpc::commands.create_redirect(from_key, to_key, \

src/command_logging.cc

@@ -142,5 +142,6 @@ initialize_command_logging() {
 
   CMD2_ANY_STRING  ("log.execute",    std::bind(&apply_log, std::placeholders::_2, 0));
   CMD2_ANY_STRING  ("log.vmmap.dump", std::bind(&log_vmmap_dump, std::placeholders::_2));
-  CMD2_ANY_STRING_V("log.xmlrpc",     std::bind(&ThreadWorker::set_xmlrpc_log, worker_thread, std::placeholders::_2));
+  CMD2_ANY_STRING_V("log.rpc",        std::bind(&ThreadWorker::set_rpc_log, worker_thread, std::placeholders::_2));
+  CMD2_REDIRECT    ("log.xmlrpc",     "log.rpc"); // For backwards compatibility
 }

src/command_network.cc

@@ -95,7 +95,7 @@ apply_tos(const torrent::Object::string_type& arg) {
 torrent::Object apply_encoding_list(const std::string& arg) { torrent::encoding_list()->push_back(arg); return torrent::Object(); }
 
 torrent::File*
-xmlrpc_find_file(core::Download* download, uint32_t index) {
+rpc_find_file(core::Download* download, uint32_t index) {
   if (index >= download->file_list()->size_files())
     return NULL;
 
@@ -104,15 +104,15 @@ xmlrpc_find_file(core::Download* download, uint32_t index) {
 
 // Ergh... time to update the Tracker API to allow proper ptrs.
 torrent::Tracker*
-xmlrpc_find_tracker(core::Download* download, uint32_t index) {
+rpc_find_tracker(core::Download* download, uint32_t index) {
   if (index >= download->tracker_list()->size())
     return NULL;
 
   return download->tracker_list()->at(index);
 }
 
 torrent::Peer*
-xmlrpc_find_peer(core::Download* download, const torrent::HashString& hash) {
+rpc_find_peer(core::Download* download, const torrent::HashString& hash) {
   torrent::ConnectionList::iterator itr = download->connection_list()->find(hash.c_str());
 
   if (itr == download->connection_list()->end())
@@ -122,32 +122,31 @@ xmlrpc_find_peer(core::Download* download, const torrent::HashString& hash) {
 }
 
 void
-initialize_xmlrpc() {
-  rpc::xmlrpc.initialize();
-  rpc::xmlrpc.slot_find_download() = std::bind(&core::DownloadList::find_hex_ptr, control->core()->download_list(), std::placeholders::_1);
-  rpc::xmlrpc.slot_find_file() = std::bind(&xmlrpc_find_file, std::placeholders::_1, std::placeholders::_2);
-  rpc::xmlrpc.slot_find_tracker() = std::bind(&xmlrpc_find_tracker, std::placeholders::_1, std::placeholders::_2);
-  rpc::xmlrpc.slot_find_peer() = std::bind(&xmlrpc_find_peer, std::placeholders::_1, std::placeholders::_2);
+initialize_rpc() {
+  rpc::rpc.initialize();
+  rpc::rpc.slot_find_download() = [](const char* hash) { return control->core()->download_list()->find_hex_ptr(hash); };
+  rpc::rpc.slot_find_file() = [](core::Download* d, uint32_t index) { return rpc_find_file(d, index); };
+  rpc::rpc.slot_find_tracker() = [](core::Download* d, uint32_t index) { return rpc_find_tracker(d, index); };
+  rpc::rpc.slot_find_peer() = [](core::Download* d, const torrent::HashString& hash) { return rpc_find_peer(d, hash); };
 
   unsigned int count = 0;
 
   for (rpc::CommandMap::const_iterator itr = rpc::commands.begin(), last = rpc::commands.end(); itr != last; itr++, count++) {
-    if (!(itr->second.m_flags & rpc::CommandMap::flag_public_xmlrpc))
+    if (!(itr->second.m_flags & rpc::CommandMap::flag_public_rpc))
       continue;
 
-    rpc::xmlrpc.insert_command(itr->first.c_str(), itr->second.m_parm, itr->second.m_doc);
+    rpc::rpc.insert_command(itr->first.c_str(), itr->second.m_parm, itr->second.m_doc);
   }
 
-  lt_log_print(torrent::LOG_RPC_EVENTS, "XMLRPC initialized with %u functions.", count);
+  lt_log_print(torrent::LOG_RPC_EVENTS, "RPC initialized with %u functions.", count);
 }
 
 torrent::Object
 apply_scgi(const std::string& arg, int type) {
   if (worker_thread->scgi() != NULL)
     throw torrent::input_error("SCGI already enabled.");
 
-  if (!rpc::xmlrpc.is_valid())
-    initialize_xmlrpc();
+  initialize_rpc();
 
   rpc::SCgi* scgi = new rpc::SCgi;
 
@@ -225,7 +224,7 @@ apply_xmlrpc_dialect(const std::string& arg) {
   else
     value = -1;
 
-  rpc::xmlrpc.set_dialect(value);
+  rpc::rpc.set_dialect(value);
   return torrent::Object();
 }
 
@@ -298,9 +297,12 @@ initialize_command_network() {
   CMD2_ANY_STRING  ("network.scgi.open_local",       std::bind(&apply_scgi, std::placeholders::_2, 2));
   CMD2_VAR_BOOL    ("network.scgi.dont_route",       false);
 
-  CMD2_ANY_STRING  ("network.xmlrpc.dialect.set",    std::bind(&apply_xmlrpc_dialect, std::placeholders::_2));
-  CMD2_ANY         ("network.xmlrpc.size_limit",     std::bind(&rpc::XmlRpc::size_limit, rpc::xmlrpc));
-  CMD2_ANY_VALUE_V ("network.xmlrpc.size_limit.set", std::bind(&rpc::XmlRpc::set_size_limit, rpc::xmlrpc, std::placeholders::_2));
+  CMD2_ANY_STRING  ("network.xmlrpc.dialect.set",    [](const auto&, const auto& arg) { return apply_xmlrpc_dialect(arg); })
+  CMD2_ANY         ("network.xmlrpc.size_limit",     [](const auto&, const auto&){ return rpc::rpc.size_limit(); });
+  CMD2_ANY_VALUE_V ("network.xmlrpc.size_limit.set", [](const auto&, const auto& arg){ return rpc::rpc.set_size_limit(arg); });
+
+  CMD2_VAR_BOOL    ("network.rpc.use_xmlrpc",        true);
+  CMD2_VAR_BOOL    ("network.rpc.use_jsonrpc",       true);
 
   CMD2_ANY         ("network.block.ipv4",            std::bind(&torrent::ConnectionManager::is_block_ipv4, cm));
   CMD2_ANY_VALUE_V ("network.block.ipv4.set",        std::bind(&torrent::ConnectionManager::set_block_ipv4, cm, std::placeholders::_2));

src/control.cc

@@ -93,7 +93,7 @@ Control::initialize() {
 void
 Control::cleanup() {
   //  delete m_scgi; m_scgi = NULL;
-  rpc::xmlrpc.cleanup();
+  rpc::rpc.cleanup();
 
   priority_queue_erase(&taskScheduler, &m_taskShutdown);
 

src/core/manager.cc

@@ -23,6 +23,7 @@
 
 #include "rpc/parse_commands.h"
 #include "utils/directory.h"
+#include "utils/base64.h"
 #include "utils/file_status_cache.h"
 
 #include "globals.h"
@@ -313,13 +314,29 @@ Manager::receive_http_failed(std::string msg) {
   push_log_std("Http download error: \"" + msg + "\"");
 }
 
+bool
+is_data_uri(const std::string& uri) {
+  return std::strncmp(uri.c_str(), "data:", 5) == 0;
+}
+
+std::string
+decode_data_uri(const std::string& uri) {
+  const auto start = uri.find("base64,", 5) + 7;
+  if (start == std::string::npos)
+    throw torrent::input_error("Invalid data uri: not base64 encoded.");
+  if (start >= uri.size())
+    throw torrent::input_error("Empty base64.");
+  return utils::decode_base64(uri.substr(start));
+}
+
 void
 Manager::try_create_download(const std::string& uri, int flags, const command_list_type& commands) {
   // If the path was attempted loaded before, skip it.
   if ((flags & create_tied) &&
       !(flags & create_raw_data) &&
       !is_network_uri(uri) &&
       !is_magnet_uri(uri) &&
+      !is_data_uri(uri) &&
       !file_status_cache()->insert(uri, 0))
     return;
 
@@ -333,10 +350,16 @@ Manager::try_create_download(const std::string& uri, int flags, const command_li
   f->set_print_log(!(flags & create_quiet));
   f->slot_finished([f]() { delete f; });
 
-  if (flags & create_raw_data)
+  if (is_data_uri(uri)) {
+    // Allow the use of data URIs, primarily for JSON-RPC which
+    // doesn't have a defined mechanism for binary data
+    f->load_raw_data(decode_data_uri(uri));
+    f->variables()["tied_to_file"] = (int64_t)false;
+  } else if (flags & create_raw_data) {
     f->load_raw_data(uri);
-  else
+  } else {
     f->load(uri);
+  }
 
   f->commit();
 }

src/rpc/command_map.cc

@@ -48,8 +48,7 @@
 #include "command.h"
 #include "command_map.h"
 
-// For XMLRPC stuff, clean up.
-#include "xmlrpc.h"
+#include "rpc_manager.h"
 #include "parse_commands.h"
 
 namespace rpc {
@@ -64,8 +63,8 @@ CommandMap::insert(const key_type& key, int flags, const char* parm, const char*
     throw torrent::internal_error("CommandMap::insert(...) tried to insert an already existing key.");
 
   // TODO: This is not honoring the public_xmlrpc flags!!!
-  if (rpc::xmlrpc.is_valid() && (flags & flag_public_xmlrpc))
-    rpc::xmlrpc.insert_command(key.c_str(), parm, doc);
+  if (rpc::rpc.is_initialized() && (flags & flag_public_rpc))
+    rpc::rpc.insert_command(key.c_str(), parm, doc);
 
   return base_type::insert(itr, value_type(key, command_map_data_type(flags, parm, doc)));
 }
@@ -102,11 +101,11 @@ CommandMap::create_redirect(const key_type& key_new, const key_type& key_dest, i
 
   dest_itr->second.m_flags |= flag_has_redirects;
 
-  flags |= dest_itr->second.m_flags & ~(flag_has_redirects | flag_public_xmlrpc);
+  flags |= dest_itr->second.m_flags & ~(flag_has_redirects | flag_public_rpc);
 
   // TODO: This is not honoring the public_xmlrpc flags!!!
-  if (rpc::xmlrpc.is_valid() && (flags & flag_public_xmlrpc))
-    rpc::xmlrpc.insert_command(key_new.c_str(), dest_itr->second.m_parm, dest_itr->second.m_doc);
+  if (rpc::rpc.is_initialized() && (flags & flag_public_rpc))
+    rpc::rpc.insert_command(key_new.c_str(), dest_itr->second.m_parm, dest_itr->second.m_doc);
 
   iterator itr = base_type::insert(base_type::end(),
                                    value_type(key_new, command_map_data_type(flags,

src/rpc/command_map.h

@@ -86,7 +86,7 @@ class CommandMap : public std::map<std::string, command_map_data_type> {
   using base_type::find;
 
   static const int flag_dont_delete   = 0x1;
-  static const int flag_public_xmlrpc = 0x4;
+  static const int flag_public_rpc    = 0x4;
   static const int flag_modifiable    = 0x10;
   static const int flag_is_redirect   = 0x20;
   static const int flag_has_redirects = 0x40;