12 files changed, 3145 insertions, 0 deletions

diff --git a/OpenSim/Framework/Console/AssemblyInfo.cs b/OpenSim/Framework/Console/AssemblyInfo.cs
new file mode 100644
index 0000000..67af471
--- /dev/null
+++ b/OpenSim/Framework/Console/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly : AssemblyTitle("ServerConsole")]
+[assembly : AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly : AssemblyProduct("ServerConsole")]
+[assembly: AssemblyCopyright("Copyright (c) OpenSimulator.org Developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+
+[assembly : ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly : AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Framework/Console/CommandConsole.cs b/OpenSim/Framework/Console/CommandConsole.cs
new file mode 100644
index 0000000..0f68afe
--- /dev/null
+++ b/OpenSim/Framework/Console/CommandConsole.cs
@@ -0,0 +1,793 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Xml;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using log4net;
+using OpenSim.Framework;
+
+namespace OpenSim.Framework.Console
+{
+    public class Commands : ICommands
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Encapsulates a command that can be invoked from the console
+        /// </summary>
+        private class CommandInfo
+        {
+            /// <value>
+            /// The module from which this command comes
+            /// </value>
+            public string module;
+            
+            /// <value>
+            /// Whether the module is shared
+            /// </value>
+            public bool shared;
+            
+            /// <value>
+            /// Very short BNF description
+            /// </value>
+            public string help_text;
+            
+            /// <value>
+            /// Longer one line help text
+            /// </value>
+            public string long_help;
+            
+            /// <value>
+            /// Full descriptive help for this command
+            /// </value>
+            public string descriptive_help;
+            
+            /// <value>
+            /// The method to invoke for this command
+            /// </value>
+            public List<CommandDelegate> fn;
+        }
+
+        public const string GeneralHelpText
+            = "To enter an argument that contains spaces, surround the argument with double quotes.\nFor example, show object name \"My long object name\"\n";
+
+        public const string ItemHelpText
+= @"For more information, type 'help all' to get a list of all commands, 
+  or type help <item>' where <item> is one of the following:";
+
+        /// <value>
+        /// Commands organized by keyword in a tree
+        /// </value>
+        private Dictionary<string, object> tree =
+                new Dictionary<string, object>();
+
+        /// <summary>
+        /// Commands organized by module
+        /// </summary>
+        private Dictionary<string, List<CommandInfo>> m_modulesCommands = new Dictionary<string, List<CommandInfo>>();
+
+        /// <summary>
+        /// Get help for the given help string
+        /// </summary>
+        /// <param name="helpParts">Parsed parts of the help string.  If empty then general help is returned.</param>
+        /// <returns></returns>
+        public List<string> GetHelp(string[] cmd)
+        {
+            List<string> help = new List<string>();
+            List<string> helpParts = new List<string>(cmd);
+            
+            // Remove initial help keyword
+            helpParts.RemoveAt(0);
+
+            help.Add(""); // Will become a newline.
+
+            // General help
+            if (helpParts.Count == 0)
+            {
+                help.Add(GeneralHelpText);
+                help.Add(ItemHelpText);
+                help.AddRange(CollectModulesHelp(tree));
+            }
+            else if (helpParts.Count == 1 && helpParts[0] == "all")
+            {
+                help.AddRange(CollectAllCommandsHelp());
+            }
+            else
+            {
+                help.AddRange(CollectHelp(helpParts));
+            }
+
+            help.Add(""); // Will become a newline.
+
+            return help;
+        }
+
+        /// <summary>
+        /// Collects the help from all commands and return in alphabetical order.
+        /// </summary>
+        /// <returns></returns>
+        private List<string> CollectAllCommandsHelp()
+        {
+            List<string> help = new List<string>();
+
+            lock (m_modulesCommands)
+            {
+                foreach (List<CommandInfo> commands in m_modulesCommands.Values)
+                {
+                    var ourHelpText = commands.ConvertAll(c => string.Format("{0} - {1}", c.help_text, c.long_help));
+                    help.AddRange(ourHelpText);
+                }
+            }
+
+            help.Sort();
+
+            return help;
+        }
+        
+        /// <summary>
+        /// See if we can find the requested command in order to display longer help
+        /// </summary>
+        /// <param name="helpParts"></param>
+        /// <returns></returns>
+        private List<string> CollectHelp(List<string> helpParts)
+        {
+            string originalHelpRequest = string.Join(" ", helpParts.ToArray());
+            List<string> help = new List<string>();
+
+            // Check modules first to see if we just need to display a list of those commands
+            if (TryCollectModuleHelp(originalHelpRequest, help))
+            {
+                help.Insert(0, ItemHelpText);
+                return help;
+            }
+            
+            Dictionary<string, object> dict = tree;
+            while (helpParts.Count > 0)
+            {
+                string helpPart = helpParts[0];
+                
+                if (!dict.ContainsKey(helpPart))
+                    break;
+                
+                //m_log.Debug("Found {0}", helpParts[0]);
+                
+                if (dict[helpPart] is Dictionary<string, Object>)
+                    dict = (Dictionary<string, object>)dict[helpPart]; 
+                
+                helpParts.RemoveAt(0);
+            }
+        
+            // There was a command for the given help string
+            if (dict.ContainsKey(String.Empty))
+            {
+                CommandInfo commandInfo = (CommandInfo)dict[String.Empty];
+                help.Add(commandInfo.help_text);
+                help.Add(commandInfo.long_help);
+
+                string descriptiveHelp = commandInfo.descriptive_help;
+
+                // If we do have some descriptive help then insert a spacing line before for readability.
+                if (descriptiveHelp != string.Empty)
+                    help.Add(string.Empty);
+                
+                help.Add(commandInfo.descriptive_help);
+            }
+            else
+            {
+                help.Add(string.Format("No help is available for {0}", originalHelpRequest));
+            }
+            
+            return help;
+        }
+
+        /// <summary>
+        /// Try to collect help for the given module if that module exists.
+        /// </summary>
+        /// <param name="moduleName"></param>
+        /// <param name="helpText">/param>
+        /// <returns>true if there was the module existed, false otherwise.</returns>
+        private bool TryCollectModuleHelp(string moduleName, List<string> helpText)
+        {
+            lock (m_modulesCommands)
+            {
+                foreach (string key in m_modulesCommands.Keys)
+                {
+                    // Allow topic help requests to succeed whether they are upper or lowercase.
+                    if (moduleName.ToLower() == key.ToLower())
+                    {
+                        List<CommandInfo> commands = m_modulesCommands[key];
+                        var ourHelpText = commands.ConvertAll(c => string.Format("{0} - {1}", c.help_text, c.long_help));
+                        ourHelpText.Sort();
+                        helpText.AddRange(ourHelpText);
+
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
+        private List<string> CollectModulesHelp(Dictionary<string, object> dict)
+        {
+            lock (m_modulesCommands)
+            {
+                List<string> helpText = new List<string>(m_modulesCommands.Keys);
+                helpText.Sort();
+                return helpText;
+            }
+        }
+
+//        private List<string> CollectHelp(Dictionary<string, object> dict)
+//        {
+//            List<string> result = new List<string>();
+//
+//            foreach (KeyValuePair<string, object> kvp in dict)
+//            {
+//                if (kvp.Value is Dictionary<string, Object>)
+//                {
+//                    result.AddRange(CollectHelp((Dictionary<string, Object>)kvp.Value));
+//                }
+//                else
+//                {
+//                    if (((CommandInfo)kvp.Value).long_help != String.Empty)
+//                        result.Add(((CommandInfo)kvp.Value).help_text+" - "+
+//                                ((CommandInfo)kvp.Value).long_help);
+//                }
+//            }
+//            return result;
+//        }
+        
+        /// <summary>
+        /// Add a command to those which can be invoked from the console.
+        /// </summary>
+        /// <param name="module"></param>
+        /// <param name="command"></param>
+        /// <param name="help"></param>
+        /// <param name="longhelp"></param>
+        /// <param name="fn"></param>
+        public void AddCommand(string module, bool shared, string command,
+                string help, string longhelp, CommandDelegate fn)
+        {
+            AddCommand(module, shared, command, help, longhelp, String.Empty, fn);
+        }
+
+        /// <summary>
+        /// Add a command to those which can be invoked from the console.
+        /// </summary>
+        /// <param name="module"></param>
+        /// <param name="command"></param>
+        /// <param name="help"></param>
+        /// <param name="longhelp"></param>
+        /// <param name="descriptivehelp"></param>
+        /// <param name="fn"></param>
+        public void AddCommand(string module, bool shared, string command,
+                string help, string longhelp, string descriptivehelp,
+                CommandDelegate fn)
+        {
+            string[] parts = Parser.Parse(command);
+
+            Dictionary<string, Object> current = tree;
+            
+            foreach (string part in parts)
+            {
+                if (current.ContainsKey(part))
+                {
+                    if (current[part] is Dictionary<string, Object>)
+                        current = (Dictionary<string, Object>)current[part];
+                    else
+                        return;
+                }
+                else
+                {
+                    current[part] = new Dictionary<string, Object>();
+                    current = (Dictionary<string, Object>)current[part];
+                }
+            }
+
+            CommandInfo info;
+
+            if (current.ContainsKey(String.Empty))
+            {
+                info = (CommandInfo)current[String.Empty];
+                if (!info.shared && !info.fn.Contains(fn))
+                    info.fn.Add(fn);
+
+                return;
+            }
+            
+            info = new CommandInfo();
+            info.module = module;
+            info.shared = shared;
+            info.help_text = help;
+            info.long_help = longhelp;
+            info.descriptive_help = descriptivehelp;
+            info.fn = new List<CommandDelegate>();
+            info.fn.Add(fn);
+            current[String.Empty] = info;
+
+            // Now add command to modules dictionary
+            lock (m_modulesCommands)
+            {
+                List<CommandInfo> commands;
+                if (m_modulesCommands.ContainsKey(module))
+                {
+                    commands = m_modulesCommands[module];
+                }
+                else
+                {
+                    commands = new List<CommandInfo>();
+                    m_modulesCommands[module] = commands;
+                }
+
+//                m_log.DebugFormat("[COMMAND CONSOLE]: Adding to category {0} command {1}", module, command);
+                commands.Add(info);
+            }
+        }
+
+        public string[] FindNextOption(string[] cmd, bool term)
+        {
+            Dictionary<string, object> current = tree;
+
+            int remaining = cmd.Length;
+
+            foreach (string s in cmd)
+            {
+                remaining--;
+
+                List<string> found = new List<string>();
+
+                foreach (string opt in current.Keys)
+                {
+                    if (remaining > 0 && opt == s)
+                    {
+                        found.Clear();
+                        found.Add(opt);
+                        break;
+                    }
+                    if (opt.StartsWith(s))
+                    {
+                        found.Add(opt);
+                    }
+                }
+
+                if (found.Count == 1 && (remaining != 0 || term))
+                {
+                    current = (Dictionary<string, object>)current[found[0]];
+                }
+                else if (found.Count > 0)
+                {
+                    return found.ToArray();
+                }
+                else
+                {
+                    break;
+//                    return new string[] {"<cr>"};
+                }
+            }
+
+            if (current.Count > 1)
+            {
+                List<string> choices = new List<string>();
+
+                bool addcr = false;
+                foreach (string s in current.Keys)
+                {
+                    if (s == String.Empty)
+                    {
+                        CommandInfo ci = (CommandInfo)current[String.Empty];
+                        if (ci.fn.Count != 0)
+                            addcr = true;
+                    }
+                    else
+                        choices.Add(s);
+                }
+                if (addcr)
+                    choices.Add("<cr>");
+                return choices.ToArray();
+            }
+
+            if (current.ContainsKey(String.Empty))
+                return new string[] { "Command help: "+((CommandInfo)current[String.Empty]).help_text};
+
+            return new string[] { new List<string>(current.Keys)[0] };
+        }
+
+        private CommandInfo ResolveCommand(string[] cmd, out string[] result)
+        {
+            result = cmd;
+            int index = -1;
+
+            Dictionary<string, object> current = tree;
+
+            foreach (string s in cmd)
+            {
+                index++;
+
+                List<string> found = new List<string>();
+
+                foreach (string opt in current.Keys)
+                {
+                    if (opt == s)
+                    {
+                        found.Clear();
+                        found.Add(opt);
+                        break;
+                    }
+                    if (opt.StartsWith(s))
+                    {
+                        found.Add(opt);
+                    }
+                }
+
+                if (found.Count == 1)
+                {
+                    result[index] = found[0];
+                    current = (Dictionary<string, object>)current[found[0]];
+                }
+                else if (found.Count > 0)
+                {
+                    return null;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            if (current.ContainsKey(String.Empty))
+                return (CommandInfo)current[String.Empty];
+
+            return null;
+        }
+                
+        public bool HasCommand(string command)
+        {
+            string[] result;
+            return ResolveCommand(Parser.Parse(command), out result) != null;
+        }
+
+        public string[] Resolve(string[] cmd)
+        {
+            string[] result;
+            CommandInfo ci = ResolveCommand(cmd, out result);
+
+            if (ci == null)
+                return new string[0];
+
+            if (ci.fn.Count == 0)
+                return new string[0];
+
+            foreach (CommandDelegate fn in ci.fn)
+            {
+                if (fn != null)
+                    fn(ci.module, result);
+                else
+                    return new string[0];
+            }
+
+            return result;
+        }
+
+        public XmlElement GetXml(XmlDocument doc)
+        {
+            CommandInfo help = (CommandInfo)((Dictionary<string, object>)tree["help"])[String.Empty];
+            ((Dictionary<string, object>)tree["help"]).Remove(string.Empty);
+            if (((Dictionary<string, object>)tree["help"]).Count == 0)
+                tree.Remove("help");
+
+            CommandInfo quit = (CommandInfo)((Dictionary<string, object>)tree["quit"])[String.Empty];
+            ((Dictionary<string, object>)tree["quit"]).Remove(string.Empty);
+            if (((Dictionary<string, object>)tree["quit"]).Count == 0)
+                tree.Remove("quit");
+
+            XmlElement root = doc.CreateElement("", "HelpTree", "");
+
+            ProcessTreeLevel(tree, root, doc);
+
+            if (!tree.ContainsKey("help"))
+                tree["help"] = (object) new Dictionary<string, object>();
+            ((Dictionary<string, object>)tree["help"])[String.Empty] = help;
+
+            if (!tree.ContainsKey("quit"))
+                tree["quit"] = (object) new Dictionary<string, object>();
+            ((Dictionary<string, object>)tree["quit"])[String.Empty] = quit;
+
+            return root;
+        }
+
+        private void ProcessTreeLevel(Dictionary<string, object> level, XmlElement xml, XmlDocument doc)
+        {
+            foreach (KeyValuePair<string, object> kvp in level)
+            {
+                if (kvp.Value is Dictionary<string, Object>)
+                {
+                    XmlElement next = doc.CreateElement("", "Level", "");
+                    next.SetAttribute("Name", kvp.Key);
+
+                    xml.AppendChild(next);
+
+                    ProcessTreeLevel((Dictionary<string, object>)kvp.Value, next, doc);
+                }
+                else
+                {
+                    CommandInfo c = (CommandInfo)kvp.Value;
+
+                    XmlElement cmd = doc.CreateElement("", "Command", "");
+
+                    XmlElement e;
+
+                    e = doc.CreateElement("", "Module", "");
+                    cmd.AppendChild(e);
+                    e.AppendChild(doc.CreateTextNode(c.module));
+
+                    e = doc.CreateElement("", "Shared", "");
+                    cmd.AppendChild(e);
+                    e.AppendChild(doc.CreateTextNode(c.shared.ToString()));
+
+                    e = doc.CreateElement("", "HelpText", "");
+                    cmd.AppendChild(e);
+                    e.AppendChild(doc.CreateTextNode(c.help_text));
+
+                    e = doc.CreateElement("", "LongHelp", "");
+                    cmd.AppendChild(e);
+                    e.AppendChild(doc.CreateTextNode(c.long_help));
+
+                    e = doc.CreateElement("", "Description", "");
+                    cmd.AppendChild(e);
+                    e.AppendChild(doc.CreateTextNode(c.descriptive_help));
+
+                    xml.AppendChild(cmd);
+                }
+            }
+        }
+
+        public void FromXml(XmlElement root, CommandDelegate fn)
+        {
+            CommandInfo help = (CommandInfo)((Dictionary<string, object>)tree["help"])[String.Empty];
+            ((Dictionary<string, object>)tree["help"]).Remove(string.Empty);
+            if (((Dictionary<string, object>)tree["help"]).Count == 0)
+                tree.Remove("help");
+
+            CommandInfo quit = (CommandInfo)((Dictionary<string, object>)tree["quit"])[String.Empty];
+            ((Dictionary<string, object>)tree["quit"]).Remove(string.Empty);
+            if (((Dictionary<string, object>)tree["quit"]).Count == 0)
+                tree.Remove("quit");
+
+            tree.Clear();
+
+            ReadTreeLevel(tree, root, fn);
+
+            if (!tree.ContainsKey("help"))
+                tree["help"] = (object) new Dictionary<string, object>();
+            ((Dictionary<string, object>)tree["help"])[String.Empty] = help;
+
+            if (!tree.ContainsKey("quit"))
+                tree["quit"] = (object) new Dictionary<string, object>();
+            ((Dictionary<string, object>)tree["quit"])[String.Empty] = quit;
+        }
+
+        private void ReadTreeLevel(Dictionary<string, object> level, XmlNode node, CommandDelegate fn)
+        {
+            Dictionary<string, object> next;
+            string name;
+
+            XmlNodeList nodeL = node.ChildNodes;
+            XmlNodeList cmdL;
+            CommandInfo c;
+
+            foreach (XmlNode part in nodeL)
+            {
+                switch (part.Name)
+                {
+                case "Level":
+                    name = ((XmlElement)part).GetAttribute("Name");
+                    next = new Dictionary<string, object>();
+                    level[name] = next;
+                    ReadTreeLevel(next, part, fn);
+                    break;
+                case "Command":
+                    cmdL = part.ChildNodes;
+                    c = new CommandInfo();
+                    foreach (XmlNode cmdPart in cmdL)
+                    {
+                        switch (cmdPart.Name)
+                        {
+                        case "Module":
+                            c.module = cmdPart.InnerText;
+                            break;
+                        case "Shared":
+                            c.shared = Convert.ToBoolean(cmdPart.InnerText);
+                            break;
+                        case "HelpText":
+                            c.help_text = cmdPart.InnerText;
+                            break;
+                        case "LongHelp":
+                            c.long_help = cmdPart.InnerText;
+                            break;
+                        case "Description":
+                            c.descriptive_help = cmdPart.InnerText;
+                            break;
+                        }
+                    }
+                    c.fn = new List<CommandDelegate>();
+                    c.fn.Add(fn);
+                    level[String.Empty] = c;
+                    break;
+                }
+            }
+        }
+    }
+
+    public class Parser
+    {
+        // If an unquoted portion ends with an element matching this regex
+        // and the next element contains a space, then we have stripped
+        // embedded quotes that should not have been stripped
+        private static Regex optionRegex = new Regex("^--[a-zA-Z0-9-]+=$");
+
+        public static string[] Parse(string text)
+        {
+            List<string> result = new List<string>();
+
+            int index;
+
+            string[] unquoted = text.Split(new char[] {'"'});
+
+            for (index = 0 ; index < unquoted.Length ; index++)
+            {
+                if (index % 2 == 0)
+                {
+                    string[] words = unquoted[index].Split(new char[] {' '});
+
+                    bool option = false;
+                    foreach (string w in words)
+                    {
+                        if (w != String.Empty)
+                        {
+                            if (optionRegex.Match(w) == Match.Empty)
+                                option = false;
+                            else
+                                option = true;
+                            result.Add(w);
+                        }
+                    }
+                    // The last item matched the regex, put the quotes back
+                    if (option)
+                    {
+                        // If the line ended with it, don't do anything
+                        if (index < (unquoted.Length - 1))
+                        {
+                            // Get and remove the option name
+                            string optionText = result[result.Count - 1];
+                            result.RemoveAt(result.Count - 1);
+
+                            // Add the quoted value back
+                            optionText += "\"" + unquoted[index + 1] + "\"";
+
+                            // Push the result into our return array
+                            result.Add(optionText);
+
+                            // Skip the already used value
+                            index++;
+                        }
+                    }
+                }
+                else
+                {
+                    result.Add(unquoted[index]);
+                }
+            }
+
+            return result.ToArray();
+        }
+    }
+
+    /// <summary>
+    /// A console that processes commands internally
+    /// </summary>
+    public class CommandConsole : ConsoleBase, ICommandConsole
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public event OnOutputDelegate OnOutput;
+
+        public ICommands Commands { get; private set; }
+
+        public CommandConsole(string defaultPrompt) : base(defaultPrompt)
+        {
+            Commands = new Commands();
+
+            Commands.AddCommand(
+                "Help", false, "help", "help [<item>]",
+                "Display help on a particular command or on a list of commands in a category", Help);
+        }
+
+        private void Help(string module, string[] cmd)
+        {
+            List<string> help = Commands.GetHelp(cmd);
+
+            foreach (string s in help)
+                Output(s);
+        }
+
+        protected void FireOnOutput(string text)
+        {
+            OnOutputDelegate onOutput = OnOutput;
+            if (onOutput != null)
+                onOutput(text);
+        }
+
+        /// <summary>
+        /// Display a command prompt on the console and wait for user input
+        /// </summary>
+        public void Prompt()
+        {
+            string line = ReadLine(DefaultPrompt + "# ", true, true);
+
+            if (line != String.Empty)
+                Output("Invalid command");
+        }
+
+        public void RunCommand(string cmd)
+        {
+            string[] parts = Parser.Parse(cmd);
+            Commands.Resolve(parts);
+        }
+
+        public override string ReadLine(string p, bool isCommand, bool e)
+        {
+            System.Console.Write("{0}", p);
+            string cmdinput = System.Console.ReadLine();
+
+            if (isCommand)
+            {
+                string[] cmd = Commands.Resolve(Parser.Parse(cmdinput));
+
+                if (cmd.Length != 0)
+                {
+                    int i;
+
+                    for (i=0 ; i < cmd.Length ; i++)
+                    {
+                        if (cmd[i].Contains(" "))
+                            cmd[i] = "\"" + cmd[i] + "\"";
+                    }
+                    return String.Empty;
+                }
+            }
+            return cmdinput;
+        }
+    }
+}
diff --git a/OpenSim/Framework/Console/ConsoleBase.cs b/OpenSim/Framework/Console/ConsoleBase.cs
new file mode 100755
index 0000000..2d8e723
--- /dev/null
+++ b/OpenSim/Framework/Console/ConsoleBase.cs
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using log4net;
+
+namespace OpenSim.Framework.Console
+{
+    public class ConsoleBase
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected string prompt = "# ";
+
+        public object ConsoleScene { get; set; }
+
+        public string DefaultPrompt { get; set; }
+
+        public ConsoleBase(string defaultPrompt)
+        {
+            DefaultPrompt = defaultPrompt;
+        }
+
+        public virtual void LockOutput()
+        {
+        }
+
+        public virtual void UnlockOutput()
+        {
+        }
+
+        public virtual void Output(string text, string level)
+        {
+            Output(text);
+        }
+
+        public virtual void Output(string text)
+        {
+            System.Console.WriteLine(text);
+        }
+        
+        public virtual void OutputFormat(string format, params object[] components)
+        {
+            Output(string.Format(format, components));
+        }
+
+        public string CmdPrompt(string p)
+        {
+            return ReadLine(String.Format("{0}: ", p), false, true);
+        }
+
+        public string CmdPrompt(string p, string def)
+        {
+            string ret = ReadLine(String.Format("{0} [{1}]: ", p, def), false, true);
+            if (ret == String.Empty)
+                ret = def;
+
+            return ret;
+        }
+                
+        public string CmdPrompt(string p, List<char> excludedCharacters)
+        {
+            bool itisdone = false;
+            string ret = String.Empty;
+            while (!itisdone)
+            {
+                itisdone = true;
+                ret = CmdPrompt(p);
+                
+                foreach (char c in excludedCharacters)
+                {
+                    if (ret.Contains(c.ToString()))
+                    {
+                        System.Console.WriteLine("The character \"" + c.ToString() + "\" is not permitted.");
+                        itisdone = false;
+                    }
+                }
+            }
+
+            return ret;
+        }
+
+        public string CmdPrompt(string p, string def, List<char> excludedCharacters)
+        {
+            bool itisdone = false;
+            string ret = String.Empty;
+            while (!itisdone)
+            {
+                itisdone = true;
+                ret = CmdPrompt(p, def);
+                
+                if (ret == String.Empty)
+                {
+                    ret = def;
+                }
+                else
+                {
+                    foreach (char c in excludedCharacters)
+                    {
+                        if (ret.Contains(c.ToString()))
+                        {
+                            System.Console.WriteLine("The character \"" + c.ToString() + "\" is not permitted.");
+                            itisdone = false;
+                        }
+                    }
+                }
+            }
+
+            return ret;
+        }
+
+        // Displays a command prompt and returns a default value, user may only enter 1 of 2 options
+        public string CmdPrompt(string prompt, string defaultresponse, List<string> options)
+        {
+            bool itisdone = false;
+            string optstr = String.Empty;
+            foreach (string s in options)
+                optstr += " " + s;
+
+            string temp = CmdPrompt(prompt, defaultresponse);
+            while (itisdone == false)
+            {
+                if (options.Contains(temp))
+                {
+                    itisdone = true;
+                }
+                else
+                {
+                    System.Console.WriteLine("Valid options are" + optstr);
+                    temp = CmdPrompt(prompt, defaultresponse);
+                }
+            }
+            return temp;
+        }
+
+        // Displays a prompt and waits for the user to enter a string, then returns that string
+        // (Done with no echo and suitable for passwords)
+        public string PasswdPrompt(string p)
+        {
+            return ReadLine(String.Format("{0}: ", p), false, false);
+        }
+
+        public virtual string ReadLine(string p, bool isCommand, bool e)
+        {
+            System.Console.Write("{0}", p);
+            string cmdinput = System.Console.ReadLine();
+
+            return cmdinput;
+        }
+    }
+}
diff --git a/OpenSim/Framework/Console/ConsoleDisplayList.cs b/OpenSim/Framework/Console/ConsoleDisplayList.cs
new file mode 100644
index 0000000..6885509
--- /dev/null
+++ b/OpenSim/Framework/Console/ConsoleDisplayList.cs
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OpenSim.Framework.Console
+{
+    /// <summary>
+    /// Used to generated a formatted table for the console.
+    /// </summary>
+    /// <remarks>
+    /// Currently subject to change.  If you use this, be prepared to change your code when this class changes.
+    /// </remarks>
+    public class ConsoleDisplayList
+    {
+        /// <summary>
+        /// The default divider between key and value for a list item.
+        /// </summary>
+        public const string DefaultKeyValueDivider = " : ";
+
+        /// <summary>
+        /// The divider used between key and value for a list item.
+        /// </summary>
+        public string KeyValueDivider { get; set; }
+
+        /// <summary>
+        /// Table rows
+        /// </summary>
+        public List<KeyValuePair<string, string>> Rows { get; private set; }
+
+        /// <summary>
+        /// Number of spaces to indent the list.
+        /// </summary>
+        public int Indent { get; set; }
+
+        public ConsoleDisplayList()
+        {
+            Rows = new List<KeyValuePair<string, string>>();
+            KeyValueDivider = DefaultKeyValueDivider;
+        }
+
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            AddToStringBuilder(sb);
+            return sb.ToString();
+        }
+
+        public void AddToStringBuilder(StringBuilder sb)
+        {
+            string formatString = GetFormatString();
+//            System.Console.WriteLine("FORMAT STRING [{0}]", formatString);
+
+            // rows
+            foreach (KeyValuePair<string, string> row in Rows)
+                sb.AppendFormat(formatString, row.Key, row.Value);
+        }
+
+        /// <summary>
+        /// Gets the format string for the table.
+        /// </summary>
+        private string GetFormatString()
+        {
+            StringBuilder formatSb = new StringBuilder();
+
+            int longestKey = -1;
+
+            foreach (KeyValuePair<string, string> row in Rows)
+                if (row.Key.Length > longestKey)
+                    longestKey = row.Key.Length;
+
+            formatSb.Append(' ', Indent);
+
+            // Can only do left formatting for now
+            formatSb.AppendFormat("{{0,-{0}}}{1}{{1}}\n", longestKey, KeyValueDivider);
+
+            return formatSb.ToString();
+        }
+
+        public void AddRow(object key, object value)
+        {
+            Rows.Add(new KeyValuePair<string, string>(key.ToString(), value.ToString()));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Console/ConsoleDisplayTable.cs b/OpenSim/Framework/Console/ConsoleDisplayTable.cs
new file mode 100644
index 0000000..711a337
--- /dev/null
+++ b/OpenSim/Framework/Console/ConsoleDisplayTable.cs
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OpenSim.Framework.Console
+{
+    /// <summary>
+    /// Used to generated a formatted table for the console.
+    /// </summary>
+    /// <remarks>
+    /// Currently subject to change.  If you use this, be prepared to change your code when this class changes.
+    /// </remarks>
+    public class ConsoleDisplayTable
+    {
+        /// <summary>
+        /// Default number of spaces between table columns.
+        /// </summary>
+        public const int DefaultTableSpacing = 2;
+
+        /// <summary>
+        /// Table columns.
+        /// </summary>
+        public List<ConsoleDisplayTableColumn> Columns { get; private set; }
+
+        /// <summary>
+        /// Table rows
+        /// </summary>
+        public List<ConsoleDisplayTableRow> Rows { get; private set; }
+
+        /// <summary>
+        /// Number of spaces to indent the whole table.
+        /// </summary>
+        public int Indent { get; set; }
+
+        /// <summary>
+        /// Spacing between table columns
+        /// </summary>
+        public int TableSpacing { get; set; }
+
+        public ConsoleDisplayTable()
+        {
+            TableSpacing = DefaultTableSpacing;
+            Columns = new List<ConsoleDisplayTableColumn>();
+            Rows = new List<ConsoleDisplayTableRow>();
+        }
+
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            AddToStringBuilder(sb);
+            return sb.ToString();
+        }
+
+        public void AddColumn(string name, int width)
+        {
+            Columns.Add(new ConsoleDisplayTableColumn(name, width));
+        }
+
+        public void AddRow(params object[] cells)
+        {
+            Rows.Add(new ConsoleDisplayTableRow(cells));
+        }
+
+        public void AddToStringBuilder(StringBuilder sb)
+        {
+            string formatString = GetFormatString();
+//            System.Console.WriteLine("FORMAT STRING [{0}]", formatString);
+
+            // columns
+            sb.AppendFormat(formatString, Columns.ConvertAll(c => c.Header).ToArray());
+
+            // rows
+            foreach (ConsoleDisplayTableRow row in Rows)
+                sb.AppendFormat(formatString, row.Cells.ToArray());
+        }
+
+        /// <summary>
+        /// Gets the format string for the table.
+        /// </summary>
+        private string GetFormatString()
+        {
+            StringBuilder formatSb = new StringBuilder();
+
+            formatSb.Append(' ', Indent);
+
+            for (int i = 0; i < Columns.Count; i++)
+            {
+                if (i != 0)
+                    formatSb.Append(' ', TableSpacing);
+
+                // Can only do left formatting for now
+                formatSb.AppendFormat("{{{0},-{1}}}", i, Columns[i].Width);
+            }
+
+            formatSb.Append('\n');
+
+            return formatSb.ToString();
+        }
+    }
+
+    public struct ConsoleDisplayTableColumn
+    {
+        public string Header { get; set; }
+        public int Width { get; set; }
+
+        public ConsoleDisplayTableColumn(string header, int width) : this()
+        {
+            Header = header;
+            Width = width;
+        }
+    }
+
+    public struct ConsoleDisplayTableRow
+    {
+        public List<object> Cells { get; private set; }
+
+        public ConsoleDisplayTableRow(List<object> cells) : this()
+        {
+            Cells = cells;
+        }
+
+        public ConsoleDisplayTableRow(params object[] cells) : this()
+        {
+            Cells = new List<object>(cells);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Console/ConsoleDisplayUtil.cs b/OpenSim/Framework/Console/ConsoleDisplayUtil.cs
new file mode 100644
index 0000000..6417663
--- /dev/null
+++ b/OpenSim/Framework/Console/ConsoleDisplayUtil.cs
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+
+namespace OpenSim.Framework.Console
+{
+    /// <summary>
+    /// This will be a set of typical column sizes to allow greater consistency between console commands.
+    /// </summary>
+    public static class ConsoleDisplayUtil
+    {
+        public const int CoordTupleSize = 11;
+        public const int PortSize = 5;
+
+        public const int EstateNameSize = 20;
+        public const int ParcelNameSize = 40;
+        public const int RegionNameSize = 20;
+        public const int UserNameSize = 35;
+
+        public const int UuidSize = 36;
+        public const int VectorSize = 15;
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Console/ConsolePluginCommand.cs b/OpenSim/Framework/Console/ConsolePluginCommand.cs
new file mode 100755
index 0000000..f4d3687
--- /dev/null
+++ b/OpenSim/Framework/Console/ConsolePluginCommand.cs
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+
+namespace OpenSim.Framework.Console
+{
+    public delegate void ConsoleCommand(string[] comParams);
+
+    /// <summary>
+    /// Holder object for a new console plugin command
+    ///
+    /// Override the methods like Run and IsHelpfull (but the defaults might work ok.)
+    /// </summary>
+    public class ConsolePluginCommand
+    {
+        /// <summary>
+        /// command delegate used in running
+        /// </summary>
+        private ConsoleCommand m_commandDelegate;
+        /// <summary>
+        /// help text displayed
+        /// </summary>
+        private string m_helpText;
+        /// <summary>
+        /// command in the form of "showme new commands"
+        /// </summary>
+        private string[] m_cmdText;
+
+        /// <summary>
+        /// Construct a new ConsolePluginCommand
+        ///
+        /// for use with OpenSim.RegisterConsolePluginCommand(myCmd);
+        ///
+        /// </summary>
+        /// <param name="command">in the form of "showme new commands"</param>
+        /// <param name="dlg">ommand delegate used in running</param>
+        /// <param name="help">the text displayed in "help showme new commands"</param>
+        public ConsolePluginCommand(string command, ConsoleCommand dlg, string help)
+        {
+            m_cmdText = command.Split(new char[] { ' ' });
+            m_commandDelegate = dlg;
+            m_helpText = help;
+        }
+
+        /// <summary>
+        /// Returns the match length this command has upon the 'cmdWithParams'
+        /// At least a higher number for "show plugin status" then "show" would return
+        /// This is used to have multi length command verbs
+        ///
+        /// @see OopenSim.RunPluginCommands
+        /// It will only run the one with the highest number
+        ///
+        /// </summary>
+        public int matchLength(string cmdWithParams)
+        {
+            // QUESTION: have a case insensitive flag?
+            cmdWithParams = cmdWithParams.ToLower().Trim();
+            string matchText = String.Join(" ",m_cmdText).ToLower().Trim();
+            if (cmdWithParams.StartsWith(matchText))
+            {
+                // QUESTION Instead return cmdText.Length; ?
+                return matchText.Length;
+            }
+            return 0;
+        }
+
+        /// <summary>
+        /// Run the delegate the incomming string may contain the command, if so, it is chopped off the cmdParams[]
+        /// </summary>
+        public void Run(string cmd, string[] cmdParams)
+        {
+            int skipParams = 0;
+            if (m_cmdText.Length > 1)
+            {
+                int currentParam = 1;
+                while (currentParam < m_cmdText.Length)
+                {
+                    if (cmdParams[skipParams].ToLower().Equals(m_cmdText[currentParam].ToLower()))
+                    {
+                        skipParams++;
+                    }
+                    currentParam++;
+                }
+
+            }
+            string[] sendCmdParams = cmdParams;
+            if (skipParams > 0)
+            {
+                sendCmdParams = new string[cmdParams.Length-skipParams];
+                for (int i=0;i<sendCmdParams.Length;i++) {
+                    sendCmdParams[i] = cmdParams[skipParams++];
+                }
+            }
+            m_commandDelegate(sendCmdParams);//.Trim().Split(new char[] { ' ' }));
+        }
+
+        /// <summary>
+        /// Shows help information on the console's Notice method
+        /// </summary>
+        public void ShowHelp(ConsoleBase console)
+        {
+            console.Output(String.Join(" ", m_cmdText) + " - " + m_helpText + "\n");
+        }
+
+        /// <summary>
+        /// return true if the ShowHelp(..) method might be helpfull
+        /// </summary>
+        public bool IsHelpfull(string cmdWithParams)
+        {
+            cmdWithParams = cmdWithParams.ToLower();
+            return cmdWithParams.Contains(String.Join(" ", m_cmdText).ToLower()) || m_helpText.ToLower().Contains(cmdWithParams);
+        }
+    }
+}
diff --git a/OpenSim/Framework/Console/ConsoleUtil.cs b/OpenSim/Framework/Console/ConsoleUtil.cs
new file mode 100644
index 0000000..44f6dc1
--- /dev/null
+++ b/OpenSim/Framework/Console/ConsoleUtil.cs
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using log4net;
+using OpenMetaverse;
+
+namespace OpenSim.Framework.Console
+{
+    public class ConsoleUtil
+    {
+    //    private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public const int LocalIdNotFound = 0;
+    
+        /// <summary>
+        /// Used by modules to display stock co-ordinate help, though possibly this should be under some general section
+        /// rather than in each help summary.
+        /// </summary>
+        public const string CoordHelp
+    = @"Each component of the coord is comma separated.  There must be no spaces between the commas.
+    If you don't care about the z component you can simply omit it.
+    If you don't care about the x or y components then you can leave them blank (though a comma is still required)
+    If you want to specify the maximum value of a component then you can use ~ instead of a number
+    If you want to specify the minimum value of a component then you can use -~ instead of a number
+    e.g.
+    show object pos 20,20,20 to 40,40,40
+    delete object pos 20,20 to 40,40
+    show object pos ,20,20 to ,40,40
+    delete object pos ,,30 to ,,~
+    show object pos ,,-~ to ,,30";
+    
+        public const string MinRawConsoleVectorValue = "-~";
+        public const string MaxRawConsoleVectorValue = "~";
+    
+        public const string VectorSeparator = ",";
+        public static char[] VectorSeparatorChars = VectorSeparator.ToCharArray();
+
+        /// <summary>
+        /// Check if the given file path exists.
+        /// </summary>
+        /// <remarks>If not, warning is printed to the given console.</remarks>
+        /// <returns>true if the file does not exist, false otherwise.</returns>
+        /// <param name='console'></param>
+        /// <param name='path'></param>
+        public static bool CheckFileDoesNotExist(ICommandConsole console, string path)
+        {
+            if (File.Exists(path))
+            {
+                console.OutputFormat("File {0} already exists.  Please move or remove it.", path);
+                return false;
+            }
+
+            return true;
+        }
+    
+        /// <summary>
+        /// Try to parse a console UUID from the console.
+        /// </summary>
+        /// <remarks>
+        /// Will complain to the console if parsing fails.
+        /// </remarks>
+        /// <returns></returns>
+        /// <param name='console'>If null then no complaint is printed.</param>
+        /// <param name='rawUuid'></param>
+        /// <param name='uuid'></param>
+        public static bool TryParseConsoleUuid(ICommandConsole console, string rawUuid, out UUID uuid)
+        {
+            if (!UUID.TryParse(rawUuid, out uuid))
+            {
+                if (console != null)
+                    console.OutputFormat("ERROR: {0} is not a valid uuid", rawUuid);
+
+                return false;
+            }
+    
+            return true;
+        }
+
+        public static bool TryParseConsoleLocalId(ICommandConsole console, string rawLocalId, out uint localId)
+        {
+            if (!uint.TryParse(rawLocalId, out localId))
+            {
+                if (console != null)
+                    console.OutputFormat("ERROR: {0} is not a valid local id", localId);
+
+                return false;
+            }
+
+            if (localId == 0)
+            {
+                if (console != null)
+                    console.OutputFormat("ERROR: {0} is not a valid local id - it must be greater than 0", localId);
+
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Tries to parse the input as either a UUID or a local ID.
+        /// </summary>
+        /// <returns>true if parsing succeeded, false otherwise.</returns>
+        /// <param name='console'></param>
+        /// <param name='rawId'></param>
+        /// <param name='uuid'></param>
+        /// <param name='localId'>
+        /// Will be set to ConsoleUtil.LocalIdNotFound if parsing result was a UUID or no parse succeeded.
+        /// </param>
+        public static bool TryParseConsoleId(ICommandConsole console, string rawId, out UUID uuid, out uint localId)
+        {
+            if (TryParseConsoleUuid(null, rawId, out uuid))
+            {
+                localId = LocalIdNotFound;
+                return true;
+            }
+
+            if (TryParseConsoleLocalId(null, rawId, out localId))
+            {
+                return true;
+            }
+
+            if (console != null)
+                console.OutputFormat("ERROR: {0} is not a valid UUID or local id", rawId);
+
+            return false;
+        }
+
+        /// <summary>
+        /// Convert a console input to a bool, automatically complaining if a console is given.
+        /// </summary>
+        /// <param name='console'>Can be null if no console is available.</param>
+        /// <param name='rawConsoleVector'>/param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleBool(ICommandConsole console, string rawConsoleString, out bool b)
+        {
+            if (!bool.TryParse(rawConsoleString, out b))
+            {
+                if (console != null)
+                    console.OutputFormat("ERROR: {0} is not a true or false value", rawConsoleString);
+
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Convert a console input to an int, automatically complaining if a console is given.
+        /// </summary>
+        /// <param name='console'>Can be null if no console is available.</param>
+        /// <param name='rawConsoleInt'>/param>
+        /// <param name='i'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleInt(ICommandConsole console, string rawConsoleInt, out int i)
+        {
+            if (!int.TryParse(rawConsoleInt, out i))
+            {
+                if (console != null)
+                    console.OutputFormat("ERROR: {0} is not a valid integer", rawConsoleInt);
+
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Convert a console input to a float, automatically complaining if a console is given.
+        /// </summary>
+        /// <param name='console'>Can be null if no console is available.</param>
+        /// <param name='rawConsoleInput'>/param>
+        /// <param name='i'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleFloat(ICommandConsole console, string rawConsoleInput, out float i)
+        {
+            if (!float.TryParse(rawConsoleInput, out i))
+            {
+                if (console != null)
+                    console.OutputFormat("ERROR: {0} is not a valid float", rawConsoleInput);
+
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Convert a console input to a double, automatically complaining if a console is given.
+        /// </summary>
+        /// <param name='console'>Can be null if no console is available.</param>
+        /// <param name='rawConsoleInput'>/param>
+        /// <param name='i'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleDouble(ICommandConsole console, string rawConsoleInput, out double i)
+        {
+            if (!double.TryParse(rawConsoleInput, out i))
+            {
+                if (console != null)
+                    console.OutputFormat("ERROR: {0} is not a valid double", rawConsoleInput);
+
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Convert a console integer to a natural int, automatically complaining if a console is given.
+        /// </summary>
+        /// <param name='console'>Can be null if no console is available.</param>
+        /// <param name='rawConsoleInt'>/param>
+        /// <param name='i'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleNaturalInt(ICommandConsole console, string rawConsoleInt, out int i)
+        {
+            if (TryParseConsoleInt(console, rawConsoleInt, out i))
+            {
+                if (i < 0)
+                {
+                    if (console != null)
+                        console.OutputFormat("ERROR: {0} is not a positive integer", rawConsoleInt);
+
+                    return false;
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+    
+        /// <summary>
+        /// Convert a minimum vector input from the console to an OpenMetaverse.Vector3
+        /// </summary>
+        /// <param name='rawConsoleVector'>/param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleMinVector(string rawConsoleVector, out Vector3 vector)
+        {
+            return TryParseConsoleVector(rawConsoleVector, c => float.MinValue.ToString(), out vector);
+        }
+    
+        /// <summary>
+        /// Convert a maximum vector input from the console to an OpenMetaverse.Vector3
+        /// </summary>
+        /// <param name='rawConsoleVector'>/param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleMaxVector(string rawConsoleVector, out Vector3 vector)
+        {
+            return TryParseConsoleVector(rawConsoleVector, c => float.MaxValue.ToString(), out vector);
+        }
+    
+        /// <summary>
+        /// Convert a vector input from the console to an OpenMetaverse.Vector3
+        /// </summary>
+        /// <param name='rawConsoleVector'>
+        /// A string in the form <x>,<y>,<z> where there is no space between values.
+        /// Any component can be missing (e.g. ,,40).  blankComponentFunc is invoked to replace the blank with a suitable value
+        /// Also, if the blank component is at the end, then the comma can be missed off entirely (e.g. 40,30 or 40)
+        /// The strings "~" and "-~" are valid in components.  The first substitutes float.MaxValue whilst the second is float.MinValue
+        /// Other than that, component values must be numeric.
+        /// </param>
+        /// <param name='blankComponentFunc'>
+        /// Behaviour if component is blank.  If null then conversion fails on a blank component.
+        /// </param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsoleVector(
+            string rawConsoleVector, Func<string, string> blankComponentFunc, out Vector3 vector)
+        {
+            return Vector3.TryParse(CookVector(rawConsoleVector, 3, blankComponentFunc), out vector);
+        }
+
+        /// <summary>
+        /// Convert a vector input from the console to an OpenMetaverse.Vector2
+        /// </summary>
+        /// <param name='rawConsoleVector'>
+        /// A string in the form <x>,<y> where there is no space between values.
+        /// Any component can be missing (e.g. ,40).  blankComponentFunc is invoked to replace the blank with a suitable value
+        /// Also, if the blank component is at the end, then the comma can be missed off entirely (e.g. 40)
+        /// The strings "~" and "-~" are valid in components.  The first substitutes float.MaxValue whilst the second is float.MinValue
+        /// Other than that, component values must be numeric.
+        /// </param>
+        /// <param name='blankComponentFunc'>
+        /// Behaviour if component is blank.  If null then conversion fails on a blank component.
+        /// </param>
+        /// <param name='vector'></param>
+        /// <returns></returns>
+        public static bool TryParseConsole2DVector(
+            string rawConsoleVector, Func<string, string> blankComponentFunc, out Vector2 vector)
+        {
+            // We don't use Vector2.TryParse() for now because for some reason it expects an input with 3 components
+            // rather than 2.
+            string cookedVector = CookVector(rawConsoleVector, 2, blankComponentFunc);
+
+            if (cookedVector == null)
+            {
+                vector = Vector2.Zero;
+
+                return false;
+            }
+            else
+            {
+                string[] cookedComponents = cookedVector.Split(VectorSeparatorChars);
+
+                vector = new Vector2(float.Parse(cookedComponents[0]), float.Parse(cookedComponents[1]));
+
+                return true;
+            }
+
+            //return Vector2.TryParse(CookVector(rawConsoleVector, 2, blankComponentFunc), out vector);
+        }
+
+        /// <summary>
+        /// Convert a raw console vector into a vector that can be be parsed by the relevant OpenMetaverse.TryParse()
+        /// </summary>
+        /// <param name='rawConsoleVector'></param>
+        /// <param name='dimensions'></param>
+        /// <param name='blankComponentFunc'></param>
+        /// <returns>null if conversion was not possible</returns>
+        private static string CookVector(
+            string rawConsoleVector, int dimensions, Func<string, string> blankComponentFunc)
+        {
+            List<string> components = rawConsoleVector.Split(VectorSeparatorChars).ToList();
+    
+            if (components.Count < 1 || components.Count > dimensions)
+                return null;
+    
+            if (components.Count < dimensions)
+            {
+                if (blankComponentFunc == null)
+                    return null;
+                else
+                    for (int i = components.Count; i < dimensions; i++)
+                        components.Add("");
+            }
+
+            List<string> cookedComponents
+                = components.ConvertAll<string>(
+                    c =>
+                    {
+                        if (c == "")
+                            return blankComponentFunc.Invoke(c);
+                        else if (c == MaxRawConsoleVectorValue)
+                            return float.MaxValue.ToString();
+                        else if (c == MinRawConsoleVectorValue)
+                            return float.MinValue.ToString();
+                        else
+                            return c;
+                    });
+    
+            return string.Join(VectorSeparator, cookedComponents.ToArray());
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Console/LocalConsole.cs b/OpenSim/Framework/Console/LocalConsole.cs
new file mode 100644
index 0000000..28293c0
--- /dev/null
+++ b/OpenSim/Framework/Console/LocalConsole.cs
@@ -0,0 +1,585 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.IO;
+using Nini.Config;
+using log4net;
+
+namespace OpenSim.Framework.Console
+{
+    /// <summary>
+    /// A console that uses cursor control and color
+    /// </summary>
+    public class LocalConsole : CommandConsole
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private string m_historyPath;
+        private bool m_historyEnable;
+
+        // private readonly object m_syncRoot = new object();
+        private const string LOGLEVEL_NONE = "(none)";
+
+        // Used to extract categories for colourization.
+        private Regex m_categoryRegex 
+            = new Regex(
+                @"^(?<Front>.*?)\[(?<Category>[^\]]+)\]:?(?<End>.*)", RegexOptions.Singleline | RegexOptions.Compiled);
+
+        private int m_cursorYPosition = -1;
+        private int m_cursorXPosition = 0;
+        private StringBuilder m_commandLine = new StringBuilder();
+        private bool m_echo = true;
+        private List<string> m_history = new List<string>();
+
+        private static readonly ConsoleColor[] Colors = {
+            // the dark colors don't seem to be visible on some black background terminals like putty :(
+            //ConsoleColor.DarkBlue,
+            //ConsoleColor.DarkGreen,
+            //ConsoleColor.DarkCyan,
+            //ConsoleColor.DarkMagenta,
+            //ConsoleColor.DarkYellow,
+            ConsoleColor.Gray,
+            //ConsoleColor.DarkGray,
+            ConsoleColor.Blue,
+            ConsoleColor.Green,
+            ConsoleColor.Cyan,
+            ConsoleColor.Magenta,
+            ConsoleColor.Yellow
+        };
+
+        private static ConsoleColor DeriveColor(string input)
+        {
+            // it is important to do Abs, hash values can be negative
+            return Colors[(Math.Abs(input.ToUpper().GetHashCode()) % Colors.Length)];
+        }
+
+        public LocalConsole(string defaultPrompt, IConfig startupConfig = null) : base(defaultPrompt)
+        {
+
+            if (startupConfig == null) return;
+
+            m_historyEnable = startupConfig.GetBoolean("ConsoleHistoryFileEnabled", false);
+            if (!m_historyEnable)
+            {
+                m_log.Info("[LOCAL CONSOLE]: Persistent command line history from file is Disabled");
+                return;
+            }
+
+            string m_historyFile = startupConfig.GetString("ConsoleHistoryFile", "OpenSimConsoleHistory.txt");
+            int m_historySize = startupConfig.GetInt("ConsoleHistoryFileLines", 100);
+            m_historyPath = Path.GetFullPath(Path.Combine(Util.configDir(), m_historyFile));
+            m_log.InfoFormat("[LOCAL CONSOLE]: Persistent command line history is Enabled, up to {0} lines from file {1}", m_historySize, m_historyPath);
+
+            if (File.Exists(m_historyPath))
+            {
+                using (StreamReader history_file = new StreamReader(m_historyPath))
+                {
+                    string line;
+                    while ((line = history_file.ReadLine()) != null)
+                    {
+                        m_history.Add(line);
+                    }
+                }
+
+                if (m_history.Count > m_historySize)
+                {
+                    while (m_history.Count > m_historySize)
+                        m_history.RemoveAt(0);
+
+                    using (StreamWriter history_file = new StreamWriter(m_historyPath))
+                    {
+                        foreach (string line in m_history)
+                        {
+                            history_file.WriteLine(line);
+                        }
+                    }
+                }
+                m_log.InfoFormat("[LOCAL CONSOLE]: Read {0} lines of command line history from file {1}", m_history.Count, m_historyPath);
+            }
+            else
+            {
+                m_log.InfoFormat("[LOCAL CONSOLE]: Creating new empty command line history file {0}", m_historyPath);
+                File.Create(m_historyPath).Dispose();
+            }
+        }
+
+        private void AddToHistory(string text)
+        {
+            while (m_history.Count >= 100)
+                m_history.RemoveAt(0);
+
+            m_history.Add(text);
+            if (m_historyEnable)
+            {
+                File.AppendAllText(m_historyPath, text + Environment.NewLine);
+            }
+        }
+
+        /// <summary>
+        /// Set the cursor row.
+        /// </summary>
+        ///
+        /// <param name="top">
+        /// Row to set.  If this is below 0, then the row is set to 0.  If it is equal to the buffer height or greater
+        /// then it is set to one less than the height.
+        /// </param>
+        /// <returns>
+        /// The new cursor row.
+        /// </returns>
+        private int SetCursorTop(int top)
+        {
+            // From at least mono 2.4.2.3, window resizing can give mono an invalid row and column values.  If we try
+            // to set a cursor row position with a currently invalid column, mono will throw an exception.
+            // Therefore, we need to make sure that the column position is valid first.
+            int left = System.Console.CursorLeft;
+
+            if (left < 0)
+            {
+                System.Console.CursorLeft = 0;
+            }
+            else 
+            {
+                int bufferWidth = System.Console.BufferWidth;
+                
+                // On Mono 2.4.2.3 (and possibly above), the buffer value is sometimes erroneously zero (Mantis 4657)
+                if (bufferWidth > 0 && left >= bufferWidth)
+                    System.Console.CursorLeft = bufferWidth - 1;
+            }
+            
+            if (top < 0)
+            {
+                top = 0;
+            }
+            else
+            {
+                int bufferHeight = System.Console.BufferHeight;
+                
+                // On Mono 2.4.2.3 (and possibly above), the buffer value is sometimes erroneously zero (Mantis 4657)
+                if (bufferHeight > 0 && top >= bufferHeight)
+                    top = bufferHeight - 1;
+            }
+
+            System.Console.CursorTop = top;
+
+            return top;
+        }
+
+        /// <summary>
+        /// Set the cursor column.
+        /// </summary>
+        ///
+        /// <param name="left">
+        /// Column to set.  If this is below 0, then the column is set to 0.  If it is equal to the buffer width or greater
+        /// then it is set to one less than the width.
+        /// </param>
+        /// <returns>
+        /// The new cursor column.
+        /// </returns>
+        private int SetCursorLeft(int left)
+        {
+            // From at least mono 2.4.2.3, window resizing can give mono an invalid row and column values.  If we try
+            // to set a cursor column position with a currently invalid row, mono will throw an exception.
+            // Therefore, we need to make sure that the row position is valid first.
+            int top = System.Console.CursorTop;
+
+            if (top < 0)
+            {
+                System.Console.CursorTop = 0;
+            }
+            else 
+            {
+                int bufferHeight = System.Console.BufferHeight;
+                // On Mono 2.4.2.3 (and possibly above), the buffer value is sometimes erroneously zero (Mantis 4657)
+                if (bufferHeight > 0 && top >= bufferHeight)
+                    System.Console.CursorTop = bufferHeight - 1;
+            }
+            
+            if (left < 0)
+            {
+                left = 0;
+            }
+            else
+            {
+                int bufferWidth = System.Console.BufferWidth;
+
+                // On Mono 2.4.2.3 (and possibly above), the buffer value is sometimes erroneously zero (Mantis 4657)
+                if (bufferWidth > 0 && left >= bufferWidth)
+                    left = bufferWidth - 1;
+            }
+
+            System.Console.CursorLeft = left;
+
+            return left;
+        }
+
+        private void Show()
+        {
+            lock (m_commandLine)
+            {
+                if (m_cursorYPosition == -1 || System.Console.BufferWidth == 0)
+                    return;
+
+                int xc = prompt.Length + m_cursorXPosition;
+                int new_x = xc % System.Console.BufferWidth;
+                int new_y = m_cursorYPosition + xc / System.Console.BufferWidth;
+                int end_y = m_cursorYPosition + (m_commandLine.Length + prompt.Length) / System.Console.BufferWidth;
+
+                if (end_y >= System.Console.BufferHeight) // wrap
+                {
+                    m_cursorYPosition--;
+                    new_y--;
+                    SetCursorLeft(0);
+                    SetCursorTop(System.Console.BufferHeight - 1);
+                    System.Console.WriteLine(" ");
+                }
+
+                m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+                SetCursorLeft(0);
+
+                if (m_echo)
+                    System.Console.Write("{0}{1}", prompt, m_commandLine);
+                else
+                    System.Console.Write("{0}", prompt);
+
+                SetCursorTop(new_y);
+                SetCursorLeft(new_x);
+            }
+        }
+
+        public override void LockOutput()
+        {
+            Monitor.Enter(m_commandLine);
+            try
+            {
+                if (m_cursorYPosition != -1)
+                {
+                    m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+                    System.Console.CursorLeft = 0;
+
+                    int count = m_commandLine.Length + prompt.Length;
+
+                    while (count-- > 0)
+                        System.Console.Write(" ");
+
+                    m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+                    SetCursorLeft(0);
+                }
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        public override void UnlockOutput()
+        {
+            if (m_cursorYPosition != -1)
+            {
+                m_cursorYPosition = System.Console.CursorTop;
+                Show();
+            }
+            Monitor.Exit(m_commandLine);
+        }
+
+        private void WriteColorText(ConsoleColor color, string sender)
+        {
+            try
+            {
+                lock (this)
+                {
+                    try
+                    {
+                        System.Console.ForegroundColor = color;
+                        System.Console.Write(sender);
+                        System.Console.ResetColor();
+                    }
+                    catch (ArgumentNullException)
+                    {
+                        // Some older systems dont support coloured text.
+                        System.Console.WriteLine(sender);
+                    }
+                }
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+        }
+
+        private void WriteLocalText(string text, string level)
+        {
+            string outText = text;
+
+            if (level != LOGLEVEL_NONE)
+            {               
+                MatchCollection matches = m_categoryRegex.Matches(text);
+
+                if (matches.Count == 1)
+                {
+                    outText = matches[0].Groups["End"].Value;
+                    System.Console.Write(matches[0].Groups["Front"].Value);
+
+                    System.Console.Write("[");
+                    WriteColorText(DeriveColor(matches[0].Groups["Category"].Value),
+                            matches[0].Groups["Category"].Value);
+                    System.Console.Write("]:");
+                }
+                else
+                {
+                    outText = outText.Trim();
+                }
+            }
+
+            if (level == "error")
+                WriteColorText(ConsoleColor.Red, outText);
+            else if (level == "warn")
+                WriteColorText(ConsoleColor.Yellow, outText);
+            else
+                System.Console.Write(outText);
+        
+            System.Console.WriteLine();
+        }
+
+        public override void Output(string text)
+        {
+            Output(text, LOGLEVEL_NONE);
+        }
+
+        public override void Output(string text, string level)
+        {
+            FireOnOutput(text);
+
+            lock (m_commandLine)
+            {
+                if (m_cursorYPosition == -1)
+                {
+                    WriteLocalText(text, level);
+
+                    return;
+                }
+
+                m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+                SetCursorLeft(0);
+
+                int count = m_commandLine.Length + prompt.Length;
+
+                while (count-- > 0)
+                    System.Console.Write(" ");
+
+                m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+                SetCursorLeft(0);
+
+                WriteLocalText(text, level);
+
+                m_cursorYPosition = System.Console.CursorTop;
+
+                Show();
+            }
+        }
+
+        private bool ContextHelp()
+        {
+            string[] words = Parser.Parse(m_commandLine.ToString());
+
+            bool trailingSpace = m_commandLine.ToString().EndsWith(" ");
+
+            // Allow ? through while typing a URI
+            //
+            if (words.Length > 0 && words[words.Length-1].StartsWith("http") && !trailingSpace)
+                return false;
+
+            string[] opts = Commands.FindNextOption(words, trailingSpace);
+
+            if (opts[0].StartsWith("Command help:"))
+                Output(opts[0]);
+            else
+                Output(String.Format("Options: {0}", String.Join(" ", opts)));
+
+            return true;
+        }
+
+        public override string ReadLine(string p, bool isCommand, bool e)
+        {
+            m_cursorXPosition = 0;
+            prompt = p;
+            m_echo = e;
+            int historyLine = m_history.Count;
+
+            SetCursorLeft(0); // Needed for mono
+            System.Console.Write(" "); // Needed for mono
+
+            lock (m_commandLine)
+            {
+                m_cursorYPosition = System.Console.CursorTop;
+                m_commandLine.Remove(0, m_commandLine.Length);
+            }
+
+            while (true)
+            {
+                Show();
+
+                ConsoleKeyInfo key = System.Console.ReadKey(true);
+                char enteredChar = key.KeyChar;
+
+                if (!Char.IsControl(enteredChar))
+                {
+                    if (m_cursorXPosition >= 318)
+                        continue;
+
+                    if (enteredChar == '?' && isCommand)
+                    {
+                        if (ContextHelp())
+                            continue;
+                    }
+
+                    m_commandLine.Insert(m_cursorXPosition, enteredChar);
+                    m_cursorXPosition++;
+                }
+                else
+                {
+                    switch (key.Key)
+                    {
+                    case ConsoleKey.Backspace:
+                        if (m_cursorXPosition == 0)
+                            break;
+                        m_commandLine.Remove(m_cursorXPosition-1, 1);
+                        m_cursorXPosition--;
+
+                        SetCursorLeft(0);
+                        m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+
+                        if (m_echo)
+                            System.Console.Write("{0}{1} ", prompt, m_commandLine);
+                        else
+                            System.Console.Write("{0}", prompt);
+
+                        break;
+                    case ConsoleKey.Delete:
+                        if (m_cursorXPosition == m_commandLine.Length)
+                            break;
+
+                        m_commandLine.Remove(m_cursorXPosition, 1);
+
+                        SetCursorLeft(0);
+                        m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+
+                        if (m_echo)
+                            System.Console.Write("{0}{1} ", prompt, m_commandLine);
+                        else
+                            System.Console.Write("{0}", prompt);
+
+                        break;
+                    case ConsoleKey.End:
+                        m_cursorXPosition = m_commandLine.Length;
+                        break;
+                    case ConsoleKey.Home:
+                        m_cursorXPosition = 0;
+                        break;
+                    case ConsoleKey.UpArrow:
+                        if (historyLine < 1)
+                            break;
+                        historyLine--;
+                        LockOutput();
+                        m_commandLine.Remove(0, m_commandLine.Length);
+                        m_commandLine.Append(m_history[historyLine]);
+                        m_cursorXPosition = m_commandLine.Length;
+                        UnlockOutput();
+                        break;
+                    case ConsoleKey.DownArrow:
+                        if (historyLine >= m_history.Count)
+                            break;
+                        historyLine++;
+                        LockOutput();
+                        if (historyLine == m_history.Count)
+                        {
+                            m_commandLine.Remove(0, m_commandLine.Length);
+                        }
+                        else
+                        {
+                            m_commandLine.Remove(0, m_commandLine.Length);
+                            m_commandLine.Append(m_history[historyLine]);
+                        }
+                        m_cursorXPosition = m_commandLine.Length;
+                        UnlockOutput();
+                        break;
+                    case ConsoleKey.LeftArrow:
+                        if (m_cursorXPosition > 0)
+                            m_cursorXPosition--;
+                        break;
+                    case ConsoleKey.RightArrow:
+                        if (m_cursorXPosition < m_commandLine.Length)
+                            m_cursorXPosition++;
+                        break;
+                    case ConsoleKey.Enter:
+                        SetCursorLeft(0);
+                        m_cursorYPosition = SetCursorTop(m_cursorYPosition);
+
+                        System.Console.WriteLine();
+                        //Show();
+
+                        lock (m_commandLine)
+                        {
+                            m_cursorYPosition = -1;
+                        }
+
+                        string commandLine = m_commandLine.ToString();
+                        
+                        if (isCommand)
+                        {
+                            string[] cmd = Commands.Resolve(Parser.Parse(commandLine));
+
+                            if (cmd.Length != 0)
+                            {
+                                int index;
+
+                                for (index=0 ; index < cmd.Length ; index++)
+                                {
+                                    if (cmd[index].Contains(" "))
+                                        cmd[index] = "\"" + cmd[index] + "\"";
+                                }
+                                AddToHistory(String.Join(" ", cmd));
+                                return String.Empty;
+                            }
+                        }
+
+                        // If we're not echoing to screen (e.g. a password) then we probably don't want it in history
+                        if (m_echo && commandLine != "")
+                            AddToHistory(commandLine);
+                        
+                        return commandLine;
+                    default:
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Framework/Console/MockConsole.cs b/OpenSim/Framework/Console/MockConsole.cs
new file mode 100644
index 0000000..1a142df
--- /dev/null
+++ b/OpenSim/Framework/Console/MockConsole.cs
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Threading;
+using System.Collections.Generic;
+using System.Text;
+using System.Xml;
+
+namespace OpenSim.Framework.Console
+{
+    /// <summary>
+    /// This is a Fake console that's used when setting up the Scene in Unit Tests
+    /// Don't use this except for Unit Testing or you're in for a world of hurt when the 
+    /// sim gets to ReadLine
+    /// </summary>
+    public class MockConsole : ICommandConsole
+    {
+#pragma warning disable 0067
+        public event OnOutputDelegate OnOutput;
+#pragma warning restore 0067
+
+        private MockCommands m_commands = new MockCommands();
+
+        public ICommands Commands { get { return m_commands; } }
+
+        public string DefaultPrompt { get; set; }
+
+        public void Prompt() {}
+
+        public void RunCommand(string cmd) {}
+
+        public string ReadLine(string p, bool isCommand, bool e) { return ""; }
+
+        public object ConsoleScene { 
+            get { return null; }
+            set {}
+        }
+
+        public void Output(string text, string level) {}
+        public void Output(string text) {}
+        public void OutputFormat(string format, params object[] components) {}
+
+        public string CmdPrompt(string p) { return ""; }
+        public string CmdPrompt(string p, string def) { return ""; }
+        public string CmdPrompt(string p, List<char> excludedCharacters) { return ""; }
+        public string CmdPrompt(string p, string def, List<char> excludedCharacters) { return ""; }
+
+        public string CmdPrompt(string prompt, string defaultresponse, List<string> options) { return ""; }
+
+        public string PasswdPrompt(string p) { return ""; }
+    }
+
+    public class MockCommands : ICommands
+    {
+        public void FromXml(XmlElement root, CommandDelegate fn) {}
+        public List<string> GetHelp(string[] cmd) { return null; }
+        public void AddCommand(string module, bool shared, string command, string help, string longhelp, CommandDelegate fn) {}
+        public void AddCommand(string module, bool shared, string command, string help, string longhelp, string descriptivehelp, CommandDelegate fn) {}
+        public string[] FindNextOption(string[] cmd, bool term) { return null; }
+        public bool HasCommand(string cmd) { return false; }
+        public string[] Resolve(string[] cmd) { return null; }
+        public XmlElement GetXml(XmlDocument doc) { return null; }
+    }
+}
diff --git a/OpenSim/Framework/Console/OpenSimAppender.cs b/OpenSim/Framework/Console/OpenSimAppender.cs
new file mode 100644
index 0000000..72a251e
--- /dev/null
+++ b/OpenSim/Framework/Console/OpenSimAppender.cs
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using log4net.Appender;
+using log4net.Core;
+
+namespace OpenSim.Framework.Console
+{
+    /// <summary>
+    /// Writes log information out onto the console
+    /// </summary>
+    public class OpenSimAppender : AnsiColorTerminalAppender
+    {
+        private ConsoleBase m_console = null;
+
+        public ConsoleBase Console
+        {
+            get { return m_console; }
+            set { m_console = value; }
+        }
+
+        override protected void Append(LoggingEvent le)
+        {
+            if (m_console != null)
+                m_console.LockOutput();
+
+            string loggingMessage = RenderLoggingEvent(le);
+
+            try
+            {
+                if (m_console != null)
+                {
+                    string level = "normal";
+
+                    if (le.Level == Level.Error)
+                        level = "error";
+                    else if (le.Level == Level.Warn)
+                        level = "warn";
+
+                    m_console.Output(loggingMessage, level);
+                }
+                else
+                {
+                    if (!loggingMessage.EndsWith("\n"))
+                        System.Console.WriteLine(loggingMessage);
+                    else
+                        System.Console.Write(loggingMessage);
+                }
+            }
+            catch (Exception e)
+            {
+                System.Console.WriteLine("Couldn't write out log message: {0}", e.ToString());
+            }
+            finally
+            {
+                if (m_console != null)
+                    m_console.UnlockOutput();
+            }
+        }
+    }
+}
diff --git a/OpenSim/Framework/Console/RemoteConsole.cs b/OpenSim/Framework/Console/RemoteConsole.cs
new file mode 100644
index 0000000..8ad7b0d
--- /dev/null
+++ b/OpenSim/Framework/Console/RemoteConsole.cs
@@ -0,0 +1,513 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Xml;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using OpenMetaverse;
+using Nini.Config;
+using OpenSim.Framework.Servers.HttpServer;
+using log4net;
+
+namespace OpenSim.Framework.Console
+{
+    public class ConsoleConnection
+    {
+        public int last;
+        public long lastLineSeen;
+        public bool newConnection = true;
+    }
+
+    // A console that uses REST interfaces
+    //
+    public class RemoteConsole : CommandConsole
+    {
+        private IHttpServer m_Server = null;
+        private IConfigSource m_Config = null;
+
+        private List<string> m_Scrollback = new List<string>();
+        private ManualResetEvent m_DataEvent = new ManualResetEvent(false);
+        private List<string> m_InputData = new List<string>();
+        private long m_LineNumber = 0;
+        private Dictionary<UUID, ConsoleConnection> m_Connections =
+                new Dictionary<UUID, ConsoleConnection>();
+        private string m_UserName = String.Empty;
+        private string m_Password = String.Empty;
+        private string m_AllowedOrigin = String.Empty;
+
+        public RemoteConsole(string defaultPrompt) : base(defaultPrompt)
+        {
+        }
+
+        public void ReadConfig(IConfigSource config)
+        {
+            m_Config = config;
+
+            IConfig netConfig = m_Config.Configs["Network"];
+            if (netConfig == null)
+                return;
+
+            m_UserName = netConfig.GetString("ConsoleUser", String.Empty);
+            m_Password = netConfig.GetString("ConsolePass", String.Empty);
+            m_AllowedOrigin = netConfig.GetString("ConsoleAllowedOrigin", String.Empty);
+        }
+
+        public void SetServer(IHttpServer server)
+        {
+            m_Server = server;
+
+            m_Server.AddHTTPHandler("/StartSession/", HandleHttpStartSession);
+            m_Server.AddHTTPHandler("/CloseSession/", HandleHttpCloseSession);
+            m_Server.AddHTTPHandler("/SessionCommand/", HandleHttpSessionCommand);
+        }
+
+        public override void Output(string text, string level)
+        {
+            lock (m_Scrollback)
+            {
+                while (m_Scrollback.Count >= 1000)
+                    m_Scrollback.RemoveAt(0);
+                m_LineNumber++;
+                m_Scrollback.Add(String.Format("{0}", m_LineNumber)+":"+level+":"+text);
+            }
+            FireOnOutput(text.Trim());
+            System.Console.WriteLine(text.Trim());
+        }
+
+        public override void Output(string text)
+        {
+            Output(text, "normal");
+        }
+
+        public override string ReadLine(string p, bool isCommand, bool e)
+        {
+            if (isCommand)
+                Output("+++"+p);
+            else
+                Output("-++"+p);
+
+            m_DataEvent.WaitOne();
+
+            string cmdinput;
+
+            lock (m_InputData)
+            {
+                if (m_InputData.Count == 0)
+                {
+                    m_DataEvent.Reset();
+                    return "";
+                }
+
+                cmdinput = m_InputData[0];
+                m_InputData.RemoveAt(0);
+                if (m_InputData.Count == 0)
+                    m_DataEvent.Reset();
+
+            }
+
+            if (isCommand)
+            {
+                string[] cmd = Commands.Resolve(Parser.Parse(cmdinput));
+
+                if (cmd.Length != 0)
+                {
+                    int i;
+
+                    for (i=0 ; i < cmd.Length ; i++)
+                    {
+                        if (cmd[i].Contains(" "))
+                            cmd[i] = "\"" + cmd[i] + "\"";
+                    }
+                    return String.Empty;
+                }
+            }
+            return cmdinput;
+        }
+
+        private Hashtable CheckOrigin(Hashtable result)
+        {
+            if (!string.IsNullOrEmpty(m_AllowedOrigin))
+                result["access_control_allow_origin"] = m_AllowedOrigin;
+            return result;
+        }
+        /* TODO: Figure out how PollServiceHTTPHandler can access the request headers
+         * in order to use m_AllowedOrigin as a regular expression
+        private Hashtable CheckOrigin(Hashtable headers, Hashtable result)
+        {
+            if (!string.IsNullOrEmpty(m_AllowedOrigin))
+            {
+                if (headers.ContainsKey("origin"))
+                {
+                    string origin = headers["origin"].ToString();
+                    if (Regex.IsMatch(origin, m_AllowedOrigin))
+                        result["access_control_allow_origin"] = origin;
+                }
+            }
+            return result;
+        }
+        */
+
+        private void DoExpire()
+        {
+            List<UUID> expired = new List<UUID>();
+
+            lock (m_Connections)
+            {
+                foreach (KeyValuePair<UUID, ConsoleConnection> kvp in m_Connections)
+                {
+                    if (System.Environment.TickCount - kvp.Value.last > 500000)
+                        expired.Add(kvp.Key);
+                }
+
+                foreach (UUID id in expired)
+                {
+                    m_Connections.Remove(id);
+                    CloseConnection(id);
+                }
+            }
+        }
+
+        private Hashtable HandleHttpStartSession(Hashtable request)
+        {
+            DoExpire();
+
+            Hashtable post = DecodePostString(request["body"].ToString());
+            Hashtable reply = new Hashtable();
+
+            reply["str_response_string"] = "";
+            reply["int_response_code"] = 401;
+            reply["content_type"] = "text/plain";
+
+            if (m_UserName == String.Empty)
+                return reply;
+
+            if (post["USER"] == null || post["PASS"] == null)
+                return reply;
+
+            if (m_UserName != post["USER"].ToString() ||
+                m_Password != post["PASS"].ToString())
+            {
+                return reply;
+            }
+
+            ConsoleConnection c = new ConsoleConnection();
+            c.last = System.Environment.TickCount;
+            c.lastLineSeen = 0;
+
+            UUID sessionID = UUID.Random();
+
+            lock (m_Connections)
+            {
+                m_Connections[sessionID] = c;
+            }
+
+            string uri = "/ReadResponses/" + sessionID.ToString() + "/";
+
+            m_Server.AddPollServiceHTTPHandler(
+                uri, new PollServiceEventArgs(null, uri, HasEvents, GetEvents, NoEvents, sessionID,25000)); // 25 secs timeout
+
+            XmlDocument xmldoc = new XmlDocument();
+            XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            xmldoc.AppendChild(xmlnode);
+            XmlElement rootElement = xmldoc.CreateElement("", "ConsoleSession",
+                    "");
+
+            xmldoc.AppendChild(rootElement);
+
+            XmlElement id = xmldoc.CreateElement("", "SessionID", "");
+            id.AppendChild(xmldoc.CreateTextNode(sessionID.ToString()));
+
+            rootElement.AppendChild(id);
+
+            XmlElement prompt = xmldoc.CreateElement("", "Prompt", "");
+            prompt.AppendChild(xmldoc.CreateTextNode(DefaultPrompt));
+
+            rootElement.AppendChild(prompt);
+
+            rootElement.AppendChild(MainConsole.Instance.Commands.GetXml(xmldoc));
+
+            reply["str_response_string"] = xmldoc.InnerXml;
+            reply["int_response_code"] = 200;
+            reply["content_type"] = "text/xml";
+            reply = CheckOrigin(reply);
+
+            return reply;
+        }
+
+        private Hashtable HandleHttpCloseSession(Hashtable request)
+        {
+            DoExpire();
+
+            Hashtable post = DecodePostString(request["body"].ToString());
+            Hashtable reply = new Hashtable();
+
+            reply["str_response_string"] = "";
+            reply["int_response_code"] = 404;
+            reply["content_type"] = "text/plain";
+
+            if (post["ID"] == null)
+                return reply;
+
+            UUID id;
+            if (!UUID.TryParse(post["ID"].ToString(), out id))
+                return reply;
+
+            lock (m_Connections)
+            {
+                if (m_Connections.ContainsKey(id))
+                {
+                    m_Connections.Remove(id);
+                    CloseConnection(id);
+                }
+            }
+
+            XmlDocument xmldoc = new XmlDocument();
+            XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            xmldoc.AppendChild(xmlnode);
+            XmlElement rootElement = xmldoc.CreateElement("", "ConsoleSession",
+                    "");
+
+            xmldoc.AppendChild(rootElement);
+
+            XmlElement res = xmldoc.CreateElement("", "Result", "");
+            res.AppendChild(xmldoc.CreateTextNode("OK"));
+
+            rootElement.AppendChild(res);
+
+            reply["str_response_string"] = xmldoc.InnerXml;
+            reply["int_response_code"] = 200;
+            reply["content_type"] = "text/xml";
+            reply = CheckOrigin(reply);
+
+            return reply;
+        }
+
+        private Hashtable HandleHttpSessionCommand(Hashtable request)
+        {
+            DoExpire();
+
+            Hashtable post = DecodePostString(request["body"].ToString());
+            Hashtable reply = new Hashtable();
+
+            reply["str_response_string"] = "";
+            reply["int_response_code"] = 404;
+            reply["content_type"] = "text/plain";
+
+            if (post["ID"] == null)
+                return reply;
+
+            UUID id;
+            if (!UUID.TryParse(post["ID"].ToString(), out id))
+                return reply;
+
+            lock (m_Connections)
+            {
+                if (!m_Connections.ContainsKey(id))
+                    return reply;
+            }
+
+            if (post["COMMAND"] == null)
+                return reply;
+
+            lock (m_InputData)
+            {
+                m_DataEvent.Set();
+                m_InputData.Add(post["COMMAND"].ToString());
+            }
+
+            XmlDocument xmldoc = new XmlDocument();
+            XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            xmldoc.AppendChild(xmlnode);
+            XmlElement rootElement = xmldoc.CreateElement("", "ConsoleSession",
+                    "");
+
+            xmldoc.AppendChild(rootElement);
+
+            XmlElement res = xmldoc.CreateElement("", "Result", "");
+            res.AppendChild(xmldoc.CreateTextNode("OK"));
+
+            rootElement.AppendChild(res);
+
+            reply["str_response_string"] = xmldoc.InnerXml;
+            reply["int_response_code"] = 200;
+            reply["content_type"] = "text/xml";
+            reply = CheckOrigin(reply);
+
+            return reply;
+        }
+
+        private Hashtable DecodePostString(string data)
+        {
+            Hashtable result = new Hashtable();
+
+            string[] terms = data.Split(new char[] {'&'});
+
+            foreach (string term in terms)
+            {
+                string[] elems = term.Split(new char[] {'='});
+                if (elems.Length == 0)
+                    continue;
+
+                string name = System.Web.HttpUtility.UrlDecode(elems[0]);
+                string value = String.Empty;
+
+                if (elems.Length > 1)
+                    value = System.Web.HttpUtility.UrlDecode(elems[1]);
+                
+                result[name] = value;
+            }
+
+            return result;
+        }
+
+        public void CloseConnection(UUID id)
+        {
+            try
+            {
+                string uri = "/ReadResponses/" + id.ToString() + "/";
+
+                m_Server.RemovePollServiceHTTPHandler("", uri);
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        private bool HasEvents(UUID RequestID, UUID sessionID)
+        {
+            ConsoleConnection c = null;
+
+            lock (m_Connections)
+            {
+                if (!m_Connections.ContainsKey(sessionID))
+                    return false;
+                c = m_Connections[sessionID];
+            }
+            c.last = System.Environment.TickCount;
+            if (c.lastLineSeen < m_LineNumber)
+                return true;
+            return false;
+        }
+
+        private Hashtable GetEvents(UUID RequestID, UUID sessionID)
+        {
+            ConsoleConnection c = null;
+
+            lock (m_Connections)
+            {
+                if (!m_Connections.ContainsKey(sessionID))
+                    return NoEvents(RequestID, UUID.Zero);
+                c = m_Connections[sessionID];
+            }
+            c.last = System.Environment.TickCount;
+            if (c.lastLineSeen >= m_LineNumber)
+                return NoEvents(RequestID, UUID.Zero);
+
+            Hashtable result = new Hashtable();
+
+            XmlDocument xmldoc = new XmlDocument();
+            XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            xmldoc.AppendChild(xmlnode);
+            XmlElement rootElement = xmldoc.CreateElement("", "ConsoleSession",
+                    "");
+
+            if (c.newConnection)
+            {
+                c.newConnection = false;
+                Output("+++" + DefaultPrompt);
+            }
+
+            lock (m_Scrollback)
+            {
+                long startLine = m_LineNumber - m_Scrollback.Count;
+                long sendStart = startLine;
+                if (sendStart < c.lastLineSeen)
+                    sendStart = c.lastLineSeen;
+
+                for (long i = sendStart ; i < m_LineNumber ; i++)
+                {
+                    XmlElement res = xmldoc.CreateElement("", "Line", "");
+                    long line = i + 1;
+                    res.SetAttribute("Number", line.ToString());
+                    res.AppendChild(xmldoc.CreateTextNode(m_Scrollback[(int)(i - startLine)]));
+
+                    rootElement.AppendChild(res);
+                }
+            }
+            c.lastLineSeen = m_LineNumber;
+
+            xmldoc.AppendChild(rootElement);
+
+            result["str_response_string"] = xmldoc.InnerXml;
+            result["int_response_code"] = 200;
+            result["content_type"] = "application/xml";
+            result["keepalive"] = false;
+            result["reusecontext"] = false;
+            result = CheckOrigin(result);
+
+            return result;
+        }
+
+        private Hashtable NoEvents(UUID RequestID, UUID id)
+        {
+            Hashtable result = new Hashtable();
+
+            XmlDocument xmldoc = new XmlDocument();
+            XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            xmldoc.AppendChild(xmlnode);
+            XmlElement rootElement = xmldoc.CreateElement("", "ConsoleSession",
+                    "");
+
+            xmldoc.AppendChild(rootElement);
+
+            result["str_response_string"] = xmldoc.InnerXml;
+            result["int_response_code"] = 200;
+            result["content_type"] = "text/xml";
+            result["keepalive"] = false;
+            result["reusecontext"] = false;
+            result = CheckOrigin(result);
+
+            return result;
+        }
+    }
+}