Browse Source

* Allow ';' as a separator for multi-command lines. Not recognized by

the string parser, so it must be preceeded by whitespace.

* Allow escaping of newlines in the resource file.

* Cleanup of the parse_command_* commands.


git-svn-id: svn://rakshasa.no/libtorrent/trunk/rtorrent@936 e378c898-3ddf-0310-93e7-cc216c733640
pull/30/head
rakshasa 19 years ago
parent
commit
350bdfde7e
  1. 21
      rak/functional_fun.h
  2. 90
      src/command_download.cc
  3. 15
      src/command_events.cc
  4. 2
      src/command_local.cc
  5. 8
      src/command_network.cc
  6. 17
      src/command_ui.cc
  7. 2
      src/control.cc
  8. 6
      src/core/manager.cc
  9. 4
      src/core/manager.h
  10. 2
      src/rpc/Makefile.am
  11. 117
      src/rpc/exec_file.cc
  12. 57
      src/rpc/exec_file.h
  13. 10
      src/rpc/parse.cc
  14. 7
      src/rpc/parse.h
  15. 121
      src/rpc/parse_commands.cc
  16. 21
      src/rpc/parse_commands.h
  17. 2
      src/ui/download_list.cc
  18. 2
      src/ui/element_download_list.cc

21
rak/functional_fun.h

