fujin/rtorrent
1
0
Fork 0
mirror of https://github.com/rakshasa/rtorrent.git synced 2026-10-06 14:19:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

* Proper fault handling for bad SCGI requests.

Browse Source 
* Cleaned up duplicate code in 'xmlrpc.cc'.

* Cleaned up 'parse_commands.h'.


git-svn-id: svn://rakshasa.no/libtorrent/trunk/rtorrent@966 e378c898-3ddf-0310-93e7-cc216c733640
This commit is contained in:
rakshasa
2007-08-27 23:00:48 +00:00
parent 02b790c0bf
commit 32b74ffc48
19 changed files with 161 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/rpc/command_map.cc
+17
View File
@@ -144,4 +144,21 @@ CommandMap::call_command(key_type key, const mapped_type& arg, target_type targe
}
}
const CommandMap::mapped_type
CommandMap::call_command(const_iterator itr, const mapped_type& arg, target_type target) {
if ((itr->second.m_target != target.first && itr->second.m_target != target_generic) ||
(itr->second.m_target != target_generic && target.second == NULL))
throw torrent::input_error("Command type mis-match.");
// This _should_ be optimized int just two calls.
switch (itr->second.m_target) {
case target_generic: return itr->second.m_genericSlot(itr->second.m_variable, arg);
case target_download: return itr->second.m_downloadSlot(itr->second.m_variable, (core::Download*)target.second, arg);
case target_file: return itr->second.m_fileSlot(itr->second.m_variable, (torrent::File*)target.second, arg);
case target_peer: return itr->second.m_peerSlot(itr->second.m_variable, (torrent::Peer*)target.second, arg);
case target_tracker: return itr->second.m_trackerSlot(itr->second.m_variable, (torrent::Tracker*)target.second, arg);
default: throw torrent::internal_error("CommandMap::call_command(...) Invalid target.");
}
}
}
src/rpc/command_map.h
+6 -1
View File
@@ -73,6 +73,8 @@ struct command_map_data_type {
command_map_data_type(Command* variable, int flags, const char* parm, const char* doc) :
m_variable(variable), m_flags(flags), m_parm(parm), m_doc(doc) {}
int target() const { return m_target; }
Command* m_variable;
union {
@@ -104,6 +106,7 @@ public:
typedef mapped_type::value_type mapped_value_type;
using base_type::iterator;
using base_type::const_iterator;
using base_type::key_type;
using base_type::value_type;
@@ -138,7 +141,9 @@ public:
void insert(key_type key, const command_map_data_type src);
const mapped_type call_command (key_type key, const mapped_type& arg, target_type target = target_type((int)target_generic, NULL));
const mapped_type call_command (key_type key, const mapped_type& arg, target_type target = target_type((int)target_generic, NULL));
const mapped_type call_command (const_iterator itr, const mapped_type& arg, target_type target = target_type((int)target_generic, NULL));
const mapped_type call_command_d(key_type key, core::Download* download, const mapped_type& arg) { return call_command(key, arg, target_type((int)target_download, download)); }
const mapped_type call_command_f(key_type key, torrent::File* file, const mapped_type& arg) { return call_command(key, arg, target_type((int)target_file, file)); }
const mapped_type call_command_p(key_type key, torrent::Peer* peer, const mapped_type& arg) { return call_command(key, arg, target_type((int)target_peer, peer)); }
src/rpc/parse_commands.h
+18 -19
View File
@@ -50,26 +50,29 @@ namespace core {
namespace rpc {
typedef CommandMap::target_type target_type;
// Move to another file?
extern CommandMap commands;
extern XmlRpc xmlrpc;
extern ExecFile execFile;
inline CommandMap::target_type make_target() { return CommandMap::target_type((int)CommandMap::target_generic, NULL); }
inline CommandMap::target_type make_target(core::Download* target) { return CommandMap::target_type((int)CommandMap::target_download, target); }
inline CommandMap::target_type make_target(torrent::File* target) { return CommandMap::target_type((int)CommandMap::target_file, target); }
inline CommandMap::target_type make_target(torrent::Peer* target) { return CommandMap::target_type((int)CommandMap::target_peer, target); }
inline CommandMap::target_type make_target(torrent::Tracker* target) { return CommandMap::target_type((int)CommandMap::target_tracker, target); }
inline target_type make_target() { return target_type((int)CommandMap::target_generic, NULL); }
inline target_type make_target(core::Download* target) { return target_type((int)CommandMap::target_download, target); }
inline target_type make_target(torrent::File* target) { return target_type((int)CommandMap::target_file, target); }
inline target_type make_target(torrent::Peer* target) { return target_type((int)CommandMap::target_peer, target); }
inline target_type make_target(torrent::Tracker* target) { return target_type((int)CommandMap::target_tracker, target); }
inline target_type make_target(int type, void* target) { return target_type(type, target); }
typedef std::pair<torrent::Object, const char*> parse_command_type;
// The generic parse command function, used by the rest. At some point
// the 'download' parameter should be replaced by a more generic one.
parse_command_type parse_command(CommandMap::target_type target, const char* first, const char* last);
void parse_command_multiple(CommandMap::target_type target, const char* first, const char* last);
parse_command_type parse_command(target_type target, const char* first, const char* last);
void parse_command_multiple(target_type target, const char* first, const char* last);
inline void parse_command_single(CommandMap::target_type target, const char* first) { parse_command(target, first, first + std::strlen(first)); }
inline void parse_command_multiple(CommandMap::target_type target, const char* first) { parse_command_multiple(target, first, first + std::strlen(first)); }
inline void parse_command_single(target_type target, const char* first) { parse_command(target, first, first + std::strlen(first)); }
inline void parse_command_multiple(target_type target, const char* first) { parse_command_multiple(target, first, first + std::strlen(first)); }
bool parse_command_file(const std::string& path);
const char* parse_command_name(const char* first, const char* last, std::string* dest);
@@ -94,22 +97,18 @@ parse_command_d_multiple_std(core::Download* download, const std::string& cmd) {
parse_command_multiple(make_target(download), cmd.c_str(), cmd.c_str() + cmd.size());
}
inline torrent::Object call_command(const char* key, const torrent::Object& obj) { return commands.call_command(key, obj); }
inline torrent::Object call_command_void(const char* key) { return commands.call_command(key, torrent::Object()); }
inline std::string call_command_string(const char* key) { return commands.call_command(key, torrent::Object()).as_string(); }
inline int64_t call_command_value(const char* key) { return commands.call_command(key, torrent::Object()).as_value(); }
// inline torrent::Object call_command(const char* key, const torrent::Object& obj, target_type target = target_type((int)CommandMap::target_generic, NULL)) { return commands.call_command(key, obj); }
inline torrent::Object call_command (const char* key, const torrent::Object& obj, target_type target = make_target()) { return commands.call_command(key, obj, target); }
inline torrent::Object call_command_void (const char* key, target_type target = make_target()) { return commands.call_command(key, torrent::Object(), target); }
inline std::string call_command_string(const char* key, target_type target = make_target()) { return commands.call_command(key, torrent::Object(), target).as_string(); }
inline int64_t call_command_value (const char* key, target_type target = make_target()) { return commands.call_command(key, torrent::Object(), target).as_value(); }
inline void call_command_set_string(const char* key, const std::string& arg) { commands.call_command(key, torrent::Object(arg)); }
inline void call_command_set_std_string(const std::string& key, const std::string& arg) { commands.call_command(key.c_str(), torrent::Object(arg)); }
inline torrent::Object call_command_d(const char* key, core::Download* download, const torrent::Object& obj) { return commands.call_command_d(key, download, obj); }
inline torrent::Object call_command_d_void(const char* key, core::Download* download) { return commands.call_command_d(key, download, torrent::Object()); }
inline std::string call_command_d_string(const char* key, core::Download* download) { return commands.call_command_d(key, download, torrent::Object()).as_string(); }
inline int64_t call_command_d_value(const char* key, core::Download* download) { return commands.call_command_d(key, download, torrent::Object()).as_value(); }
inline void call_command_d_v_void(const char* key, core::Download* download) { commands.call_command_d(key, download, torrent::Object()); }
inline void call_command_d_set_value(const char* key, core::Download* download, int64_t arg) { commands.call_command_d(key, download, torrent::Object(arg)); }
inline void call_command_set_value(const char* key, int64_t arg, target_type target = make_target()) { commands.call_command(key, torrent::Object(arg), target); }
inline void call_command_d_set_string(const char* key, core::Download* download, const std::string& arg) { commands.call_command_d(key, download, torrent::Object(arg)); }
inline void call_command_d_set_std_string(const std::string& key, core::Download* download, const std::string& arg) { commands.call_command_d(key.c_str(), download, torrent::Object(arg)); }
src/rpc/scgi_task.cc
+8 -5
View File
@@ -97,8 +97,8 @@ void
SCgiTask::event_read() {
int bytes = ::recv(m_fileDesc, m_position, m_bufferSize - (m_position - m_buffer), 0);
if (bytes == -1) {
if (!rak::error_number::current().is_blocked_momentary())
if (bytes <= 0) {
if (bytes == 0 || !rak::error_number::current().is_blocked_momentary())
close();
return;
@@ -116,10 +116,12 @@ SCgiTask::event_read() {
int contentSize;
int headerSize = strtol(m_buffer, &current, 0);
if (current == m_buffer || current == m_position)
if (current == m_position)
return;
if (*current != ':' || headerSize < 17 || headerSize > max_header_size)
// If the request doesn't start with an integer or if it didn't
// end in ':', then close the connection.
if (current == m_buffer || *current != ':' || headerSize < 17 || headerSize > max_header_size)
goto event_read_failed;
if (std::distance(++current, m_position) < headerSize + 1)
@@ -171,7 +173,8 @@ SCgiTask::event_read() {
return;
event_read_failed:
throw torrent::internal_error("SCgiTask::event_read() fault not handled.");
// throw torrent::internal_error("SCgiTask::event_read() fault not handled.");
close();
}
void
src/rpc/scgi_task.h
+1 -1
View File
@@ -51,7 +51,7 @@ class SCgiTask : public torrent::Event {
public:
static const unsigned int default_buffer_size = 2047;
static const int max_header_size = 2000;
static const int max_content_size = (128 << 10);
static const int max_content_size = (2 << 20);
SCgiTask() { m_fileDesc = -1; }
src/rpc/xmlrpc.cc
+10 -61
View File
@@ -373,64 +373,22 @@ object_to_xmlrpc(xmlrpc_env* env, const torrent::Object& object) {
xmlrpc_value*
xmlrpc_call_command(xmlrpc_env* env, xmlrpc_value* args, void* voidServerInfo) {
torrent::Object object = xmlrpc_to_object(env, args);
CommandMap::const_iterator itr = commands.find((const char*)voidServerInfo);
if (env->fault_occurred)
return NULL;
try {
return object_to_xmlrpc(env, rpc::call_command((const char*)voidServerInfo, object));
} catch (torrent::local_error& e) {
xmlrpc_env_set_fault(env, XMLRPC_PARSE_ERROR, e.what());
if (itr == commands.end()) {
xmlrpc_env_set_fault(env, XMLRPC_PARSE_ERROR, ("Command \"" + std::string((const char*)voidServerInfo) + "\" does not exist.").c_str());
return NULL;
}
}
xmlrpc_value*
xmlrpc_call_command_d(xmlrpc_env* env, xmlrpc_value* args, void* voidServerInfo) {
core::Download* download = NULL;
torrent::Object object = xmlrpc_to_object_target(env, args, XmlRpc::call_download, (void**)&download);
int type = itr->second.target();
void* target = NULL;
torrent::Object object = (type == 0) ? xmlrpc_to_object(env, args) : xmlrpc_to_object_target(env, args, type, &target);
if (env->fault_occurred)
return NULL;
try {
return object_to_xmlrpc(env, rpc::call_command_d((const char*)voidServerInfo, download, object));
} catch (torrent::local_error& e) {
xmlrpc_env_set_fault(env, XMLRPC_PARSE_ERROR, e.what());
return NULL;
}
}
xmlrpc_value*
xmlrpc_call_command_f(xmlrpc_env* env, xmlrpc_value* args, void* voidServerInfo) {
torrent::File* file = NULL;
torrent::Object object = xmlrpc_to_object_target(env, args, XmlRpc::call_file, (void**)&file);
if (env->fault_occurred)
return NULL;
try {
return object_to_xmlrpc(env, rpc::commands.call_command_f((const char*)voidServerInfo, file, object));
} catch (torrent::local_error& e) {
xmlrpc_env_set_fault(env, XMLRPC_PARSE_ERROR, e.what());
return NULL;
}
}
xmlrpc_value*
xmlrpc_call_command_t(xmlrpc_env* env, xmlrpc_value* args, void* voidServerInfo) {
torrent::Tracker* tracker = NULL;
torrent::Object object = xmlrpc_to_object_target(env, args, XmlRpc::call_tracker, (void**)&tracker);
if (env->fault_occurred)
return NULL;
try {
return object_to_xmlrpc(env, rpc::commands.call_command_t((const char*)voidServerInfo, tracker, object));
return object_to_xmlrpc(env, rpc::commands.call_command(itr, object, rpc::make_target(type, target)));
} catch (torrent::local_error& e) {
xmlrpc_env_set_fault(env, XMLRPC_PARSE_ERROR, e.what());
@@ -476,21 +434,12 @@ XmlRpc::process(const char* inBuffer, uint32_t length, slot_write slotWrite) {
}
void
XmlRpc::insert_command(const char* name, const char* parm, const char* doc, int call) {
XmlRpc::insert_command(const char* name, const char* parm, const char* doc) {
xmlrpc_env localEnv;
xmlrpc_env_init(&localEnv);
xmlrpc_value* (*callSlot)(xmlrpc_env*, xmlrpc_value*, void*);
switch (call) {
case call_download: callSlot = &xmlrpc_call_command_d; break;
case call_file: callSlot = &xmlrpc_call_command_f; break;
case call_tracker: callSlot = &xmlrpc_call_command_t; break;
default: callSlot = &xmlrpc_call_command; break;
}
xmlrpc_registry_add_method_w_doc(&localEnv, (xmlrpc_registry*)m_registry, NULL, name,
callSlot, const_cast<char*>(name), parm, doc);
&xmlrpc_call_command, const_cast<char*>(name), parm, doc);
if (localEnv.fault_occurred)
throw torrent::internal_error("Fault occured while inserting xmlrpc call.");
@@ -539,7 +488,7 @@ XmlRpc::set_dialect(int dialect) {
void XmlRpc::initialize() { throw torrent::resource_error("XMLRPC not supported."); }
void XmlRpc::cleanup() {}
void XmlRpc::insert_command(__UNUSED const char* name, __UNUSED const char* parm, __UNUSED const char* doc, __UNUSED int call) {}
void XmlRpc::insert_command(__UNUSED const char* name, __UNUSED const char* parm, __UNUSED const char* doc) {}
void XmlRpc::set_dialect(__UNUSED int dialect) {}
bool XmlRpc::process(__UNUSED const char* inBuffer, __UNUSED uint32_t length, __UNUSED slot_write slotWrite) { return false; }
src/rpc/xmlrpc.h
+2 -1
View File
@@ -62,6 +62,7 @@ public:
static const int dialect_i8 = 1;
static const int dialect_apache = 2;
// These need to match CommandMap type values.
static const int call_generic = 0;
static const int call_download = 1;
static const int call_file = 2;
@@ -76,7 +77,7 @@ public:
bool process(const char* inBuffer, uint32_t length, slot_write slotWrite);
void insert_command(const char* name, const char* parm, const char* doc, int call);
void insert_command(const char* name, const char* parm, const char* doc);
int dialect() { return m_dialect; }
void set_dialect(int dialect);