* 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

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 \

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();
+}
+
+}

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

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

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);

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.");
+// 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;
 
-  for ( ; first != last && (std::isalnum(*first) || *first == '_'); ++first)
-    dest->push_back(*first);
+  while (last != first && *--last == '\\')
+    escaped++;
 
-  return first;
-}
-
-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;
+parse_command_single(const char* first) {
+  parse_command(NULL, first, first + std::strlen(first));
+}
 
-      while (*last != '\n' && *last != '\0') last++;
+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);
 
-      // 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;
-
-      first = last + 1;
-    }
-
-  } 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;
+}
+
 }

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) {