/// Thrown by built-in 'exit' command
struct ExitException {};
+ /// Executor policy function
+ typedef boost::function<void (DirectoryNode &,std::string const &)> SecurityPolicy;
+
+ /// Thrown by the SecurityPolicy to silently ignore a command
+ struct IgnoreCommandException {};
+
+ typedef void result_type;
+
///////////////////////////////////////////////////////////////////////////
//\/name Structors and default members
///\{
/**< Output will be written to \a output.
Same as execute(). */
DirectoryNode & cwd() const; ///< Current working directory
+ std::string cwdPath() const; ///< Return pathname of current directory
+ bool skipping() const; ///< \c true, if currently skipping a directory group
+
+ bool autocd() const; ///< Get current autocd status
+ /**< if autocd is enabled, specifying a directory name as
+ command will cd to that directory. Disabled by
+ default (but enabled automatically by the interactive
+ console). */
+ Executor & autocd(bool v); ///< Set autocd status
+ /**< \see autocd() */
+
+ bool autocomplete() const; ///< Get current autocomplete status
+ /**< if autocomplete is enabled, path components which can
+ be uniquely completed will be completed
+ automatically. Disabled by default (but enabled
+ automatically by the interactive console) void
+ autocomplete(bool v). */
+
+ Executor & autocomplete(bool v); ///< Set autocomplete status
+ /**< \see autocomplete() */
+
+ DirectoryNode & chroot() const; ///< Get root node
+ /**< The root node defaults to senf::console::root(). If
+ changed, all path references are relative to this node
+ and objects outside that tree cannot be accessed. */
+ Executor & chroot(DirectoryNode & node); ///< chroot into given directory
+ /**< After this call, all path's are interpreted relative to
+ \a node and only nodes in the tree rooted at \a node
+ are accessible via the executor. This value defaults to
+ senf::console::root(). */
+
+ Executor & policy(SecurityPolicy policy = SecurityPolicy()); ///< Set security policy
+ /**< The security policy is called before traversing a node
+ to validate that access. */
protected:
private:
- GenericNode & traverseNode(ParseCommandInfo::argument_value_type const & path);
- DirectoryNode & traverseDirectory(ParseCommandInfo::argument_value_type const & path);
- CommandNode & traverseCommand(ParseCommandInfo::CommandPathRange const & path);
+ typedef std::vector<DirectoryNode::weak_ptr> Path;
+
+ void exec(std::ostream & output, ParseCommandInfo const & command);
+
+ void cd(ParseCommandInfo::TokensRange dir);
+ void ls(std::ostream & output, ParseCommandInfo::TokensRange dir);
+ void pushd(ParseCommandInfo::TokensRange dir);
+ void popd();
+ void exit();
+ void help(std::ostream & output, ParseCommandInfo::TokensRange path);
+
+ GenericNode & traverseNode(ParseCommandInfo::TokensRange const & path);
+ void traverseDirectory(ParseCommandInfo::TokensRange const & path,
+ Path & dir);
+ std::string complete(DirectoryNode & dir, std::string const & name);
struct InvalidPathException {};
struct InvalidDirectoryException {};
struct InvalidCommandException {};
+
+ DirectoryNode::ptr root_;
+ SecurityPolicy policy_;
+ mutable Path cwd_;
+ Path oldCwd_;
- DirectoryNode::weak_ptr cwd_;
- DirectoryNode::weak_ptr oldCwd_;
- typedef std::vector<DirectoryNode::weak_ptr> DirStack;
+ typedef std::vector<Path> DirStack;
DirStack dirstack_;
- };
+ bool autocd_;
+ bool autocomplete_;
+ };
}}