@ -351,6 +351,21 @@ private:
Arg1 m_arg1;
};
template <typename Result, typename Arg1, typename Arg2, typename Arg3>
class ptr_fn2_b1_t : public function_base2<Result, Arg2, Arg3> {
public:
typedef Result (*Func)(Arg1, Arg2, Arg3);
ptr_fn2_b1_t(Func func, const Arg1 arg1) : m_func(func), m_arg1(arg1) {}
virtual ~ptr_fn2_b1_t() {}
virtual Result operator () (Arg2 arg2, Arg3 arg3) { return m_func(m_arg1, arg2, arg3); }
private:
Func m_func;
Arg1 m_arg1;
};
template <typename Ftor>
class ftor_fn1_t : public function_base1<typename Ftor::result_type, typename Ftor::argument_type> {
public:
@ -519,6 +534,12 @@ bind_ptr_fn(Result (*func)(Arg1, Arg2), const Arg1 arg1) {
return new ptr_fn1_b1_t<Result, Arg1, Arg2>(func, arg1);
}
template <typename Arg1, typename Arg2, typename Arg3, typename Result>
inline function_base2<Result, Arg2, Arg3>*
bind_ptr_fn(Result (*func)(Arg1, Arg2, Arg3), const Arg1 arg1) {
return new ptr_fn2_b1_t<Result, Arg1, Arg2, Arg3>(func, arg1);
}
template <typename Ftor>
inline function_base1<typename Ftor::result_type, typename Ftor::argument_type>*
ftor_fn1(Ftor ftor) {

90
src/command_download.cc

@ -64,23 +64,23 @@ retrieve_d_base_path(core::Download* download) {
std::string
retrieve_d_base_filename(core::Download* download) {
std::string base;
const std::string* base;
if (download->file_list()->is_multi_file())
base = download->file_list()->root_dir();
base = &download->file_list()->root_dir();
else
base = download->file_list()->at(0)->frozen_path();
base = &download->file_list()->at(0)->frozen_path();
std::string::size_type split = base.rfind('/');
std::string::size_type split = base->rfind('/');
if (split == std::string::npos)
return base;
return *base;
else
return base.substr(split + 1);
return base->substr(split + 1);
}
torrent::Object
apply_d_create_link(core::Download* download, const torrent::Object& rawArgs) {
apply_d_change_link(int changeType, core::Download* download, const torrent::Object& rawArgs) {
const torrent::Object::list_type& args = rawArgs.as_list();
if (args.size() != 3)
@ -119,56 +119,28 @@ apply_d_create_link(core::Download* download, const torrent::Object& rawArgs) {
throw torrent::input_error("Unknown type argument.");
}
if (symlink(target.c_str(), link.c_str()) == -1)
// control->core()->push_log("create_link failed: " + std::string(rak::error_number::current().c_str()));
// control->core()->push_log("create_link failed: " + std::string(rak::error_number::current().c_str()) + " to " + target);
; // Disabled.
return torrent::Object();
}
torrent::Object
apply_d_delete_link(core::Download* download, const torrent::Object& rawArgs) {
const torrent::Object::list_type& args = rawArgs.as_list();
if (args.size() != 3)
throw torrent::input_error("Wrong argument count.");
torrent::Object::list_type::const_iterator itr = args.begin();
const std::string& type = (itr++)->as_string();
const std::string& prefix = (itr++)->as_string();
const std::string& postfix = (itr++)->as_string();
if (type.empty())
throw torrent::input_error("Invalid arguments.");
std::string link;
if (type == "base_path") {
link = rak::path_expand(prefix + rpc::call_command_d_string("get_d_base_path", download) + postfix);
} else if (type == "base_filename") {
link = rak::path_expand(prefix + rpc::call_command_d_string("get_d_base_filename", download) + postfix);
} else if (type == "tied") {
link = rak::path_expand(rpc::call_command_d_string("get_d_tied_to_file", download));
switch (changeType) {
case 0:
if (symlink(target.c_str(), link.c_str()) == -1)
// control->core()->push_log("create_link failed: " + std::string(rak::error_number::current().c_str()));
// control->core()->push_log("create_link failed: " + std::string(rak::error_number::current().c_str()) + " to " + target);
; // Disabled.
break;
if (link.empty())
return torrent::Object();
case 1:
{
rak::file_stat fileStat;
rak::error_number::clear_global();
link = rak::path_expand(prefix + link + postfix);
if (!fileStat.update_link(link) || !fileStat.is_link() ||
unlink(link.c_str()) == -1)
; // control->core()->push_log("delete_link failed: " + std::string(rak::error_number::current().c_str()));
} else {
throw torrent::input_error("Unknown type argument.");
break;
}
default:
break;
}
rak::file_stat fileStat;
rak::error_number::clear_global();
if (!fileStat.update_link(link) || !fileStat.is_link() ||
unlink(link.c_str()) == -1)
; // control->core()->push_log("delete_link failed: " + std::string(rak::error_number::current().c_str()));
return torrent::Object();
}
@ -181,7 +153,7 @@ apply_d_delete_tied(core::Download* download) {
return;
if (::unlink(rak::path_expand(tie).c_str()) == -1)
control->core()->push_log("Could not unlink tied file: " + std::string(rak::error_number::current().c_str()));
control->core()->push_log_std("Could not unlink tied file: " + std::string(rak::error_number::current().c_str()));
rpc::call_command_d("set_d_tied_to_file", download, std::string());
}
@ -295,8 +267,8 @@ initialize_command_download() {
ADD_CD_VOID("base_path", &retrieve_d_base_path);
ADD_CD_VOID("base_filename", &retrieve_d_base_filename);
ADD_CD_LIST("create_link", rak::ptr_fn(&apply_d_create_link));
ADD_CD_LIST("delete_link", rak::ptr_fn(&apply_d_delete_link));
ADD_CD_LIST("create_link", rak::bind_ptr_fn(&apply_d_change_link, 0));
ADD_CD_LIST("delete_link", rak::bind_ptr_fn(&apply_d_change_link, 1));
ADD_CD_V_VOID("delete_tied", &apply_d_delete_tied);
ADD_CD_F_VOID("start", rak::make_mem_fun(control->core()->download_list(), &core::DownloadList::start_normal));
@ -316,6 +288,12 @@ initialize_command_download() {
ADD_CD_VARIABLE_VALUE("state", "rtorrent", "state");
ADD_CD_VARIABLE_VALUE("complete", "rtorrent", "complete");
// 0 off
// 1 scheduled, being controlled by a download scheduler. Includes a priority.
// 3 forced off
// 2 forced on
ADD_CD_VARIABLE_VALUE("mode", "rtorrent", "mode");
// 0 - Not hashing
// 1 - Normal hashing
// 2 - Download finished, hashing

15
src/command_events.cc

@ -73,7 +73,7 @@ apply_on_state_change(core::DownloadList::slot_map* slotMap, const torrent::Obje
if (args.back().as_string().empty())
slotMap->erase(key);
else
(*slotMap)[key] = sigc::bind(sigc::ptr_fun(&rpc::parse_command_d_single_std), rpc::convert_list_to_command(++args.begin(), args.end()));
(*slotMap)[key] = sigc::bind(sigc::ptr_fun(&rpc::parse_command_d_multiple_std), rpc::convert_list_to_command(++args.begin(), args.end()));
return torrent::Object();
}
@ -203,15 +203,18 @@ void apply_load_start(const std::string& arg) { control->core()->try_cre
void apply_load_start_verbose(const std::string& arg) { control->core()->try_create_download_expand(arg, true, true, true); }
void apply_import(const std::string& path) { if (!rpc::parse_command_file(path)) throw torrent::input_error("Could not open option file: " + path); }
void apply_try_import(const std::string& path) { if (!rpc::parse_command_file(path)) control->core()->push_log("Could not read resource file: " + path); }
void apply_try_import(const std::string& path) { if (!rpc::parse_command_file(path)) control->core()->push_log_std("Could not read resource file: " + path); }
void
apply_close_low_diskspace(int64_t arg) {
core::Manager::DListItr itr = control->core()->download_list()->begin();
core::DownloadList* downloadList = control->core()->download_list();
core::Manager::DListItr itr = downloadList->begin();
while ((itr = std::find_if(itr, control->core()->download_list()->end(), std::mem_fun(&core::Download::is_downloading))) != control->core()->download_list()->end()) {
while ((itr = std::find_if(itr, downloadList->end(), std::mem_fun(&core::Download::is_downloading)))
!= downloadList->end()) {
if ((*itr)->file_list()->free_diskspace() < (uint64_t)arg) {
control->core()->download_list()->close(*itr);
downloadList->close(*itr);
(*itr)->set_hash_failed(true);
(*itr)->set_message(std::string("Low diskspace."));
@ -223,7 +226,7 @@ apply_close_low_diskspace(int64_t arg) {
torrent::Object
apply_download_list(const torrent::Object& rawArgs) {
const torrent::Object::list_type& args = rawArgs.as_list();
const torrent::Object::list_type& args = rawArgs.as_list();
torrent::Object::list_type::const_iterator argsItr = args.begin();
core::ViewManager* viewManager = control->view_manager();

2
src/command_local.cc

@ -81,4 +81,6 @@ initialize_command_local() {
ADD_COMMAND_VALUE_TRI_OCT("umask", rak::make_mem_fun(control, &Control::set_umask), rak::make_mem_fun(control, &Control::umask));
ADD_COMMAND_STRING_TRI("working_directory", rak::make_mem_fun(control, &Control::set_working_directory), rak::make_mem_fun(control, &Control::working_directory));
ADD_COMMAND_LIST("execute", rak::mem_fn(&rpc::execFile, &rpc::ExecFile::execute_object));
}

8
src/command_network.cc

@ -82,7 +82,7 @@ apply_encryption(const torrent::Object& rawArgs) {
else if (opt == "prefer_plaintext")
options_mask |= torrent::ConnectionManager::encryption_prefer_plaintext;
else
throw torrent::input_error("Invalid encryption option '" + opt + "'.");
throw torrent::input_error("Invalid encryption option.");
}
torrent::connection_manager()->set_encryption_options(options_mask);
@ -99,19 +99,14 @@ apply_tos(const torrent::Object& rawArg) {
if (arg == "default")
value = torrent::ConnectionManager::iptos_default;
else if (arg == "lowdelay")
value = torrent::ConnectionManager::iptos_lowdelay;
else if (arg == "throughput")
value = torrent::ConnectionManager::iptos_throughput;
else if (arg == "reliability")
value = torrent::ConnectionManager::iptos_reliability;
else if (arg == "mincost")
value = torrent::ConnectionManager::iptos_mincost;
else if (!rpc::parse_whole_value_nothrow(arg.c_str(), &value, 16, 1))
throw torrent::input_error("Invalid TOS identifier.");
@ -127,7 +122,6 @@ void apply_encoding_list(const std::string& arg) { torrent::encoding_list()->pus
void
apply_enable_trackers(int64_t arg) {
for (core::Manager::DListItr itr = control->core()->download_list()->begin(), last = control->core()->download_list()->end(); itr != last; ++itr) {
torrent::TrackerList tl = (*itr)->download()->tracker_list();
for (int i = 0, last = tl.size(); i < last; ++i)

17
src/command_ui.cc

@ -99,22 +99,27 @@ apply_view_sort(const torrent::Object& rawArgs) {
torrent::Object
apply_print(const torrent::Object& rawArgs) {
std::string output;
char buffer[1024];
char* current = buffer;
for (torrent::Object::list_type::const_iterator itr = rawArgs.as_list().begin(), last = rawArgs.as_list().end(); itr != last; itr++) {
switch (itr->type()) {
case torrent::Object::TYPE_STRING:
output += itr->as_string();
break;
{
int len = std::min<int>(itr->as_string().size(), buffer + 1024 - current);
std::memcpy(current, itr->as_string().c_str(), len);
current += len;
break;
}
case torrent::Object::TYPE_VALUE:
default:
output += "<unknown>";
current += snprintf(buffer, buffer + 1024 - current, "%lli", itr->as_value());
break;
}
}
control->core()->push_log(output);
control->core()->push_log(buffer);
return torrent::Object();
}

2
src/control.cc

@ -80,7 +80,7 @@ Control::Control() :
m_taskShutdown.set_slot(rak::mem_fn(this, &Control::handle_shutdown));
m_commandScheduler->set_slot_error_message(rak::mem_fn(m_core, &core::Manager::push_log));
m_commandScheduler->set_slot_error_message(rak::mem_fn(m_core, &core::Manager::push_log_std));
}
Control::~Control() {

6
src/core/manager.cc

@ -165,6 +165,12 @@ Manager::handshake_log(const sockaddr* sa, int msg, int err, const torrent::Hash
}
}
void
Manager::push_log(const char* msg) {
m_logImportant.push_front(msg);
m_logComplete.push_front(msg);
}
Manager::Manager() :
m_hashingView(NULL),

4
src/core/manager.h

@ -51,6 +51,7 @@ namespace core {
class DownloadStore;
class HttpQueue;
class View;
class Manager {
@ -92,7 +93,8 @@ public:
void shutdown(bool force);
void push_log(const std::string& msg) { m_logImportant.push_front(msg); m_logComplete.push_front(msg); }
void push_log(const char* msg);
void push_log_std(const std::string& msg) { m_logImportant.push_front(msg); m_logComplete.push_front(msg); }
void handshake_log(const sockaddr* sa, int msg, int err, const torrent::HashString* hash);

2
src/rpc/Makefile.am

@ -14,6 +14,8 @@ libsub_rpc_a_SOURCES = \
command_slot.h \
command_variable.cc \
command_variable.h \
exec_file.cc \
exec_file.h \
parse.cc \
parse.h \
parse_commands.cc \

117
src/rpc/exec_file.cc

@ -0,0 +1,117 @@
// rTorrent - BitTorrent client
// Copyright (C) 2006, 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 <jaris@ifi.uio.no>
//
// Skomakerveien 33
// 3185 Skoppum, NORWAY
#include "config.h"
#include <unistd.h>
#include "exec_file.h"
namespace rpc {
int
ExecFile::execute(const char* file, char* const* argv) {
pid_t childPid = fork();
if (childPid == -1)
throw torrent::input_error("ExecFile::execute(...) Fork failed.");
if (childPid == 0) {
// Close all fd's.
for (int i = 0, last = sysconf(_SC_OPEN_MAX); i != last; i++)
::close(i);
int result = execvp(file, argv);
_exit(result);
} else {
int status;
if (waitpid(childPid, &status, 0) != childPid)
throw torrent::internal_error("ExecFile::execute(...) waitpid failed.");
// Check return value?
return status;
}
}
torrent::Object
ExecFile::execute_object(const torrent::Object& rawArgs) {
char* argsBuffer[128];
char** argsCurrent = argsBuffer;
// Size of strings are less than 24.
char valueBuffer[3072];
char* valueCurrent = valueBuffer;
const torrent::Object::list_type& args = rawArgs.as_list();
if (args.empty())
throw torrent::input_error("Too few arguments.");
for (torrent::Object::list_type::const_iterator itr = args.begin(), last = args.end(); itr != last; itr++, argsCurrent++) {
if (argsCurrent == argsBuffer + 128 - 1)
throw torrent::input_error("Too many arguments.");
switch (itr->type()) {
case torrent::Object::TYPE_STRING:
*argsCurrent = const_cast<char*>(itr->as_string().c_str());
break;
case torrent::Object::TYPE_VALUE:
*argsCurrent = valueCurrent;
valueCurrent += std::max(snprintf(valueCurrent, valueBuffer + 3072 - valueCurrent, "%lli", itr->as_value()), 0);
break;
default:
throw torrent::input_error("Invalid type.");
}
}
*argsCurrent = NULL;
int status = execute(argsBuffer[0], argsBuffer);
if (status != 0)
throw torrent::input_error("ExecFile::execute_object(...) status != 0.");
return torrent::Object();
}
}

57
src/rpc/exec_file.h

@ -0,0 +1,57 @@
// rTorrent - BitTorrent client
// Copyright (C) 2006, 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 <jaris@ifi.uio.no>
//
// Skomakerveien 33
// 3185 Skoppum, NORWAY
#ifndef RTORRENT_RPC_EXEC_FILE_H
#define RTORRENT_RPC_EXEC_FILE_H
#include <torrent/object.h>
namespace rpc {
class ExecFile {
public:
int execute(const char* file, char* const* argv);
torrent::Object execute_object(const torrent::Object& rawArgs);
private:
};
}
#endif

10
src/rpc/parse.cc

@ -45,7 +45,7 @@ namespace rpc {
const char*
parse_skip_wspace(const char* first, const char* last) {
while (first != last && std::isspace(*first))
while (first != last && parse_is_space(*first))
first++;
return first;
@ -53,8 +53,7 @@ parse_skip_wspace(const char* first, const char* last) {
const char*
parse_skip_wspace(const char* first) {
// Assume isspace('\0') == false.
while (std::isspace(*first))
while (parse_is_space(*first))
first++;
return first;
@ -190,7 +189,7 @@ parse_list(const char* first, const char* last, torrent::Object* dest) {
return first;
}
void
const char*
parse_whole_list(const char* first, const char* last, torrent::Object* dest) {
std::string str;
@ -208,8 +207,7 @@ parse_whole_list(const char* first, const char* last, torrent::Object* dest) {
*dest = str;
}
if (first != last)
throw torrent::input_error("Junk at end of input.");
return first;
}
std::string

7
src/rpc/parse.h

@ -49,9 +49,10 @@ namespace rpc {
// parse_whole_* functions allow for whitespaces and throw an
// exception if there is any garbage at the end of the input.
inline bool parse_is_quote(const char c) { return c == '"'; }
inline bool parse_is_escape(const char c) { return c == '\\'; }
inline bool parse_is_quote(const char c) { return c == '"'; }
inline bool parse_is_escape(const char c) { return c == '\\'; }
inline bool parse_is_seperator(const char c) { return c == ','; }
inline bool parse_is_space(const char c) { return c == ' ' || c == '\t'; }
const char* parse_skip_wspace(const char* first);
const char* parse_skip_wspace(const char* first, const char* last);
@ -66,7 +67,7 @@ void parse_whole_value(const char* src, int64_t* value, int base = 0, int
bool parse_whole_value_nothrow(const char* src, int64_t* value, int base = 0, int unit = 1);
const char* parse_list(const char* first, const char* last, torrent::Object* dest);
void parse_whole_list(const char* first, const char* last, torrent::Object* dest);
const char* parse_whole_list(const char* first, const char* last, torrent::Object* dest);
std::string convert_list_to_string(const torrent::Object& src);
std::string convert_list_to_string(torrent::Object::list_type::const_iterator first, torrent::Object::list_type::const_iterator last);

121
src/rpc/parse_commands.cc

@ -50,44 +50,41 @@ namespace rpc {
CommandMap commands;
XmlRpc xmlrpc;
ExecFile execFile;
struct command_map_is_space : std::unary_function<char, bool> {
bool operator () (char c) const {
return std::isspace(c);
return c == ' ' || c == '\t';
}
};
struct command_map_is_newline : std::unary_function<char, bool> {
bool operator () (char c) const {
return c == '\n' || c == '\0';
return c == '\n' || c == '\0' || c == ';';
}
};
// Use a static length buffer for dest.
const char*
parse_command_name(const char* first, const char* last, std::string* dest) {
if (first == last || !std::isalpha(*first))
throw torrent::input_error("Invalid start of name.");
for ( ; first != last && (std::isalnum(*first) || *first == '_'); ++first)
dest->push_back(*first);
// Only escape eol on odd number of escape characters. We know that
// there can't be any characters in between, so this should work for
// all cases.
int
parse_count_escaped(const char* first, const char* last) {
int escaped = 0;
return first;
}
while (last != first && *--last == '\\')
escaped++;
void
parse_command_single(const char* first) {
parse_command_single(first, first + std::strlen(first));
return escaped;
}
// Set 'download' to NULL to call the generic functions, thus reusing
// the code below for both cases.
torrent::Object
parse_command_d_single(core::Download* download, const char* first, const char* last) {
std::pair<torrent::Object, const char*>
parse_command(core::Download* download, const char* first, const char* last) {
first = std::find_if(first, last, std::not1(command_map_is_space()));
if (first == last || *first == '#')
return torrent::Object();
return std::make_pair(torrent::Object(), first);
std::string key;
first = parse_command_name(first, last, &key);
@ -97,7 +94,19 @@ parse_command_d_single(core::Download* download, const char* first, const char*
throw torrent::input_error("Could not find '='.");
torrent::Object args;
parse_whole_list(first + 1, last, &args);
first = parse_whole_list(first + 1, last, &args);
// Find the last character that is part of this command, skipping
// the whitespace at the end. This ensures us that the caller
// doesn't need to do this nor check for junk at the end.
first = std::find_if(first, last, std::not1(command_map_is_space()));
if (first != last) {
if (*first != '\n' && *first != ';' && *first != '\0')
throw torrent::input_error("Junk at end of input.");
first++;
}
// Replace any strings starting with '$' with the result of the
// following command.
@ -118,32 +127,30 @@ parse_command_d_single(core::Download* download, const char* first, const char*
args = parse_command_d_single(download, str.c_str() + 1, str.c_str() + str.size());
}
return commands.call_command_d(key.c_str(), download, args);
return std::make_pair(commands.call_command_d(key.c_str(), download, args), first);
}
void
parse_command_multiple(const char* first) {
try {
while (first != '\0') {
const char* last = first;
while (*last != '\n' && *last != '\0') last++;
// Should we check the return value? Probably not necessary as
// parse_args throws on unquoted multi-word input.
parse_command_single(first, last);
if (*last == '\0')
return;
parse_command_single(const char* first) {
parse_command(NULL, first, first + std::strlen(first));
}
first = last + 1;
}
void
parse_command_multiple(core::Download* download, const char* first, const char* last) {
while (first != last) {
// Should we check the return value? Probably not necessary as
// parse_args throws on unquoted multi-word input.
std::pair<torrent::Object, const char*> result = parse_command(download, first, last);
} catch (torrent::input_error& e) {
throw torrent::input_error(std::string("Error parsing multi-line option: ") + e.what());
first = result.second;
}
}
void
parse_command_d_multiple(core::Download* download, const char* first) {
parse_command_multiple(download, first, first + std::strlen(first));
}
bool
parse_command_file(const std::string& path) {
std::fstream file(rak::path_expand(path).c_str(), std::ios::in);
@ -151,19 +158,37 @@ parse_command_file(const std::string& path) {
if (!file.is_open())
return false;
int lineNumber = 0;
char buffer[2048];
unsigned int lineNumber = 0;
char buffer[4096];
try {
unsigned int getCount = 0;
while (file.getline(buffer + getCount, 4096 - getCount).good()) {
if (file.gcount() == 0)
throw torrent::internal_error("parse_command_file(...) file.gcount() == 0.");
int escaped = parse_count_escaped(buffer + getCount, buffer + getCount + file.gcount() - 1);
while (file.getline(buffer, 2048).good()) {
lineNumber++;
getCount += file.gcount() - 1;
if (getCount == 4096 - 1)
throw torrent::input_error("Exceeded max line lenght.");
if (escaped & 0x1) {
// Remove the escape characters and continue reading.
getCount -= escaped;
continue;
}
// Would be nice to make this zero-copy.
parse_command_single(buffer, buffer + std::strlen(buffer));
parse_command(NULL, buffer, buffer + getCount);
getCount = 0;
}
} catch (torrent::input_error& e) {
snprintf(buffer, 2048, "Error in option file: %s:%i: %s", path.c_str(), lineNumber, e.what());
snprintf(buffer, 2048, "Error in option file: %s:%u: %s", path.c_str(), lineNumber, e.what());
throw torrent::input_error(buffer);
}
@ -171,4 +196,16 @@ parse_command_file(const std::string& path) {
return true;
}
// Use a static length buffer for dest.
const char*
parse_command_name(const char* first, const char* last, std::string* dest) {
if (first == last || !std::isalpha(*first))
throw torrent::input_error("Invalid start of name.");
for ( ; first != last && (std::isalnum(*first) || *first == '_'); ++first)
dest->push_back(*first);
return first;
}
}

21
src/rpc/parse_commands.h

@ -40,6 +40,7 @@
#include <string>
#include "command_map.h"
#include "exec_file.h"
#include "xmlrpc.h"
namespace core {
@ -51,16 +52,24 @@ namespace rpc {
// Move to another file?
extern CommandMap commands;
extern XmlRpc xmlrpc;
extern ExecFile execFile;
const char* parse_command_name(const char* first, const char* last, std::string* dest);
// The generic parse command function, used by the rest. At some point
// the 'download' parameter should be replaced by a more generic one.
std::pair<torrent::Object, const char*> parse_command(core::Download* download, const char* first, const char* last);
void parse_command_single(const char* first);
void parse_command_single(const char* first);
inline torrent::Object parse_command_single(const char* first, const char* last) { return parse_command(NULL, first, last).first; }
inline torrent::Object parse_command_d_single(core::Download* download, const char* first, const char* last) { return parse_command(download, first, last).first; }
torrent::Object parse_command_d_single(core::Download* download, const char* first, const char* last);
inline torrent::Object parse_command_single(const char* first, const char* last) { return parse_command_d_single(NULL, first, last); }
void parse_command_multiple(core::Download* download, const char* first, const char* last);
void parse_command_multiple(const char* first);
bool parse_command_file(const std::string& path);
void parse_command_d_multiple(core::Download* download, const char* first);
inline void parse_command_d_multiple_std(core::Download* download, const std::string& cmd) { parse_command_d_multiple(download, cmd.c_str()); }
inline void parse_command_multiple(const char* first) { parse_command_d_multiple(NULL, first); }
bool parse_command_file(const std::string& path);
const char* parse_command_name(const char* first, const char* last, std::string* dest);
inline void
parse_command_single_std(const std::string& cmd) {

2
src/ui/download_list.cc

@ -288,7 +288,7 @@ DownloadList::receive_exit_input(Input type) {
throw torrent::input_error("No download in focus to change root directory.");
rpc::call_command_d("set_d_directory", *current_view()->focus(), rak::trim(input->str()));
control->core()->push_log("New root directory \"" + rpc::call_command_d_string("get_d_directory", *current_view()->focus()) + "\" for torrent.");
control->core()->push_log_std("New root directory \"" + rpc::call_command_d_string("get_d_directory", *current_view()->focus()) + "\" for torrent.");
break;
case INPUT_COMMAND:

2
src/ui/element_download_list.cc

@ -234,7 +234,7 @@ ElementDownloadList::receive_change_view(const std::string& name) {
core::ViewManager::iterator itr = control->view_manager()->find(name);
if (itr == control->view_manager()->end()) {
control->core()->push_log("Could not find view \"" + name + "\".");
control->core()->push_log_std("Could not find view \"" + name + "\".");
return;
}

Loading…
Cancel
Save