Merge remote-tracking branch 'os/master'

71 files changed, 13302 insertions, 0 deletions

diff --git a/OpenSim/Server/Base/CommandManager.cs b/OpenSim/Server/Base/CommandManager.cs
new file mode 100644
index 0000000..bd18485
--- /dev/null
+++ b/OpenSim/Server/Base/CommandManager.cs
@@ -0,0 +1,359 @@
+/*
+ * 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.Text;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Mono.Addins.Setup;
+using Mono.Addins;
+using Mono.Addins.Description;
+using OpenSim.Framework;
+
+namespace OpenSim.Server.Base
+{
+    /// <summary>
+    /// Command manager -
+    /// Wrapper for OpenSim.Framework.PluginManager to allow 
+    /// us to add commands to the console to perform operations
+    /// on our repos and plugins
+    /// </summary>
+        public class CommandManager
+        {
+                public AddinRegistry PluginRegistry;
+                protected PluginManager PluginManager;
+
+                public CommandManager(AddinRegistry registry)
+        {
+                        PluginRegistry = registry;
+                        PluginManager = new PluginManager(PluginRegistry);
+                        AddManagementCommands();
+                }
+
+                private void AddManagementCommands()
+                {
+                        // add plugin
+                        MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin add", "plugin add \"plugin index\"",
+                                                                 "Install plugin from repository.",
+                                                     HandleConsoleInstallPlugin);
+
+                        // remove plugin
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin remove", "plugin remove \"plugin index\"",
+                                                                 "Remove plugin from repository",
+                                                     HandleConsoleUnInstallPlugin);
+
+                        // list installed plugins
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin list installed", 
+                                                                 "plugin list installed","List install plugins",
+                                                     HandleConsoleListInstalledPlugin);
+
+                        // list plugins available from registered repositories
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin list available",
+                                                                 "plugin list available","List available plugins",
+                                                     HandleConsoleListAvailablePlugin);
+                        // List available updates
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin updates", "plugin updates","List availble updates",
+                                                     HandleConsoleListUpdates);
+
+                        // Update plugin
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin update", "plugin update \"plugin index\"","Update the plugin",
+                                                     HandleConsoleUpdatePlugin);
+
+                        // Add repository
+            MainConsole.Instance.Commands.AddCommand("Repository", true,
+                                                     "repo add", "repo add \"url\"","Add repository",
+                                                     HandleConsoleAddRepo);
+
+                        // Refresh repo
+            MainConsole.Instance.Commands.AddCommand("Repository", true,
+                                                     "repo refresh", "repo refresh \"url\"", "Sync with a registered repository",
+                                                     HandleConsoleGetRepo);
+
+                        // Remove repository from registry
+            MainConsole.Instance.Commands.AddCommand("Repository", true,
+                                                     "repo remove",
+                                                                 "repo remove \"[url | index]\"",
+                                                                 "Remove repository from registry",
+                                                     HandleConsoleRemoveRepo);
+
+                        // Enable repo
+            MainConsole.Instance.Commands.AddCommand("Repository", true,
+                                                     "repo enable", "repo enable \"[url | index]\"",
+                                                                 "Enable registered repository",
+                                                     HandleConsoleEnableRepo);
+
+                        // Disable repo
+            MainConsole.Instance.Commands.AddCommand("Repository", true,
+                                                     "repo disable", "repo disable\"[url | index]\"",
+                                                                 "Disable registered repository",
+                                                     HandleConsoleDisableRepo);
+
+                        // List registered repositories
+            MainConsole.Instance.Commands.AddCommand("Repository", true,
+                                                     "repo list", "repo list",
+                                                                 "List registered repositories",
+                                                     HandleConsoleListRepos);
+
+                        // *
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin info", "plugin info \"plugin index\"","Show detailed information for plugin",
+                                                     HandleConsoleShowAddinInfo);
+
+                        // Plugin disable
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin disable", "plugin disable \"plugin index\"",
+                                                                 "Disable a plugin",
+                                                     HandleConsoleDisablePlugin);
+
+                        // Enable plugin
+            MainConsole.Instance.Commands.AddCommand("Plugin", true,
+                                                     "plugin enable", "plugin enable \"plugin index\"",
+                                                                 "Enable the selected plugin plugin",
+                                                     HandleConsoleEnablePlugin);
+        }
+                
+        #region console handlers
+        // Handle our console commands
+        //
+        // Install plugin from registered repository
+        /// <summary>
+        /// Handles the console install plugin command. Attempts to install the selected plugin
+        /// and 
+        /// </summary>
+        /// <param name='module'>
+        /// Module.
+        /// </param>
+        /// <param name='cmd'>
+        /// Cmd.
+        /// </param>
+        private void HandleConsoleInstallPlugin(string module, string[] cmd)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+
+            if (cmd.Length == 3)
+            {
+                int ndx = Convert.ToInt16(cmd[2]);
+                if (PluginManager.InstallPlugin(ndx, out result) == true)
+                {
+                    ArrayList s = new ArrayList();
+                    s.AddRange(result.Keys);
+                    s.Sort();
+
+                    var list = result.Keys.ToList();
+                    list.Sort();
+                    foreach (var k in list)
+                    {
+                        Dictionary<string, object> plugin = (Dictionary<string, object>)result[k];
+                        bool enabled = (bool)plugin["enabled"];
+                        MainConsole.Instance.OutputFormat("{0}) {1} {2} rev. {3}",
+                                                  k,
+                                                  enabled == true ? "[ ]" : "[X]",
+                                                  plugin["name"], plugin["version"]);
+                    }
+                }
+            }
+            return;
+        }
+
+        // Remove installed plugin
+        private void HandleConsoleUnInstallPlugin(string module, string[] cmd)
+        {
+            if (cmd.Length == 3)
+            {
+                int ndx = Convert.ToInt16(cmd[2]);
+                PluginManager.UnInstall(ndx);
+            }
+            return;
+        }
+
+        // List installed plugins
+        private void HandleConsoleListInstalledPlugin(string module, string[] cmd)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            PluginManager.ListInstalledAddins(out result);
+
+            ArrayList s = new ArrayList();
+            s.AddRange(result.Keys);
+            s.Sort();
+
+            var list = result.Keys.ToList();
+            list.Sort();
+            foreach (var k in list)
+            {
+                Dictionary<string, object> plugin = (Dictionary<string, object>)result[k];
+                bool enabled = (bool)plugin["enabled"];
+                MainConsole.Instance.OutputFormat("{0}) {1} {2} rev. {3}",
+                                                  k,
+                                                  enabled == true ? "[ ]" : "[X]",
+                                                  plugin["name"], plugin["version"]);
+            }
+            return;
+        }
+
+        // List available plugins on registered repositories
+        private void HandleConsoleListAvailablePlugin(string module, string[] cmd)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            PluginManager.ListAvailable(out result);
+
+            var list = result.Keys.ToList();
+            list.Sort();
+            foreach (var k in list)
+            {
+                // name, version, repository
+                Dictionary<string, object> plugin = (Dictionary<string, object>)result[k];
+                MainConsole.Instance.OutputFormat("{0}) {1} rev. {2} {3}",
+                                                  k,
+                                                  plugin["name"],
+                                                  plugin["version"],
+                                                  plugin["repository"]);
+            }
+            return;
+        }
+
+        // List available updates **not ready
+        private void HandleConsoleListUpdates(string module, string[] cmd)
+        {
+            PluginManager.ListUpdates();
+            return;
+        }
+
+        // Update plugin **not ready
+        private void HandleConsoleUpdatePlugin(string module, string[] cmd)
+        {
+            MainConsole.Instance.Output(PluginManager.Update());
+            return;
+        }
+
+        // Register repository
+        private void HandleConsoleAddRepo(string module, string[] cmd)
+        {
+            if ( cmd.Length == 3)
+            {
+                PluginManager.AddRepository(cmd[2]);
+            }
+            return;
+        }
+
+        // Get repository status **not working
+        private void HandleConsoleGetRepo(string module, string[] cmd)
+        {
+            PluginManager.GetRepository();
+            return;
+        }
+
+        // Remove registered repository
+        private void HandleConsoleRemoveRepo(string module, string[] cmd)
+        {
+            if (cmd.Length == 3)
+                PluginManager.RemoveRepository(cmd);
+            return;
+        }
+
+        // Enable repository
+        private void HandleConsoleEnableRepo(string module, string[] cmd)
+        {
+            PluginManager.EnableRepository(cmd);
+            return;
+        }
+
+        // Disable repository
+        private void HandleConsoleDisableRepo(string module, string[] cmd)
+        {
+            PluginManager.DisableRepository(cmd);
+            return;
+        }
+
+        // List repositories
+        private void HandleConsoleListRepos(string module, string[] cmd)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            PluginManager.ListRepositories(out result);
+
+            var list = result.Keys.ToList();
+            list.Sort();
+            foreach (var k in list)
+            {
+                Dictionary<string, object> repo = (Dictionary<string, object>)result[k];
+                bool enabled = (bool)repo["enabled"];
+                MainConsole.Instance.OutputFormat("{0}) {1} {2}",
+                                                  k,
+                                                  enabled == true ? "[ ]" : "[X]",
+                                                  repo["name"], repo["url"]);
+            }
+
+            return;
+        }
+
+        // Show description information
+        private void HandleConsoleShowAddinInfo(string module, string[] cmd)
+        {
+            if (cmd.Length >= 3)
+            {
+                
+                Dictionary<string, object> result = new Dictionary<string, object>();
+
+                int ndx = Convert.ToInt16(cmd[2]);
+                PluginManager.AddinInfo(ndx, out result);
+
+                MainConsole.Instance.OutputFormat("Name: {0}\nURL: {1}\nFile: {2}\nAuthor: {3}\nCategory: {4}\nDesc: {5}",
+                                                  result["name"],
+                                                  result["url"],
+                                                  result["file_name"],
+                                                  result["author"],
+                                                  result["category"],
+                                                  result["description"]);
+
+                return;
+            }
+        }
+
+        // Disable plugin
+        private void HandleConsoleDisablePlugin(string module, string[] cmd)
+        {
+            PluginManager.DisablePlugin(cmd);
+            return;
+        }
+
+        // Enable plugin
+        private void HandleConsoleEnablePlugin(string module, string[] cmd)
+        {
+            PluginManager.EnablePlugin(cmd);
+            return;
+        }
+        #endregion
+        }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Base/HttpServerBase.cs b/OpenSim/Server/Base/HttpServerBase.cs
new file mode 100644
index 0000000..44ef124
--- /dev/null
+++ b/OpenSim/Server/Base/HttpServerBase.cs
@@ -0,0 +1,152 @@
+/*
+ * 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.Threading;
+using System.Reflection;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Server.Base
+{
+    public class HttpServerBase : ServicesServerBase
+    {
+//        private static readonly ILog m_Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private uint m_consolePort;
+
+        // Handle all the automagical stuff
+        //
+        public HttpServerBase(string prompt, string[] args) : base(prompt, args)
+        {
+        }
+
+        protected override void ReadConfig()
+        {
+            IConfig networkConfig = Config.Configs["Network"];
+
+            if (networkConfig == null)
+            {
+                System.Console.WriteLine("ERROR: Section [Network] not found, server can't start");
+                Environment.Exit(1);
+            }
+
+            uint port = (uint)networkConfig.GetInt("port", 0);
+
+            if (port == 0)
+            {
+                System.Console.WriteLine("ERROR: No 'port' entry found in [Network].  Server can't start");
+                Environment.Exit(1);
+            }
+
+            bool ssl_main = networkConfig.GetBoolean("https_main",false);
+            bool ssl_listener = networkConfig.GetBoolean("https_listener",false);
+
+            m_consolePort = (uint)networkConfig.GetInt("ConsolePort", 0);
+
+            BaseHttpServer httpServer = null;
+
+            //
+            // This is where to make the servers:
+            //
+            //
+            // Make the base server according to the port, etc.
+            // ADD: Possibility to make main server ssl
+            // Then, check for https settings and ADD a server to
+            // m_Servers
+            //
+            if (!ssl_main)
+            {
+                httpServer = new BaseHttpServer(port);
+            }
+            else
+            {
+                string cert_path = networkConfig.GetString("cert_path",String.Empty);
+                if (cert_path == String.Empty)
+                {
+                    System.Console.WriteLine("ERROR: Path to X509 certificate is missing, server can't start.");
+                    Environment.Exit(1);
+                }
+
+                string cert_pass = networkConfig.GetString("cert_pass",String.Empty);
+                if (cert_pass == String.Empty)
+                {
+                    System.Console.WriteLine("ERROR: Password for X509 certificate is missing, server can't start.");
+                    Environment.Exit(1);
+                }
+
+                httpServer = new BaseHttpServer(port, ssl_main, cert_path, cert_pass);
+            }
+
+            MainServer.AddHttpServer(httpServer);
+            MainServer.Instance = httpServer;
+
+            // If https_listener = true, then add an ssl listener on the https_port...
+            if (ssl_listener == true) 
+            {
+                uint https_port = (uint)networkConfig.GetInt("https_port", 0);
+
+                string cert_path = networkConfig.GetString("cert_path",String.Empty);
+                if (cert_path == String.Empty)
+                {
+                    System.Console.WriteLine("ERROR: Path to X509 certificate is missing, server can't start.");
+                    Environment.Exit(1);
+                }
+
+                string cert_pass = networkConfig.GetString("cert_pass",String.Empty);
+                if (cert_pass == String.Empty)
+                {
+                    System.Console.WriteLine("ERROR: Password for X509 certificate is missing, server can't start.");
+                    Environment.Exit(1);
+                }
+
+                MainServer.AddHttpServer(new BaseHttpServer(https_port, ssl_listener, cert_path, cert_pass));
+            }
+        }
+
+        protected override void Initialise()
+        {
+            foreach (BaseHttpServer s in MainServer.Servers.Values)
+                s.Start();
+
+            MainServer.RegisterHttpConsoleCommands(MainConsole.Instance);
+
+            if (MainConsole.Instance is RemoteConsole)
+            {
+                if (m_consolePort == 0)
+                    ((RemoteConsole)MainConsole.Instance).SetServer(MainServer.Instance);
+                else
+                    ((RemoteConsole)MainConsole.Instance).SetServer(MainServer.GetHttpServer(m_consolePort));
+            }
+        }
+    }
+}
diff --git a/OpenSim/Server/Base/Properties/AssemblyInfo.cs b/OpenSim/Server/Base/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..e819a2b
--- /dev/null
+++ b/OpenSim/Server/Base/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Server.Base")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8fbd5035-0dbc-4b9a-ad1a-a7567f254ea9")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.8.2.*")]
+
diff --git a/OpenSim/Server/Base/ProtocolVersions.cs b/OpenSim/Server/Base/ProtocolVersions.cs
new file mode 100644
index 0000000..8db5bb6
--- /dev/null
+++ b/OpenSim/Server/Base/ProtocolVersions.cs
@@ -0,0 +1,56 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Server.Base
+{
+    public class ProtocolVersions
+    {
+        /// <value>
+        /// This is the external protocol versions.  It is separate from the OpenSimulator project version.
+        /// 
+        /// These version numbers should be increased by 1 every time a code
+        /// change in the Service.Connectors and Server.Handlers, espectively, 
+        /// makes the previous OpenSimulator revision incompatible
+        /// with the new revision. 
+        /// 
+        /// Changes which are compatible with an older revision (e.g. older revisions experience degraded functionality
+        /// but not outright failure) do not need a version number increment.
+        /// 
+        /// Having this version number allows the grid service to reject connections from regions running a version
+        /// of the code that is too old. 
+        ///
+        /// </value>
+        
+        // The range of acceptable servers for client-side connectors
+        public readonly static int ClientProtocolVersionMin = 0;
+        public readonly static int ClientProtocolVersionMax = 0;
+
+        // The range of acceptable clients in server-side handlers
+        public readonly static int ServerProtocolVersionMin = 0;
+        public readonly static int ServerProtocolVersionMax = 0;
+    }
+}
diff --git a/OpenSim/Server/Base/ServerUtils.cs b/OpenSim/Server/Base/ServerUtils.cs
new file mode 100644
index 0000000..18a4266
--- /dev/null
+++ b/OpenSim/Server/Base/ServerUtils.cs
@@ -0,0 +1,542 @@
+/*
+ * 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.IO;
+using System.Reflection;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Text;
+using System.Collections.Generic;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenMetaverse;
+using Mono.Addins;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework.Servers;
+
+
+[assembly:AddinRoot("Robust", OpenSim.VersionInfo.VersionNumber)]
+namespace OpenSim.Server.Base
+{
+    [TypeExtensionPoint(Path="/Robust/Connector", Name="RobustConnector")]
+    public interface IRobustConnector
+    {
+        string ConfigName
+        {
+            get;
+        }
+
+        bool Enabled
+        {
+            get;
+        }
+
+        string PluginPath
+        {
+            get;
+            set;
+        }
+
+        uint Configure(IConfigSource config);
+        void Initialize(IHttpServer server);
+        void Unload();
+    }
+
+    public class PluginLoader
+    {
+        static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public AddinRegistry Registry
+        {
+            get;
+            private set;
+        }
+
+        public IConfigSource Config
+        {
+            get;
+            private set;
+        }
+
+        public PluginLoader(IConfigSource config, string registryPath)
+        {
+            Config = config;
+
+            Registry = new AddinRegistry(registryPath, ".");
+            //suppress_console_output_(true);
+            AddinManager.Initialize(registryPath);
+            //suppress_console_output_(false);
+            AddinManager.Registry.Update();
+            CommandManager commandmanager = new CommandManager(Registry);
+            AddinManager.AddExtensionNodeHandler("/Robust/Connector", OnExtensionChanged);
+        }
+
+        private static TextWriter prev_console_;
+        // Temporarily masking the errors reported on start
+        // This is caused by a non-managed dll in the ./bin dir
+        // when the registry is initialized. The dll belongs to
+        // libomv, which has a hard-coded path to "." for pinvoke
+        // to load the openjpeg dll
+        //
+        // Will look for a way to fix, but for now this keeps the 
+        // confusion to a minimum. this was copied from our region
+        // plugin loader, we have been doing this in there for a long time.
+        //
+        public void suppress_console_output_(bool save)
+        {
+            if (save)
+            {
+                prev_console_ = System.Console.Out;
+                System.Console.SetOut(new StreamWriter(Stream.Null));
+            }
+            else
+            {
+                if (prev_console_ != null)
+                    System.Console.SetOut(prev_console_);
+            }
+        }
+
+        private void OnExtensionChanged(object s, ExtensionNodeEventArgs args)
+        {
+            IRobustConnector connector = (IRobustConnector)args.ExtensionObject;
+            Addin a = Registry.GetAddin(args.ExtensionNode.Addin.Id);
+
+            if(a == null)
+            {
+                Registry.Rebuild(null);
+                a = Registry.GetAddin(args.ExtensionNode.Addin.Id);
+            }
+
+            switch(args.Change)
+            {
+                case ExtensionChange.Add:
+                    if (a.AddinFile.Contains(Registry.DefaultAddinsFolder))
+                    {
+                        m_log.InfoFormat("[SERVER UTILS]: Adding {0} from registry", a.Name);
+                        connector.PluginPath = System.IO.Path.Combine(Registry.DefaultAddinsFolder,a.Name.Replace(',', '.'));                    }
+                    else
+                    {
+                        m_log.InfoFormat("[SERVER UTILS]: Adding {0} from ./bin", a.Name);
+                        connector.PluginPath = a.AddinFile;
+                    }
+                    LoadPlugin(connector);
+                    break;
+                case ExtensionChange.Remove:
+                    m_log.InfoFormat("[SERVER UTILS]: Removing {0}", a.Name);
+                    UnloadPlugin(connector);
+                    break;
+            }
+        }
+
+        private void LoadPlugin(IRobustConnector connector)
+        {
+            IHttpServer server = null;
+            uint port = connector.Configure(Config);
+
+            if(connector.Enabled)
+            {
+                server = GetServer(connector, port);
+                connector.Initialize(server);
+            }
+            else
+            {
+                m_log.InfoFormat("[SERVER UTILS]: {0} Disabled.", connector.ConfigName);
+            }
+        }
+
+        private void UnloadPlugin(IRobustConnector connector)
+        {
+            m_log.InfoFormat("[SERVER UTILS]: Unloading {0}", connector.ConfigName);
+
+            connector.Unload();
+        }
+
+        private IHttpServer GetServer(IRobustConnector connector, uint port)
+        {
+            IHttpServer server;
+
+            if(port != 0)
+                server = MainServer.GetHttpServer(port);
+            else    
+                server = MainServer.Instance;
+
+            return server;
+        }
+    }
+
+    public static class ServerUtils
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public static  byte[] SerializeResult(XmlSerializer xs, object data)
+        {
+            using (MemoryStream ms = new MemoryStream())
+            using (XmlTextWriter xw = new XmlTextWriter(ms, Util.UTF8))
+            {
+                xw.Formatting = Formatting.Indented;
+                xs.Serialize(xw, data);
+                xw.Flush();
+
+                ms.Seek(0, SeekOrigin.Begin);
+                byte[] ret = ms.GetBuffer();
+                Array.Resize(ref ret, (int)ms.Length);
+
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// Load a plugin from a dll with the given class or interface
+        /// </summary>
+        /// <param name="dllName"></param>
+        /// <param name="args">The arguments which control which constructor is invoked on the plugin</param>
+        /// <returns></returns>
+        public static T LoadPlugin<T> (string dllName, Object[] args) where T:class
+        {
+            // This is good to debug configuration problems
+            //if (dllName == string.Empty)
+            //    Util.PrintCallStack();
+            
+            string className = String.Empty;
+
+            // The path for a dynamic plugin will contain ":" on Windows
+            string[] parts = dllName.Split (new char[] {':'});
+
+            if (parts [0].Length > 1) 
+            {
+                dllName = parts [0];
+                if (parts.Length > 1)
+                    className = parts[1];
+            } 
+            else 
+            {
+                // This is Windows - we must replace the ":" in the path
+                dllName = String.Format ("{0}:{1}", parts [0], parts [1]);
+                if (parts.Length > 2)
+                    className = parts[2];
+            }
+
+            return LoadPlugin<T>(dllName, className, args);
+        }
+
+        /// <summary>
+        /// Load a plugin from a dll with the given class or interface
+        /// </summary>
+        /// <param name="dllName"></param>
+        /// <param name="className"></param>
+        /// <param name="args">The arguments which control which constructor is invoked on the plugin</param>
+        /// <returns></returns>
+        public static T LoadPlugin<T>(string dllName, string className, Object[] args) where T:class
+        {
+            string interfaceName = typeof(T).ToString();
+
+            try
+            {
+                Assembly pluginAssembly = Assembly.LoadFrom(dllName);
+
+                foreach (Type pluginType in pluginAssembly.GetTypes())
+                {
+                    if (pluginType.IsPublic)
+                    {
+                        if (className != String.Empty 
+                            && pluginType.ToString() != pluginType.Namespace + "." + className)
+                            continue;
+                        
+                        Type typeInterface = pluginType.GetInterface(interfaceName);
+
+                        if (typeInterface != null)
+                        {
+                            T plug = null;
+                            try
+                            {
+                                plug = (T)Activator.CreateInstance(pluginType,
+                                        args);
+                            }
+                            catch (Exception e)
+                            {
+                                if (!(e is System.MissingMethodException))
+                                {
+                                    m_log.Error(string.Format("[SERVER UTILS]: Error loading plugin {0} from {1}. Exception: {2}",
+                                        interfaceName, 
+                                        dllName, 
+                                        e.InnerException == null ? e.Message : e.InnerException.Message),
+                                            e);
+                                }
+                                m_log.ErrorFormat("[SERVER UTILS]: Error loading plugin {0}: {1} args.Length {2}", dllName, e.Message, args.Length);
+                                return null;
+                            }
+
+                            return plug;
+                        }
+                    }
+                }
+
+                return null;
+            }
+            catch (ReflectionTypeLoadException rtle)
+            {
+                m_log.Error(string.Format("[SERVER UTILS]: Error loading plugin from {0}:\n{1}", dllName,
+                    String.Join("\n", Array.ConvertAll(rtle.LoaderExceptions, e => e.ToString()))),
+                    rtle);
+                return null;
+            }
+            catch (Exception e)
+            {
+                m_log.Error(string.Format("[SERVER UTILS]: Error loading plugin from {0}", dllName), e);
+                return null;
+            }
+        }
+
+        public static Dictionary<string, object> ParseQueryString(string query)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            string[] terms = query.Split(new char[] {'&'});
+
+            if (terms.Length == 0)
+                return result;
+
+            foreach (string t in terms)
+            {
+                string[] elems = t.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]);
+
+                if (name.EndsWith("[]"))
+                {
+                    string cleanName = name.Substring(0, name.Length - 2);
+                    if (result.ContainsKey(cleanName))
+                    {
+                        if (!(result[cleanName] is List<string>))
+                            continue;
+
+                        List<string> l = (List<string>)result[cleanName];
+
+                        l.Add(value);
+                    }
+                    else
+                    {
+                        List<string> newList = new List<string>();
+
+                        newList.Add(value);
+
+                        result[cleanName] = newList;
+                    }
+                }
+                else
+                {
+                    if (!result.ContainsKey(name))
+                        result[name] = value;
+                }
+            }
+
+            return result;
+        }
+
+        public static string BuildQueryString(Dictionary<string, object> data)
+        {
+            string qstring = String.Empty;
+
+            string part;
+
+            foreach (KeyValuePair<string, object> kvp in data)
+            {
+                if (kvp.Value is List<string>)
+                {
+                    List<string> l = (List<String>)kvp.Value;
+
+                    foreach (string s in l)
+                    {
+                        part = System.Web.HttpUtility.UrlEncode(kvp.Key) +
+                                "[]=" + System.Web.HttpUtility.UrlEncode(s);
+
+                        if (qstring != String.Empty)
+                            qstring += "&";
+
+                        qstring += part;
+                    }
+                }
+                else
+                {
+                    if (kvp.Value.ToString() != String.Empty)
+                    {
+                        part = System.Web.HttpUtility.UrlEncode(kvp.Key) +
+                                "=" + System.Web.HttpUtility.UrlEncode(kvp.Value.ToString());
+                    }
+                    else
+                    {
+                        part = System.Web.HttpUtility.UrlEncode(kvp.Key);
+                    }
+
+                    if (qstring != String.Empty)
+                        qstring += "&";
+
+                    qstring += part;
+                }
+            }
+
+            return qstring;
+        }
+
+        public static string BuildXmlResponse(Dictionary<string, object> data)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            BuildXmlData(rootElement, data);
+
+            return doc.InnerXml;
+        }
+
+        private static void BuildXmlData(XmlElement parent, Dictionary<string, object> data)
+        {
+            foreach (KeyValuePair<string, object> kvp in data)
+            {
+                if (kvp.Value == null)
+                    continue;
+
+                XmlElement elem = parent.OwnerDocument.CreateElement("",
+                        XmlConvert.EncodeLocalName(kvp.Key), "");
+
+                if (kvp.Value is Dictionary<string, object>)
+                {
+                    XmlAttribute type = parent.OwnerDocument.CreateAttribute("",
+                        "type", "");
+                    type.Value = "List";
+
+                    elem.Attributes.Append(type);
+
+                    BuildXmlData(elem, (Dictionary<string, object>)kvp.Value);
+                }
+                else
+                {
+                    elem.AppendChild(parent.OwnerDocument.CreateTextNode(
+                            kvp.Value.ToString()));
+                }
+
+                parent.AppendChild(elem);
+            }
+        }
+
+        public static Dictionary<string, object> ParseXmlResponse(string data)
+        {
+            //m_log.DebugFormat("[XXX]: received xml string: {0}", data);
+
+            Dictionary<string, object> ret = new Dictionary<string, object>();
+
+            XmlDocument doc = new XmlDocument();
+
+            doc.LoadXml(data);
+            
+            XmlNodeList rootL = doc.GetElementsByTagName("ServerResponse");
+
+            if (rootL.Count != 1)
+                return ret;
+
+            XmlNode rootNode = rootL[0];
+
+            ret = ParseElement(rootNode);
+
+            return ret;
+        }
+
+        private static Dictionary<string, object> ParseElement(XmlNode element)
+        {
+            Dictionary<string, object> ret = new Dictionary<string, object>();
+
+            XmlNodeList partL = element.ChildNodes;
+
+            foreach (XmlNode part in partL)
+            {
+                XmlNode type = part.Attributes.GetNamedItem("type");
+                if (type == null || type.Value != "List")
+                {
+                    ret[XmlConvert.DecodeName(part.Name)] = part.InnerText;
+                }
+                else
+                {
+                    ret[XmlConvert.DecodeName(part.Name)] = ParseElement(part);
+                }
+            }
+
+            return ret;
+        }
+
+        public static IConfig GetConfig(string configFile, string configName)
+        {
+            IConfig config;
+
+            if (File.Exists(configFile))
+            {
+                IConfigSource configsource = new IniConfigSource(configFile);
+                config = configsource.Configs[configName];
+            }
+            else
+                config = null;
+
+            return config;
+        }
+
+        public static IConfigSource LoadInitialConfig(string url)
+        {
+            IConfigSource source = new XmlConfigSource();
+            m_log.InfoFormat("[SERVER UTILS]: {0} is a http:// URI, fetching ...", url);
+
+            // The ini file path is a http URI
+            // Try to read it
+            try
+            {
+                XmlReader r = XmlReader.Create(url);
+                IConfigSource cs = new XmlConfigSource(r);
+                source.Merge(cs);
+            }
+            catch (Exception e)
+            {
+                m_log.FatalFormat("[SERVER UTILS]: Exception reading config from URI {0}\n" + e.ToString(), url);
+                Environment.Exit(1);
+            }
+
+            return source;
+        }
+    }
+}
diff --git a/OpenSim/Server/Base/ServicesServerBase.cs b/OpenSim/Server/Base/ServicesServerBase.cs
new file mode 100644
index 0000000..1f2c54d
--- /dev/null
+++ b/OpenSim/Server/Base/ServicesServerBase.cs
@@ -0,0 +1,243 @@
+/*
+ * 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.Reflection;
+using System.Threading;
+using System.Text;
+using System.Xml;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Monitoring;
+using OpenSim.Framework.Servers;
+using log4net;
+using log4net.Config;
+using log4net.Appender;
+using log4net.Core;
+using log4net.Repository;
+using Nini.Config;
+
+namespace OpenSim.Server.Base
+{
+    public class ServicesServerBase : ServerBase
+    {
+        // Logger
+        //
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // Command line args
+        //
+        protected string[] m_Arguments;
+
+        public string ConfigDirectory
+        {
+            get;
+            private set;
+        }
+
+        // Run flag
+        //
+        private bool m_Running = true;
+
+        // Handle all the automagical stuff
+        //
+        public ServicesServerBase(string prompt, string[] args) : base()
+        {
+            // Save raw arguments
+            m_Arguments = args;
+
+            // Read command line
+            ArgvConfigSource argvConfig = new ArgvConfigSource(args);
+
+            argvConfig.AddSwitch("Startup", "console", "c");
+            argvConfig.AddSwitch("Startup", "logfile", "l");
+            argvConfig.AddSwitch("Startup", "inifile", "i");
+            argvConfig.AddSwitch("Startup", "prompt",  "p");
+            argvConfig.AddSwitch("Startup", "logconfig", "g");
+
+            // Automagically create the ini file name
+            string fileName = "";
+            if (Assembly.GetEntryAssembly() != null)
+                fileName = Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location);
+            string iniFile = fileName + ".ini";
+            string logConfig = null;
+
+            IConfig startupConfig = argvConfig.Configs["Startup"];
+            if (startupConfig != null)
+            {
+                // Check if a file name was given on the command line
+                iniFile = startupConfig.GetString("inifile", iniFile);
+
+                // Check if a prompt was given on the command line
+                prompt = startupConfig.GetString("prompt", prompt);
+                
+                // Check for a Log4Net config file on the command line
+                logConfig =startupConfig.GetString("logconfig", logConfig);
+            }
+
+            // Find out of the file name is a URI and remote load it if possible.
+            // Load it as a local file otherwise.
+            Uri configUri;
+
+            try
+            {
+                if (Uri.TryCreate(iniFile, UriKind.Absolute, out configUri) &&
+                    configUri.Scheme == Uri.UriSchemeHttp)
+                {
+                    XmlReader r = XmlReader.Create(iniFile);
+                    Config = new XmlConfigSource(r);
+                }
+                else
+                {
+                    Config = new IniConfigSource(iniFile);
+                }
+            }
+            catch (Exception e)
+            {
+                System.Console.WriteLine("Error reading from config source.  {0}", e.Message);
+                Environment.Exit(1);
+            }
+
+            // Merge OpSys env vars
+            m_log.Info("[CONFIG]: Loading environment variables for Config");
+            Util.MergeEnvironmentToConfig(Config);
+            
+            // Merge the configuration from the command line into the loaded file
+            Config.Merge(argvConfig);
+
+            Config.ReplaceKeyValues();
+
+            // Refresh the startupConfig post merge
+            if (Config.Configs["Startup"] != null)
+            {
+                startupConfig = Config.Configs["Startup"];
+            }
+
+            ConfigDirectory = startupConfig.GetString("ConfigDirectory", ".");
+
+            prompt = startupConfig.GetString("Prompt", prompt);
+
+            // Allow derived classes to load config before the console is opened.
+            ReadConfig();
+
+            // Create main console
+            string consoleType = "local";
+            if (startupConfig != null)
+                consoleType = startupConfig.GetString("console", consoleType);
+
+            if (consoleType == "basic")
+            {
+                MainConsole.Instance = new CommandConsole(prompt);
+            }
+            else if (consoleType == "rest")
+            {
+                MainConsole.Instance = new RemoteConsole(prompt);
+                ((RemoteConsole)MainConsole.Instance).ReadConfig(Config);
+            }
+            else if (consoleType == "mock")
+            {
+                MainConsole.Instance = new MockConsole();
+            }
+            else if (consoleType == "local")
+            {
+                MainConsole.Instance = new LocalConsole(prompt, startupConfig);
+            }
+
+            m_console = MainConsole.Instance;
+
+            if (logConfig != null)
+            {
+                FileInfo cfg = new FileInfo(logConfig);
+                XmlConfigurator.Configure(cfg);
+            }
+            else
+            {
+                XmlConfigurator.Configure();
+            }
+
+            LogEnvironmentInformation();
+            RegisterCommonAppenders(startupConfig);
+
+            if (startupConfig.GetString("PIDFile", String.Empty) != String.Empty)
+            {
+                CreatePIDFile(startupConfig.GetString("PIDFile"));
+            }
+
+            RegisterCommonCommands();
+            RegisterCommonComponents(Config);
+
+            // Allow derived classes to perform initialization that
+            // needs to be done after the console has opened
+            Initialise();
+        }
+
+        public bool Running
+        {
+            get { return m_Running; }
+        }
+
+        public virtual int Run()
+        {
+            Watchdog.Enabled = true;
+            MemoryWatchdog.Enabled = true;
+
+            while (m_Running)
+            {
+                try
+                {
+                    MainConsole.Instance.Prompt();
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("Command error: {0}", e);
+                }
+            }
+
+            RemovePIDFile();
+
+            return 0;
+        }
+
+        protected override void ShutdownSpecific()
+        {
+            m_Running = false;
+            m_log.Info("[CONSOLE] Quitting");
+
+            base.ShutdownSpecific();
+        }
+
+        protected virtual void ReadConfig()
+        {
+        }
+
+        protected virtual void Initialise()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/AgentPreferences/AgentPreferencesServerPostHandler.cs b/OpenSim/Server/Handlers/AgentPreferences/AgentPreferencesServerPostHandler.cs
new file mode 100644
index 0000000..713b755
--- /dev/null
+++ b/OpenSim/Server/Handlers/AgentPreferences/AgentPreferencesServerPostHandler.cs
@@ -0,0 +1,206 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.AgentPreferences
+{
+    public class AgentPreferencesServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAgentPreferencesService m_AgentPreferencesService;
+
+        public AgentPreferencesServerPostHandler(IAgentPreferencesService service, IServiceAuth auth) :
+        base("POST", "/agentprefs", auth)
+        {
+            m_AgentPreferencesService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+            IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+
+            try
+            {
+                Dictionary<string, object> request =
+                    ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                string method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "getagentprefs":
+                        return GetAgentPrefs(request);
+                    case "setagentprefs":
+                        return SetAgentPrefs(request);
+                    case "getagentlang":
+                        return GetAgentLang(request);
+                }
+                m_log.DebugFormat("[AGENT PREFERENCES HANDLER]: unknown method request: {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AGENT PREFERENCES HANDLER]: Exception {0}", e);
+            }
+
+            return FailureResult();
+        }
+
+        byte[] GetAgentPrefs(Dictionary<string, object> request)
+        {
+            if (!request.ContainsKey("UserID"))
+                return FailureResult();
+
+            UUID userID;
+            if (!UUID.TryParse(request["UserID"].ToString(), out userID))
+                return FailureResult();
+            AgentPrefs prefs = m_AgentPreferencesService.GetAgentPreferences(userID);
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            result = prefs.ToKeyValuePairs();
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] SetAgentPrefs(Dictionary<string, object> request)
+        {
+            if (!request.ContainsKey("PrincipalID") || !request.ContainsKey("AccessPrefs") || !request.ContainsKey("HoverHeight")
+                || !request.ContainsKey("Language") || !request.ContainsKey("LanguageIsPublic") || !request.ContainsKey("PermEveryone")
+                || !request.ContainsKey("PermGroup") || !request.ContainsKey("PermNextOwner"))
+            {
+                return FailureResult();
+            }
+
+            UUID userID;
+            if (!UUID.TryParse(request["PrincipalID"].ToString(), out userID))
+                return FailureResult();
+
+            AgentPrefs data = new AgentPrefs(userID);
+            data.AccessPrefs = request["AccessPrefs"].ToString();
+            data.HoverHeight = double.Parse(request["HoverHeight"].ToString());
+            data.Language = request["Language"].ToString();
+            data.LanguageIsPublic = bool.Parse(request["LanguageIsPublic"].ToString());
+            data.PermEveryone = int.Parse(request["PermEveryone"].ToString());
+            data.PermGroup = int.Parse(request["PermGroup"].ToString());
+            data.PermNextOwner = int.Parse(request["PermNextOwner"].ToString());
+
+            return m_AgentPreferencesService.StoreAgentPreferences(data) ? SuccessResult() : FailureResult();
+        }
+
+        byte[] GetAgentLang(Dictionary<string, object> request)
+        {
+            if (!request.ContainsKey("UserID"))
+                return FailureResult();
+            UUID userID;
+            if (!UUID.TryParse(request["UserID"].ToString(), out userID))
+                return FailureResult();
+
+            string lang = "en-us";
+            AgentPrefs prefs = m_AgentPreferencesService.GetAgentPreferences(userID);
+            if (prefs != null)
+            {
+                if (prefs.LanguageIsPublic)
+                    lang = prefs.Language;
+            }
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            result["Language"] = lang;
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/AgentPreferences/AgentPreferencesServiceConnector.cs b/OpenSim/Server/Handlers/AgentPreferences/AgentPreferencesServiceConnector.cs
new file mode 100644
index 0000000..a581ea2
--- /dev/null
+++ b/OpenSim/Server/Handlers/AgentPreferences/AgentPreferencesServiceConnector.cs
@@ -0,0 +1,64 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.AgentPreferences
+{
+    public class AgentPreferencesServiceConnector : ServiceConnector
+    {
+        private IAgentPreferencesService m_AgentPreferencesService;
+        private string m_ConfigName = "AgentPreferencesService";
+
+        public AgentPreferencesServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string service = serverConfig.GetString("LocalServiceModule", String.Empty);
+
+            if (String.IsNullOrWhiteSpace(service))
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_AgentPreferencesService = ServerUtils.LoadPlugin<IAgentPreferencesService>(service, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName); ;
+
+            server.AddStreamHandler(new AgentPreferencesServerPostHandler(m_AgentPreferencesService, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Asset/AssetServerConnector.cs b/OpenSim/Server/Handlers/Asset/AssetServerConnector.cs
new file mode 100644
index 0000000..ab81dd6
--- /dev/null
+++ b/OpenSim/Server/Handlers/Asset/AssetServerConnector.cs
@@ -0,0 +1,221 @@
+/*
+ * 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.IO;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Console;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Asset
+{
+    public class AssetServiceConnector : ServiceConnector
+    {
+        private IAssetService m_AssetService;
+        private string m_ConfigName = "AssetService";
+
+        public AssetServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string assetService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (assetService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config, m_ConfigName };
+            m_AssetService =
+                    ServerUtils.LoadPlugin<IAssetService>(assetService, args);
+
+            if (m_AssetService == null)
+                throw new Exception(String.Format("Failed to load AssetService from {0}; config is {1}", assetService, m_ConfigName));
+
+            bool allowDelete = serverConfig.GetBoolean("AllowRemoteDelete", false);
+            bool allowDeleteAllTypes = serverConfig.GetBoolean("AllowRemoteDeleteAllTypes", false);
+
+            string redirectURL = serverConfig.GetString("RedirectURL", string.Empty);
+
+            AllowedRemoteDeleteTypes allowedRemoteDeleteTypes;
+
+            if (!allowDelete)
+            {
+                allowedRemoteDeleteTypes = AllowedRemoteDeleteTypes.None;
+            }
+            else
+            {
+                if (allowDeleteAllTypes)
+                    allowedRemoteDeleteTypes = AllowedRemoteDeleteTypes.All;
+                else
+                    allowedRemoteDeleteTypes = AllowedRemoteDeleteTypes.MapTile;
+            }
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+
+            server.AddStreamHandler(new AssetServerGetHandler(m_AssetService, auth, redirectURL));
+            server.AddStreamHandler(new AssetServerPostHandler(m_AssetService, auth));
+            server.AddStreamHandler(new AssetServerDeleteHandler(m_AssetService, allowedRemoteDeleteTypes, auth));
+            server.AddStreamHandler(new AssetsExistHandler(m_AssetService));
+
+            MainConsole.Instance.Commands.AddCommand("Assets", false,
+                    "show asset",
+                    "show asset <ID>",
+                    "Show asset information",
+                    HandleShowAsset);
+
+            MainConsole.Instance.Commands.AddCommand("Assets", false,
+                    "delete asset",
+                    "delete asset <ID>",
+                    "Delete asset from database",
+                    HandleDeleteAsset);
+
+            MainConsole.Instance.Commands.AddCommand("Assets", false,
+                    "dump asset",
+                    "dump asset <ID>",
+                    "Dump asset to a file",
+                    "The filename is the same as the ID given.",
+                    HandleDumpAsset);
+        }
+
+        void HandleDeleteAsset(string module, string[] args)
+        {
+            if (args.Length < 3)
+            {
+                MainConsole.Instance.Output("Syntax: delete asset <ID>");
+                return;
+            }
+
+            AssetBase asset = m_AssetService.Get(args[2]);
+
+            if (asset == null || asset.Data.Length == 0)
+            {
+                MainConsole.Instance.OutputFormat("Could not find asset with ID {0}", args[2]);
+                return;
+            }
+
+            if (!m_AssetService.Delete(asset.ID))
+                MainConsole.Instance.OutputFormat("ERROR: Could not delete asset {0} {1}", asset.ID, asset.Name);
+            else
+                MainConsole.Instance.OutputFormat("Deleted asset {0} {1}", asset.ID, asset.Name);
+        }
+
+        void HandleDumpAsset(string module, string[] args)
+        {
+            if (args.Length < 3)
+            {
+                MainConsole.Instance.Output("Usage is dump asset <ID>");
+                return;
+            }
+
+            UUID assetId;
+            string rawAssetId = args[2];
+
+            if (!UUID.TryParse(rawAssetId, out assetId))
+            {
+                MainConsole.Instance.OutputFormat("ERROR: {0} is not a valid ID format", rawAssetId);
+                return;
+            }
+            
+            AssetBase asset = m_AssetService.Get(assetId.ToString());
+            if (asset == null)
+            {                
+                MainConsole.Instance.OutputFormat("ERROR: No asset found with ID {0}", assetId);
+                return;                
+            }
+            
+            string fileName = rawAssetId;
+
+            if (!ConsoleUtil.CheckFileDoesNotExist(MainConsole.Instance, fileName))
+                return;
+            
+            using (FileStream fs = new FileStream(fileName, FileMode.CreateNew))
+            {
+                using (BinaryWriter bw = new BinaryWriter(fs))
+                {
+                    bw.Write(asset.Data);
+                }
+            }   
+            
+            MainConsole.Instance.OutputFormat("Asset dumped to file {0}", fileName);
+        }
+
+        void HandleShowAsset(string module, string[] args)
+        {
+            if (args.Length < 3)
+            {
+                MainConsole.Instance.Output("Syntax: show asset <ID>");
+                return;
+            }
+
+            AssetBase asset = m_AssetService.Get(args[2]);
+
+            if (asset == null || asset.Data.Length == 0)
+            {
+                MainConsole.Instance.Output("Asset not found");
+                return;
+            }
+
+            int i;
+
+            MainConsole.Instance.OutputFormat("Name: {0}", asset.Name);
+            MainConsole.Instance.OutputFormat("Description: {0}", asset.Description);
+            MainConsole.Instance.OutputFormat("Type: {0} (type number = {1})", (AssetType)asset.Type, asset.Type);
+            MainConsole.Instance.OutputFormat("Content-type: {0}", asset.Metadata.ContentType);
+            MainConsole.Instance.OutputFormat("Size: {0} bytes", asset.Data.Length);
+            MainConsole.Instance.OutputFormat("Temporary: {0}", asset.Temporary ? "yes" : "no");
+            MainConsole.Instance.OutputFormat("Flags: {0}", asset.Metadata.Flags);
+
+            for (i = 0 ; i < 5 ; i++)
+            {
+                int off = i * 16;
+                if (asset.Data.Length <= off)
+                    break;
+                int len = 16;
+                if (asset.Data.Length < off + len)
+                    len = asset.Data.Length - off;
+
+                byte[] line = new byte[len];
+                Array.Copy(asset.Data, off, line, 0, len);
+
+                string text = BitConverter.ToString(line);
+                MainConsole.Instance.Output(String.Format("{0:x4}: {1}", off, text));
+            }
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Asset/AssetServerDeleteHandler.cs b/OpenSim/Server/Handlers/Asset/AssetServerDeleteHandler.cs
new file mode 100644
index 0000000..d85d471
--- /dev/null
+++ b/OpenSim/Server/Handlers/Asset/AssetServerDeleteHandler.cs
@@ -0,0 +1,115 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Server.Handlers.Asset
+{
+    /// <summary>
+    /// Remote deletes allowed.
+    /// </summary>
+    public enum AllowedRemoteDeleteTypes
+    {
+        None,
+        MapTile,
+        All
+    }
+
+    public class AssetServerDeleteHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAssetService m_AssetService;
+
+        /// <summary>
+        /// Asset types that can be deleted remotely.
+        /// </summary>
+        private AllowedRemoteDeleteTypes m_allowedTypes;
+
+        public AssetServerDeleteHandler(IAssetService service, AllowedRemoteDeleteTypes allowedTypes) :
+                base("DELETE", "/assets")
+        {
+            m_AssetService = service;
+            m_allowedTypes = allowedTypes;
+        }
+
+        public AssetServerDeleteHandler(IAssetService service, AllowedRemoteDeleteTypes allowedTypes, IServiceAuth auth) :
+            base("DELETE", "/assets", auth)
+        {
+            m_AssetService = service;
+            m_allowedTypes = allowedTypes;
+        }
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            bool result = false;
+
+            string[] p = SplitParams(path);
+
+            if (p.Length > 0)
+            {
+                if (m_allowedTypes != AllowedRemoteDeleteTypes.None)
+                {
+                    string assetID = p[0];
+
+                    AssetBase asset = m_AssetService.Get(assetID);
+                    if (asset != null)
+                    {
+                        if (m_allowedTypes == AllowedRemoteDeleteTypes.All
+                            || (int)(asset.Flags & AssetFlags.Maptile) != 0)
+                        {
+                            result = m_AssetService.Delete(assetID);
+                        }
+                        else
+                        {
+                            m_log.DebugFormat(
+                                "[ASSET SERVER DELETE HANDLER]: Request to delete asset {0}, but type is {1} and allowed remote delete types are {2}",
+                                assetID, (AssetFlags)asset.Flags, m_allowedTypes);
+                        }
+                    }
+                }
+            }
+
+            XmlSerializer xs = new XmlSerializer(typeof(bool));
+            return ServerUtils.SerializeResult(xs, result);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/Asset/AssetServerGetHandler.cs b/OpenSim/Server/Handlers/Asset/AssetServerGetHandler.cs
new file mode 100644
index 0000000..91c5c54
--- /dev/null
+++ b/OpenSim/Server/Handlers/Asset/AssetServerGetHandler.cs
@@ -0,0 +1,172 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Server.Handlers.Asset
+{
+    public class AssetServerGetHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAssetService m_AssetService;
+        private string m_RedirectURL;
+
+        public AssetServerGetHandler(IAssetService service) :
+                base("GET", "/assets")
+        {
+            m_AssetService = service; 
+        }
+
+        public AssetServerGetHandler(IAssetService service, IServiceAuth auth, string redirectURL) :
+            base("GET", "/assets", auth)
+        {
+            m_AssetService = service;
+            m_RedirectURL = redirectURL;
+            if (!m_RedirectURL.EndsWith("/"))
+                m_RedirectURL = m_RedirectURL.TrimEnd('/');
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            byte[] result = new byte[0];
+
+            string[] p = SplitParams(path);
+
+            if (p.Length == 0)
+                return result;
+
+            string id = string.Empty;
+            if (p.Length > 1)
+            {
+                id = p[0];
+                string cmd = p[1];
+
+                if (cmd == "data")
+                {
+                    result = m_AssetService.GetData(id);
+                    if (result == null)
+                    {
+                        httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+                        httpResponse.ContentType = "text/plain";
+                        result = new byte[0];
+                    }
+                    else
+                    {
+                        httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                        httpResponse.ContentType = "application/octet-stream";
+                    }
+                }
+                else if (cmd == "metadata")
+                {
+                    AssetMetadata metadata = m_AssetService.GetMetadata(id);
+
+                    if (metadata != null)
+                    {
+                        XmlSerializer xs =
+                                new XmlSerializer(typeof(AssetMetadata));
+                        result = ServerUtils.SerializeResult(xs, metadata);
+
+                        httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                        httpResponse.ContentType =
+                                SLUtil.SLAssetTypeToContentType(metadata.Type);
+                    }
+                    else
+                    {
+                        httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+                        httpResponse.ContentType = "text/plain";
+                        result = new byte[0];
+                    }
+                }
+                else
+                {
+                    // Unknown request
+                    httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
+                    httpResponse.ContentType = "text/plain";
+                    result = new byte[0];
+                }
+            }
+            else if (p.Length == 1)
+            {
+                // Get the entire asset (metadata + data)
+
+                id = p[0];
+                AssetBase asset = m_AssetService.Get(id);
+
+                if (asset != null)
+                {
+                    XmlSerializer xs = new XmlSerializer(typeof(AssetBase));
+                    result = ServerUtils.SerializeResult(xs, asset);
+
+                    httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                    httpResponse.ContentType =
+                            SLUtil.SLAssetTypeToContentType(asset.Type);
+                }
+                else
+                {
+                    httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+                    httpResponse.ContentType = "text/plain";
+                    result = new byte[0];
+                }
+            }
+            else
+            {
+                // Unknown request
+                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
+                httpResponse.ContentType = "text/plain";
+                result = new byte[0];
+            }
+            
+            if (httpResponse.StatusCode == (int)HttpStatusCode.NotFound && !string.IsNullOrEmpty(m_RedirectURL) && !string.IsNullOrEmpty(id))
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.Redirect;
+                string rurl = m_RedirectURL;
+                if (!path.StartsWith("/"))
+                    rurl += "/";
+                rurl += path;
+                httpResponse.AddHeader("Location", rurl);
+                m_log.DebugFormat("[ASSET GET HANDLER]: Asset not found, redirecting to {0} ({1})", rurl, httpResponse.StatusCode);
+            }
+            return result;
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Asset/AssetServerPostHandler.cs b/OpenSim/Server/Handlers/Asset/AssetServerPostHandler.cs
new file mode 100644
index 0000000..1c706a7
--- /dev/null
+++ b/OpenSim/Server/Handlers/Asset/AssetServerPostHandler.cs
@@ -0,0 +1,98 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Server.Handlers.Asset
+{
+    public class AssetServerPostHandler : BaseStreamHandler
+    {
+        // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAssetService m_AssetService;
+
+        public AssetServerPostHandler(IAssetService service) :
+                base("POST", "/assets")
+        {
+            m_AssetService = service;
+        }
+
+        public AssetServerPostHandler(IAssetService service, IServiceAuth auth) :
+            base("POST", "/assets", auth)
+        {
+            m_AssetService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            AssetBase asset;
+            XmlSerializer xs = new XmlSerializer(typeof(AssetBase));
+
+            try
+            {
+                asset = (AssetBase)xs.Deserialize(request);
+            }
+            catch (Exception)
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
+                return null;
+            }
+
+            string[] p = SplitParams(path);
+            if (p.Length > 0)
+            {
+                string id = p[0];
+                bool result = m_AssetService.UpdateContent(id, asset.Data);
+
+                xs = new XmlSerializer(typeof(bool));
+                return ServerUtils.SerializeResult(xs, result);
+            }
+            else
+            {
+                string id = m_AssetService.Store(asset);
+
+                xs = new XmlSerializer(typeof(string));
+                return ServerUtils.SerializeResult(xs, id);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Asset/AssetsExistHandler.cs b/OpenSim/Server/Handlers/Asset/AssetsExistHandler.cs
new file mode 100644
index 0000000..32901b3
--- /dev/null
+++ b/OpenSim/Server/Handlers/Asset/AssetsExistHandler.cs
@@ -0,0 +1,87 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Asset
+{
+    public class AssetsExistHandler : BaseStreamHandler
+    {
+        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAssetService m_AssetService;
+
+        public AssetsExistHandler(IAssetService service) :
+            base("POST", "/get_assets_exist")
+        {
+            m_AssetService = service;
+        }
+
+        public AssetsExistHandler(IAssetService service, IServiceAuth auth) :
+            base("POST", "/get_assets_exist", auth)
+        {
+            m_AssetService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            XmlSerializer xs;
+
+            string[] ids;
+            try
+            {
+                xs = new XmlSerializer(typeof(string[]));
+                ids = (string[])xs.Deserialize(request);
+            }
+            catch (Exception)
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
+                return null;
+            }
+
+            bool[] exist = m_AssetService.AssetsExist(ids);
+
+            xs = new XmlSerializer(typeof(bool[]));
+            return ServerUtils.SerializeResult(xs, exist);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Asset/Tests/AssetServerPostHandlerTests.cs b/OpenSim/Server/Handlers/Asset/Tests/AssetServerPostHandlerTests.cs
new file mode 100644
index 0000000..faa6fb7
--- /dev/null
+++ b/OpenSim/Server/Handlers/Asset/Tests/AssetServerPostHandlerTests.cs
@@ -0,0 +1,109 @@
+/*
+ * 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.IO;
+using System.Net;
+using System.Text;
+using System.Xml;
+using System.Xml.Serialization;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Server.Handlers.Asset;
+using OpenSim.Services.AssetService;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Server.Handlers.Asset.Test
+{
+    [TestFixture]
+    public class AssetServerPostHandlerTests : OpenSimTestCase
+    {
+        [Test]
+        public void TestGoodAssetStoreRequest()
+        {
+            TestHelpers.InMethod();
+
+            UUID assetId = TestHelpers.ParseTail(0x1);
+
+            IConfigSource config = new IniConfigSource();         
+            config.AddConfig("AssetService");           
+            config.Configs["AssetService"].Set("StorageProvider", "OpenSim.Tests.Common.dll");
+
+            AssetService assetService = new AssetService(config);
+
+            AssetServerPostHandler asph = new AssetServerPostHandler(assetService);
+
+            AssetBase asset = AssetHelpers.CreateNotecardAsset(assetId, "Hello World");
+
+            MemoryStream buffer = new MemoryStream();
+
+            XmlWriterSettings settings = new XmlWriterSettings();
+            settings.Encoding = Encoding.UTF8;
+
+            using (XmlWriter writer = XmlWriter.Create(buffer, settings))
+            {
+                XmlSerializer serializer = new XmlSerializer(typeof(AssetBase));
+                serializer.Serialize(writer, asset);
+                writer.Flush();
+            }            
+
+            buffer.Position = 0;
+            asph.Handle(null, buffer, null, null);
+
+            AssetBase retrievedAsset = assetService.Get(assetId.ToString());
+
+            Assert.That(retrievedAsset, Is.Not.Null);
+        }
+
+        [Test]
+        public void TestBadXmlAssetStoreRequest()
+        {
+            TestHelpers.InMethod();
+
+            IConfigSource config = new IniConfigSource();         
+            config.AddConfig("AssetService");           
+            config.Configs["AssetService"].Set("StorageProvider", "OpenSim.Tests.Common.dll");
+
+            AssetService assetService = new AssetService(config);
+
+            AssetServerPostHandler asph = new AssetServerPostHandler(assetService);          
+
+            MemoryStream buffer = new MemoryStream();
+            byte[] badData = new byte[] { 0x48, 0x65, 0x6c, 0x6c, 0x6f };
+            buffer.Write(badData, 0, badData.Length);
+            buffer.Position = 0;
+
+            TestOSHttpResponse response = new TestOSHttpResponse();
+            asph.Handle(null, buffer, null, response);
+
+            Assert.That(response.StatusCode, Is.EqualTo((int)HttpStatusCode.BadRequest));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/Authentication/AuthenticationServerConnector.cs b/OpenSim/Server/Handlers/Authentication/AuthenticationServerConnector.cs
new file mode 100644
index 0000000..c9a8dce
--- /dev/null
+++ b/OpenSim/Server/Handlers/Authentication/AuthenticationServerConnector.cs
@@ -0,0 +1,67 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Authentication
+{
+    public class AuthenticationServiceConnector : ServiceConnector
+    {
+        private IAuthenticationService m_AuthenticationService;
+        private string m_ConfigName = "AuthenticationService";
+
+        public AuthenticationServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string authenticationService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (authenticationService == String.Empty)
+                throw new Exception("No AuthenticationService in config file");
+
+            Object[] args = new Object[] { config };
+            m_AuthenticationService = ServerUtils.LoadPlugin<IAuthenticationService>(authenticationService, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+
+            server.AddStreamHandler(new AuthenticationServerPostHandler(m_AuthenticationService, serverConfig, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Authentication/AuthenticationServerPostHandler.cs b/OpenSim/Server/Handlers/Authentication/AuthenticationServerPostHandler.cs
new file mode 100644
index 0000000..6ee98b3
--- /dev/null
+++ b/OpenSim/Server/Handlers/Authentication/AuthenticationServerPostHandler.cs
@@ -0,0 +1,318 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Authentication
+{
+    public class AuthenticationServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAuthenticationService m_AuthenticationService;
+
+        private bool m_AllowGetAuthInfo = false;
+        private bool m_AllowSetAuthInfo = false;
+        private bool m_AllowSetPassword = false;
+
+        public AuthenticationServerPostHandler(IAuthenticationService service) :
+                this(service, null, null) {}
+
+        public AuthenticationServerPostHandler(IAuthenticationService service, IConfig config, IServiceAuth auth) :
+                base("POST", "/auth", auth)
+        {
+            m_AuthenticationService = service;
+
+            if (config != null)
+            {
+                m_AllowGetAuthInfo = config.GetBoolean("AllowGetAuthInfo", m_AllowGetAuthInfo);
+                m_AllowSetAuthInfo = config.GetBoolean("AllowSetAuthInfo", m_AllowSetAuthInfo);
+                m_AllowSetPassword = config.GetBoolean("AllowSetPassword", m_AllowSetPassword);
+            }
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+//            m_log.Error("[XXX]: Authenticating...");
+            string[] p = SplitParams(path);
+
+            if (p.Length > 0)
+            {
+                switch (p[0])
+                {
+                case "plain":
+                    StreamReader sr = new StreamReader(request);
+                    string body = sr.ReadToEnd();
+                    sr.Close();
+
+                    return DoPlainMethods(body);
+                case "crypt":
+                    byte[] buffer = new byte[request.Length];
+                    long length = request.Length;
+                    if (length > 16384)
+                        length = 16384;
+                    request.Read(buffer, 0, (int)length);
+
+                    return DoEncryptedMethods(buffer);
+                }
+            }
+            return new byte[0];
+        }
+
+        private byte[] DoPlainMethods(string body)
+        {
+            Dictionary<string, object> request =
+                    ServerUtils.ParseQueryString(body);
+
+            int lifetime = 30;
+
+            if (request.ContainsKey("LIFETIME"))
+            {
+                lifetime = Convert.ToInt32(request["LIFETIME"].ToString());
+                if (lifetime > 30)
+                    lifetime = 30;
+            }
+
+            if (!request.ContainsKey("METHOD"))
+                return FailureResult();
+            if (!request.ContainsKey("PRINCIPAL"))
+                return FailureResult();
+
+            string method = request["METHOD"].ToString();
+
+            UUID principalID;
+            string token;
+
+            if (!UUID.TryParse(request["PRINCIPAL"].ToString(), out principalID))
+                return FailureResult();
+
+            switch (method)
+            {
+                case "authenticate":
+                    if (!request.ContainsKey("PASSWORD"))
+                        return FailureResult();
+                    
+                    token = m_AuthenticationService.Authenticate(principalID, request["PASSWORD"].ToString(), lifetime);
+    
+                    if (token != String.Empty)
+                        return SuccessResult(token);
+                    return FailureResult();
+    
+                case "setpassword":
+                    if (!m_AllowSetPassword)
+                        return FailureResult();
+
+                    if (!request.ContainsKey("PASSWORD"))
+                        return FailureResult();
+    
+                    if (m_AuthenticationService.SetPassword(principalID, request["PASSWORD"].ToString()))
+                        return SuccessResult();
+                    else
+                        return FailureResult();
+    
+                case "verify":
+                    if (!request.ContainsKey("TOKEN"))
+                        return FailureResult();
+                    
+                    if (m_AuthenticationService.Verify(principalID, request["TOKEN"].ToString(), lifetime))
+                        return SuccessResult();
+    
+                    return FailureResult();
+    
+                case "release":
+                    if (!request.ContainsKey("TOKEN"))
+                        return FailureResult();
+    
+                    if (m_AuthenticationService.Release(principalID, request["TOKEN"].ToString()))
+                        return SuccessResult();
+    
+                    return FailureResult();
+
+                case "getauthinfo":
+                    if (m_AllowGetAuthInfo)
+                        return GetAuthInfo(principalID);
+
+                    break;
+
+                case "setauthinfo":
+                    if (m_AllowSetAuthInfo)
+                        return SetAuthInfo(principalID, request);
+
+                    break;
+            }
+
+            return FailureResult();
+        }
+
+        private byte[] DoEncryptedMethods(byte[] ciphertext)
+        {
+            return new byte[0];
+        }
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        byte[] GetAuthInfo(UUID principalID)
+        {
+            AuthInfo info = m_AuthenticationService.GetAuthInfo(principalID);
+
+            if (info != null)
+            {
+                Dictionary<string, object> result = new Dictionary<string, object>();
+                result["result"] = info.ToKeyValuePairs();
+
+                return ResultToBytes(result);
+            }
+            else
+            {
+                return FailureResult();
+            }
+        }
+
+        byte[] SetAuthInfo(UUID principalID, Dictionary<string, object> request)
+        {
+            AuthInfo existingInfo = m_AuthenticationService.GetAuthInfo(principalID);
+
+            if (existingInfo == null)
+                return FailureResult();
+
+            if (request.ContainsKey("AccountType"))
+                existingInfo.AccountType = request["AccountType"].ToString();
+
+            if (request.ContainsKey("PasswordHash"))
+                existingInfo.PasswordHash = request["PasswordHash"].ToString();
+
+            if (request.ContainsKey("PasswordSalt"))
+                existingInfo.PasswordSalt = request["PasswordSalt"].ToString();
+
+            if (request.ContainsKey("WebLoginKey"))
+                existingInfo.WebLoginKey = request["WebLoginKey"].ToString();
+
+            if (!m_AuthenticationService.SetAuthInfo(existingInfo))
+            {
+                m_log.ErrorFormat(
+                    "[AUTHENTICATION SERVER POST HANDLER]: Authentication info store failed for account {0} {1} {2}",
+                    existingInfo.PrincipalID);
+
+                return FailureResult();
+            }
+
+            return SuccessResult();
+        }
+
+        private byte[] FailureResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] SuccessResult(string token)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            XmlElement t = doc.CreateElement("", "Token", "");
+            t.AppendChild(doc.CreateTextNode(token));
+
+            rootElement.AppendChild(t);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] ResultToBytes(Dictionary<string, object> result)
+        {
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Authentication/OpenIdServerConnector.cs b/OpenSim/Server/Handlers/Authentication/OpenIdServerConnector.cs
new file mode 100644
index 0000000..6464399
--- /dev/null
+++ b/OpenSim/Server/Handlers/Authentication/OpenIdServerConnector.cs
@@ -0,0 +1,77 @@
+/*
+ * 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.Reflection;
+using Nini.Config;
+using log4net;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Authentication
+{
+    public class OpenIdServerConnector : ServiceConnector
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+ 
+        private IAuthenticationService m_AuthenticationService;
+        private IUserAccountService m_UserAccountService;
+        private string m_ConfigName = "OpenIdService";
+
+        public OpenIdServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string authService = serverConfig.GetString("AuthenticationServiceModule",
+                    String.Empty);
+            string userService = serverConfig.GetString("UserAccountServiceModule",
+                    String.Empty);
+
+            if (authService == String.Empty || userService == String.Empty)
+                throw new Exception("No AuthenticationServiceModule or no UserAccountServiceModule in config file for OpenId authentication");
+
+            Object[] args = new Object[] { config };
+            m_AuthenticationService = ServerUtils.LoadPlugin<IAuthenticationService>(authService, args);
+            m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(userService, args);
+
+            // Handler for OpenID user identity pages
+            server.AddStreamHandler(new OpenIdStreamHandler("GET", "/users/", m_UserAccountService, m_AuthenticationService));
+            // Handlers for the OpenID endpoint server
+            server.AddStreamHandler(new OpenIdStreamHandler("POST", "/openid/server/", m_UserAccountService, m_AuthenticationService));
+            server.AddStreamHandler(new OpenIdStreamHandler("GET", "/openid/server/", m_UserAccountService, m_AuthenticationService));
+
+            m_log.Info("[OPENID]: OpenId service enabled");
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Authentication/OpenIdServerHandler.cs b/OpenSim/Server/Handlers/Authentication/OpenIdServerHandler.cs
new file mode 100644
index 0000000..b201dc7
--- /dev/null
+++ b/OpenSim/Server/Handlers/Authentication/OpenIdServerHandler.cs
@@ -0,0 +1,339 @@
+/*
+ * 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.Collections.Specialized;
+using System.IO;
+using System.Net;
+using System.Web;
+using DotNetOpenId;
+using DotNetOpenId.Provider;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using Nini.Config;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Authentication
+{
+    /// <summary>
+    /// Temporary, in-memory store for OpenID associations
+    /// </summary>
+    public class ProviderMemoryStore : IAssociationStore<AssociationRelyingPartyType>
+    {
+        private class AssociationItem
+        {
+            public AssociationRelyingPartyType DistinguishingFactor;
+            public string Handle;
+            public DateTime Expires;
+            public byte[] PrivateData;
+        }
+
+        Dictionary<string, AssociationItem> m_store = new Dictionary<string, AssociationItem>();
+        SortedList<DateTime, AssociationItem> m_sortedStore = new SortedList<DateTime, AssociationItem>();
+        object m_syncRoot = new object();
+
+        #region IAssociationStore<AssociationRelyingPartyType> Members
+
+        public void StoreAssociation(AssociationRelyingPartyType distinguishingFactor, Association assoc)
+        {
+            AssociationItem item = new AssociationItem();
+            item.DistinguishingFactor = distinguishingFactor;
+            item.Handle = assoc.Handle;
+            item.Expires = assoc.Expires.ToLocalTime();
+            item.PrivateData = assoc.SerializePrivateData();
+
+            lock (m_syncRoot)
+            {
+                m_store[item.Handle] = item;
+                m_sortedStore[item.Expires] = item;
+            }
+        }
+
+        public Association GetAssociation(AssociationRelyingPartyType distinguishingFactor)
+        {
+            lock (m_syncRoot)
+            {
+                if (m_sortedStore.Count > 0)
+                {
+                    AssociationItem item = m_sortedStore.Values[m_sortedStore.Count - 1];
+                    return Association.Deserialize(item.Handle, item.Expires.ToUniversalTime(), item.PrivateData);
+                }
+                else
+                {
+                    return null;
+                }
+            }
+        }
+
+        public Association GetAssociation(AssociationRelyingPartyType distinguishingFactor, string handle)
+        {
+            AssociationItem item;
+            bool success = false;
+            lock (m_syncRoot)
+                success = m_store.TryGetValue(handle, out item);
+
+            if (success)
+                return Association.Deserialize(item.Handle, item.Expires.ToUniversalTime(), item.PrivateData);
+            else
+                return null;
+        }
+
+        public bool RemoveAssociation(AssociationRelyingPartyType distinguishingFactor, string handle)
+        {
+            lock (m_syncRoot)
+            {
+                for (int i = 0; i < m_sortedStore.Values.Count; i++)
+                {
+                    AssociationItem item = m_sortedStore.Values[i];
+                    if (item.Handle == handle)
+                    {
+                        m_sortedStore.RemoveAt(i);
+                        break;
+                    }
+                }
+
+                return m_store.Remove(handle);
+            }
+        }
+
+        public void ClearExpiredAssociations()
+        {
+            lock (m_syncRoot)
+            {
+                List<AssociationItem> itemsCopy = new List<AssociationItem>(m_sortedStore.Values);
+                DateTime now = DateTime.Now;
+
+                for (int i = 0; i < itemsCopy.Count; i++)
+                {
+                    AssociationItem item = itemsCopy[i];
+
+                    if (item.Expires <= now)
+                    {
+                        m_sortedStore.RemoveAt(i);
+                        m_store.Remove(item.Handle);
+                    }
+                }
+            }
+        }
+
+        #endregion
+    }
+
+    public class OpenIdStreamHandler : BaseOutputStreamHandler, IStreamHandler
+    {
+        #region HTML
+
+        /// <summary>Login form used to authenticate OpenID requests</summary>
+        const string LOGIN_PAGE =
+@"<html>
+<head><title>OpenSim OpenID Login</title></head>
+<body>
+<h3>OpenSim Login</h3>
+<form method=""post"">
+<label for=""first"">First Name:</label> <input readonly type=""text"" name=""first"" id=""first"" value=""{0}""/>
+<label for=""last"">Last Name:</label> <input readonly type=""text"" name=""last"" id=""last"" value=""{1}""/>
+<label for=""pass"">Password:</label> <input type=""password"" name=""pass"" id=""pass""/>
+<input type=""submit"" value=""Login"">
+</form>
+</body>
+</html>";
+
+        /// <summary>Page shown for a valid OpenID identity</summary>
+        const string OPENID_PAGE =
+@"<html>
+<head>
+<title>{2} {3}</title>
+<link rel=""openid2.provider openid.server"" href=""{0}://{1}/openid/server/""/>
+</head>
+<body>OpenID identifier for {2} {3}</body>
+</html>
+";
+
+        /// <summary>Page shown for an invalid OpenID identity</summary>
+        const string INVALID_OPENID_PAGE = 
+@"<html><head><title>Identity not found</title></head>
+<body>Invalid OpenID identity</body></html>";
+
+        /// <summary>Page shown if the OpenID endpoint is requested directly</summary>
+        const string ENDPOINT_PAGE =
+@"<html><head><title>OpenID Endpoint</title></head><body>
+This is an OpenID server endpoint, not a human-readable resource. 
+For more information, see <a href='http://openid.net/'>http://openid.net/</a>.
+</body></html>";
+
+        #endregion HTML
+
+        IAuthenticationService m_authenticationService;
+        IUserAccountService m_userAccountService;
+        ProviderMemoryStore m_openidStore = new ProviderMemoryStore();
+
+        public override string ContentType { get { return "text/html"; } }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public OpenIdStreamHandler(
+            string httpMethod, string path, IUserAccountService userService, IAuthenticationService authService)
+            : base(httpMethod, path, "OpenId", "OpenID stream handler")
+        {
+            m_authenticationService = authService;
+            m_userAccountService = userService;
+        }
+
+        /// <summary>
+        /// Handles all GET and POST requests for OpenID identifier pages and endpoint
+        /// server communication
+        /// </summary>
+        protected override void ProcessRequest(
+            string path, Stream request, Stream response, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            Uri providerEndpoint = new Uri(String.Format("{0}://{1}{2}", httpRequest.Url.Scheme, httpRequest.Url.Authority, httpRequest.Url.AbsolutePath));
+
+            // Defult to returning HTML content
+            httpResponse.ContentType = ContentType;
+
+            try
+            {
+                NameValueCollection postQuery = HttpUtility.ParseQueryString(new StreamReader(httpRequest.InputStream).ReadToEnd());
+                NameValueCollection getQuery = HttpUtility.ParseQueryString(httpRequest.Url.Query);
+                NameValueCollection openIdQuery = (postQuery.GetValues("openid.mode") != null ? postQuery : getQuery);
+
+                OpenIdProvider provider = new OpenIdProvider(m_openidStore, providerEndpoint, httpRequest.Url, openIdQuery);
+
+                if (provider.Request != null)
+                {
+                    if (!provider.Request.IsResponseReady && provider.Request is IAuthenticationRequest)
+                    {
+                        IAuthenticationRequest authRequest = (IAuthenticationRequest)provider.Request;
+                        string[] passwordValues = postQuery.GetValues("pass");
+
+                        UserAccount account;
+                        if (TryGetAccount(new Uri(authRequest.ClaimedIdentifier.ToString()), out account))
+                        {
+                            // Check for form POST data
+                            if (passwordValues != null && passwordValues.Length == 1)
+                            {
+                                if (account != null && 
+                                    (m_authenticationService.Authenticate(account.PrincipalID,Util.Md5Hash(passwordValues[0]), 30) != string.Empty))
+                                    authRequest.IsAuthenticated = true;
+                                else
+                                    authRequest.IsAuthenticated = false;
+                            }
+                            else
+                            {
+                                // Authentication was requested, send the client a login form
+                                using (StreamWriter writer = new StreamWriter(response))
+                                    writer.Write(String.Format(LOGIN_PAGE, account.FirstName, account.LastName));
+                                return;
+                            }
+                        }
+                        else
+                        {
+                            // Cannot find an avatar matching the claimed identifier
+                            authRequest.IsAuthenticated = false;
+                        }
+                    }
+
+                    // Add OpenID headers to the response
+                    foreach (string key in provider.Request.Response.Headers.Keys)
+                        httpResponse.AddHeader(key, provider.Request.Response.Headers[key]);
+
+                    string[] contentTypeValues = provider.Request.Response.Headers.GetValues("Content-Type");
+                    if (contentTypeValues != null && contentTypeValues.Length == 1)
+                        httpResponse.ContentType = contentTypeValues[0];
+
+                    // Set the response code and document body based on the OpenID result
+                    httpResponse.StatusCode = (int)provider.Request.Response.Code;
+                    response.Write(provider.Request.Response.Body, 0, provider.Request.Response.Body.Length);
+                    response.Close();
+                }
+                else if (httpRequest.Url.AbsolutePath.Contains("/openid/server"))
+                {
+                    // Standard HTTP GET was made on the OpenID endpoint, send the client the default error page
+                    using (StreamWriter writer = new StreamWriter(response))
+                        writer.Write(ENDPOINT_PAGE);
+                }
+                else
+                {
+                    // Try and lookup this avatar
+                    UserAccount account;
+                    if (TryGetAccount(httpRequest.Url, out account))
+                    {
+                        using (StreamWriter writer = new StreamWriter(response))
+                        {
+                            // TODO: Print out a full profile page for this avatar
+                            writer.Write(String.Format(OPENID_PAGE, httpRequest.Url.Scheme,
+                                httpRequest.Url.Authority, account.FirstName, account.LastName));
+                        }
+                    }
+                    else
+                    {
+                        // Couldn't parse an avatar name, or couldn't find the avatar in the user server
+                        using (StreamWriter writer = new StreamWriter(response))
+                            writer.Write(INVALID_OPENID_PAGE);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.InternalServerError;
+                using (StreamWriter writer = new StreamWriter(response))
+                    writer.Write(ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Parse a URL with a relative path of the form /users/First_Last and try to
+        /// retrieve the profile matching that avatar name
+        /// </summary>
+        /// <param name="requestUrl">URL to parse for an avatar name</param>
+        /// <param name="profile">Profile data for the avatar</param>
+        /// <returns>True if the parse and lookup were successful, otherwise false</returns>
+        bool TryGetAccount(Uri requestUrl, out UserAccount account)
+        {
+            if (requestUrl.Segments.Length == 3 && requestUrl.Segments[1] == "users/")
+            {
+                // Parse the avatar name from the path
+                string username = requestUrl.Segments[requestUrl.Segments.Length - 1];
+                string[] name = username.Split('_');
+
+                if (name.Length == 2)
+                {
+                    account = m_userAccountService.GetUserAccount(UUID.Zero, name[0], name[1]);
+                    return (account != null);
+                }
+            }
+
+            account = null;
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/Authorization/AuthorizationServerConnector.cs b/OpenSim/Server/Handlers/Authorization/AuthorizationServerConnector.cs
new file mode 100644
index 0000000..20fd0f7
--- /dev/null
+++ b/OpenSim/Server/Handlers/Authorization/AuthorizationServerConnector.cs
@@ -0,0 +1,64 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Authorization
+{
+    public class AuthorizationServerConnector : ServiceConnector
+    {
+        private IAuthorizationService m_AuthorizationService;
+        private string m_ConfigName = "AuthorizationService";
+
+        public AuthorizationServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string authorizationService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (authorizationService == String.Empty)
+                throw new Exception("No AuthorizationService in config file");
+
+            Object[] args = new Object[] { config };
+            m_AuthorizationService =
+                    ServerUtils.LoadPlugin<IAuthorizationService>(authorizationService, args);
+
+            server.AddStreamHandler(new AuthorizationServerPostHandler(m_AuthorizationService));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Authorization/AuthorizationServerPostHandler.cs b/OpenSim/Server/Handlers/Authorization/AuthorizationServerPostHandler.cs
new file mode 100644
index 0000000..c9b4e9b
--- /dev/null
+++ b/OpenSim/Server/Handlers/Authorization/AuthorizationServerPostHandler.cs
@@ -0,0 +1,73 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Server.Handlers.Authorization
+{
+    public class AuthorizationServerPostHandler : BaseStreamHandler
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAuthorizationService m_AuthorizationService;
+
+        public AuthorizationServerPostHandler(IAuthorizationService service) :
+                base("POST", "/authorization")
+        {
+            m_AuthorizationService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            XmlSerializer xs = new XmlSerializer(typeof (AuthorizationRequest));
+            AuthorizationRequest Authorization = (AuthorizationRequest) xs.Deserialize(request);
+
+            string message = String.Empty;
+            bool authorized = m_AuthorizationService.IsAuthorizedForRegion(Authorization.ID, Authorization.FirstName, Authorization.SurName, Authorization.RegionID, out message);
+
+            AuthorizationResponse result = new AuthorizationResponse(authorized, Authorization.ID + " has been authorized");
+
+            xs = new XmlSerializer(typeof(AuthorizationResponse));
+            return ServerUtils.SerializeResult(xs, result);
+            
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Avatar/AvatarServerConnector.cs b/OpenSim/Server/Handlers/Avatar/AvatarServerConnector.cs
new file mode 100644
index 0000000..1831e84
--- /dev/null
+++ b/OpenSim/Server/Handlers/Avatar/AvatarServerConnector.cs
@@ -0,0 +1,64 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Avatar
+{
+    public class AvatarServiceConnector : ServiceConnector
+    {
+        private IAvatarService m_AvatarService;
+        private string m_ConfigName = "AvatarService";
+
+        public AvatarServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string avatarService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (avatarService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_AvatarService = ServerUtils.LoadPlugin<IAvatarService>(avatarService, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+
+            server.AddStreamHandler(new AvatarServerPostHandler(m_AvatarService, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Avatar/AvatarServerPostHandler.cs b/OpenSim/Server/Handlers/Avatar/AvatarServerPostHandler.cs
new file mode 100644
index 0000000..ff8699f
--- /dev/null
+++ b/OpenSim/Server/Handlers/Avatar/AvatarServerPostHandler.cs
@@ -0,0 +1,276 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Avatar
+{
+    public class AvatarServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IAvatarService m_AvatarService;
+
+        public AvatarServerPostHandler(IAvatarService service, IServiceAuth auth) :
+                base("POST", "/avatar", auth)
+        {
+            m_AvatarService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                string method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "getavatar":
+                        return GetAvatar(request);
+                    case "setavatar":
+                        return SetAvatar(request);
+                    case "resetavatar":
+                        return ResetAvatar(request);
+                    case "setitems":
+                        return SetItems(request);
+                    case "removeitems":
+                        return RemoveItems(request);
+                }
+                m_log.DebugFormat("[AVATAR HANDLER]: unknown method request: {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.Debug("[AVATAR HANDLER]: Exception {0}" + e);
+            }
+
+            return FailureResult();
+
+        }
+
+        byte[] GetAvatar(Dictionary<string, object> request)
+        {
+            UUID user = UUID.Zero;
+
+            if (!request.ContainsKey("UserID"))
+                return FailureResult();
+
+            if (UUID.TryParse(request["UserID"].ToString(), out user))
+            {
+                AvatarData avatar = m_AvatarService.GetAvatar(user);
+                if (avatar == null)
+                    return FailureResult();
+
+                Dictionary<string, object> result = new Dictionary<string, object>();
+                if (avatar == null)
+                    result["result"] = "null";
+                else
+                    result["result"] = avatar.ToKeyValuePairs();
+
+                string xmlString = ServerUtils.BuildXmlResponse(result);
+
+                return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+            }
+
+            return FailureResult();
+        }
+
+        byte[] SetAvatar(Dictionary<string, object> request)
+        {
+            UUID user = UUID.Zero;
+
+            if (!request.ContainsKey("UserID"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["UserID"].ToString(), out user))
+                return FailureResult();
+
+            RemoveRequestParamsNotForStorage(request);
+
+            AvatarData avatar = new AvatarData(request);
+            if (m_AvatarService.SetAvatar(user, avatar))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        byte[] ResetAvatar(Dictionary<string, object> request)
+        {
+            UUID user = UUID.Zero;
+            if (!request.ContainsKey("UserID"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["UserID"].ToString(), out user))
+                return FailureResult();
+
+            RemoveRequestParamsNotForStorage(request);
+
+            if (m_AvatarService.ResetAvatar(user))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        /// <summary>
+        /// Remove parameters that were used to invoke the method and should not in themselves be persisted.
+        /// </summary>
+        /// <param name='request'></param>
+        private void RemoveRequestParamsNotForStorage(Dictionary<string, object> request)
+        {
+            request.Remove("VERSIONMAX");
+            request.Remove("VERSIONMIN");
+            request.Remove("METHOD");
+            request.Remove("UserID");
+        }
+        
+        byte[] SetItems(Dictionary<string, object> request)
+        {
+            UUID user = UUID.Zero;
+            string[] names, values;
+
+            if (!request.ContainsKey("UserID") || !request.ContainsKey("Names") || !request.ContainsKey("Values"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["UserID"].ToString(), out user))
+                return FailureResult();
+
+            if (!(request["Names"] is List<string> || request["Values"] is List<string>))
+                return FailureResult();
+
+            RemoveRequestParamsNotForStorage(request);
+
+            List<string> _names = (List<string>)request["Names"];
+            names = _names.ToArray();
+            List<string> _values = (List<string>)request["Values"];
+            values = _values.ToArray();
+            
+            if (m_AvatarService.SetItems(user, names, values))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        byte[] RemoveItems(Dictionary<string, object> request)
+        {
+            UUID user = UUID.Zero;
+            string[] names;
+
+            if (!request.ContainsKey("UserID") || !request.ContainsKey("Names"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["UserID"].ToString(), out user))
+                return FailureResult();
+
+            if (!(request["Names"] is List<string>))
+                return FailureResult();
+
+            List<string> _names = (List<string>)request["Names"];
+            names = _names.ToArray();
+
+            if (m_AvatarService.RemoveItems(user, names))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+
+        
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/BakedTextures/XBakes.cs b/OpenSim/Server/Handlers/BakedTextures/XBakes.cs
new file mode 100644
index 0000000..4e55433
--- /dev/null
+++ b/OpenSim/Server/Handlers/BakedTextures/XBakes.cs
@@ -0,0 +1,148 @@
+/*
+ * 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.Diagnostics;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Reflection;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Server.Base;
+using OpenSim.Services.Base;
+using OpenSim.Services.Interfaces;
+using Nini.Config;
+using log4net;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.BakedTextures
+{
+    public class XBakes : ServiceBase, IBakedTextureService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected string m_FSBase;
+
+        private System.Text.UTF8Encoding utf8encoding =
+                new System.Text.UTF8Encoding();
+
+        public XBakes(IConfigSource config) : base(config)
+        {
+            MainConsole.Instance.Commands.AddCommand("fs", false,
+                    "delete bakes", "delete bakes <ID>",
+                    "Delete agent's baked textures from server",
+                    HandleDeleteBakes);
+
+            IConfig assetConfig = config.Configs["BakedTextureService"];
+            if (assetConfig == null)
+            {
+                throw new Exception("No BakedTextureService configuration");
+            }
+
+            m_FSBase = assetConfig.GetString("BaseDirectory", String.Empty);
+            if (m_FSBase == String.Empty)
+            {
+                m_log.ErrorFormat("[BAKES]: BaseDirectory not specified");
+                throw new Exception("Configuration error");
+            }
+
+            m_log.Info("[BAKES]: XBakes service enabled");
+        }
+
+        public string Get(string id)
+        {
+            string file = HashToFile(id);
+            string diskFile = Path.Combine(m_FSBase, file);
+
+            if (File.Exists(diskFile))
+            {
+                try
+                {
+                    byte[] content = File.ReadAllBytes(diskFile);
+
+                    return utf8encoding.GetString(content);
+                }
+                catch
+                {
+                }
+            }
+            return String.Empty;
+        }
+
+        public void Store(string id, string sdata)
+        {
+            string file = HashToFile(id);
+            string diskFile = Path.Combine(m_FSBase, file);
+
+            Directory.CreateDirectory(Path.GetDirectoryName(diskFile));
+
+            File.Delete(diskFile);
+
+            byte[] data = utf8encoding.GetBytes(sdata);
+
+            using (FileStream fs = File.Create(diskFile))
+                fs.Write(data, 0, data.Length);
+        }
+
+        private void HandleDeleteBakes(string module, string[] args)
+        {
+            if (args.Length < 3)
+            {
+                MainConsole.Instance.Output("Syntax: delete bakes <ID>");
+                return;
+            }
+
+            string file = HashToFile(args[2]);
+            string diskFile = Path.Combine(m_FSBase, file);
+
+            if (File.Exists(diskFile))
+            {
+                File.Delete(diskFile);
+                MainConsole.Instance.Output("Bakes deleted");
+                return;
+            }
+            MainConsole.Instance.Output("Bakes not found");
+        }
+
+        public string HashToPath(string hash)
+        {
+            return Path.Combine(hash.Substring(0, 2),
+                   Path.Combine(hash.Substring(2, 2),
+                   Path.Combine(hash.Substring(4, 2),
+                   hash.Substring(6, 4))));
+        }
+
+        public string HashToFile(string hash)
+        {
+            return Path.Combine(HashToPath(hash), hash);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/BakedTextures/XBakesGetHandler.cs b/OpenSim/Server/Handlers/BakedTextures/XBakesGetHandler.cs
new file mode 100644
index 0000000..3c61673
--- /dev/null
+++ b/OpenSim/Server/Handlers/BakedTextures/XBakesGetHandler.cs
@@ -0,0 +1,71 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Server.Handlers.BakedTextures
+{
+    public class BakesServerGetHandler : BaseStreamHandler
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IBakedTextureService m_BakesService;
+        private System.Text.UTF8Encoding utf8 =
+                new System.Text.UTF8Encoding();
+
+        public BakesServerGetHandler(IBakedTextureService service, IServiceAuth auth) :
+                base("GET", "/bakes", auth)
+        {
+            m_BakesService = service;
+        }
+
+        protected override byte[] ProcessRequest(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            string[] p = SplitParams(path);
+
+            if (p.Length == 0)
+                return new byte[0];
+
+            return utf8.GetBytes(m_BakesService.Get(p[0]));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/BakedTextures/XBakesHandler.cs b/OpenSim/Server/Handlers/BakedTextures/XBakesHandler.cs
new file mode 100644
index 0000000..4c12967
--- /dev/null
+++ b/OpenSim/Server/Handlers/BakedTextures/XBakesHandler.cs
@@ -0,0 +1,69 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.BakedTextures
+{
+    public class XBakesConnector : ServiceConnector
+    {
+        private IBakedTextureService m_BakesService;
+        private string m_ConfigName = "BakedTextureService";
+
+        public XBakesConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string assetService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (assetService == String.Empty)
+                throw new Exception("No BakedTextureService in config file");
+
+            Object[] args = new Object[] { config };
+            m_BakesService =
+                    ServerUtils.LoadPlugin<IBakedTextureService>(assetService, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+            
+            server.AddStreamHandler(new BakesServerGetHandler(m_BakesService, auth));
+            server.AddStreamHandler(new BakesServerPostHandler(m_BakesService, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/BakedTextures/XBakesPostHandler.cs b/OpenSim/Server/Handlers/BakedTextures/XBakesPostHandler.cs
new file mode 100644
index 0000000..e38543b
--- /dev/null
+++ b/OpenSim/Server/Handlers/BakedTextures/XBakesPostHandler.cs
@@ -0,0 +1,76 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Server.Handlers.BakedTextures
+{
+    public class BakesServerPostHandler : BaseStreamHandler
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IBakedTextureService m_BakesService;
+
+        public BakesServerPostHandler(IBakedTextureService service, IServiceAuth auth) :
+                base("POST", "/bakes", auth)
+        {
+            m_BakesService = service;
+        }
+
+        protected override byte[] ProcessRequest(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            string[] p = SplitParams(path);
+
+            if (p.Length == 0)
+            {
+                return new byte[0];
+            }
+
+            StreamReader sr = new StreamReader(request);
+
+            m_BakesService.Store(p[0], sr.ReadToEnd());
+            sr.Close();
+
+            return new byte[0];
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/Base/ServerConnector.cs b/OpenSim/Server/Handlers/Base/ServerConnector.cs
new file mode 100644
index 0000000..72014db
--- /dev/null
+++ b/OpenSim/Server/Handlers/Base/ServerConnector.cs
@@ -0,0 +1,113 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Server.Handlers.Base
+{
+    public interface IServiceConnector
+    {
+    }
+
+    public class ServiceConnector : IServiceConnector
+    {
+        public virtual string ConfigURL
+        {
+            get { return String.Empty; }
+        }
+
+        public virtual string ConfigName
+        {
+            get;
+            protected set;
+        }
+
+        public virtual string ConfigFile
+        {
+            get;
+            protected set;
+        }
+
+        public virtual IConfigSource Config
+        {
+            get;
+            protected set;
+        }
+
+        public ServiceConnector()
+        {
+        }
+
+        public ServiceConnector(IConfigSource config, IHttpServer server, string configName)
+        {
+        }
+
+        // We call this from our plugin module to get our configuration
+        public IConfig GetConfig()
+        { 
+            IConfig config = null;
+            config = ServerUtils.GetConfig(ConfigFile, ConfigName);
+
+            // Our file is not here? We can get one to bootstrap our plugin module
+            if ( config == null )
+            {
+                IConfigSource remotesource = GetConfigSource();
+
+                if (remotesource != null)
+                {
+                    IniConfigSource initialconfig = new IniConfigSource();
+                    initialconfig.Merge (remotesource);
+                    initialconfig.Save(ConfigFile);
+                }
+
+                config = remotesource.Configs[ConfigName];
+            }
+
+            return config;
+        }
+
+        // We get our remote initial configuration for bootstrapping in case
+        // we have no configuration in our main file or in an existing
+        // modular config file. This is the last resort to bootstrap the 
+        // configuration, likely a new plugin loading for the first time.
+        private IConfigSource GetConfigSource()
+        {
+            IConfigSource source = null;
+            
+            source = ServerUtils.LoadInitialConfig(ConfigURL);
+
+            if (source == null)
+                System.Console.WriteLine(String.Format ("Config Url: {0} Not found!", ConfigURL));
+
+            return source;
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Base/Utils.cs b/OpenSim/Server/Handlers/Base/Utils.cs
new file mode 100644
index 0000000..48d923f
--- /dev/null
+++ b/OpenSim/Server/Handlers/Base/Utils.cs
@@ -0,0 +1,97 @@
+/*
+ * 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;
+using System.Net;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Base
+{
+    public class RestHandlerUtils
+    {
+        /// <summary>
+        /// Extract the param from an uri.
+        /// </summary>
+        /// <param name="uri">Something like this: /uuid/ or /uuid/handle/release</param>
+        /// <param name="uri">uuid on uuid field</param>
+        /// <param name="action">optional action</param>
+        public static bool GetParams(string path, out UUID uuid, out ulong regionHandle, out string action)
+        {
+            uuid = UUID.Zero;
+            action = "";
+            regionHandle = 0;
+
+            path = path.Trim(new char[] { '/' });
+            string[] parts = path.Split('/');
+            if (parts.Length <= 1)
+            {
+                return false;
+            }
+            else
+            {
+                if (!UUID.TryParse(parts[0], out uuid))
+                    return false;
+
+                if (parts.Length >= 2)
+                    UInt64.TryParse(parts[1], out regionHandle);
+                if (parts.Length >= 3)
+                    action = parts[2];
+
+                return true;
+            }
+        }
+
+        public static bool GetAuthentication(IOSHttpRequest httpRequest, out string authority, out string authKey)
+        {
+            authority = string.Empty;
+            authKey = string.Empty;
+
+            Uri authUri;
+
+            string auth = httpRequest.Headers["authentication"];
+            // Authentication keys look like this:
+            // http://orgrid.org:8002/<uuid>
+            if ((auth != null) && (!string.Empty.Equals(auth)) && auth != "None")
+            {
+                if (Uri.TryCreate(auth, UriKind.Absolute, out authUri))
+                {
+                    authority = authUri.Authority;
+                    authKey = authUri.PathAndQuery.Trim('/');
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Estate/EstateDataRobustConnector.cs b/OpenSim/Server/Handlers/Estate/EstateDataRobustConnector.cs
new file mode 100644
index 0000000..e0c2810
--- /dev/null
+++ b/OpenSim/Server/Handlers/Estate/EstateDataRobustConnector.cs
@@ -0,0 +1,343 @@
+/*
+ * 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.Reflection;
+using System.Net;
+
+using Nini.Config;
+using log4net;
+using OpenMetaverse;
+
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers
+{
+    public class EstateDataRobustConnector : ServiceConnector
+    {
+        private string m_ConfigName = "EstateService";
+
+        public EstateDataRobustConnector(IConfigSource config, IHttpServer server, string configName) :
+            base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string service = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (service == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            IEstateDataService e_service = ServerUtils.LoadPlugin<IEstateDataService>(service, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName); ;
+
+            server.AddStreamHandler(new EstateServerGetHandler(e_service, auth));
+            server.AddStreamHandler(new EstateServerPostHandler(e_service, auth));
+        }
+    }
+
+
+    public class EstateServerGetHandler : BaseStreamHandler
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        IEstateDataService m_EstateService;
+
+        // Possibilities
+        // /estates/estate/?region=uuid&create=[t|f]
+        // /estates/estate/?eid=int
+        // /estates/?name=string
+        // /estates/?owner=uuid
+        // /estates/  (all)
+        // /estates/regions/?eid=int
+
+        public EstateServerGetHandler(IEstateDataService service, IServiceAuth auth) :
+            base("GET", "/estates", auth)
+        {
+            m_EstateService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            Dictionary<string, object> data = null;
+
+            string[] p = SplitParams(path);
+
+            // /estates/  (all)
+            // /estates/?name=string
+            // /estates/?owner=uuid
+            if (p.Length == 0)
+                data = GetEstates(httpRequest, httpResponse);
+            else
+            {
+                string resource = p[0];
+
+                // /estates/estate/?region=uuid&create=[t|f]
+                // /estates/estate/?eid=int
+                if ("estate".Equals(resource))
+                    data = GetEstate(httpRequest, httpResponse);
+                // /estates/regions/?eid=int
+                else if ("regions".Equals(resource))
+                    data = GetRegions(httpRequest, httpResponse);
+            }
+
+            if (data == null)
+                data = new Dictionary<string, object>();
+
+            string xmlString = ServerUtils.BuildXmlResponse(data);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+
+        }
+
+        private Dictionary<string, object> GetEstates(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // /estates/  (all)
+            // /estates/?name=string
+            // /estates/?owner=uuid
+
+            Dictionary<string, object> data = null;
+            string name = (string)httpRequest.Query["name"];
+            string owner = (string)httpRequest.Query["owner"];
+
+            if (!string.IsNullOrEmpty(name) || !string.IsNullOrEmpty(owner))
+            {
+                List<int> estateIDs = null;
+                if (!string.IsNullOrEmpty(name))
+                {
+                    estateIDs = m_EstateService.GetEstates(name);
+                }
+                else if (!string.IsNullOrEmpty(owner))
+                {
+                    UUID ownerID = UUID.Zero;
+                    if (UUID.TryParse(owner, out ownerID))
+                        estateIDs = m_EstateService.GetEstatesByOwner(ownerID);
+                }
+
+                if (estateIDs == null || (estateIDs != null && estateIDs.Count == 0))
+                    httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+                else
+                {
+                    httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                    httpResponse.ContentType = "text/xml";
+                    data = new Dictionary<string, object>();
+                    int i = 0;
+                    foreach (int id in estateIDs)
+                        data["estate" + i++] = id;
+                }
+            }
+            else
+            {
+                List<EstateSettings> estates = m_EstateService.LoadEstateSettingsAll();
+                if (estates == null || estates.Count == 0)
+                {
+                    httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+                }
+                else
+                {
+                    httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                    httpResponse.ContentType = "text/xml";
+                    data = new Dictionary<string, object>();
+                    int i = 0;
+                    foreach (EstateSettings es in estates)
+                        data["estate" + i++] = es.ToMap();
+
+                }
+            }
+
+            return data;
+        }
+
+        private Dictionary<string, object> GetEstate(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // /estates/estate/?region=uuid&create=[t|f]
+            // /estates/estate/?eid=int
+            Dictionary<string, object> data = null;
+            string region = (string)httpRequest.Query["region"];
+            string eid = (string)httpRequest.Query["eid"];
+
+            EstateSettings estate = null;
+
+            if (!string.IsNullOrEmpty(region))
+            {
+                UUID regionID = UUID.Zero;
+                if (UUID.TryParse(region, out regionID))
+                {
+                    string create = (string)httpRequest.Query["create"];
+                    bool createYN = false;
+                    Boolean.TryParse(create, out createYN);
+                    estate = m_EstateService.LoadEstateSettings(regionID, createYN);
+                }
+            }
+            else if (!string.IsNullOrEmpty(eid))
+            {
+                int id = 0;
+                if (Int32.TryParse(eid, out id))
+                    estate = m_EstateService.LoadEstateSettings(id);
+            }
+
+            if (estate != null)
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                httpResponse.ContentType = "text/xml";
+                data = estate.ToMap();
+            }
+            else
+                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+
+            return data;
+        }
+
+        private Dictionary<string, object> GetRegions(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // /estates/regions/?eid=int
+            Dictionary<string, object> data = null;
+            string eid = (string)httpRequest.Query["eid"];
+
+            httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+            if (!string.IsNullOrEmpty(eid))
+            {
+                int id = 0;
+                if (Int32.TryParse(eid, out id))
+                {
+                    List<UUID> regions = m_EstateService.GetRegions(id);
+                    if (regions != null && regions.Count > 0)
+                    {
+                        data = new Dictionary<string, object>();
+                        int i = 0;
+                        foreach (UUID uuid in regions)
+                            data["region" + i++] = uuid.ToString();
+                        httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                        httpResponse.ContentType = "text/xml";
+                    }
+                }
+            }
+
+            return data;
+        }
+    }
+
+    public class EstateServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        IEstateDataService m_EstateService;
+
+        // Possibilities
+        // /estates/estate/ (post an estate)
+        // /estates/estate/?eid=int&region=uuid (link a region to an estate)
+
+        public EstateServerPostHandler(IEstateDataService service, IServiceAuth auth) :
+            base("POST", "/estates", auth)
+        {
+            m_EstateService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                                                 IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            Dictionary<string, object> data = null;
+
+            string[] p = SplitParams(path);
+
+            if (p.Length > 0)
+            {
+                string resource = p[0];
+
+                // /estates/estate/
+                // /estates/estate/?eid=int&region=uuid
+                if ("estate".Equals(resource))
+                {
+                    StreamReader sr = new StreamReader(request);
+                    string body = sr.ReadToEnd();
+                    sr.Close();
+                    body = body.Trim();
+
+                    Dictionary<string, object> requestData = ServerUtils.ParseQueryString(body);
+
+                    data = UpdateEstate(requestData, httpRequest, httpResponse);
+                }
+            }
+
+            if (data == null)
+                data = new Dictionary<string, object>();
+
+            string xmlString = ServerUtils.BuildXmlResponse(data);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+
+        }
+
+        private Dictionary<string, object> UpdateEstate(Dictionary<string, object> requestData, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // /estates/estate/
+            // /estates/estate/?eid=int&region=uuid
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            string eid = (string)httpRequest.Query["eid"];
+            string region = (string)httpRequest.Query["region"];
+
+            httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+
+            if (string.IsNullOrEmpty(eid) && string.IsNullOrEmpty(region) &&
+                requestData.ContainsKey("OP") && requestData["OP"] != null && "STORE".Equals(requestData["OP"]))
+            {
+                // /estates/estate/
+                EstateSettings es = new EstateSettings(requestData);
+                m_EstateService.StoreEstateSettings(es);
+                //m_log.DebugFormat("[EstateServerPostHandler]: Store estate {0}", es.ToString());
+                httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                result["Result"] = true;
+            }
+            else if (!string.IsNullOrEmpty(region) && !string.IsNullOrEmpty(eid) &&
+                requestData.ContainsKey("OP") && requestData["OP"] != null && "LINK".Equals(requestData["OP"]))
+            {
+                int id = 0;
+                UUID regionID = UUID.Zero;
+                if (UUID.TryParse(region, out regionID) && Int32.TryParse(eid, out id))
+                {
+                    m_log.DebugFormat("[EstateServerPostHandler]: Link region {0} to estate {1}", regionID, id);
+                    httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                    result["Result"] = m_EstateService.LinkRegion(regionID, id);
+                }
+            }
+            else
+                m_log.WarnFormat("[EstateServerPostHandler]: something wrong with POST request {0}", httpRequest.RawUrl);
+
+            return result;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Freeswitch/FreeswitchServerConnector.cs b/OpenSim/Server/Handlers/Freeswitch/FreeswitchServerConnector.cs
new file mode 100644
index 0000000..da56b87
--- /dev/null
+++ b/OpenSim/Server/Handlers/Freeswitch/FreeswitchServerConnector.cs
@@ -0,0 +1,128 @@
+/*
+ * 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;
+using System.Web;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using log4net;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Server.Handlers.Freeswitch
+{
+    public class FreeswitchServerConnector : ServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IFreeswitchService m_FreeswitchService;
+        private string m_ConfigName = "FreeswitchService";
+        protected readonly string m_freeSwitchAPIPrefix = "/fsapi";
+
+        public FreeswitchServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string freeswitchService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (freeswitchService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_FreeswitchService =
+                    ServerUtils.LoadPlugin<IFreeswitchService>(freeswitchService, args);
+
+            server.AddHTTPHandler(String.Format("{0}/freeswitch-config", m_freeSwitchAPIPrefix), FreeSwitchConfigHTTPHandler);
+            server.AddHTTPHandler(String.Format("{0}/region-config", m_freeSwitchAPIPrefix), RegionConfigHTTPHandler);
+        }
+
+        public Hashtable FreeSwitchConfigHTTPHandler(Hashtable request)
+        {
+            Hashtable response = new Hashtable();
+            response["str_response_string"] = string.Empty;
+            response["content_type"] = "text/plain";
+            response["keepalive"] = false;
+            response["int_response_code"] = 500;
+
+            Hashtable requestBody = ParseRequestBody((string) request["body"]);
+
+            string section = (string) requestBody["section"];
+
+            if (section == "directory")
+                response = m_FreeswitchService.HandleDirectoryRequest(requestBody);
+            else if (section == "dialplan")
+                response = m_FreeswitchService.HandleDialplanRequest(requestBody);
+            else
+                m_log.WarnFormat("[FreeSwitchVoice]: section was {0}", section);
+
+            return response;
+        }
+
+        private Hashtable ParseRequestBody(string body)
+        {
+            Hashtable bodyParams = new Hashtable();
+            // split string
+            string [] nvps = body.Split(new Char [] {'&'});
+
+            foreach (string s in nvps)
+            {
+                if (s.Trim() != "")
+                {
+                    string [] nvp = s.Split(new Char [] {'='});
+                    bodyParams.Add(HttpUtility.UrlDecode(nvp[0]), HttpUtility.UrlDecode(nvp[1]));
+                }
+            }
+
+            return bodyParams;
+        }
+
+        public Hashtable RegionConfigHTTPHandler(Hashtable request)
+        {
+            Hashtable response = new Hashtable();
+            response["content_type"] = "text/json";
+            response["keepalive"] = false;
+            response["int_response_code"] = 200;
+
+            response["str_response_string"] = m_FreeswitchService.GetJsonConfig();
+
+            return response;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Friends/FriendServerConnector.cs b/OpenSim/Server/Handlers/Friends/FriendServerConnector.cs
new file mode 100644
index 0000000..b0e6c7d
--- /dev/null
+++ b/OpenSim/Server/Handlers/Friends/FriendServerConnector.cs
@@ -0,0 +1,63 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Friends
+{
+    public class FriendsServiceConnector : ServiceConnector
+    {
+        private IFriendsService m_FriendsService;
+        private string m_ConfigName = "FriendsService";
+
+        public FriendsServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string theService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (theService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_FriendsService = ServerUtils.LoadPlugin<IFriendsService>(theService, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+            server.AddStreamHandler(new FriendsServerPostHandler(m_FriendsService, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Friends/FriendsServerPostHandler.cs b/OpenSim/Server/Handlers/Friends/FriendsServerPostHandler.cs
new file mode 100644
index 0000000..3aab30b
--- /dev/null
+++ b/OpenSim/Server/Handlers/Friends/FriendsServerPostHandler.cs
@@ -0,0 +1,282 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using FriendInfo = OpenSim.Services.Interfaces.FriendInfo;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Friends
+{
+    public class FriendsServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IFriendsService m_FriendsService;
+
+        public FriendsServerPostHandler(IFriendsService service, IServiceAuth auth) :
+                base("POST", "/friends", auth)
+        {
+            m_FriendsService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                string method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "getfriends":
+                        return GetFriends(request);
+
+                    case "getfriends_string":
+                        return GetFriendsString(request);
+
+                    case "storefriend":
+                        return StoreFriend(request);
+
+                    case "deletefriend":
+                        return DeleteFriend(request);
+
+                    case "deletefriend_string":
+                        return DeleteFriendString(request);
+
+                }
+
+                m_log.DebugFormat("[FRIENDS HANDLER]: unknown method request {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[FRIENDS HANDLER]: Exception {0}", e);
+            }
+
+            return FailureResult();
+        }
+
+        #region Method-specific handlers
+
+        byte[] GetFriends(Dictionary<string, object> request)
+        {
+            UUID principalID = UUID.Zero;
+            if (request.ContainsKey("PRINCIPALID"))
+                UUID.TryParse(request["PRINCIPALID"].ToString(), out principalID);
+            else
+                m_log.WarnFormat("[FRIENDS HANDLER]: no principalID in request to get friends");
+
+            FriendInfo[] finfos = m_FriendsService.GetFriends(principalID);
+
+            return PackageFriends(finfos);
+        }
+
+        byte[] GetFriendsString(Dictionary<string, object> request)
+        {
+            string principalID = string.Empty;
+            if (request.ContainsKey("PRINCIPALID"))
+                principalID = request["PRINCIPALID"].ToString();
+            else
+                m_log.WarnFormat("[FRIENDS HANDLER]: no principalID in request to get friends");
+
+            FriendInfo[] finfos = m_FriendsService.GetFriends(principalID);
+
+            return PackageFriends(finfos);
+        }
+
+        private byte[] PackageFriends(FriendInfo[] finfos)
+        {
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((finfos == null) || ((finfos != null) && (finfos.Length == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (FriendInfo finfo in finfos)
+                {
+                    Dictionary<string, object> rinfoDict = finfo.ToKeyValuePairs();
+                    result["friend" + i] = rinfoDict;
+                    i++;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[FRIENDS HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] StoreFriend(Dictionary<string, object> request)
+        {
+            string principalID = string.Empty, friend = string.Empty; int flags = 0;
+            FromKeyValuePairs(request, out principalID, out friend, out flags);
+            bool success = m_FriendsService.StoreFriend(principalID, friend, flags);
+
+            if (success)
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] DeleteFriend(Dictionary<string, object> request)
+        {
+            UUID principalID = UUID.Zero;
+            if (request.ContainsKey("PRINCIPALID"))
+                UUID.TryParse(request["PRINCIPALID"].ToString(), out principalID);
+            else
+                m_log.WarnFormat("[FRIENDS HANDLER]: no principalID in request to delete friend");
+            string friend = string.Empty;
+            if (request.ContainsKey("FRIEND"))
+                friend = request["FRIEND"].ToString();
+
+            bool success = m_FriendsService.Delete(principalID, friend);
+            if (success)
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] DeleteFriendString(Dictionary<string, object> request)
+        {
+            string principalID = string.Empty;
+            if (request.ContainsKey("PRINCIPALID"))
+                principalID = request["PRINCIPALID"].ToString();
+            else
+                m_log.WarnFormat("[FRIENDS HANDLER]: no principalID in request to delete friend");
+            string friend = string.Empty;
+            if (request.ContainsKey("FRIEND"))
+                friend = request["FRIEND"].ToString();
+
+            bool success = m_FriendsService.Delete(principalID, friend);
+            if (success)
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        #endregion
+
+        #region Misc
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult()
+        {
+            return FailureResult(String.Empty);
+        }
+
+        private byte[] FailureResult(string msg)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            XmlElement message = doc.CreateElement("", "Message", "");
+            message.AppendChild(doc.CreateTextNode(msg));
+
+            rootElement.AppendChild(message);
+
+            return Util.DocToBytes(doc);
+        }
+
+        void FromKeyValuePairs(Dictionary<string, object> kvp, out string principalID, out string friend, out int flags)
+        {
+            principalID = string.Empty;
+            if (kvp.ContainsKey("PrincipalID") && kvp["PrincipalID"] != null)
+                principalID = kvp["PrincipalID"].ToString();
+            friend = string.Empty;
+            if (kvp.ContainsKey("Friend") && kvp["Friend"] != null)
+                friend = kvp["Friend"].ToString();
+            flags = 0;
+            if (kvp.ContainsKey("MyFlags") && kvp["MyFlags"] != null)
+                Int32.TryParse(kvp["MyFlags"].ToString(), out flags);
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Server/Handlers/Grid/GridInfoHandlers.cs b/OpenSim/Server/Handlers/Grid/GridInfoHandlers.cs
new file mode 100644
index 0000000..346af32
--- /dev/null
+++ b/OpenSim/Server/Handlers/Grid/GridInfoHandlers.cs
@@ -0,0 +1,199 @@
+/*
+ * 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;
+using System.IO;
+using System.Net;
+using System.Reflection;
+using System.Security;
+using System.Text;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Server.Handlers.Grid
+{
+    public class GridInfoHandlers
+    {
+        private static readonly ILog _log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private IConfigSource m_Config;
+        private Hashtable _info = new Hashtable();
+
+        /// <summary>
+        /// Instantiate a GridInfoService object.
+        /// </summary>
+        /// <param name="configPath">path to config path containing
+        /// grid information</param>
+        /// <remarks>
+        /// GridInfoService uses the [GridInfo] section of the
+        /// standard OpenSim.ini file --- which is not optimal, but
+        /// anything else requires a general redesign of the config
+        /// system.
+        /// </remarks>
+        public GridInfoHandlers(IConfigSource configSource)
+        {
+            m_Config = configSource;
+            loadGridInfo(configSource);
+        }
+
+        private void loadGridInfo(IConfigSource configSource)
+        {
+            _info["platform"] = "OpenSim";
+            try
+            {
+                IConfig gridCfg = configSource.Configs["GridInfoService"];
+                IConfig netCfg = configSource.Configs["Network"];
+
+                if (null != gridCfg)
+                {
+                    foreach (string k in gridCfg.GetKeys())
+                    {
+                        _info[k] = gridCfg.GetString(k);
+                    }
+                }
+                else if (null != netCfg)
+                {
+                    _info["login"]
+                        = String.Format(
+                            "http://127.0.0.1:{0}/", 
+                            netCfg.GetString(
+                                "http_listener_port", ConfigSettings.DefaultRegionHttpPort.ToString()));
+                    
+                    IssueWarning();
+                }
+                else
+                {
+                    _info["login"] = "http://127.0.0.1:9000/";
+                    IssueWarning();
+                }
+            }
+            catch (Exception)
+            {
+                _log.Warn("[GRID INFO SERVICE]: Cannot get grid info from config source, using minimal defaults");
+            }
+            
+            _log.DebugFormat("[GRID INFO SERVICE]: Grid info service initialized with {0} keys", _info.Count);
+        }
+
+        private void IssueWarning()
+        {
+            _log.Warn("[GRID INFO SERVICE]: found no [GridInfo] section in your configuration files");
+            _log.Warn("[GRID INFO SERVICE]: trying to guess sensible defaults, you might want to provide better ones:");
+            
+            foreach (string k in _info.Keys)
+            {
+                _log.WarnFormat("[GRID INFO SERVICE]: {0}: {1}", k, _info[k]);
+            }
+        }
+
+        public XmlRpcResponse XmlRpcGridInfoMethod(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            XmlRpcResponse response = new XmlRpcResponse();
+            Hashtable responseData = new Hashtable();
+
+            _log.Debug("[GRID INFO SERVICE]: Request for grid info");
+
+            foreach (string k in _info.Keys)
+            {
+                responseData[k] = _info[k];
+            }
+            response.Value = responseData;
+
+            return response;
+        }
+
+        public string RestGetGridInfoMethod(string request, string path, string param,
+                                            IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StringBuilder sb = new StringBuilder();
+
+            sb.Append("<gridinfo>\n");
+            foreach (string k in _info.Keys)
+            {
+                sb.AppendFormat("<{0}>{1}</{0}>\n", k, SecurityElement.Escape(_info[k].ToString()));
+            }
+            sb.Append("</gridinfo>\n");
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Get GridInfo in json format: Used bu the OSSL osGetGrid*
+        /// Adding the SRV_HomeIRI to the kvp returned for use in scripts
+        /// </summary>
+        /// <returns>
+        /// json string
+        /// </returns>
+        /// <param name='request'>
+        /// Request.
+        /// </param>
+        /// <param name='path'>
+        ///  /json_grid_info
+        /// </param>
+        /// <param name='param'>
+        /// Parameter.
+        /// </param>
+        /// <param name='httpRequest'>
+        /// Http request.
+        /// </param>
+        /// <param name='httpResponse'>
+        /// Http response.
+        /// </param>
+        public string JsonGetGridInfoMethod(string request, string path, string param,
+                                            IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            OSDMap map = new OSDMap();
+
+            foreach (string k in _info.Keys)
+            {
+                map[k] = OSD.FromString(_info[k].ToString());
+            }
+
+            string HomeURI = Util.GetConfigVarFromSections<string>(m_Config, "HomeURI",
+                new string[] { "Startup", "Hypergrid" }, String.Empty);
+
+            if (!String.IsNullOrEmpty(HomeURI))
+                map["home"] = OSD.FromString(HomeURI); 
+            else // Legacy. Remove soon!
+            {
+                IConfig cfg = m_Config.Configs["LoginService"];
+
+                if (null != cfg)
+                    HomeURI = cfg.GetString("SRV_HomeURI", HomeURI);
+
+                if (!String.IsNullOrEmpty(HomeURI))
+                    map["home"] = OSD.FromString(HomeURI);
+            }
+
+            return OSDParser.SerializeJsonString(map).ToString();
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Grid/GridInfoServerInConnector.cs b/OpenSim/Server/Handlers/Grid/GridInfoServerInConnector.cs
new file mode 100644
index 0000000..f9b5915
--- /dev/null
+++ b/OpenSim/Server/Handlers/Grid/GridInfoServerInConnector.cs
@@ -0,0 +1,57 @@
+/*
+ * 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.Reflection;
+using log4net;
+using OpenMetaverse;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Grid
+{
+    public class GridInfoServerInConnector : ServiceConnector
+    {
+//        private string m_ConfigName = "GridInfoService";
+
+        public GridInfoServerInConnector(IConfigSource config, IHttpServer server, string configName) :
+            base(config, server, configName)
+        {
+            GridInfoHandlers handlers = new GridInfoHandlers(config);
+
+            server.AddStreamHandler(new RestStreamHandler("GET", "/get_grid_info",
+                                                               handlers.RestGetGridInfoMethod));
+            server.AddStreamHandler(new RestStreamHandler("GET", "/json_grid_info",
+                                                          handlers.JsonGetGridInfoMethod));
+            server.AddXmlRPCHandler("get_grid_info", handlers.XmlRpcGridInfoMethod);
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Grid/GridServerConnector.cs b/OpenSim/Server/Handlers/Grid/GridServerConnector.cs
new file mode 100644
index 0000000..6eb6a79
--- /dev/null
+++ b/OpenSim/Server/Handlers/Grid/GridServerConnector.cs
@@ -0,0 +1,64 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Grid
+{
+    public class GridServiceConnector : ServiceConnector
+    {
+        private IGridService m_GridService;
+        private string m_ConfigName = "GridService";
+
+        public GridServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string gridService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (gridService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+
+            server.AddStreamHandler(new GridServerPostHandler(m_GridService, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Grid/GridServerPostHandler.cs b/OpenSim/Server/Handlers/Grid/GridServerPostHandler.cs
new file mode 100644
index 0000000..849fa94
--- /dev/null
+++ b/OpenSim/Server/Handlers/Grid/GridServerPostHandler.cs
@@ -0,0 +1,661 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Grid
+{
+    public class GridServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+#pragma warning disable 414
+        private static string LogHeader = "[GRID HANDLER]";
+#pragma warning restore 414
+
+        private IGridService m_GridService;
+
+        public GridServerPostHandler(IGridService service, IServiceAuth auth) :
+                base("POST", "/grid", auth)
+        {
+            m_GridService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                string method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "register":
+                        return Register(request);
+
+                    case "deregister":
+                        return Deregister(request);
+
+                    case "get_neighbours":
+                        return GetNeighbours(request);
+
+                    case "get_region_by_uuid":
+                        return GetRegionByUUID(request);
+
+                    case "get_region_by_position":
+                        return GetRegionByPosition(request);
+
+                    case "get_region_by_name":
+                        return GetRegionByName(request);
+
+                    case "get_regions_by_name":
+                        return GetRegionsByName(request);
+
+                    case "get_region_range":
+                        return GetRegionRange(request);
+
+                    case "get_default_regions":
+                        return GetDefaultRegions(request);
+
+                    case "get_default_hypergrid_regions":
+                        return GetDefaultHypergridRegions(request);
+
+                    case "get_fallback_regions":
+                        return GetFallbackRegions(request);
+
+                    case "get_hyperlinks":
+                        return GetHyperlinks(request);
+
+                    case "get_region_flags":
+                        return GetRegionFlags(request);
+
+                    case "get_grid_extra_features":
+                        return GetGridExtraFeatures(request);
+                }
+                
+                m_log.DebugFormat("[GRID HANDLER]: unknown method request {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[GRID HANDLER]: Exception {0} {1}", e.Message, e.StackTrace);
+            }
+
+            return FailureResult();
+        }
+
+        #region Method-specific handlers
+
+        byte[] Register(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to register region");
+
+            int versionNumberMin = 0, versionNumberMax = 0;
+            if (request.ContainsKey("VERSIONMIN"))
+                Int32.TryParse(request["VERSIONMIN"].ToString(), out versionNumberMin);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no minimum protocol version in request to register region");
+
+            if (request.ContainsKey("VERSIONMAX"))
+                Int32.TryParse(request["VERSIONMAX"].ToString(), out versionNumberMax);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no maximum protocol version in request to register region");
+
+            // Check the protocol version
+            if ((versionNumberMin > ProtocolVersions.ServerProtocolVersionMax && versionNumberMax < ProtocolVersions.ServerProtocolVersionMax))
+            {
+                // Can't do, there is no overlap in the acceptable ranges
+                return FailureResult();
+            }
+
+            Dictionary<string, object> rinfoData = new Dictionary<string, object>();
+            GridRegion rinfo = null;
+            try
+            {
+                foreach (KeyValuePair<string, object> kvp in request)
+                    rinfoData[kvp.Key] = kvp.Value.ToString();
+                rinfo = new GridRegion(rinfoData);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID HANDLER]: exception unpacking region data: {0}", e);
+            }
+
+            string result = "Error communicating with grid service";
+            if (rinfo != null)
+                result = m_GridService.RegisterRegion(scopeID, rinfo);
+
+            if (result == String.Empty)
+                return SuccessResult();
+            else
+                return FailureResult(result);
+        }
+
+        byte[] Deregister(Dictionary<string, object> request)
+        {
+            UUID regionID = UUID.Zero;
+            if (request.ContainsKey("REGIONID"))
+                UUID.TryParse(request["REGIONID"].ToString(), out regionID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no regionID in request to deregister region");
+
+            bool result = m_GridService.DeregisterRegion(regionID);
+
+            if (result)
+                return SuccessResult();
+            else
+                return FailureResult();
+
+        }
+
+        byte[] GetNeighbours(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get neighbours");
+
+            UUID regionID = UUID.Zero;
+            if (request.ContainsKey("REGIONID"))
+                UUID.TryParse(request["REGIONID"].ToString(), out regionID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no regionID in request to get neighbours");
+
+            List<GridRegion> rinfos = m_GridService.GetNeighbours(scopeID, regionID);
+            //m_log.DebugFormat("[GRID HANDLER]: neighbours for region {0}: {1}", regionID, rinfos.Count);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((rinfos == null) || ((rinfos != null) && (rinfos.Count == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridRegion rinfo in rinfos)
+                {
+                    Dictionary<string, object> rinfoDict = rinfo.ToKeyValuePairs();
+                    result["region" + i] = rinfoDict;
+                    i++;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetRegionByUUID(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get neighbours");
+
+            UUID regionID = UUID.Zero;
+            if (request.ContainsKey("REGIONID"))
+                UUID.TryParse(request["REGIONID"].ToString(), out regionID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no regionID in request to get neighbours");
+
+            GridRegion rinfo = m_GridService.GetRegionByUUID(scopeID, regionID);
+            //m_log.DebugFormat("[GRID HANDLER]: neighbours for region {0}: {1}", regionID, rinfos.Count);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if (rinfo == null)
+                result["result"] = "null";
+            else
+                result["result"] = rinfo.ToKeyValuePairs();
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetRegionByPosition(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get region by position");
+
+            int x = 0, y = 0;
+            if (request.ContainsKey("X"))
+                Int32.TryParse(request["X"].ToString(), out x);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no X in request to get region by position");
+            if (request.ContainsKey("Y"))
+                Int32.TryParse(request["Y"].ToString(), out y);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no Y in request to get region by position");
+
+            // m_log.DebugFormat("{0} GetRegionByPosition: loc=<{1},{2}>", LogHeader, x, y);
+            GridRegion rinfo = m_GridService.GetRegionByPosition(scopeID, x, y);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if (rinfo == null)
+                result["result"] = "null";
+            else
+                result["result"] = rinfo.ToKeyValuePairs();
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetRegionByName(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get region by name");
+
+            string regionName = string.Empty;
+            if (request.ContainsKey("NAME"))
+                regionName = request["NAME"].ToString();
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no name in request to get region by name");
+
+            GridRegion rinfo = m_GridService.GetRegionByName(scopeID, regionName);
+            //m_log.DebugFormat("[GRID HANDLER]: neighbours for region {0}: {1}", regionID, rinfos.Count);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if (rinfo == null)
+                result["result"] = "null";
+            else
+                result["result"] = rinfo.ToKeyValuePairs();
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetRegionsByName(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get regions by name");
+
+            string regionName = string.Empty;
+            if (request.ContainsKey("NAME"))
+                regionName = request["NAME"].ToString();
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no NAME in request to get regions by name");
+
+            int max = 0;
+            if (request.ContainsKey("MAX"))
+                Int32.TryParse(request["MAX"].ToString(), out max);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no MAX in request to get regions by name");
+
+            List<GridRegion> rinfos = m_GridService.GetRegionsByName(scopeID, regionName, max);
+            //m_log.DebugFormat("[GRID HANDLER]: neighbours for region {0}: {1}", regionID, rinfos.Count);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((rinfos == null) || ((rinfos != null) && (rinfos.Count == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridRegion rinfo in rinfos)
+                {
+                    Dictionary<string, object> rinfoDict = rinfo.ToKeyValuePairs();
+                    result["region" + i] = rinfoDict;
+                    i++;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetRegionRange(Dictionary<string, object> request)
+        {
+            //m_log.DebugFormat("[GRID HANDLER]: GetRegionRange");
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get region range");
+
+            int xmin = 0, xmax = 0, ymin = 0, ymax = 0;
+            if (request.ContainsKey("XMIN"))
+                Int32.TryParse(request["XMIN"].ToString(), out xmin);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no XMIN in request to get region range");
+            if (request.ContainsKey("XMAX"))
+                Int32.TryParse(request["XMAX"].ToString(), out xmax);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no XMAX in request to get region range");
+            if (request.ContainsKey("YMIN"))
+                Int32.TryParse(request["YMIN"].ToString(), out ymin);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no YMIN in request to get region range");
+            if (request.ContainsKey("YMAX"))
+                Int32.TryParse(request["YMAX"].ToString(), out ymax);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no YMAX in request to get region range");
+
+
+            List<GridRegion> rinfos = m_GridService.GetRegionRange(scopeID, xmin, xmax, ymin, ymax);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((rinfos == null) || ((rinfos != null) && (rinfos.Count == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridRegion rinfo in rinfos)
+                {
+                    Dictionary<string, object> rinfoDict = rinfo.ToKeyValuePairs();
+                    result["region" + i] = rinfoDict;
+                    i++;
+                }
+            }
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetDefaultRegions(Dictionary<string, object> request)
+        {
+            //m_log.DebugFormat("[GRID HANDLER]: GetDefaultRegions");
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get region range");
+
+            List<GridRegion> rinfos = m_GridService.GetDefaultRegions(scopeID);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((rinfos == null) || ((rinfos != null) && (rinfos.Count == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridRegion rinfo in rinfos)
+                {
+                    Dictionary<string, object> rinfoDict = rinfo.ToKeyValuePairs();
+                    result["region" + i] = rinfoDict;
+                    i++;
+                }
+            }
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetDefaultHypergridRegions(Dictionary<string, object> request)
+        {
+            //m_log.DebugFormat("[GRID HANDLER]: GetDefaultRegions");
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get region range");
+
+            List<GridRegion> rinfos = m_GridService.GetDefaultHypergridRegions(scopeID);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((rinfos == null) || ((rinfos != null) && (rinfos.Count == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridRegion rinfo in rinfos)
+                {
+                    Dictionary<string, object> rinfoDict = rinfo.ToKeyValuePairs();
+                    result["region" + i] = rinfoDict;
+                    i++;
+                }
+            }
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetFallbackRegions(Dictionary<string, object> request)
+        {
+            //m_log.DebugFormat("[GRID HANDLER]: GetRegionRange");
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get fallback regions");
+
+            int x = 0, y = 0;
+            if (request.ContainsKey("X"))
+                Int32.TryParse(request["X"].ToString(), out x);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no X in request to get fallback regions");
+            if (request.ContainsKey("Y"))
+                Int32.TryParse(request["Y"].ToString(), out y);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no Y in request to get fallback regions");
+
+
+            List<GridRegion> rinfos = m_GridService.GetFallbackRegions(scopeID, x, y);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((rinfos == null) || ((rinfos != null) && (rinfos.Count == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridRegion rinfo in rinfos)
+                {
+                    Dictionary<string, object> rinfoDict = rinfo.ToKeyValuePairs();
+                    result["region" + i] = rinfoDict;
+                    i++;
+                }
+            }
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetHyperlinks(Dictionary<string, object> request)
+        {
+            //m_log.DebugFormat("[GRID HANDLER]: GetHyperlinks");
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get linked regions");
+
+            List<GridRegion> rinfos = m_GridService.GetHyperlinks(scopeID);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((rinfos == null) || ((rinfos != null) && (rinfos.Count == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridRegion rinfo in rinfos)
+                {
+                    Dictionary<string, object> rinfoDict = rinfo.ToKeyValuePairs();
+                    result["region" + i] = rinfoDict;
+                    i++;
+                }
+            }
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetRegionFlags(Dictionary<string, object> request)
+        {
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("SCOPEID"))
+                UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get neighbours");
+
+            UUID regionID = UUID.Zero;
+            if (request.ContainsKey("REGIONID"))
+                UUID.TryParse(request["REGIONID"].ToString(), out regionID);
+            else
+                m_log.WarnFormat("[GRID HANDLER]: no regionID in request to get neighbours");
+
+            int flags = m_GridService.GetRegionFlags(scopeID, regionID);
+           // m_log.DebugFormat("[GRID HANDLER]: flags for region {0}: {1}", regionID, flags);
+
+            Dictionary<string, object> result = new Dictionary<string, object>(); 
+            result["result"] = flags.ToString();
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+        
+        byte[] GetGridExtraFeatures(Dictionary<string, object> request)
+        {
+
+            Dictionary<string, object> result = new Dictionary<string, object> ();
+            Dictionary<string, object> extraFeatures = m_GridService.GetExtraFeatures ();
+
+            foreach (string key in extraFeatures.Keys) 
+            {
+                result [key] = extraFeatures [key];
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        #endregion
+
+        #region Misc
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult()
+        {
+            return FailureResult(String.Empty);
+        }
+
+        private byte[] FailureResult(string msg)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            XmlElement message = doc.CreateElement("", "Message", "");
+            message.AppendChild(doc.CreateTextNode(msg));
+
+            rootElement.AppendChild(message);
+
+            return Util.DocToBytes(doc);
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Server/Handlers/GridUser/GridUserServerConnector.cs b/OpenSim/Server/Handlers/GridUser/GridUserServerConnector.cs
new file mode 100644
index 0000000..1e29378
--- /dev/null
+++ b/OpenSim/Server/Handlers/GridUser/GridUserServerConnector.cs
@@ -0,0 +1,64 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.GridUser
+{
+    public class GridUserServiceConnector : ServiceConnector
+    {
+        private IGridUserService m_GridUserService;
+        private string m_ConfigName = "GridUserService";
+
+        public GridUserServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string service = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (service == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_GridUserService = ServerUtils.LoadPlugin<IGridUserService>(service, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName); ;
+
+            server.AddStreamHandler(new GridUserServerPostHandler(m_GridUserService, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/GridUser/GridUserServerPostHandler.cs b/OpenSim/Server/Handlers/GridUser/GridUserServerPostHandler.cs
new file mode 100644
index 0000000..9237c63
--- /dev/null
+++ b/OpenSim/Server/Handlers/GridUser/GridUserServerPostHandler.cs
@@ -0,0 +1,308 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.GridUser
+{
+    public class GridUserServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IGridUserService m_GridUserService;
+
+        public GridUserServerPostHandler(IGridUserService service, IServiceAuth auth) :
+                base("POST", "/griduser", auth)
+        {
+            m_GridUserService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+            string method = string.Empty;
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "loggedin":
+                        return LoggedIn(request);
+                    case "loggedout":
+                        return LoggedOut(request);
+                    case "sethome":
+                        return SetHome(request);
+                    case "setposition":
+                        return SetPosition(request);
+                    case "getgriduserinfo":
+                        return GetGridUserInfo(request);
+                    case "getgriduserinfos":
+                        return GetGridUserInfos(request);
+                }
+                m_log.DebugFormat("[GRID USER HANDLER]: unknown method request: {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID USER HANDLER]: Exception in method {0}: {1}", method, e);
+            }
+
+            return FailureResult();
+
+        }
+
+        byte[] LoggedIn(Dictionary<string, object> request)
+        {
+            string user = String.Empty;
+
+            if (!request.ContainsKey("UserID"))
+                return FailureResult();
+
+            user = request["UserID"].ToString();
+
+            GridUserInfo guinfo = m_GridUserService.LoggedIn(user);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            result["result"] = guinfo.ToKeyValuePairs();
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID USER HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] LoggedOut(Dictionary<string, object> request)
+        {
+            string userID = string.Empty;
+            UUID regionID = UUID.Zero;
+            Vector3 position = Vector3.Zero;
+            Vector3 lookat = Vector3.Zero;
+
+            if (!UnpackArgs(request, out userID, out regionID, out position, out lookat))
+                return FailureResult();
+
+            if (m_GridUserService.LoggedOut(userID, UUID.Zero, regionID, position, lookat))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        byte[] SetHome(Dictionary<string, object> request)
+        {
+            string user = string.Empty;
+            UUID region = UUID.Zero;
+            Vector3 position = new Vector3(128, 128, 70);
+            Vector3 look = Vector3.Zero;
+
+            if (!UnpackArgs(request, out user, out region, out position, out look))
+                return FailureResult();
+
+            if (m_GridUserService.SetHome(user, region, position, look))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        byte[] SetPosition(Dictionary<string, object> request)
+        {
+            string user = string.Empty;
+            UUID region = UUID.Zero;
+            Vector3 position = new Vector3(128, 128, 70);
+            Vector3 look = Vector3.Zero;
+
+            if (!request.ContainsKey("UserID") || !request.ContainsKey("RegionID"))
+                return FailureResult();
+
+            if (!UnpackArgs(request, out user, out region, out position, out look))
+                return FailureResult();
+
+            if (m_GridUserService.SetLastPosition(user, UUID.Zero, region, position, look))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        byte[] GetGridUserInfo(Dictionary<string, object> request)
+        {
+            string user = String.Empty;
+
+            if (!request.ContainsKey("UserID"))
+                return FailureResult();
+
+            user = request["UserID"].ToString();
+
+            GridUserInfo guinfo = m_GridUserService.GetGridUserInfo(user);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if (guinfo != null)
+                result["result"] = guinfo.ToKeyValuePairs();
+            else
+                result["result"] = "null";
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            //m_log.DebugFormat("[GRID USER HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetGridUserInfos(Dictionary<string, object> request)
+        {
+
+            string[] userIDs;
+
+            if (!request.ContainsKey("AgentIDs"))
+            {
+                m_log.DebugFormat("[GRID USER HANDLER]: GetGridUserInfos called without required uuids argument");
+                return FailureResult();
+            }
+
+            if (!(request["AgentIDs"] is List<string>))
+            {
+                m_log.DebugFormat("[GRID USER HANDLER]: GetGridUserInfos input argument was of unexpected type {0}", request["uuids"].GetType().ToString());
+                return FailureResult();
+            }
+
+            userIDs = ((List<string>)request["AgentIDs"]).ToArray();
+
+            GridUserInfo[] pinfos = m_GridUserService.GetGridUserInfo(userIDs);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((pinfos == null) || ((pinfos != null) && (pinfos.Length == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (GridUserInfo pinfo in pinfos)
+                {
+                    Dictionary<string, object> rinfoDict = pinfo.ToKeyValuePairs();
+                    result["griduser" + i] = rinfoDict;
+                    i++;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        private bool UnpackArgs(Dictionary<string, object> request, out string user, out UUID region, out Vector3 position, out Vector3 lookAt)
+        {
+            user = string.Empty;
+            region = UUID.Zero;
+            position = new Vector3(128, 128, 70);
+            lookAt = Vector3.Zero;
+
+            if (!request.ContainsKey("UserID") || !request.ContainsKey("RegionID"))
+                return false;
+
+            user = request["UserID"].ToString();
+
+            if (!UUID.TryParse(request["RegionID"].ToString(), out region))
+                return false;
+
+            if (request.ContainsKey("Position"))
+                Vector3.TryParse(request["Position"].ToString(), out position);
+
+            if (request.ContainsKey("LookAt"))
+                Vector3.TryParse(request["LookAt"].ToString(), out lookAt);
+
+            return true;
+        }
+
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/AgentHandlers.cs b/OpenSim/Server/Handlers/Hypergrid/AgentHandlers.cs
new file mode 100644
index 0000000..95a0510
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/AgentHandlers.cs
@@ -0,0 +1,70 @@
+/*
+ * 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;
+using System.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Simulation;
+using Utils = OpenSim.Server.Handlers.Simulation.Utils;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class GatekeeperAgentHandler : OpenSim.Server.Handlers.Simulation.AgentPostHandler
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private IGatekeeperService m_GatekeeperService;
+
+        public GatekeeperAgentHandler(IGatekeeperService gatekeeper, bool proxy) : base("/foreignagent")
+        {
+            m_GatekeeperService = gatekeeper;
+            m_Proxy = proxy;
+        }
+
+        protected override bool CreateAgent(GridRegion source, GridRegion gatekeeper, GridRegion destination,
+            AgentCircuitData aCircuit, uint teleportFlags, bool fromLogin, out string reason)
+        {
+            return m_GatekeeperService.LoginAgent(source, aCircuit, destination, out reason);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/GatekeeperServerConnector.cs b/OpenSim/Server/Handlers/Hypergrid/GatekeeperServerConnector.cs
new file mode 100644
index 0000000..ffe2f36
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/GatekeeperServerConnector.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.Collections.Generic;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+using log4net;
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class GatekeeperServiceInConnector : ServiceConnector
+    {
+//        private static readonly ILog m_log =
+//                LogManager.GetLogger(
+//                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IGatekeeperService m_GatekeeperService;
+        public IGatekeeperService GateKeeper
+        {
+            get { return m_GatekeeperService; }
+        }
+
+        bool m_Proxy = false;
+
+        public GatekeeperServiceInConnector(IConfigSource config, IHttpServer server, ISimulationService simService) :
+                base(config, server, String.Empty)
+        {
+            IConfig gridConfig = config.Configs["GatekeeperService"];
+            if (gridConfig != null)
+            {
+                string serviceDll = gridConfig.GetString("LocalServiceModule", string.Empty);
+                Object[] args = new Object[] { config, simService };
+                m_GatekeeperService = ServerUtils.LoadPlugin<IGatekeeperService>(serviceDll, args);
+
+            }
+            if (m_GatekeeperService == null)
+                throw new Exception("Gatekeeper server connector cannot proceed because of missing service");
+
+            m_Proxy = gridConfig.GetBoolean("HasProxy", false);
+
+            HypergridHandlers hghandlers = new HypergridHandlers(m_GatekeeperService);
+            server.AddXmlRPCHandler("link_region", hghandlers.LinkRegionRequest, false);
+            server.AddXmlRPCHandler("get_region", hghandlers.GetRegion, false);
+
+            server.AddStreamHandler(new GatekeeperAgentHandler(m_GatekeeperService, m_Proxy));
+        }
+
+        public GatekeeperServiceInConnector(IConfigSource config, IHttpServer server, string configName)
+            : this(config, server, (ISimulationService)null)
+        {
+        }
+
+        public GatekeeperServiceInConnector(IConfigSource config, IHttpServer server)
+            : this(config, server, String.Empty)
+        {
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/HGFriendServerConnector.cs b/OpenSim/Server/Handlers/Hypergrid/HGFriendServerConnector.cs
new file mode 100644
index 0000000..6c79c60
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/HGFriendServerConnector.cs
@@ -0,0 +1,77 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class HGFriendsServerConnector : ServiceConnector
+    {
+        private IUserAgentService m_UserAgentService;
+        private IHGFriendsService m_TheService;
+        private string m_ConfigName = "HGFriendsService";
+
+        // Called from Robust
+        public HGFriendsServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                this(config, server, configName, null)
+        {
+
+        }
+
+        // Called from standalone configurations
+        public HGFriendsServerConnector(IConfigSource config, IHttpServer server, string configName, IFriendsSimConnector localConn) 
+            : base(config, server, configName)
+        {
+            if (configName != string.Empty)
+                m_ConfigName = configName;
+
+            Object[] args = new Object[] { config, m_ConfigName, localConn };
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string theService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+            if (theService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+            m_TheService = ServerUtils.LoadPlugin<IHGFriendsService>(theService, args);
+
+            theService = serverConfig.GetString("UserAgentService", string.Empty);
+            if (theService == String.Empty)
+                throw new Exception("No UserAgentService in " + m_ConfigName);
+            m_UserAgentService = ServerUtils.LoadPlugin<IUserAgentService>(theService, new Object[] { config, localConn });
+
+            server.AddStreamHandler(new HGFriendsServerPostHandler(m_TheService, m_UserAgentService, localConn));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/HGFriendsServerPostHandler.cs b/OpenSim/Server/Handlers/Hypergrid/HGFriendsServerPostHandler.cs
new file mode 100644
index 0000000..37b47ed
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/HGFriendsServerPostHandler.cs
@@ -0,0 +1,425 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using FriendInfo = OpenSim.Services.Interfaces.FriendInfo;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class HGFriendsServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IUserAgentService m_UserAgentService;
+        private IFriendsSimConnector m_FriendsLocalSimConnector;
+        private IHGFriendsService m_TheService;
+
+        public HGFriendsServerPostHandler(IHGFriendsService service, IUserAgentService uas, IFriendsSimConnector friendsConn) :
+                base("POST", "/hgfriends")
+        {
+            m_TheService = service;
+            m_UserAgentService = uas;
+            m_FriendsLocalSimConnector = friendsConn;
+
+            m_log.DebugFormat("[HGFRIENDS HANDLER]: HGFriendsServerPostHandler is On ({0})", 
+                (m_FriendsLocalSimConnector == null ? "robust" : "standalone"));
+
+            if (m_TheService == null)
+                m_log.ErrorFormat("[HGFRIENDS HANDLER]: TheService is null!");
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                string method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "getfriendperms":
+                        return GetFriendPerms(request);
+
+                    case "newfriendship":
+                        return NewFriendship(request);
+
+                    case "deletefriendship":
+                        return DeleteFriendship(request);
+
+                        /* Same as inter-sim */
+                    case "friendship_offered":
+                        return FriendshipOffered(request);
+
+                    case "validate_friendship_offered":
+                        return ValidateFriendshipOffered(request);
+                        
+                    case "statusnotification":
+                        return StatusNotification(request);
+                    /*
+                    case "friendship_approved":
+                        return FriendshipApproved(request);
+                    
+                    case "friendship_denied":
+                        return FriendshipDenied(request);
+                    
+                    case "friendship_terminated":
+                        return FriendshipTerminated(request);
+                    
+                    case "grant_rights":
+                        return GrantRights(request);
+                        */
+                }
+                
+                m_log.DebugFormat("[HGFRIENDS HANDLER]: unknown method {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[HGFRIENDS HANDLER]: Exception {0}", e);
+            }
+
+            return FailureResult();
+        }
+
+        #region Method-specific handlers
+
+        byte[] GetFriendPerms(Dictionary<string, object> request)
+        {
+            if (!VerifyServiceKey(request))
+                return FailureResult();
+
+            UUID principalID = UUID.Zero;
+            if (request.ContainsKey("PRINCIPALID"))
+                UUID.TryParse(request["PRINCIPALID"].ToString(), out principalID);
+            else
+            {
+                m_log.WarnFormat("[HGFRIENDS HANDLER]: no principalID in request to get friend perms");
+                return FailureResult();
+            }
+
+            UUID friendID = UUID.Zero;
+            if (request.ContainsKey("FRIENDID"))
+                UUID.TryParse(request["FRIENDID"].ToString(), out friendID);
+            else
+            {
+                m_log.WarnFormat("[HGFRIENDS HANDLER]: no friendID in request to get friend perms");
+                return FailureResult();
+            }
+
+            int perms = m_TheService.GetFriendPerms(principalID, friendID);
+            if (perms < 0)
+                return FailureResult("Friend not found");
+
+            return SuccessResult(perms.ToString());
+        }
+
+        byte[] NewFriendship(Dictionary<string, object> request)
+        {
+            bool verified = VerifyServiceKey(request);
+
+            FriendInfo friend = new FriendInfo(request);
+
+            bool success = m_TheService.NewFriendship(friend, verified);
+
+            if (success)
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] DeleteFriendship(Dictionary<string, object> request)
+        {
+            FriendInfo friend = new FriendInfo(request);
+            string secret = string.Empty;
+            if (request.ContainsKey("SECRET"))
+                secret = request["SECRET"].ToString();
+
+            if (secret == string.Empty)
+                return BoolResult(false);
+
+            bool success = m_TheService.DeleteFriendship(friend, secret);
+
+            return BoolResult(success);
+        }
+
+        byte[] FriendshipOffered(Dictionary<string, object> request)
+        {
+            UUID fromID = UUID.Zero;
+            UUID toID = UUID.Zero;
+            string message = string.Empty;
+            string name = string.Empty;
+
+            if (!request.ContainsKey("FromID") || !request.ContainsKey("ToID"))
+                return BoolResult(false);
+
+            if (!UUID.TryParse(request["ToID"].ToString(), out toID))
+                return BoolResult(false);
+
+            message = request["Message"].ToString();
+
+            if (!UUID.TryParse(request["FromID"].ToString(), out fromID))
+                return BoolResult(false);
+
+            if (request.ContainsKey("FromName"))
+                name = request["FromName"].ToString();
+
+            bool success = m_TheService.FriendshipOffered(fromID, name, toID, message);
+
+            return BoolResult(success);
+        }
+
+        byte[] ValidateFriendshipOffered(Dictionary<string, object> request)
+        {
+            FriendInfo friend = new FriendInfo(request);
+            UUID friendID = UUID.Zero;
+            if (!UUID.TryParse(friend.Friend, out friendID))
+                return BoolResult(false);
+
+            bool success = m_TheService.ValidateFriendshipOffered(friend.PrincipalID, friendID);
+
+            return BoolResult(success);
+        }
+
+        byte[] StatusNotification(Dictionary<string, object> request)
+        {
+            UUID principalID = UUID.Zero;
+            if (request.ContainsKey("userID"))
+                UUID.TryParse(request["userID"].ToString(), out principalID);
+            else
+            {
+                m_log.WarnFormat("[HGFRIENDS HANDLER]: no userID in request to notify");
+                return FailureResult();
+            }
+
+            bool online = true;
+            if (request.ContainsKey("online"))
+                Boolean.TryParse(request["online"].ToString(), out online);
+            else
+            {
+                m_log.WarnFormat("[HGFRIENDS HANDLER]: no online in request to notify");
+                return FailureResult();
+            }
+
+            List<string> friends = new List<string>();
+            int i = 0;
+            foreach (KeyValuePair<string, object> kvp in request)
+            {
+                if (kvp.Key.Equals("friend_" + i.ToString()))
+                {
+                    friends.Add(kvp.Value.ToString());
+                    i++;
+                }
+            }
+
+            List<UUID> onlineFriends = m_TheService.StatusNotification(friends, principalID, online);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((onlineFriends == null) || ((onlineFriends != null) && (onlineFriends.Count == 0)))
+                result["RESULT"] = "NULL";
+            else
+            {
+                i = 0;
+                foreach (UUID f in onlineFriends)
+                {
+                    result["friend_" + i] = f.ToString();
+                    i++;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        #endregion
+
+        #region Misc
+
+        private bool VerifyServiceKey(Dictionary<string, object> request)
+        {
+            if (!request.ContainsKey("KEY") || !request.ContainsKey("SESSIONID"))
+            {
+                m_log.WarnFormat("[HGFRIENDS HANDLER]: ignoring request without Key or SessionID");
+                return false;
+            }
+
+            if (request["KEY"] == null || request["SESSIONID"] == null)
+                return false;
+
+            string serviceKey = request["KEY"].ToString();
+            string sessionStr = request["SESSIONID"].ToString();
+
+            UUID sessionID;
+            if (!UUID.TryParse(sessionStr, out sessionID) || serviceKey == string.Empty)
+                return false;
+
+            if (!m_UserAgentService.VerifyAgent(sessionID, serviceKey))
+            {
+                m_log.WarnFormat("[HGFRIENDS HANDLER]: Key {0} for session {1} did not match existing key. Ignoring request", serviceKey, sessionID);
+                return false;
+            }
+
+            m_log.DebugFormat("[HGFRIENDS HANDLER]: Verification ok");
+            return true;
+        }
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] SuccessResult(string value)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "RESULT", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            XmlElement message = doc.CreateElement("", "Value", "");
+            message.AppendChild(doc.CreateTextNode(value));
+
+            rootElement.AppendChild(message);
+
+            return Util.DocToBytes(doc);
+        }
+
+
+        private byte[] FailureResult()
+        {
+            return FailureResult(String.Empty);
+        }
+
+        private byte[] FailureResult(string msg)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "RESULT", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            XmlElement message = doc.CreateElement("", "Message", "");
+            message.AppendChild(doc.CreateTextNode(msg));
+
+            rootElement.AppendChild(message);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] BoolResult(bool value)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "RESULT", "");
+            result.AppendChild(doc.CreateTextNode(value.ToString()));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/HeloServerConnector.cs b/OpenSim/Server/Handlers/Hypergrid/HeloServerConnector.cs
new file mode 100644
index 0000000..dac4ca8
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/HeloServerConnector.cs
@@ -0,0 +1,113 @@
+/*
+ * 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.Net;
+using System.Reflection;
+using Nini.Config;
+using log4net;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class HeloServiceInConnector : ServiceConnector
+    {
+        public HeloServiceInConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+#pragma warning disable 0612
+            server.AddStreamHandler(new HeloServerGetHandler("opensim-robust"));
+#pragma warning restore 0612
+            server.AddStreamHandler(new HeloServerHeadHandler("opensim-robust"));
+        }
+    }
+
+    [Obsolete]
+    public class HeloServerGetHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_HandlersType;
+
+        public HeloServerGetHandler(string handlersType) :
+            base("GET", "/helo")
+        {
+            m_HandlersType = handlersType;
+        }
+
+        public override byte[] Handle(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            return OKResponse(httpResponse);
+        }
+
+        private byte[] OKResponse(IOSHttpResponse httpResponse)
+        {
+            m_log.Debug("[HELO]: hi, GET was called");
+            httpResponse.AddHeader("X-Handlers-Provided", m_HandlersType);
+            httpResponse.StatusCode = (int)HttpStatusCode.OK;
+            httpResponse.StatusDescription = "OK";
+            return new byte[0];
+        }
+
+    }
+
+    public class HeloServerHeadHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_HandlersType;
+
+        public HeloServerHeadHandler(string handlersType) :
+            base("HEAD", "/helo")
+        {
+            m_HandlersType = handlersType;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            return OKResponse(httpResponse);
+        }
+
+        private byte[] OKResponse(IOSHttpResponse httpResponse)
+        {
+            m_log.Debug("[HELO]: hi, HEAD was called");
+            httpResponse.AddHeader("X-Handlers-Provided", m_HandlersType);
+            httpResponse.StatusCode = (int)HttpStatusCode.OK;
+            httpResponse.StatusDescription = "OK";
+            return new byte[0];
+        }
+
+    }
+
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/HomeAgentHandlers.cs b/OpenSim/Server/Handlers/Hypergrid/HomeAgentHandlers.cs
new file mode 100644
index 0000000..e787f7c
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/HomeAgentHandlers.cs
@@ -0,0 +1,137 @@
+/*
+ * 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;
+using System.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Simulation;
+using Utils = OpenSim.Server.Handlers.Simulation.Utils;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class HomeAgentHandler : AgentPostHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private IUserAgentService m_UserAgentService;
+
+        private string m_LoginServerIP;
+
+        public HomeAgentHandler(IUserAgentService userAgentService, string loginServerIP, bool proxy) :
+            base("/homeagent")
+        {
+            m_UserAgentService = userAgentService;
+            m_LoginServerIP = loginServerIP;
+            m_Proxy = proxy;
+        }
+
+        protected override AgentDestinationData CreateAgentDestinationData()
+        {
+            return new ExtendedAgentDestinationData();
+        }
+
+        protected override void UnpackData(OSDMap args, AgentDestinationData d, Hashtable request)
+        {
+            base.UnpackData(args, d, request);
+            ExtendedAgentDestinationData data = (ExtendedAgentDestinationData)d;
+            try
+            {
+                if (args.ContainsKey("gatekeeper_host") && args["gatekeeper_host"] != null)
+                    data.host = args["gatekeeper_host"].AsString();
+                if (args.ContainsKey("gatekeeper_port") && args["gatekeeper_port"] != null)
+                    Int32.TryParse(args["gatekeeper_port"].AsString(), out data.port);
+                if (args.ContainsKey("gatekeeper_serveruri") && args["gatekeeper_serveruri"] != null)
+                    data.gatekeeperServerURI = args["gatekeeper_serveruri"];
+                if (args.ContainsKey("destination_serveruri") && args["destination_serveruri"] != null)
+                    data.destinationServerURI = args["destination_serveruri"];
+
+            }
+            catch (InvalidCastException)
+            {
+                m_log.ErrorFormat("[HOME AGENT HANDLER]: Bad cast in UnpackData");
+            }
+
+            string callerIP = GetCallerIP(request);
+            // Verify if this call came from the login server
+            if (callerIP == m_LoginServerIP)
+                data.fromLogin = true;
+
+        }
+
+        protected override GridRegion ExtractGatekeeper(AgentDestinationData d)
+        {
+            if (d is ExtendedAgentDestinationData)
+            {
+                ExtendedAgentDestinationData data = (ExtendedAgentDestinationData)d;
+                GridRegion gatekeeper = new GridRegion();
+                gatekeeper.ServerURI = data.gatekeeperServerURI;
+                gatekeeper.ExternalHostName = data.host;
+                gatekeeper.HttpPort = (uint)data.port;
+                gatekeeper.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 0);
+
+                return gatekeeper;
+            }
+            else
+                m_log.WarnFormat("[HOME AGENT HANDLER]: Wrong data type");
+
+            return null;
+        }
+
+
+        protected override bool CreateAgent(GridRegion source, GridRegion gatekeeper, GridRegion destination,
+            AgentCircuitData aCircuit, uint teleportFlags, bool fromLogin, out string reason)
+        {
+            return m_UserAgentService.LoginAgentToGrid(source, aCircuit, gatekeeper, destination, fromLogin, out reason);
+        }
+
+    }
+
+    public class ExtendedAgentDestinationData : AgentDestinationData
+    {
+        public string host;
+        public int port;
+        public string gatekeeperServerURI;
+        public string destinationServerURI;
+
+    }
+
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/HypergridHandlers.cs b/OpenSim/Server/Handlers/Hypergrid/HypergridHandlers.cs
new file mode 100644
index 0000000..c7ac9be
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/HypergridHandlers.cs
@@ -0,0 +1,136 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using log4net;
+using Nwc.XmlRpc;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class HypergridHandlers
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IGatekeeperService m_GatekeeperService;
+
+        public HypergridHandlers(IGatekeeperService gatekeeper)
+        {
+            m_GatekeeperService = gatekeeper;
+            m_log.DebugFormat("[HYPERGRID HANDLERS]: Active");
+        }
+
+        /// <summary>
+        /// Someone wants to link to us
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public XmlRpcResponse LinkRegionRequest(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            string name = (string)requestData["region_name"];
+            if (name == null)
+                name = string.Empty;
+
+            UUID regionID = UUID.Zero;
+            string externalName = string.Empty;
+            string imageURL = string.Empty;
+            ulong regionHandle = 0;
+            string reason = string.Empty;
+
+            bool success = m_GatekeeperService.LinkRegion(name, out regionID, out regionHandle, out externalName, out imageURL, out reason);
+
+            Hashtable hash = new Hashtable();
+            hash["result"] = success.ToString();
+            hash["uuid"] = regionID.ToString();
+            hash["handle"] = regionHandle.ToString();
+            hash["region_image"] = imageURL;
+            hash["external_name"] = externalName;
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+        }
+
+        public XmlRpcResponse GetRegion(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            string regionID_str = (string)requestData["region_uuid"];
+            UUID regionID = UUID.Zero;
+            UUID.TryParse(regionID_str, out regionID);
+
+            UUID agentID = UUID.Zero;
+            string agentHomeURI = null;
+            if (requestData.ContainsKey("agent_id"))
+                agentID = UUID.Parse((string)requestData["agent_id"]);
+            if (requestData.ContainsKey("agent_home_uri"))
+                agentHomeURI = (string)requestData["agent_home_uri"];
+
+            string message;
+            GridRegion regInfo = m_GatekeeperService.GetHyperlinkRegion(regionID, agentID, agentHomeURI, out message);
+
+            Hashtable hash = new Hashtable();
+            if (regInfo == null)
+            {
+                hash["result"] = "false";
+            }
+            else
+            {
+                hash["result"] = "true";
+                hash["uuid"] = regInfo.RegionID.ToString();
+                hash["x"] = regInfo.RegionLocX.ToString();
+                hash["y"] = regInfo.RegionLocY.ToString();
+                hash["size_x"] = regInfo.RegionSizeX.ToString();
+                hash["size_y"] = regInfo.RegionSizeY.ToString();
+                hash["region_name"] = regInfo.RegionName;
+                hash["hostname"] = regInfo.ExternalHostName;
+                hash["http_port"] = regInfo.HttpPort.ToString();
+                hash["internal_port"] = regInfo.InternalEndPoint.Port.ToString();
+            }
+
+            if (message != null)
+                hash["message"] = message;
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/InstantMessageServerConnector.cs b/OpenSim/Server/Handlers/Hypergrid/InstantMessageServerConnector.cs
new file mode 100644
index 0000000..8145a21
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/InstantMessageServerConnector.cs
@@ -0,0 +1,248 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using log4net;
+using Nwc.XmlRpc;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class InstantMessageServerConnector : ServiceConnector
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IInstantMessage m_IMService;
+
+        public InstantMessageServerConnector(IConfigSource config, IHttpServer server) :
+            this(config, server, (IInstantMessageSimConnector)null)
+        {            
+        }
+
+        public InstantMessageServerConnector(IConfigSource config, IHttpServer server, string configName) :
+            this(config, server)
+        {
+        }
+
+        public InstantMessageServerConnector(IConfigSource config, IHttpServer server, IInstantMessageSimConnector simConnector) :
+                base(config, server, String.Empty)
+        {
+            IConfig gridConfig = config.Configs["HGInstantMessageService"];
+            if (gridConfig != null)
+            {
+                string serviceDll = gridConfig.GetString("LocalServiceModule", string.Empty);
+
+                Object[] args = new Object[] { config, simConnector };
+                m_IMService = ServerUtils.LoadPlugin<IInstantMessage>(serviceDll, args);
+            }
+            if (m_IMService == null)
+                throw new Exception("InstantMessage server connector cannot proceed because of missing service");
+
+            server.AddXmlRPCHandler("grid_instant_message", ProcessInstantMessage, false);
+
+        }
+
+        public IInstantMessage GetService()
+        {
+            return m_IMService;
+        }
+
+        protected virtual XmlRpcResponse ProcessInstantMessage(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            bool successful = false;
+
+            try
+            {
+                // various rational defaults
+                UUID fromAgentID = UUID.Zero;
+                UUID toAgentID = UUID.Zero;
+                UUID imSessionID = UUID.Zero;
+                uint timestamp = 0;
+                string fromAgentName = "";
+                string message = "";
+                byte dialog = (byte)0;
+                bool fromGroup = false;
+                byte offline = (byte)0;
+                uint ParentEstateID = 0;
+                Vector3 Position = Vector3.Zero;
+                UUID RegionID = UUID.Zero;
+                byte[] binaryBucket = new byte[0];
+
+                float pos_x = 0;
+                float pos_y = 0;
+                float pos_z = 0;
+                //m_log.Info("Processing IM");
+
+
+                Hashtable requestData = (Hashtable)request.Params[0];
+                // Check if it's got all the data
+                if (requestData.ContainsKey("from_agent_id")
+                        && requestData.ContainsKey("to_agent_id") && requestData.ContainsKey("im_session_id")
+                        && requestData.ContainsKey("timestamp") && requestData.ContainsKey("from_agent_name")
+                        && requestData.ContainsKey("message") && requestData.ContainsKey("dialog")
+                        && requestData.ContainsKey("from_group")
+                        && requestData.ContainsKey("offline") && requestData.ContainsKey("parent_estate_id")
+                        && requestData.ContainsKey("position_x") && requestData.ContainsKey("position_y")
+                        && requestData.ContainsKey("position_z") && requestData.ContainsKey("region_id")
+                        && requestData.ContainsKey("binary_bucket"))
+                {
+                    // Do the easy way of validating the UUIDs
+                    UUID.TryParse((string)requestData["from_agent_id"], out fromAgentID);
+                    UUID.TryParse((string)requestData["to_agent_id"], out toAgentID);
+                    UUID.TryParse((string)requestData["im_session_id"], out imSessionID);
+                    UUID.TryParse((string)requestData["region_id"], out RegionID);
+                    try
+                    {
+                        timestamp = (uint)Convert.ToInt32((string)requestData["timestamp"]);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+
+                    fromAgentName = (string)requestData["from_agent_name"];
+                    message = (string)requestData["message"];
+                    if (message == null)
+                        message = string.Empty;
+
+                    // Bytes don't transfer well over XMLRPC, so, we Base64 Encode them.
+                    string requestData1 = (string)requestData["dialog"];
+                    if (string.IsNullOrEmpty(requestData1))
+                    {
+                        dialog = 0;
+                    }
+                    else
+                    {
+                        byte[] dialogdata = Convert.FromBase64String(requestData1);
+                        dialog = dialogdata[0];
+                    }
+
+                    if ((string)requestData["from_group"] == "TRUE")
+                        fromGroup = true;
+
+                    string requestData2 = (string)requestData["offline"];
+                    if (String.IsNullOrEmpty(requestData2))
+                    {
+                        offline = 0;
+                    }
+                    else
+                    {
+                        byte[] offlinedata = Convert.FromBase64String(requestData2);
+                        offline = offlinedata[0];
+                    }
+
+                    try
+                    {
+                        ParentEstateID = (uint)Convert.ToInt32((string)requestData["parent_estate_id"]);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+
+                    float.TryParse((string)requestData["position_x"], out pos_x);
+                    float.TryParse((string)requestData["position_y"], out pos_y);
+                    float.TryParse((string)requestData["position_z"], out pos_z);
+
+                    Position = new Vector3(pos_x, pos_y, pos_z);
+
+                    string requestData3 = (string)requestData["binary_bucket"];
+                    if (string.IsNullOrEmpty(requestData3))
+                    {
+                        binaryBucket = new byte[0];
+                    }
+                    else
+                    {
+                        binaryBucket = Convert.FromBase64String(requestData3);
+                    }
+
+                    // Create a New GridInstantMessageObject the the data
+                    GridInstantMessage gim = new GridInstantMessage();
+                    gim.fromAgentID = fromAgentID.Guid;
+                    gim.fromAgentName = fromAgentName;
+                    gim.fromGroup = fromGroup;
+                    gim.imSessionID = imSessionID.Guid;
+                    gim.RegionID = RegionID.Guid;
+                    gim.timestamp = timestamp;
+                    gim.toAgentID = toAgentID.Guid;
+                    gim.message = message;
+                    gim.dialog = dialog;
+                    gim.offline = offline;
+                    gim.ParentEstateID = ParentEstateID;
+                    gim.Position = Position;
+                    gim.binaryBucket = binaryBucket;
+
+                    successful = m_IMService.IncomingInstantMessage(gim);
+
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[INSTANT MESSAGE]: Caught unexpected exception:", e);
+                successful = false;
+            }
+
+            //Send response back to region calling if it was successful
+            // calling region uses this to know when to look up a user's location again.
+            XmlRpcResponse resp = new XmlRpcResponse();
+            Hashtable respdata = new Hashtable();
+            if (successful)
+                respdata["success"] = "TRUE";
+            else
+                respdata["success"] = "FALSE";
+            resp.Value = respdata;
+
+            return resp;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Hypergrid/UserAgentServerConnector.cs b/OpenSim/Server/Handlers/Hypergrid/UserAgentServerConnector.cs
new file mode 100644
index 0000000..e112e0e
--- /dev/null
+++ b/OpenSim/Server/Handlers/Hypergrid/UserAgentServerConnector.cs
@@ -0,0 +1,488 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using log4net;
+using Nwc.XmlRpc;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Hypergrid
+{
+    public class UserAgentServerConnector : ServiceConnector
+    {
+//        private static readonly ILog m_log =
+//                LogManager.GetLogger(
+//                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IUserAgentService m_HomeUsersService;
+        public IUserAgentService HomeUsersService
+        {
+            get { return m_HomeUsersService; }
+        }
+
+        private string[] m_AuthorizedCallers;
+
+        private bool m_VerifyCallers = false;
+
+        public UserAgentServerConnector(IConfigSource config, IHttpServer server) :
+            this(config, server, (IFriendsSimConnector)null)
+        {            
+        }
+
+        public UserAgentServerConnector(IConfigSource config, IHttpServer server, string configName) :
+            this(config, server)
+        {
+        }
+        
+        public UserAgentServerConnector(IConfigSource config, IHttpServer server, IFriendsSimConnector friendsConnector) :
+                base(config, server, String.Empty)
+        {
+            IConfig gridConfig = config.Configs["UserAgentService"];
+            if (gridConfig != null)
+            {
+                string serviceDll = gridConfig.GetString("LocalServiceModule", string.Empty);
+
+                Object[] args = new Object[] { config, friendsConnector };
+                m_HomeUsersService = ServerUtils.LoadPlugin<IUserAgentService>(serviceDll, args);
+            }
+            if (m_HomeUsersService == null)
+                throw new Exception("UserAgent server connector cannot proceed because of missing service");
+
+            string loginServerIP = gridConfig.GetString("LoginServerIP", "127.0.0.1");
+            bool proxy = gridConfig.GetBoolean("HasProxy", false);
+
+            m_VerifyCallers = gridConfig.GetBoolean("VerifyCallers", false);
+            string csv = gridConfig.GetString("AuthorizedCallers", "127.0.0.1");
+            csv = csv.Replace(" ", "");
+            m_AuthorizedCallers = csv.Split(',');
+
+            server.AddXmlRPCHandler("agent_is_coming_home", AgentIsComingHome, false);
+            server.AddXmlRPCHandler("get_home_region", GetHomeRegion, false);
+            server.AddXmlRPCHandler("verify_agent", VerifyAgent, false);
+            server.AddXmlRPCHandler("verify_client", VerifyClient, false);
+            server.AddXmlRPCHandler("logout_agent", LogoutAgent, false);
+
+#pragma warning disable 0612
+            server.AddXmlRPCHandler("status_notification", StatusNotification, false);
+            server.AddXmlRPCHandler("get_online_friends", GetOnlineFriends, false);
+#pragma warning restore 0612
+            server.AddXmlRPCHandler("get_user_info", GetUserInfo, false);
+            server.AddXmlRPCHandler("get_server_urls", GetServerURLs, false);
+
+            server.AddXmlRPCHandler("locate_user", LocateUser, false);
+            server.AddXmlRPCHandler("get_uui", GetUUI, false);
+            server.AddXmlRPCHandler("get_uuid", GetUUID, false);
+
+            server.AddStreamHandler(new HomeAgentHandler(m_HomeUsersService, loginServerIP, proxy));
+        }
+
+        public XmlRpcResponse GetHomeRegion(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            string userID_str = (string)requestData["userID"];
+            UUID userID = UUID.Zero;
+            UUID.TryParse(userID_str, out userID);
+
+            Vector3 position = Vector3.UnitY, lookAt = Vector3.UnitY;
+            GridRegion regInfo = m_HomeUsersService.GetHomeRegion(userID, out position, out lookAt);
+
+            Hashtable hash = new Hashtable();
+            if (regInfo == null)
+                hash["result"] = "false";
+            else
+            {
+                hash["result"] = "true";
+                hash["uuid"] = regInfo.RegionID.ToString();
+                hash["x"] = regInfo.RegionLocX.ToString();
+                hash["y"] = regInfo.RegionLocY.ToString();
+                hash["size_x"] = regInfo.RegionSizeX.ToString();
+                hash["size_y"] = regInfo.RegionSizeY.ToString();
+                hash["region_name"] = regInfo.RegionName;
+                hash["hostname"] = regInfo.ExternalHostName;
+                hash["http_port"] = regInfo.HttpPort.ToString();
+                hash["internal_port"] = regInfo.InternalEndPoint.Port.ToString();
+                hash["position"] = position.ToString();
+                hash["lookAt"] = lookAt.ToString();
+            }
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        public XmlRpcResponse AgentIsComingHome(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            string sessionID_str = (string)requestData["sessionID"];
+            UUID sessionID = UUID.Zero;
+            UUID.TryParse(sessionID_str, out sessionID);
+            string gridName = (string)requestData["externalName"];
+
+            bool success = m_HomeUsersService.IsAgentComingHome(sessionID, gridName);
+
+            Hashtable hash = new Hashtable();
+            hash["result"] = success.ToString();
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        public XmlRpcResponse VerifyAgent(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            string sessionID_str = (string)requestData["sessionID"];
+            UUID sessionID = UUID.Zero;
+            UUID.TryParse(sessionID_str, out sessionID);
+            string token = (string)requestData["token"];
+
+            bool success = m_HomeUsersService.VerifyAgent(sessionID, token);
+
+            Hashtable hash = new Hashtable();
+            hash["result"] = success.ToString();
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        public XmlRpcResponse VerifyClient(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            string sessionID_str = (string)requestData["sessionID"];
+            UUID sessionID = UUID.Zero;
+            UUID.TryParse(sessionID_str, out sessionID);
+            string token = (string)requestData["token"];
+
+            bool success = m_HomeUsersService.VerifyClient(sessionID, token);
+
+            Hashtable hash = new Hashtable();
+            hash["result"] = success.ToString();
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        public XmlRpcResponse LogoutAgent(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            string sessionID_str = (string)requestData["sessionID"];
+            UUID sessionID = UUID.Zero;
+            UUID.TryParse(sessionID_str, out sessionID);
+            string userID_str = (string)requestData["userID"];
+            UUID userID = UUID.Zero;
+            UUID.TryParse(userID_str, out userID);
+
+            m_HomeUsersService.LogoutAgent(userID, sessionID);
+
+            Hashtable hash = new Hashtable();
+            hash["result"] = "true";
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        [Obsolete]
+        public XmlRpcResponse StatusNotification(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable hash = new Hashtable();
+            hash["result"] = "false";
+
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            if (requestData.ContainsKey("userID") && requestData.ContainsKey("online"))
+            {
+                string userID_str = (string)requestData["userID"];
+                UUID userID = UUID.Zero;
+                UUID.TryParse(userID_str, out userID);
+                List<string> ids = new List<string>();
+                foreach (object key in requestData.Keys)
+                {
+                    if (key is string && ((string)key).StartsWith("friend_") && requestData[key] != null)
+                        ids.Add(requestData[key].ToString());
+                }
+                bool online = false;
+                bool.TryParse(requestData["online"].ToString(), out online);
+
+                // let's spawn a thread for this, because it may take a long time...
+                List<UUID> friendsOnline = m_HomeUsersService.StatusNotification(ids, userID, online);
+                if (friendsOnline.Count > 0)
+                {
+                    int i = 0;
+                    foreach (UUID id in friendsOnline)
+                    {
+                        hash["friend_" + i.ToString()] = id.ToString();
+                        i++;
+                    }
+                }
+                else
+                    hash["result"] = "No Friends Online";
+
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        [Obsolete]
+        public XmlRpcResponse GetOnlineFriends(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable hash = new Hashtable();
+
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            if (requestData.ContainsKey("userID"))
+            {
+                string userID_str = (string)requestData["userID"];
+                UUID userID = UUID.Zero;
+                UUID.TryParse(userID_str, out userID);
+                List<string> ids = new List<string>();
+                foreach (object key in requestData.Keys)
+                {
+                    if (key is string && ((string)key).StartsWith("friend_") && requestData[key] != null)
+                        ids.Add(requestData[key].ToString());
+                }
+
+                //List<UUID> online = m_HomeUsersService.GetOnlineFriends(userID, ids);
+                //if (online.Count > 0)
+                //{
+                //    int i = 0;
+                //    foreach (UUID id in online)
+                //    {
+                //        hash["friend_" + i.ToString()] = id.ToString();
+                //        i++;
+                //    }
+                //}
+                //else
+                //    hash["result"] = "No Friends Online";
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        public XmlRpcResponse GetUserInfo(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable hash = new Hashtable();
+            Hashtable requestData = (Hashtable)request.Params[0];
+
+            // This needs checking!
+            if (requestData.ContainsKey("userID"))
+            {
+                string userID_str = (string)requestData["userID"];
+                UUID userID = UUID.Zero;
+                UUID.TryParse(userID_str, out userID);
+
+                //int userFlags = m_HomeUsersService.GetUserFlags(userID);
+                Dictionary<string,object> userInfo = m_HomeUsersService.GetUserInfo(userID);
+                if (userInfo.Count > 0)
+                {
+                    foreach (KeyValuePair<string, object> kvp in userInfo)
+                    {
+                        hash[kvp.Key] = kvp.Value;
+                    }
+                }
+                else
+                {
+                    hash["result"] = "failure";
+                }
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+        }
+
+        public XmlRpcResponse GetServerURLs(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable hash = new Hashtable();
+
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            if (requestData.ContainsKey("userID"))
+            {
+                string userID_str = (string)requestData["userID"];
+                UUID userID = UUID.Zero;
+                UUID.TryParse(userID_str, out userID);
+
+                Dictionary<string, object> serverURLs = m_HomeUsersService.GetServerURLs(userID);
+                if (serverURLs.Count > 0)
+                {
+                    foreach (KeyValuePair<string, object> kvp in serverURLs)
+                        hash["SRV_" + kvp.Key] = kvp.Value.ToString();
+                }
+                else
+                    hash["result"] = "No Service URLs";
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        /// <summary>
+        /// Locates the user.
+        /// This is a sensitive operation, only authorized IP addresses can perform it.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="remoteClient"></param>
+        /// <returns></returns>
+        public XmlRpcResponse LocateUser(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable hash = new Hashtable();
+
+            bool authorized = true;
+            if (m_VerifyCallers)
+            {
+                authorized = false;
+                foreach (string s in m_AuthorizedCallers)
+                    if (s == remoteClient.Address.ToString())
+                    {
+                        authorized = true;
+                        break;
+                    }
+            }
+
+            if (authorized)
+            {
+                Hashtable requestData = (Hashtable)request.Params[0];
+                //string host = (string)requestData["host"];
+                //string portstr = (string)requestData["port"];
+                if (requestData.ContainsKey("userID"))
+                {
+                    string userID_str = (string)requestData["userID"];
+                    UUID userID = UUID.Zero;
+                    UUID.TryParse(userID_str, out userID);
+
+                    string url = m_HomeUsersService.LocateUser(userID);
+                    if (url != string.Empty)
+                        hash["URL"] = url;
+                    else
+                        hash["result"] = "Unable to locate user";
+                }
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+
+        }
+
+        /// <summary>
+        /// Returns the UUI of a user given a UUID.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="remoteClient"></param>
+        /// <returns></returns>
+        public XmlRpcResponse GetUUI(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable hash = new Hashtable();
+
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            if (requestData.ContainsKey("userID") && requestData.ContainsKey("targetUserID"))
+            {
+                string userID_str = (string)requestData["userID"];
+                UUID userID = UUID.Zero;
+                UUID.TryParse(userID_str, out userID);
+
+                string tuserID_str = (string)requestData["targetUserID"];
+                UUID targetUserID = UUID.Zero;
+                UUID.TryParse(tuserID_str, out targetUserID);
+                string uui = m_HomeUsersService.GetUUI(userID, targetUserID);
+                if (uui != string.Empty)
+                    hash["UUI"] = uui;
+                else
+                    hash["result"] = "User unknown";
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+        }
+
+        /// <summary>
+        /// Gets the UUID of a user given First name, Last name.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="remoteClient"></param>
+        /// <returns></returns>
+        public XmlRpcResponse GetUUID(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable hash = new Hashtable();
+
+            Hashtable requestData = (Hashtable)request.Params[0];
+            //string host = (string)requestData["host"];
+            //string portstr = (string)requestData["port"];
+            if (requestData.ContainsKey("first") && requestData.ContainsKey("last"))
+            {
+                string first = (string)requestData["first"];
+                string last = (string)requestData["last"];
+                UUID uuid = m_HomeUsersService.GetUUID(first, last);
+                hash["UUID"] = uuid.ToString();
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/Inventory/InventoryServerInConnector.cs b/OpenSim/Server/Handlers/Inventory/InventoryServerInConnector.cs
new file mode 100644
index 0000000..b295446
--- /dev/null
+++ b/OpenSim/Server/Handlers/Inventory/InventoryServerInConnector.cs
@@ -0,0 +1,330 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Inventory
+{
+    public class InventoryServiceInConnector : ServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected IInventoryService m_InventoryService;
+
+        private bool m_doLookup = false;
+
+        //private static readonly int INVENTORY_DEFAULT_SESSION_TIME = 30; // secs
+        //private AuthedSessionCache m_session_cache = new AuthedSessionCache(INVENTORY_DEFAULT_SESSION_TIME);
+
+        private string m_userserver_url;
+        protected string m_ConfigName = "InventoryService";
+
+        public InventoryServiceInConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != string.Empty)
+                m_ConfigName = configName;
+    
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string inventoryService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (inventoryService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_InventoryService =
+                    ServerUtils.LoadPlugin<IInventoryService>(inventoryService, args);
+
+            m_userserver_url = serverConfig.GetString("UserServerURI", String.Empty);
+            m_doLookup = serverConfig.GetBoolean("SessionAuthentication", false);
+
+            AddHttpHandlers(server);
+            m_log.Debug("[INVENTORY HANDLER]: handlers initialized");
+        }
+
+        protected virtual void AddHttpHandlers(IHttpServer m_httpServer)
+        {
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<Guid, List<InventoryFolderBase>>(
+                "POST", "/SystemFolders/", GetSystemFolders, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<Guid, InventoryCollection>(
+                "POST", "/GetFolderContent/", GetFolderContent, CheckAuthSession));
+            
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
+                    "POST", "/UpdateFolder/", m_InventoryService.UpdateFolder, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
+                    "POST", "/MoveFolder/", m_InventoryService.MoveFolder, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
+                    "POST", "/PurgeFolder/", m_InventoryService.PurgeFolder, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<List<Guid>, bool>(
+                    "POST", "/DeleteFolders/", DeleteFolders, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<List<Guid>, bool>(
+                    "POST", "/DeleteItem/", DeleteItems, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryItemBase, InventoryItemBase>(
+                    "POST", "/QueryItem/", m_InventoryService.GetItem, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryFolderBase, InventoryFolderBase>(
+                    "POST", "/QueryFolder/", m_InventoryService.GetFolder, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseTrustedHandler<Guid, bool>(
+                    "POST", "/CreateInventory/", CreateUsersInventory, CheckTrustSource));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
+                    "POST", "/NewFolder/", m_InventoryService.AddFolder, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
+                    "POST", "/CreateFolder/", m_InventoryService.AddFolder, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
+                    "POST", "/NewItem/", m_InventoryService.AddItem, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+             new RestDeserialiseTrustedHandler<InventoryItemBase, bool>(
+                 "POST", "/AddNewItem/", m_InventoryService.AddItem, CheckTrustSource));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<Guid, List<InventoryItemBase>>(
+                    "POST", "/GetItems/", GetFolderItems, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseSecureHandler<List<InventoryItemBase>, bool>(
+                    "POST", "/MoveItems/", MoveItems, CheckAuthSession));
+
+            m_httpServer.AddStreamHandler(new InventoryServerMoveItemsHandler(m_InventoryService));
+
+            
+            // for persistent active gestures
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>>
+                    ("POST", "/ActiveGestures/", GetActiveGestures, CheckTrustSource));
+
+            // WARNING: Root folders no longer just delivers the root and immediate child folders (e.g
+            // system folders such as Objects, Textures), but it now returns the entire inventory skeleton.
+            // It would have been better to rename this request, but complexities in the BaseHttpServer
+            // (e.g. any http request not found is automatically treated as an xmlrpc request) make it easier
+            // to do this for now.
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseTrustedHandler<Guid, List<InventoryFolderBase>>
+                    ("POST", "/RootFolders/", GetInventorySkeleton, CheckTrustSource));
+
+            m_httpServer.AddStreamHandler(
+                new RestDeserialiseTrustedHandler<InventoryItemBase, int>
+                ("POST", "/AssetPermissions/", GetAssetPermissions, CheckTrustSource));
+
+        }
+
+        #region Wrappers for converting the Guid parameter
+
+        public List<InventoryFolderBase> GetSystemFolders(Guid guid)
+        {
+            UUID userID = new UUID(guid);
+            return new List<InventoryFolderBase>(GetSystemFolders(userID).Values);
+        }
+
+        // This shouldn't be here, it should be in the inventory service.
+        // But I don't want to deal with types and dependencies for now.
+        private Dictionary<AssetType, InventoryFolderBase> GetSystemFolders(UUID userID)
+        {
+            InventoryFolderBase root = m_InventoryService.GetRootFolder(userID);
+            if (root != null)
+            {
+                InventoryCollection content = m_InventoryService.GetFolderContent(userID, root.ID);
+                if (content != null)
+                {
+                    Dictionary<AssetType, InventoryFolderBase> folders = new Dictionary<AssetType, InventoryFolderBase>();
+                    foreach (InventoryFolderBase folder in content.Folders)
+                    {
+                        if ((folder.Type != (short)AssetType.Folder) && (folder.Type != (short)AssetType.Unknown))
+                            folders[(AssetType)folder.Type] = folder;
+                    }
+                    // Put the root folder there, as type Folder
+                    folders[AssetType.Folder] = root;
+                    return folders;
+                }
+            }
+            m_log.WarnFormat("[INVENTORY SERVICE]: System folders for {0} not found", userID);
+            return new Dictionary<AssetType, InventoryFolderBase>();
+        }
+
+        public InventoryCollection GetFolderContent(Guid guid)
+        {
+            return m_InventoryService.GetFolderContent(UUID.Zero, new UUID(guid));
+        }
+
+        public List<InventoryItemBase> GetFolderItems(Guid folderID)
+        {
+            List<InventoryItemBase> allItems = new List<InventoryItemBase>();
+
+            // TODO: UUID.Zero is passed as the userID here, making the old assumption that the OpenSim
+            // inventory server only has a single inventory database and not per-user inventory databases.
+            // This could be changed but it requirs a bit of hackery to pass another parameter into this
+            // callback
+            List<InventoryItemBase> items = m_InventoryService.GetFolderItems(UUID.Zero, new UUID(folderID));
+
+            if (items != null)
+            {
+                allItems.InsertRange(0, items);
+            }
+            return allItems;
+        }
+
+        public bool CreateUsersInventory(Guid rawUserID)
+        {
+            UUID userID = new UUID(rawUserID);
+
+
+            return m_InventoryService.CreateUserInventory(userID);
+        }
+
+        public List<InventoryItemBase> GetActiveGestures(Guid rawUserID)
+        {
+            UUID userID = new UUID(rawUserID);
+
+            return m_InventoryService.GetActiveGestures(userID);
+        }
+
+        public List<InventoryFolderBase> GetInventorySkeleton(Guid rawUserID)
+        {
+            UUID userID = new UUID(rawUserID);
+            return m_InventoryService.GetInventorySkeleton(userID);
+        }
+
+        public int GetAssetPermissions(InventoryItemBase item)
+        {
+            return m_InventoryService.GetAssetPermissions(item.Owner, item.AssetID);
+        }
+
+        public bool DeleteFolders(List<Guid> items)
+        {
+            List<UUID> uuids = new List<UUID>();
+            foreach (Guid g in items)
+                uuids.Add(new UUID(g));
+            // oops we lost the user info here. Bad bad handlers
+            return m_InventoryService.DeleteFolders(UUID.Zero, uuids);
+        }
+
+        public bool DeleteItems(List<Guid> items)
+        {
+            List<UUID> uuids = new List<UUID>();
+            foreach (Guid g in items)
+                uuids.Add(new UUID(g));
+            // oops we lost the user info here. Bad bad handlers
+            return m_InventoryService.DeleteItems(UUID.Zero, uuids);
+        }
+
+        public bool MoveItems(List<InventoryItemBase> items)
+        {
+            // oops we lost the user info here. Bad bad handlers
+            // let's peek at one item
+            UUID ownerID = UUID.Zero;
+            if (items.Count > 0)
+                ownerID = items[0].Owner;
+            return m_InventoryService.MoveItems(ownerID, items);
+        }
+        #endregion
+
+        /// <summary>
+        /// Check that the source of an inventory request is one that we trust.
+        /// </summary>
+        /// <param name="peer"></param>
+        /// <returns></returns>
+        public bool CheckTrustSource(IPEndPoint peer)
+        {
+            if (m_doLookup)
+            {
+                m_log.InfoFormat("[INVENTORY IN CONNECTOR]: Checking trusted source {0}", peer);
+                UriBuilder ub = new UriBuilder(m_userserver_url);
+                IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
+                foreach (IPAddress uaddr in uaddrs)
+                {
+                    if (uaddr.Equals(peer.Address))
+                    {
+                        return true;
+                    }
+                }
+
+                m_log.WarnFormat(
+                    "[INVENTORY IN CONNECTOR]: Rejecting request since source {0} was not in the list of trusted sources",
+                    peer);
+
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Check that the source of an inventory request for a particular agent is a current session belonging to
+        /// that agent.
+        /// </summary>
+        /// <param name="session_id"></param>
+        /// <param name="avatar_id"></param>
+        /// <returns></returns>
+        public virtual bool CheckAuthSession(string session_id, string avatar_id)
+        {
+            return true;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Inventory/InventoryServerMoveItemsHandler.cs b/OpenSim/Server/Handlers/Inventory/InventoryServerMoveItemsHandler.cs
new file mode 100644
index 0000000..e2c50fe
--- /dev/null
+++ b/OpenSim/Server/Handlers/Inventory/InventoryServerMoveItemsHandler.cs
@@ -0,0 +1,81 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Inventory
+{
+    public class InventoryServerMoveItemsHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IInventoryService m_InventoryService;
+
+        public InventoryServerMoveItemsHandler(IInventoryService service) :
+                base("PUT", "/inventory")
+        {
+            m_InventoryService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            XmlSerializer xs = new XmlSerializer(typeof (List<InventoryItemBase>));
+            List<InventoryItemBase> items = (List<InventoryItemBase>)xs.Deserialize(request);
+
+            bool result = false;
+            string[] p = SplitParams(path);
+
+            if (p.Length > 0)
+            {
+                UUID ownerID = UUID.Zero;
+                UUID.TryParse(p[0], out ownerID);
+                result = m_InventoryService.MoveItems(ownerID, items);
+            }
+            else
+                m_log.WarnFormat("[MOVEITEMS HANDLER]: ownerID not provided in request. Unable to serve.");
+
+            xs = new XmlSerializer(typeof(bool));
+            return ServerUtils.SerializeResult(xs, result);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Inventory/XInventoryInConnector.cs b/OpenSim/Server/Handlers/Inventory/XInventoryInConnector.cs
new file mode 100644
index 0000000..5c4e7a9
--- /dev/null
+++ b/OpenSim/Server/Handlers/Inventory/XInventoryInConnector.cs
@@ -0,0 +1,767 @@
+/*
+ * 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.Reflection;
+using System.Text;
+using System.Xml;
+using System.Collections.Generic;
+using System.IO;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using log4net;
+using OpenMetaverse;
+
+using System.Threading;
+
+namespace OpenSim.Server.Handlers.Inventory
+{
+    public class XInventoryInConnector : ServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IInventoryService m_InventoryService;
+        private string m_ConfigName = "InventoryService";
+
+        public XInventoryInConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            m_log.DebugFormat("[XInventoryInConnector]: Starting with config name {0}", m_ConfigName);
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string inventoryService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (inventoryService == String.Empty)
+                throw new Exception("No InventoryService in config file");
+
+            Object[] args = new Object[] { config, m_ConfigName };
+            m_InventoryService =
+                    ServerUtils.LoadPlugin<IInventoryService>(inventoryService, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+
+            server.AddStreamHandler(new XInventoryConnectorPostHandler(m_InventoryService, auth));
+        }
+    }
+
+    public class XInventoryConnectorPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IInventoryService m_InventoryService;
+
+        public XInventoryConnectorPostHandler(IInventoryService service, IServiceAuth auth) :
+                base("POST", "/xinventory", auth)
+        {
+            m_InventoryService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                string method = request["METHOD"].ToString();
+                request.Remove("METHOD");
+
+                switch (method)
+                {
+                    case "CREATEUSERINVENTORY":
+                        return HandleCreateUserInventory(request);
+                    case "GETINVENTORYSKELETON":
+                        return HandleGetInventorySkeleton(request);
+                    case "GETROOTFOLDER":
+                        return HandleGetRootFolder(request);
+                    case "GETFOLDERFORTYPE":
+                        return HandleGetFolderForType(request);
+                    case "GETFOLDERCONTENT":
+                        return HandleGetFolderContent(request);
+                    case "GETMULTIPLEFOLDERSCONTENT":
+                        return HandleGetMultipleFoldersContent(request);
+                    case "GETFOLDERITEMS":
+                        return HandleGetFolderItems(request);
+                    case "ADDFOLDER":
+                        return HandleAddFolder(request);
+                    case "UPDATEFOLDER":
+                        return HandleUpdateFolder(request);
+                    case "MOVEFOLDER":
+                        return HandleMoveFolder(request);
+                    case "DELETEFOLDERS":
+                        return HandleDeleteFolders(request);
+                    case "PURGEFOLDER":
+                        return HandlePurgeFolder(request);
+                    case "ADDITEM":
+                        return HandleAddItem(request);
+                    case "UPDATEITEM":
+                        return HandleUpdateItem(request);
+                    case "MOVEITEMS":
+                        return HandleMoveItems(request);
+                    case "DELETEITEMS":
+                        return HandleDeleteItems(request);
+                    case "GETITEM":
+                        return HandleGetItem(request);
+                    case "GETMULTIPLEITEMS":
+                        return HandleGetMultipleItems(request);
+                    case "GETFOLDER":
+                        return HandleGetFolder(request);
+                    case "GETACTIVEGESTURES":
+                        return HandleGetActiveGestures(request);
+                    case "GETASSETPERMISSIONS":
+                        return HandleGetAssetPermissions(request);
+                }
+                m_log.DebugFormat("[XINVENTORY HANDLER]: unknown method request: {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.Error(string.Format("[XINVENTORY HANDLER]: Exception {0} ", e.Message), e);
+            }
+
+            return FailureResult();
+        }
+
+        private byte[] FailureResult()
+        {
+            return BoolResult(false);
+        }
+
+        private byte[] SuccessResult()
+        {
+            return BoolResult(true);
+        }
+
+        private byte[] BoolResult(bool value)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "RESULT", "");
+            result.AppendChild(doc.CreateTextNode(value.ToString()));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        byte[] HandleCreateUserInventory(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+
+            if (!request.ContainsKey("PRINCIPAL"))
+                return FailureResult();
+
+            if (m_InventoryService.CreateUserInventory(new UUID(request["PRINCIPAL"].ToString())))
+                result["RESULT"] = "True";
+            else
+                result["RESULT"] = "False";
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetInventorySkeleton(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+
+            if (!request.ContainsKey("PRINCIPAL"))
+                return FailureResult();
+
+
+            List<InventoryFolderBase> folders = m_InventoryService.GetInventorySkeleton(new UUID(request["PRINCIPAL"].ToString()));
+
+            Dictionary<string, object> sfolders = new Dictionary<string, object>();
+            if (folders != null)
+            {
+                int i = 0;
+                foreach (InventoryFolderBase f in folders)
+                {
+                    sfolders["folder_" + i.ToString()] = EncodeFolder(f);
+                    i++;
+                }
+            }
+            result["FOLDERS"] = sfolders;
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetRootFolder(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            InventoryFolderBase rfolder = m_InventoryService.GetRootFolder(principal);
+            if (rfolder != null)
+                result["folder"] = EncodeFolder(rfolder);
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetFolderForType(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            int type = 0;
+            Int32.TryParse(request["TYPE"].ToString(), out type);
+            InventoryFolderBase folder = m_InventoryService.GetFolderForType(principal, (FolderType)type);
+            if (folder != null)
+                result["folder"] = EncodeFolder(folder);
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetFolderContent(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            UUID folderID = UUID.Zero;
+            UUID.TryParse(request["FOLDER"].ToString(), out folderID);
+
+            InventoryCollection icoll = m_InventoryService.GetFolderContent(principal, folderID);
+            if (icoll != null)
+            {
+                result["FID"] = icoll.FolderID.ToString();
+                result["VERSION"] = icoll.Version.ToString();
+                Dictionary<string, object> folders = new Dictionary<string, object>();
+                int i = 0; 
+                if (icoll.Folders != null)
+                {
+                    foreach (InventoryFolderBase f in icoll.Folders)
+                    {
+                        folders["folder_" + i.ToString()] = EncodeFolder(f);
+                        i++;
+                    }
+                    result["FOLDERS"] = folders;
+                }
+                if (icoll.Items != null)
+                {
+                    i = 0;
+                    Dictionary<string, object> items = new Dictionary<string, object>();
+                    foreach (InventoryItemBase it in icoll.Items)
+                    {
+                        items["item_" + i.ToString()] = EncodeItem(it);
+                        i++;
+                    }
+                    result["ITEMS"] = items;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetMultipleFoldersContent(Dictionary<string, object> request)
+        {
+            Dictionary<string, object> resultSet = new Dictionary<string, object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            string folderIDstr = request["FOLDERS"].ToString();
+            int count = 0;
+            Int32.TryParse(request["COUNT"].ToString(), out count);
+
+            UUID[] fids = new UUID[count];
+            string[] uuids = folderIDstr.Split(',');
+            int i = 0;
+            foreach (string id in uuids)
+            {
+                UUID fid = UUID.Zero;
+                if (UUID.TryParse(id, out fid))
+                    fids[i] = fid;
+                i += 1;
+            }
+
+            count = 0;
+            InventoryCollection[] icollList = m_InventoryService.GetMultipleFoldersContent(principal, fids);
+            if (icollList != null && icollList.Length > 0)
+            {
+                foreach (InventoryCollection icoll in icollList)
+                {
+                    Dictionary<string, object> result = new Dictionary<string, object>();
+                    result["FID"] = icoll.FolderID.ToString();
+                    result["VERSION"] = icoll.Version.ToString();
+                    result["OWNER"] = icoll.OwnerID.ToString();
+                    Dictionary<string, object> folders = new Dictionary<string, object>();
+                    i = 0;
+                    if (icoll.Folders != null)
+                    {
+                        foreach (InventoryFolderBase f in icoll.Folders)
+                        {
+                            folders["folder_" + i.ToString()] = EncodeFolder(f);
+                            i++;
+                        }
+                        result["FOLDERS"] = folders;
+                    }
+                    i = 0;
+                    if (icoll.Items != null)
+                    {
+                        Dictionary<string, object> items = new Dictionary<string, object>();
+                        foreach (InventoryItemBase it in icoll.Items)
+                        {
+                            items["item_" + i.ToString()] = EncodeItem(it);
+                            i++;
+                        }
+                        result["ITEMS"] = items;
+                    }
+
+                    resultSet["F_" + fids[count++]] = result;
+                    //m_log.DebugFormat("[XXX]: Sending {0} {1}", fids[count-1], icoll.FolderID);
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(resultSet);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetFolderItems(Dictionary<string, object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            UUID folderID = UUID.Zero;
+            UUID.TryParse(request["FOLDER"].ToString(), out folderID);
+
+            List<InventoryItemBase> items = m_InventoryService.GetFolderItems(principal, folderID);
+            Dictionary<string, object> sitems = new Dictionary<string, object>();
+
+            if (items != null)
+            {
+                int i = 0;
+                foreach (InventoryItemBase item in items)
+                {
+                    sitems["item_" + i.ToString()] = EncodeItem(item);
+                    i++;
+                }
+            }
+            result["ITEMS"] = sitems;
+            
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleAddFolder(Dictionary<string,object> request)
+        {
+            InventoryFolderBase folder = BuildFolder(request);
+
+            if (m_InventoryService.AddFolder(folder))
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] HandleUpdateFolder(Dictionary<string,object> request)
+        {
+            InventoryFolderBase folder = BuildFolder(request);
+
+            if (m_InventoryService.UpdateFolder(folder))
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] HandleMoveFolder(Dictionary<string,object> request)
+        {
+            UUID parentID = UUID.Zero;
+            UUID.TryParse(request["ParentID"].ToString(), out parentID);
+            UUID folderID = UUID.Zero;
+            UUID.TryParse(request["ID"].ToString(), out folderID);
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+
+            InventoryFolderBase folder = new InventoryFolderBase(folderID, "", principal, parentID);
+            if (m_InventoryService.MoveFolder(folder))
+                return SuccessResult();
+            else
+                return FailureResult();
+
+        }
+
+        byte[] HandleDeleteFolders(Dictionary<string,object> request)
+        {
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            List<string> slist = (List<string>)request["FOLDERS"];
+            List<UUID> uuids = new List<UUID>();
+            foreach (string s in slist)
+            {
+                UUID u = UUID.Zero;
+                if (UUID.TryParse(s, out u))
+                    uuids.Add(u);
+            }
+
+            if (m_InventoryService.DeleteFolders(principal, uuids))
+                return SuccessResult();
+            else
+                return
+                    FailureResult();
+        }
+
+        byte[] HandlePurgeFolder(Dictionary<string,object> request)
+        {
+            UUID folderID = UUID.Zero;
+            UUID.TryParse(request["ID"].ToString(), out folderID);
+
+            InventoryFolderBase folder = new InventoryFolderBase(folderID);
+            if (m_InventoryService.PurgeFolder(folder))
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] HandleAddItem(Dictionary<string,object> request)
+        {
+            InventoryItemBase item = BuildItem(request);
+
+            if (m_InventoryService.AddItem(item))
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] HandleUpdateItem(Dictionary<string,object> request)
+        {
+            InventoryItemBase item = BuildItem(request);
+
+            if (m_InventoryService.UpdateItem(item))
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] HandleMoveItems(Dictionary<string,object> request)
+        {
+            List<string> idlist = (List<string>)request["IDLIST"];
+            List<string> destlist = (List<string>)request["DESTLIST"];
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+
+            List<InventoryItemBase> items = new List<InventoryItemBase>();
+            int n = 0;
+            try
+            {
+                foreach (string s in idlist)
+                {
+                    UUID u = UUID.Zero;
+                    if (UUID.TryParse(s, out u))
+                    {
+                        UUID fid = UUID.Zero;
+                        if (UUID.TryParse(destlist[n++], out fid))
+                        {
+                            InventoryItemBase item = new InventoryItemBase(u, principal);
+                            item.Folder = fid;
+                            items.Add(item);
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[XINVENTORY IN CONNECTOR]: Exception in HandleMoveItems: {0}", e.Message);
+                return FailureResult();
+            }
+
+            if (m_InventoryService.MoveItems(principal, items))
+                return SuccessResult();
+            else
+                return FailureResult();
+        }
+
+        byte[] HandleDeleteItems(Dictionary<string,object> request)
+        {
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            List<string> slist = (List<string>)request["ITEMS"];
+            List<UUID> uuids = new List<UUID>();
+            foreach (string s in slist)
+            {
+                UUID u = UUID.Zero;
+                if (UUID.TryParse(s, out u))
+                    uuids.Add(u);
+            }
+
+            if (m_InventoryService.DeleteItems(principal, uuids))
+                return SuccessResult();
+            else
+                return
+                    FailureResult();
+        }
+
+        byte[] HandleGetItem(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+            UUID id = UUID.Zero;
+            UUID.TryParse(request["ID"].ToString(), out id);
+
+            InventoryItemBase item = new InventoryItemBase(id);
+            item = m_InventoryService.GetItem(item);
+            if (item != null)
+                result["item"] = EncodeItem(item);
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetMultipleItems(Dictionary<string, object> request)
+        {
+            Dictionary<string, object> resultSet = new Dictionary<string, object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            string itemIDstr = request["ITEMS"].ToString();
+            int count = 0;
+            Int32.TryParse(request["COUNT"].ToString(), out count);
+
+            UUID[] fids = new UUID[count];
+            string[] uuids = itemIDstr.Split(',');
+            int i = 0;
+            foreach (string id in uuids)
+            {
+                UUID fid = UUID.Zero;
+                if (UUID.TryParse(id, out fid))
+                    fids[i] = fid;
+                i += 1;
+            }
+
+            InventoryItemBase[] itemsList = m_InventoryService.GetMultipleItems(principal, fids);
+            if (itemsList != null && itemsList.Length > 0)
+            {
+                count = 0;
+                foreach (InventoryItemBase item in itemsList)
+                    resultSet["item_" + count++] = (item == null) ? (object)"NULL" : EncodeItem(item);
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(resultSet);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetFolder(Dictionary<string,object> request)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            UUID id = UUID.Zero;
+            UUID.TryParse(request["ID"].ToString(), out id);
+
+            InventoryFolderBase folder = new InventoryFolderBase(id);
+            folder = m_InventoryService.GetFolder(folder);
+            if (folder != null)
+                result["folder"] = EncodeFolder(folder);
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetActiveGestures(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+
+            List<InventoryItemBase> gestures = m_InventoryService.GetActiveGestures(principal);
+            Dictionary<string, object> items = new Dictionary<string, object>();
+            if (gestures != null)
+            {
+                int i = 0;
+                foreach (InventoryItemBase item in gestures)
+                {
+                    items["item_" + i.ToString()] = EncodeItem(item);
+                    i++;
+                }
+            }
+            result["ITEMS"] = items;
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetAssetPermissions(Dictionary<string,object> request)
+        {
+            Dictionary<string,object> result = new Dictionary<string,object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+            UUID assetID = UUID.Zero;
+            UUID.TryParse(request["ASSET"].ToString(), out assetID);
+
+            int perms = m_InventoryService.GetAssetPermissions(principal, assetID);
+
+            result["RESULT"] = perms.ToString();
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        private Dictionary<string, object> EncodeFolder(InventoryFolderBase f)
+        {
+            Dictionary<string, object> ret = new Dictionary<string, object>();
+
+            ret["ParentID"] = f.ParentID.ToString();
+            ret["Type"] = f.Type.ToString();
+            ret["Version"] = f.Version.ToString();
+            ret["Name"] = f.Name;
+            ret["Owner"] = f.Owner.ToString();
+            ret["ID"] = f.ID.ToString();
+
+            return ret;
+        }
+
+        private Dictionary<string, object> EncodeItem(InventoryItemBase item)
+        {
+            Dictionary<string, object> ret = new Dictionary<string, object>();
+
+            ret["AssetID"] = item.AssetID.ToString();
+            ret["AssetType"] = item.AssetType.ToString();
+            ret["BasePermissions"] = item.BasePermissions.ToString();
+            ret["CreationDate"] = item.CreationDate.ToString();
+            if (item.CreatorId != null)
+                ret["CreatorId"] = item.CreatorId.ToString();
+            else
+                ret["CreatorId"] = String.Empty;
+            if (item.CreatorData != null)
+                ret["CreatorData"] = item.CreatorData;
+            else
+                ret["CreatorData"] = String.Empty;
+            ret["CurrentPermissions"] = item.CurrentPermissions.ToString();
+            ret["Description"] = item.Description.ToString();
+            ret["EveryOnePermissions"] = item.EveryOnePermissions.ToString();
+            ret["Flags"] = item.Flags.ToString();
+            ret["Folder"] = item.Folder.ToString();
+            ret["GroupID"] = item.GroupID.ToString();
+            ret["GroupOwned"] = item.GroupOwned.ToString();
+            ret["GroupPermissions"] = item.GroupPermissions.ToString();
+            ret["ID"] = item.ID.ToString();
+            ret["InvType"] = item.InvType.ToString();
+            ret["Name"] = item.Name.ToString();
+            ret["NextPermissions"] = item.NextPermissions.ToString();
+            ret["Owner"] = item.Owner.ToString();
+            ret["SalePrice"] = item.SalePrice.ToString();
+            ret["SaleType"] = item.SaleType.ToString();
+
+            return ret;
+        }
+
+        private InventoryFolderBase BuildFolder(Dictionary<string,object> data)
+        {
+            InventoryFolderBase folder = new InventoryFolderBase();
+
+            folder.ParentID =  new UUID(data["ParentID"].ToString());
+            folder.Type = short.Parse(data["Type"].ToString());
+            folder.Version = ushort.Parse(data["Version"].ToString());
+            folder.Name = data["Name"].ToString();
+            folder.Owner =  new UUID(data["Owner"].ToString());
+            folder.ID = new UUID(data["ID"].ToString());
+
+            return folder;
+        }
+
+        private InventoryItemBase BuildItem(Dictionary<string,object> data)
+        {
+            InventoryItemBase item = new InventoryItemBase();
+
+            item.AssetID = new UUID(data["AssetID"].ToString());
+            item.AssetType = int.Parse(data["AssetType"].ToString());
+            item.Name = data["Name"].ToString();
+            item.Owner = new UUID(data["Owner"].ToString());
+            item.ID = new UUID(data["ID"].ToString());
+            item.InvType = int.Parse(data["InvType"].ToString());
+            item.Folder = new UUID(data["Folder"].ToString());
+            item.CreatorId = data["CreatorId"].ToString();
+            item.CreatorData = data["CreatorData"].ToString();
+            item.Description = data["Description"].ToString();
+            item.NextPermissions = uint.Parse(data["NextPermissions"].ToString());
+            item.CurrentPermissions = uint.Parse(data["CurrentPermissions"].ToString());
+            item.BasePermissions = uint.Parse(data["BasePermissions"].ToString());
+            item.EveryOnePermissions = uint.Parse(data["EveryOnePermissions"].ToString());
+            item.GroupPermissions = uint.Parse(data["GroupPermissions"].ToString());
+            item.GroupID = new UUID(data["GroupID"].ToString());
+            item.GroupOwned = bool.Parse(data["GroupOwned"].ToString());
+            item.SalePrice = int.Parse(data["SalePrice"].ToString());
+            item.SaleType = byte.Parse(data["SaleType"].ToString());
+            item.Flags = uint.Parse(data["Flags"].ToString());
+            item.CreationDate = int.Parse(data["CreationDate"].ToString());
+
+            return item;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Land/LandHandlers.cs b/OpenSim/Server/Handlers/Land/LandHandlers.cs
new file mode 100644
index 0000000..b45289a
--- /dev/null
+++ b/OpenSim/Server/Handlers/Land/LandHandlers.cs
@@ -0,0 +1,96 @@
+/*
+ * 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;
+using System.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nwc.XmlRpc;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Land
+{
+    public class LandHandlers
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private ILandService m_LocalService;
+
+        public LandHandlers(ILandService service)
+        {
+            m_LocalService = service;
+        }
+
+        public XmlRpcResponse GetLandData(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            ulong regionHandle = Convert.ToUInt64(requestData["region_handle"]);
+            uint x = Convert.ToUInt32(requestData["x"]);
+            uint y = Convert.ToUInt32(requestData["y"]);
+            m_log.DebugFormat("[LAND HANDLER]: Got request for land data at {0}, {1} for region {2}", x, y, regionHandle);
+
+            byte regionAccess;
+            LandData landData = m_LocalService.GetLandData(UUID.Zero, regionHandle, x, y, out regionAccess);
+            Hashtable hash = new Hashtable();
+            if (landData != null)
+            {
+                // for now, only push out the data we need for answering a ParcelInfoReqeust
+                hash["AABBMax"] = landData.AABBMax.ToString();
+                hash["AABBMin"] = landData.AABBMin.ToString();
+                hash["Area"] = landData.Area.ToString();
+                hash["AuctionID"] = landData.AuctionID.ToString();
+                hash["Description"] = landData.Description;
+                hash["Flags"] = landData.Flags.ToString();
+                hash["GlobalID"] = landData.GlobalID.ToString();
+                hash["Name"] = landData.Name;
+                hash["OwnerID"] = landData.OwnerID.ToString();
+                hash["SalePrice"] = landData.SalePrice.ToString();
+                hash["SnapshotID"] = landData.SnapshotID.ToString();
+                hash["UserLocation"] = landData.UserLocation.ToString();
+                hash["RegionAccess"] = regionAccess.ToString();
+            }
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+            return response;
+        }
+    }
+
+}
diff --git a/OpenSim/Server/Handlers/Land/LandServiceInConnector.cs b/OpenSim/Server/Handlers/Land/LandServiceInConnector.cs
new file mode 100644
index 0000000..d368bd3
--- /dev/null
+++ b/OpenSim/Server/Handlers/Land/LandServiceInConnector.cs
@@ -0,0 +1,66 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Land
+{
+    public class LandServiceInConnector : ServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private ILandService m_LandService;
+        // TODO : private IAuthenticationService m_AuthenticationService;
+
+        public LandServiceInConnector(IConfigSource source, IHttpServer server, ILandService service, IScene scene) :
+                base(source, server, String.Empty)
+        {
+            m_LandService = service;
+            if (m_LandService == null)
+            {
+                m_log.Error("[LAND IN CONNECTOR]: Land service was not provided");
+                return;
+            }
+            
+            //bool authentication = neighbourConfig.GetBoolean("RequireAuthentication", false);
+            //if (authentication)
+            //    m_AuthenticationService = scene.RequestModuleInterface<IAuthenticationService>();
+
+            LandHandlers landHandlers = new LandHandlers(m_LandService);
+            server.AddXmlRPCHandler("land_data", landHandlers.GetLandData, false);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Login/LLLoginHandlers.cs b/OpenSim/Server/Handlers/Login/LLLoginHandlers.cs
new file mode 100644
index 0000000..f2a5678
--- /dev/null
+++ b/OpenSim/Server/Handlers/Login/LLLoginHandlers.cs
@@ -0,0 +1,309 @@
+/*
+ * 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;
+using System.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nwc.XmlRpc;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Login
+{
+    public class LLLoginHandlers
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private ILoginService m_LocalService;
+        private bool m_Proxy;
+        
+
+        public LLLoginHandlers(ILoginService service, bool hasProxy)
+        {
+            m_LocalService = service;
+            m_Proxy = hasProxy;
+        }
+
+        public XmlRpcResponse HandleXMLRPCLogin(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+            if (m_Proxy && request.Params[3] != null)
+            {
+                IPEndPoint ep = Util.GetClientIPFromXFF((string)request.Params[3]);
+                if (ep != null)
+                    // Bang!
+                    remoteClient = ep;
+            }
+
+            if (requestData != null)
+            {
+                // Debug code to show exactly what login parameters the viewer is sending us.
+                // TODO: Extract into a method that can be generally applied if one doesn't already exist.
+//                foreach (string key in requestData.Keys)
+//                {
+//                    object value = requestData[key];
+//                    Console.WriteLine("{0}:{1}", key, value);
+//                    if (value is ArrayList)
+//                    {
+//                        ICollection col = value as ICollection;
+//                        foreach (object item in col)
+//                            Console.WriteLine("  {0}", item);
+//                    }
+//                }
+
+                if (requestData.ContainsKey("first") && requestData["first"] != null &&
+                    requestData.ContainsKey("last") && requestData["last"] != null && (
+                        (requestData.ContainsKey("passwd") && requestData["passwd"] != null) ||
+                        (!requestData.ContainsKey("passwd") && requestData.ContainsKey("web_login_key") && requestData["web_login_key"] != null && requestData["web_login_key"].ToString() != UUID.Zero.ToString())
+                    ))
+                {
+                    string first = requestData["first"].ToString();
+                    string last = requestData["last"].ToString();
+                    string passwd = null;
+                    if (requestData.ContainsKey("passwd"))
+                    {
+                        passwd = requestData["passwd"].ToString();
+                    }
+                    else if (requestData.ContainsKey("web_login_key"))
+                    {
+                        passwd = "$1$" + requestData["web_login_key"].ToString();
+                        m_log.InfoFormat("[LOGIN]: XMLRPC Login Req key {0}", passwd);
+                    }
+                    string startLocation = string.Empty;
+                    UUID scopeID = UUID.Zero;
+                    if (requestData["scope_id"] != null)
+                        scopeID = new UUID(requestData["scope_id"].ToString());
+                    if (requestData.ContainsKey("start"))
+                        startLocation = requestData["start"].ToString();
+
+                    string clientVersion = "Unknown";
+                    if (requestData.Contains("version") && requestData["version"] != null)
+                        clientVersion = requestData["version"].ToString();
+                    // We should do something interesting with the client version...
+
+                    string channel = "Unknown";
+                    if (requestData.Contains("channel") && requestData["channel"] != null)
+                        channel = requestData["channel"].ToString();
+
+                    string mac = "Unknown";
+                    if (requestData.Contains("mac") && requestData["mac"] != null)
+                        mac = requestData["mac"].ToString();
+
+                    string id0 = "Unknown";
+                    if (requestData.Contains("id0") && requestData["id0"] != null)
+                        id0 = requestData["id0"].ToString();
+
+                    //m_log.InfoFormat("[LOGIN]: XMLRPC Login Requested for {0} {1}, starting in {2}, using {3}", first, last, startLocation, clientVersion);
+
+                    LoginResponse reply = null;
+                    reply = m_LocalService.Login(first, last, passwd, startLocation, scopeID, clientVersion, channel, mac, id0, remoteClient);
+
+                    XmlRpcResponse response = new XmlRpcResponse();
+                    response.Value = reply.ToHashtable();
+                    return response;
+
+                }
+            }
+
+            return FailedXMLRPCResponse();
+
+        }
+        public XmlRpcResponse HandleXMLRPCLoginBlocked(XmlRpcRequest request, IPEndPoint client)
+        {
+            XmlRpcResponse response = new XmlRpcResponse();
+            Hashtable resp = new Hashtable();
+
+            resp["reason"] = "presence";
+            resp["message"] = "Logins are currently restricted. Please try again later.";
+            resp["login"] = "false";
+            response.Value = resp;
+            return response;
+        }
+
+        public XmlRpcResponse HandleXMLRPCSetLoginLevel(XmlRpcRequest request, IPEndPoint remoteClient)
+        {
+            Hashtable requestData = (Hashtable)request.Params[0];
+
+            if (requestData != null)
+            {
+                if (requestData.ContainsKey("first") && requestData["first"] != null &&
+                    requestData.ContainsKey("last") && requestData["last"] != null &&
+                    requestData.ContainsKey("level") && requestData["level"] != null &&
+                    requestData.ContainsKey("passwd") && requestData["passwd"] != null)
+                {
+                    string first = requestData["first"].ToString();
+                    string last = requestData["last"].ToString();
+                    string passwd = requestData["passwd"].ToString();
+                    int level = Int32.Parse(requestData["level"].ToString());
+
+                    m_log.InfoFormat("[LOGIN]: XMLRPC Set Level to {2} Requested by {0} {1}", first, last, level);
+
+                    Hashtable reply = m_LocalService.SetLevel(first, last, passwd, level, remoteClient);
+
+                    XmlRpcResponse response = new XmlRpcResponse();
+                    response.Value = reply;
+
+                    return response;
+
+                }
+            }
+
+            XmlRpcResponse failResponse = new XmlRpcResponse();
+            Hashtable failHash = new Hashtable();
+            failHash["success"] = "false";
+            failResponse.Value = failHash;
+
+            return failResponse;
+
+        }
+
+        public OSD HandleLLSDLogin(OSD request, IPEndPoint remoteClient)
+        {
+            if (request.Type == OSDType.Map)
+            {
+                OSDMap map = (OSDMap)request;
+
+                if (map.ContainsKey("first") && map.ContainsKey("last") && map.ContainsKey("passwd"))
+                {
+                    string startLocation = string.Empty;
+
+                    if (map.ContainsKey("start"))
+                        startLocation = map["start"].AsString();
+
+                    UUID scopeID = UUID.Zero;
+
+                    if (map.ContainsKey("scope_id"))
+                        scopeID = new UUID(map["scope_id"].AsString());
+
+                    m_log.Info("[LOGIN]: LLSD Login Requested for: '" + map["first"].AsString() + "' '" + map["last"].AsString() + "' / " + startLocation);
+
+                    LoginResponse reply = null;
+                    reply = m_LocalService.Login(map["first"].AsString(), map["last"].AsString(), map["passwd"].AsString(), startLocation, scopeID,
+                        map["version"].AsString(), map["channel"].AsString(), map["mac"].AsString(), map["id0"].AsString(), remoteClient);
+                    return reply.ToOSDMap();
+
+                }
+            }
+
+            return FailedOSDResponse();
+        }
+
+        public void HandleWebSocketLoginEvents(string path, WebSocketHttpServerHandler sock)
+        {
+            sock.MaxPayloadSize = 16384; //16 kb payload
+            sock.InitialMsgTimeout = 5000; //5 second first message to trigger at least one of these events
+            sock.NoDelay_TCP_Nagle = true;
+            sock.OnData += delegate(object sender, WebsocketDataEventArgs data) { sock.Close("fail"); };
+            sock.OnPing += delegate(object sender, PingEventArgs pingdata) { sock.Close("fail"); };
+            sock.OnPong += delegate(object sender, PongEventArgs pongdata) { sock.Close("fail"); };
+            sock.OnText += delegate(object sender, WebsocketTextEventArgs text)
+                               {
+                                   OSD request = null;
+                                   try
+                                   {
+                                       request = OSDParser.DeserializeJson(text.Data);
+                                       if (!(request is OSDMap))
+                                       {
+                                           sock.SendMessage(OSDParser.SerializeJsonString(FailedOSDResponse()));
+                                       }
+                                       else
+                                       {
+                                           OSDMap req = request as OSDMap;
+                                           string first = req["firstname"].AsString();
+                                           string last = req["lastname"].AsString();
+                                           string passwd = req["passwd"].AsString();
+                                           string start = req["startlocation"].AsString();
+                                           string version = req["version"].AsString();
+                                           string channel = req["channel"].AsString();
+                                           string mac = req["mac"].AsString();
+                                           string id0 = req["id0"].AsString();
+                                           UUID scope = UUID.Zero;
+                                           IPEndPoint endPoint =
+                                               (sender as WebSocketHttpServerHandler).GetRemoteIPEndpoint();
+                                           LoginResponse reply = null;
+                                           reply = m_LocalService.Login(first, last, passwd, start, scope, version,
+                                                                        channel, mac, id0, endPoint);
+                                           sock.SendMessage(OSDParser.SerializeJsonString(reply.ToOSDMap()));
+
+                                       }
+
+                                   }
+                                   catch (Exception)
+                                   {
+                                       sock.SendMessage(OSDParser.SerializeJsonString(FailedOSDResponse()));
+                                   }
+                                   finally
+                                   {
+                                       sock.Close("success");
+                                   }
+                               };
+            
+            sock.HandshakeAndUpgrade();
+
+        }
+        
+
+        private XmlRpcResponse FailedXMLRPCResponse()
+        {
+            Hashtable hash = new Hashtable();
+            hash["reason"] = "key";
+            hash["message"] = "Incomplete login credentials. Check your username and password.";
+            hash["login"] = "false";
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = hash;
+
+            return response;
+        }
+
+        private OSD FailedOSDResponse()
+        {
+            OSDMap map = new OSDMap();
+
+            map["reason"] = OSD.FromString("key");
+            map["message"] = OSD.FromString("Invalid login credentials. Check your username and passwd.");
+            map["login"] = OSD.FromString("false");
+
+            return map;
+        }
+
+    }
+
+}
diff --git a/OpenSim/Server/Handlers/Login/LLLoginServiceInConnector.cs b/OpenSim/Server/Handlers/Login/LLLoginServiceInConnector.cs
new file mode 100644
index 0000000..f60e892
--- /dev/null
+++ b/OpenSim/Server/Handlers/Login/LLLoginServiceInConnector.cs
@@ -0,0 +1,117 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Login
+{
+    public class LLLoginServiceInConnector : ServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private ILoginService m_LoginService;
+        private bool m_Proxy;
+        private BasicDosProtectorOptions m_DosProtectionOptions;
+
+        public LLLoginServiceInConnector(IConfigSource config, IHttpServer server, IScene scene) :
+                base(config, server, String.Empty)
+        {
+            m_log.Debug("[LLLOGIN IN CONNECTOR]: Starting...");
+            string loginService = ReadLocalServiceFromConfig(config);
+
+            ISimulationService simService = scene.RequestModuleInterface<ISimulationService>();
+            ILibraryService libService = scene.RequestModuleInterface<ILibraryService>();
+
+            Object[] args = new Object[] { config, simService, libService };
+            m_LoginService = ServerUtils.LoadPlugin<ILoginService>(loginService, args);
+
+            InitializeHandlers(server);
+        }
+
+        public LLLoginServiceInConnector(IConfigSource config, IHttpServer server, string configName) :
+            base(config, server, configName)
+        {
+            string loginService = ReadLocalServiceFromConfig(config);
+
+            Object[] args = new Object[] { config };
+
+            m_LoginService = ServerUtils.LoadPlugin<ILoginService>(loginService, args);
+
+            InitializeHandlers(server);
+        }
+
+        public LLLoginServiceInConnector(IConfigSource config, IHttpServer server) :
+            this(config, server, String.Empty)
+        {
+        }
+
+        private string ReadLocalServiceFromConfig(IConfigSource config)
+        {
+            IConfig serverConfig = config.Configs["LoginService"];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section LoginService in config file"));
+
+            string loginService = serverConfig.GetString("LocalServiceModule", String.Empty);
+            if (loginService == string.Empty)
+                throw new Exception(String.Format("No LocalServiceModule for LoginService in config file"));
+
+            m_Proxy = serverConfig.GetBoolean("HasProxy", false);
+            m_DosProtectionOptions = new BasicDosProtectorOptions();
+            // Dos Protection Options
+            m_DosProtectionOptions.AllowXForwardedFor = serverConfig.GetBoolean("DOSAllowXForwardedForHeader", false);
+            m_DosProtectionOptions.RequestTimeSpan =
+                TimeSpan.FromMilliseconds(serverConfig.GetInt("DOSRequestTimeFrameMS", 10000));
+            m_DosProtectionOptions.MaxRequestsInTimeframe = serverConfig.GetInt("DOSMaxRequestsInTimeFrame", 5);
+            m_DosProtectionOptions.ForgetTimeSpan =
+                TimeSpan.FromMilliseconds(serverConfig.GetInt("DOSForgiveClientAfterMS", 120000));
+            m_DosProtectionOptions.ReportingName = "LOGINDOSPROTECTION";
+            
+
+            return loginService;
+        }
+
+        private void InitializeHandlers(IHttpServer server)
+        {
+            LLLoginHandlers loginHandlers = new LLLoginHandlers(m_LoginService, m_Proxy);
+            server.AddXmlRPCHandler("login_to_simulator", 
+                new XmlRpcBasicDOSProtector(loginHandlers.HandleXMLRPCLogin,loginHandlers.HandleXMLRPCLoginBlocked,
+                    m_DosProtectionOptions).Process, false);
+            server.AddXmlRPCHandler("set_login_level", loginHandlers.HandleXMLRPCSetLoginLevel, false);
+            server.SetDefaultLLSDHandler(loginHandlers.HandleLLSDLogin);
+            server.AddWebSocketHandler("/WebSocket/GridLogin", loginHandlers.HandleWebSocketLoginEvents);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Map/MapAddServerConnector.cs b/OpenSim/Server/Handlers/Map/MapAddServerConnector.cs
new file mode 100644
index 0000000..649a27e
--- /dev/null
+++ b/OpenSim/Server/Handlers/Map/MapAddServerConnector.cs
@@ -0,0 +1,247 @@
+/*
+ * 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.Reflection;
+using System.Xml;
+
+using Nini.Config;
+using log4net;
+using OpenMetaverse;
+
+using OpenSim.Framework;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+namespace OpenSim.Server.Handlers.MapImage
+{
+    public class MapAddServiceConnector : ServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IMapImageService m_MapService;
+        private IGridService m_GridService;
+        private string m_ConfigName = "MapImageService";
+
+        public MapAddServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string mapService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (mapService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_MapService = ServerUtils.LoadPlugin<IMapImageService>(mapService, args);
+
+            string gridService = serverConfig.GetString("GridService", String.Empty);
+            if (gridService != string.Empty)
+                m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
+
+            if (m_GridService != null)
+                m_log.InfoFormat("[MAP IMAGE HANDLER]: GridService check is ON");
+            else
+                m_log.InfoFormat("[MAP IMAGE HANDLER]: GridService check is OFF");
+
+            bool proxy = serverConfig.GetBoolean("HasProxy", false);
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+            server.AddStreamHandler(new MapServerPostHandler(m_MapService, m_GridService, proxy, auth));
+
+        }
+    }
+
+    class MapServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private IMapImageService m_MapService;
+        private IGridService m_GridService;
+        bool m_Proxy;
+
+        public MapServerPostHandler(IMapImageService service, IGridService grid, bool proxy, IServiceAuth auth) :
+            base("POST", "/map", auth)
+        {
+            m_MapService = service;
+            m_GridService = grid;
+            m_Proxy = proxy;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+//            m_log.DebugFormat("[MAP SERVICE IMAGE HANDLER]: Received {0}", path);
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            try
+            {
+                Dictionary<string, object> request = ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("X") || !request.ContainsKey("Y") || !request.ContainsKey("DATA"))
+                {
+                    httpResponse.StatusCode = (int)OSHttpStatusCode.ClientErrorBadRequest;
+                    return FailureResult("Bad request.");
+                }
+                uint x = 0, y = 0;
+                UInt32.TryParse(request["X"].ToString(), out x);
+                UInt32.TryParse(request["Y"].ToString(), out y);
+
+                m_log.DebugFormat("[MAP ADD SERVER CONNECTOR]: Received map data for region at {0}-{1}", x, y);
+
+//                string type = "image/jpeg";
+//
+//                if (request.ContainsKey("TYPE"))
+//                    type = request["TYPE"].ToString();
+
+                if (m_GridService != null)
+                {
+                    System.Net.IPAddress ipAddr = GetCallerIP(httpRequest);
+                    GridRegion r = m_GridService.GetRegionByPosition(UUID.Zero, (int)Util.RegionToWorldLoc(x), (int)Util.RegionToWorldLoc(y));
+                    if (r != null)
+                    {
+                        if (r.ExternalEndPoint.Address.ToString() != ipAddr.ToString())
+                        {
+                            m_log.WarnFormat("[MAP IMAGE HANDLER]: IP address {0} may be trying to impersonate region in IP {1}", ipAddr, r.ExternalEndPoint.Address);
+                            return FailureResult("IP address of caller does not match IP address of registered region");
+                        }
+
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("[MAP IMAGE HANDLER]: IP address {0} may be rogue. Region not found at coordinates {1}-{2}", 
+                            ipAddr, x, y);
+                        return FailureResult("Region not found at given coordinates");
+                    }
+                }
+
+                byte[] data = Convert.FromBase64String(request["DATA"].ToString());
+
+                string reason = string.Empty;
+                bool result = m_MapService.AddMapTile((int)x, (int)y, data, out reason);
+
+                if (result)
+                    return SuccessResult();
+                else
+                    return FailureResult(reason);
+
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[MAP SERVICE IMAGE HANDLER]: Exception {0} {1}", e.Message, e.StackTrace);
+            }
+
+            return FailureResult("Unexpected server error");
+        }
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult(string msg)
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "Result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            XmlElement message = doc.CreateElement("", "Message", "");
+            message.AppendChild(doc.CreateTextNode(msg));
+
+            rootElement.AppendChild(message);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private System.Net.IPAddress GetCallerIP(IOSHttpRequest request)
+        {
+            if (!m_Proxy)
+                return request.RemoteIPEndPoint.Address;
+
+            // We're behind a proxy
+            string xff = "X-Forwarded-For";
+            string xffValue = request.Headers[xff.ToLower()];
+            if (xffValue == null || (xffValue != null && xffValue == string.Empty))
+                xffValue = request.Headers[xff];
+
+            if (xffValue == null || (xffValue != null && xffValue == string.Empty))
+            {
+                m_log.WarnFormat("[MAP IMAGE HANDLER]: No XFF header");
+                return request.RemoteIPEndPoint.Address;
+            }
+
+            System.Net.IPEndPoint ep = Util.GetClientIPFromXFF(xffValue);
+            if (ep != null)
+                return ep.Address;
+
+            // Oops
+            return request.RemoteIPEndPoint.Address;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Map/MapGetServerConnector.cs b/OpenSim/Server/Handlers/Map/MapGetServerConnector.cs
new file mode 100644
index 0000000..7bb2f39
--- /dev/null
+++ b/OpenSim/Server/Handlers/Map/MapGetServerConnector.cs
@@ -0,0 +1,107 @@
+/*
+ * 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.IO;
+using System.Net;
+using System.Reflection;
+
+using Nini.Config;
+using log4net;
+
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.MapImage
+{
+    public class MapGetServiceConnector : ServiceConnector
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IMapImageService m_MapService;
+
+        private string m_ConfigName = "MapImageService";
+
+        public MapGetServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+            base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string gridService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (gridService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_MapService = ServerUtils.LoadPlugin<IMapImageService>(gridService, args);
+
+            server.AddStreamHandler(new MapServerGetHandler(m_MapService));
+        }
+    }
+
+    class MapServerGetHandler : BaseStreamHandler
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IMapImageService m_MapService;
+
+        public MapServerGetHandler(IMapImageService service) :
+                base("GET", "/map")
+        {
+            m_MapService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            byte[] result = new byte[0];
+
+            string format = string.Empty;
+            result = m_MapService.GetMapTile(path.Trim('/'), out format);
+            if (result.Length > 0)
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.OK;
+                if (format.Equals(".png"))
+                    httpResponse.ContentType = "image/png";
+                else if (format.Equals(".jpg") || format.Equals(".jpeg"))
+                    httpResponse.ContentType = "image/jpeg";
+            }
+            else
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
+                httpResponse.ContentType = "text/plain";
+            }
+
+            return result;
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Neighbour/NeighbourHandlers.cs b/OpenSim/Server/Handlers/Neighbour/NeighbourHandlers.cs
new file mode 100644
index 0000000..3525a01
--- /dev/null
+++ b/OpenSim/Server/Handlers/Neighbour/NeighbourHandlers.cs
@@ -0,0 +1,208 @@
+/*
+ * 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.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Neighbour
+{
+    public class NeighbourGetHandler : BaseStreamHandler
+    {
+        // TODO: unused: private ISimulationService m_SimulationService;
+        // TODO: unused: private IAuthenticationService m_AuthenticationService;
+
+        public NeighbourGetHandler(INeighbourService service, IAuthenticationService authentication) :
+                base("GET", "/region")
+        {
+            // TODO: unused: m_SimulationService = service;
+            // TODO: unused: m_AuthenticationService = authentication;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // Not implemented yet
+            Console.WriteLine("--- Get region --- " + path);
+            httpResponse.StatusCode = (int)HttpStatusCode.NotImplemented;
+            return new byte[] { };
+        }
+    }
+
+    public class NeighbourPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private INeighbourService m_NeighbourService;
+        private IAuthenticationService m_AuthenticationService;
+        // TODO: unused: private bool m_AllowForeignGuests;
+
+        public NeighbourPostHandler(INeighbourService service, IAuthenticationService authentication) :
+            base("POST", "/region")
+        {
+            m_NeighbourService = service;
+            m_AuthenticationService = authentication;
+            // TODO: unused: m_AllowForeignGuests = foreignGuests;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            byte[] result = new byte[0];
+
+            UUID regionID;
+            string action;
+            ulong regionHandle;
+            if (RestHandlerUtils.GetParams(path, out regionID, out regionHandle, out action))
+            {
+                m_log.InfoFormat("[RegionPostHandler]: Invalid parameters for neighbour message {0}", path);
+                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
+                httpResponse.StatusDescription = "Invalid parameters for neighbour message " + path;
+
+                return result;
+            }
+
+            if (m_AuthenticationService != null)
+            {
+                // Authentication
+                string authority = string.Empty;
+                string authToken = string.Empty;
+                if (!RestHandlerUtils.GetAuthentication(httpRequest, out authority, out authToken))
+                {
+                    m_log.InfoFormat("[RegionPostHandler]: Authentication failed for neighbour message {0}", path);
+                    httpResponse.StatusCode = (int)HttpStatusCode.Unauthorized;
+                    return result;
+                }
+                // TODO: Rethink this
+                //if (!m_AuthenticationService.VerifyKey(regionID, authToken))
+                //{
+                //    m_log.InfoFormat("[RegionPostHandler]: Authentication failed for neighbour message {0}", path);
+                //    httpResponse.StatusCode = (int)HttpStatusCode.Forbidden;
+                //    return result;
+                //}
+                m_log.DebugFormat("[RegionPostHandler]: Authentication succeeded for {0}", regionID);
+            }
+
+            OSDMap args = Util.GetOSDMap(request, (int)httpRequest.ContentLength);
+            if (args == null)
+            {
+                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
+                httpResponse.StatusDescription = "Unable to retrieve data";
+                m_log.DebugFormat("[RegionPostHandler]: Unable to retrieve data for post {0}", path);
+                return result;
+            }
+
+            // retrieve the regionhandle
+            ulong regionhandle = 0;
+            if (args["destination_handle"] != null)
+                UInt64.TryParse(args["destination_handle"].AsString(), out regionhandle);
+
+            RegionInfo aRegion = new RegionInfo();
+            try
+            {
+                aRegion.UnpackRegionInfoData(args);
+            }
+            catch (Exception ex)
+            {
+                m_log.InfoFormat("[RegionPostHandler]: exception on unpacking region info {0}", ex.Message);
+                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
+                httpResponse.StatusDescription = "Problems with data deserialization";
+                return result;
+            }
+
+            // Finally!
+            GridRegion thisRegion = m_NeighbourService.HelloNeighbour(regionhandle, aRegion);
+            
+            OSDMap resp = new OSDMap(1);
+
+            if (thisRegion != null)
+                resp["success"] = OSD.FromBoolean(true);
+            else
+                resp["success"] = OSD.FromBoolean(false);
+
+            httpResponse.StatusCode = (int)HttpStatusCode.OK;
+
+            return Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp));
+        }
+    }
+
+    public class NeighbourPutHandler : BaseStreamHandler
+    {
+        // TODO: unused: private ISimulationService m_SimulationService;
+        // TODO: unused: private IAuthenticationService m_AuthenticationService;
+
+        public NeighbourPutHandler(INeighbourService service, IAuthenticationService authentication) :
+            base("PUT", "/region")
+        {
+            // TODO: unused: m_SimulationService = service;
+            // TODO: unused: m_AuthenticationService = authentication;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // Not implemented yet
+            httpResponse.StatusCode = (int)HttpStatusCode.NotImplemented;
+            return new byte[] { };
+        }
+    }
+
+    public class NeighbourDeleteHandler : BaseStreamHandler
+    {
+        // TODO: unused: private ISimulationService m_SimulationService;
+        // TODO: unused: private IAuthenticationService m_AuthenticationService;
+
+        public NeighbourDeleteHandler(INeighbourService service, IAuthenticationService authentication) :
+            base("DELETE", "/region")
+        {
+            // TODO: unused: m_SimulationService = service;
+            // TODO: unused: m_AuthenticationService = authentication;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // Not implemented yet
+            httpResponse.StatusCode = (int)HttpStatusCode.NotImplemented;
+            return new byte[] { };
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Neighbour/NeighbourServiceInConnector.cs b/OpenSim/Server/Handlers/Neighbour/NeighbourServiceInConnector.cs
new file mode 100644
index 0000000..ac2e75f
--- /dev/null
+++ b/OpenSim/Server/Handlers/Neighbour/NeighbourServiceInConnector.cs
@@ -0,0 +1,68 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Neighbour
+{
+    public class NeighbourServiceInConnector : ServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private INeighbourService m_NeighbourService;
+        private IAuthenticationService m_AuthenticationService = null;
+
+        public NeighbourServiceInConnector(IConfigSource source, IHttpServer server, INeighbourService nService, IScene scene) :
+                base(source, server, String.Empty)
+        {
+
+            m_NeighbourService = nService;
+            if (m_NeighbourService == null)
+            {
+                m_log.Error("[NEIGHBOUR IN CONNECTOR]: neighbour service was not provided");
+                return;
+            }
+            
+            //bool authentication = neighbourConfig.GetBoolean("RequireAuthentication", false);
+            //if (authentication)
+            //    m_AuthenticationService = scene.RequestModuleInterface<IAuthenticationService>();
+
+
+            server.AddStreamHandler(new NeighbourPostHandler(m_NeighbourService, m_AuthenticationService));
+            server.AddStreamHandler(new NeighbourGetHandler(m_NeighbourService, m_AuthenticationService));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Presence/PresenceServerConnector.cs b/OpenSim/Server/Handlers/Presence/PresenceServerConnector.cs
new file mode 100644
index 0000000..7a63c36
--- /dev/null
+++ b/OpenSim/Server/Handlers/Presence/PresenceServerConnector.cs
@@ -0,0 +1,64 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Presence
+{
+    public class PresenceServiceConnector : ServiceConnector
+    {
+        private IPresenceService m_PresenceService;
+        private string m_ConfigName = "PresenceService";
+
+        public PresenceServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string gridService = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (gridService == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(gridService, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+
+            server.AddStreamHandler(new PresenceServerPostHandler(m_PresenceService, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Presence/PresenceServerPostHandler.cs b/OpenSim/Server/Handlers/Presence/PresenceServerPostHandler.cs
new file mode 100644
index 0000000..49dbcb5
--- /dev/null
+++ b/OpenSim/Server/Handlers/Presence/PresenceServerPostHandler.cs
@@ -0,0 +1,294 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework.ServiceAuth;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.Presence
+{
+    public class PresenceServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IPresenceService m_PresenceService;
+
+        public PresenceServerPostHandler(IPresenceService service, IServiceAuth auth) :
+                base("POST", "/presence", auth)
+        {
+            m_PresenceService = service;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+            string method = string.Empty;
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "login":
+                        return LoginAgent(request);
+                    case "logout":
+                        return LogoutAgent(request);
+                    case "logoutregion":
+                        return LogoutRegionAgents(request);
+                    case "report":
+                        return Report(request);
+                    case "getagent":
+                        return GetAgent(request);
+                    case "getagents":
+                        return GetAgents(request);
+                }
+                m_log.DebugFormat("[PRESENCE HANDLER]: unknown method request: {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[PRESENCE HANDLER]: Exception in method {0}: {1}", method, e);
+            }
+
+            return FailureResult();
+
+        }
+
+        byte[] LoginAgent(Dictionary<string, object> request)
+        {
+            string user = String.Empty;
+            UUID session = UUID.Zero;
+            UUID ssession = UUID.Zero;
+
+            if (!request.ContainsKey("UserID") || !request.ContainsKey("SessionID"))
+                return FailureResult();
+
+            user = request["UserID"].ToString();
+
+            if (!UUID.TryParse(request["SessionID"].ToString(), out session))
+                return FailureResult();
+
+            if (request.ContainsKey("SecureSessionID"))
+                // If it's malformed, we go on with a Zero on it
+                UUID.TryParse(request["SecureSessionID"].ToString(), out ssession);
+
+            if (m_PresenceService.LoginAgent(user, session, ssession))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        byte[] LogoutAgent(Dictionary<string, object> request)
+        {
+            UUID session = UUID.Zero;
+
+            if (!request.ContainsKey("SessionID"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["SessionID"].ToString(), out session))
+                return FailureResult();
+
+            if (m_PresenceService.LogoutAgent(session))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+
+        byte[] LogoutRegionAgents(Dictionary<string, object> request)
+        {
+            UUID region = UUID.Zero;
+
+            if (!request.ContainsKey("RegionID"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["RegionID"].ToString(), out region))
+                return FailureResult();
+
+            if (m_PresenceService.LogoutRegionAgents(region))
+                return SuccessResult();
+
+            return FailureResult();
+        }
+        
+        byte[] Report(Dictionary<string, object> request)
+        {
+            UUID session = UUID.Zero;
+            UUID region = UUID.Zero;
+
+            if (!request.ContainsKey("SessionID") || !request.ContainsKey("RegionID"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["SessionID"].ToString(), out session))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["RegionID"].ToString(), out region))
+                return FailureResult();
+
+            if (m_PresenceService.ReportAgent(session, region))
+            {
+                return SuccessResult();
+            }
+
+            return FailureResult();
+        }
+
+        byte[] GetAgent(Dictionary<string, object> request)
+        {
+            UUID session = UUID.Zero;
+
+            if (!request.ContainsKey("SessionID"))
+                return FailureResult();
+
+            if (!UUID.TryParse(request["SessionID"].ToString(), out session))
+                return FailureResult();
+
+            PresenceInfo pinfo = m_PresenceService.GetAgent(session);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if (pinfo == null)
+                result["result"] = "null";
+            else
+                result["result"] = pinfo.ToKeyValuePairs();
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] GetAgents(Dictionary<string, object> request)
+        {
+
+            string[] userIDs;
+
+            if (!request.ContainsKey("uuids"))
+            {
+                m_log.DebugFormat("[PRESENCE HANDLER]: GetAgents called without required uuids argument");
+                return FailureResult();
+            }
+
+            if (!(request["uuids"] is List<string>))
+            {
+                m_log.DebugFormat("[PRESENCE HANDLER]: GetAgents input argument was of unexpected type {0}", request["uuids"].GetType().ToString());
+                return FailureResult();
+            }
+
+            userIDs = ((List<string>)request["uuids"]).ToArray();
+
+            PresenceInfo[] pinfos = m_PresenceService.GetAgents(userIDs);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((pinfos == null) || ((pinfos != null) && (pinfos.Length == 0)))
+                result["result"] = "null";
+            else
+            {
+                int i = 0;
+                foreach (PresenceInfo pinfo in pinfos)
+                {
+                    Dictionary<string, object> rinfoDict = pinfo.ToKeyValuePairs();
+                    result["presence" + i] = rinfoDict;
+                    i++;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/Profiles/UserProfilesConnector.cs b/OpenSim/Server/Handlers/Profiles/UserProfilesConnector.cs
new file mode 100644
index 0000000..2dfb862
--- /dev/null
+++ b/OpenSim/Server/Handlers/Profiles/UserProfilesConnector.cs
@@ -0,0 +1,109 @@
+/*
+ * 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.Reflection;
+using Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework;
+using OpenSim.Server.Handlers.Base;
+using log4net;
+
+namespace OpenSim.Server.Handlers.Profiles
+{
+    public class UserProfilesConnector: ServiceConnector
+    {
+//        static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);        
+        
+        // Our Local Module
+        public IUserProfilesService ServiceModule
+        {
+            get; private set;
+        }
+
+        // The HTTP server.
+        public IHttpServer Server
+        {
+            get; private set;
+        }
+
+        public bool Enabled
+        {
+            get; private set;
+        }
+
+        public UserProfilesConnector(IConfigSource config, IHttpServer server, string configName) :
+            base(config, server, configName)
+        {
+            ConfigName = "UserProfilesService";
+            if(!string.IsNullOrEmpty(configName))
+                ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", ConfigName));
+
+            if(!serverConfig.GetBoolean("Enabled",false))
+            {
+                Enabled = false;
+                return;
+            }
+
+            Enabled = true;
+
+            Server = server;
+
+            string service = serverConfig.GetString("LocalServiceModule", String.Empty);
+
+            Object[] args = new Object[] { config, ConfigName };
+            ServiceModule = ServerUtils.LoadPlugin<IUserProfilesService>(service, args);
+            
+            JsonRpcProfileHandlers handler = new JsonRpcProfileHandlers(ServiceModule);
+
+            Server.AddJsonRPCHandler("avatarclassifiedsrequest", handler.AvatarClassifiedsRequest);
+            Server.AddJsonRPCHandler("classified_update", handler.ClassifiedUpdate);
+            Server.AddJsonRPCHandler("classifieds_info_query", handler.ClassifiedInfoRequest);
+            Server.AddJsonRPCHandler("classified_delete", handler.ClassifiedDelete);
+            Server.AddJsonRPCHandler("avatarpicksrequest", handler.AvatarPicksRequest);
+            Server.AddJsonRPCHandler("pickinforequest", handler.PickInfoRequest);
+            Server.AddJsonRPCHandler("picks_update", handler.PicksUpdate);
+            Server.AddJsonRPCHandler("picks_delete", handler.PicksDelete);
+            Server.AddJsonRPCHandler("avatarnotesrequest", handler.AvatarNotesRequest);
+            Server.AddJsonRPCHandler("avatar_notes_update", handler.NotesUpdate);
+            Server.AddJsonRPCHandler("avatar_properties_request", handler.AvatarPropertiesRequest);
+            Server.AddJsonRPCHandler("avatar_properties_update", handler.AvatarPropertiesUpdate);
+            Server.AddJsonRPCHandler("avatar_interests_update", handler.AvatarInterestsUpdate);
+            Server.AddJsonRPCHandler("user_preferences_update", handler.UserPreferenecesUpdate);
+            Server.AddJsonRPCHandler("user_preferences_request", handler.UserPreferencesRequest);
+            Server.AddJsonRPCHandler("image_assets_request", handler.AvatarImageAssetsRequest);
+            Server.AddJsonRPCHandler("user_data_request", handler.RequestUserAppData);
+            Server.AddJsonRPCHandler("user_data_update", handler.UpdateUserAppData);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/Profiles/UserProfilesHandlers.cs b/OpenSim/Server/Handlers/Profiles/UserProfilesHandlers.cs
new file mode 100644
index 0000000..49aa8ba
--- /dev/null
+++ b/OpenSim/Server/Handlers/Profiles/UserProfilesHandlers.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.Reflection;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using log4net;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework;
+
+namespace OpenSim.Server.Handlers
+{
+    public class UserProfilesHandlers
+    {
+        public UserProfilesHandlers ()
+        {
+        }
+    }
+
+    public class JsonRpcProfileHandlers
+    {
+        static readonly ILog m_log =
+            LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+        
+        public IUserProfilesService Service
+        {
+            get; private set;
+        }
+        
+        public JsonRpcProfileHandlers(IUserProfilesService service)
+        {
+            Service = service;
+        }
+        
+        #region Classifieds
+        /// <summary>
+        /// Request avatar's classified ads.
+        /// </summary>
+        /// <returns>
+        /// An array containing all the calassified uuid and it's name created by the creator id
+        /// </returns>
+        /// <param name='json'>
+        /// Our parameters are in the OSDMap json["params"]
+        /// </param>
+        /// <param name='response'>
+        /// If set to <c>true</c> response.
+        /// </param>
+        public bool AvatarClassifiedsRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                m_log.DebugFormat ("Classified Request");
+                return false;
+            }
+            
+            OSDMap request = (OSDMap)json["params"];
+            UUID creatorId = new UUID(request["creatorId"].AsString());
+            
+            
+            OSDArray data = (OSDArray) Service.AvatarClassifiedsRequest(creatorId);
+            response.Result = data;
+            
+            return true;
+        }
+        
+        public bool ClassifiedUpdate(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "Error parsing classified update request";
+                m_log.DebugFormat ("Classified Update Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserClassifiedAdd ad = new UserClassifiedAdd();
+            object Ad = (object)ad;
+            OSD.DeserializeMembers(ref Ad, (OSDMap)json["params"]);
+            if(Service.ClassifiedUpdate(ad, ref result))
+            {
+                response.Result = OSD.SerializeMembers(ad);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        
+        public bool ClassifiedDelete(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                m_log.DebugFormat ("Classified Delete Request");
+                return false;
+            }
+            
+            OSDMap request = (OSDMap)json["params"];
+            UUID classifiedId = new UUID(request["classifiedId"].AsString());
+            
+            if (Service.ClassifiedDelete(classifiedId))
+                return true;
+
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = "data error removing record";
+            return false;
+        }
+        
+        public bool ClassifiedInfoRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("Classified Info Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserClassifiedAdd ad = new UserClassifiedAdd();
+            object Ad = (object)ad;
+            OSD.DeserializeMembers(ref Ad, (OSDMap)json["params"]);
+            if(Service.ClassifiedInfoRequest(ref ad, ref result))
+            {
+                response.Result = OSD.SerializeMembers(ad);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        #endregion Classifieds
+        
+        #region Picks
+        public bool AvatarPicksRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                m_log.DebugFormat ("Avatar Picks Request");
+                return false;
+            }
+            
+            OSDMap request = (OSDMap)json["params"];
+            UUID creatorId = new UUID(request["creatorId"].AsString());
+            
+            
+            OSDArray data = (OSDArray) Service.AvatarPicksRequest(creatorId);
+            response.Result = data;
+            
+            return true;
+        }
+        
+        public bool PickInfoRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("Avatar Picks Info Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserProfilePick pick = new UserProfilePick();
+            object Pick = (object)pick;
+            OSD.DeserializeMembers(ref Pick, (OSDMap)json["params"]);
+            if(Service.PickInfoRequest(ref pick, ref result))
+            {
+                response.Result = OSD.SerializeMembers(pick);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        
+        public bool PicksUpdate(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("Avatar Picks Update Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserProfilePick pick = new UserProfilePick();
+            object Pick = (object)pick;
+            OSD.DeserializeMembers(ref Pick, (OSDMap)json["params"]);
+            if(Service.PicksUpdate(ref pick, ref result))
+            {
+                response.Result = OSD.SerializeMembers(pick);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = "unable to update pick";
+            
+            return false;
+        }
+        
+        public bool PicksDelete(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                m_log.DebugFormat ("Avatar Picks Delete Request");
+                return false;
+            }
+            
+            OSDMap request = (OSDMap)json["params"];
+            UUID pickId = new UUID(request["pickId"].AsString());
+            if(Service.PicksDelete(pickId))
+                return true;
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = "data error removing record";
+            return false;
+        }
+        #endregion Picks
+        
+        #region Notes
+        public bool AvatarNotesRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "Params missing";
+                m_log.DebugFormat ("Avatar Notes Request");
+                return false;
+            }
+
+            UserProfileNotes note = new UserProfileNotes();
+            object Note = (object)note;
+            OSD.DeserializeMembers(ref Note, (OSDMap)json["params"]);
+            if(Service.AvatarNotesRequest(ref note))
+            {
+                response.Result = OSD.SerializeMembers(note);
+                return true;
+            }
+
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = "Error reading notes";
+            return false;
+        }
+        
+        public bool NotesUpdate(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "No parameters";
+                m_log.DebugFormat ("Avatar Notes Update Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserProfileNotes note = new UserProfileNotes();
+            object Notes = (object) note;
+            OSD.DeserializeMembers(ref Notes, (OSDMap)json["params"]);
+            if(Service.NotesUpdate(ref note, ref result))
+            {
+                response.Result = OSD.SerializeMembers(note);
+                return true;
+            }
+            return true;
+        }
+        #endregion Notes
+        
+        #region Profile Properties
+        public bool AvatarPropertiesRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("Avatar Properties Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserProfileProperties props = new UserProfileProperties();
+            object Props = (object)props;
+            OSD.DeserializeMembers(ref Props, (OSDMap)json["params"]);
+            if(Service.AvatarPropertiesRequest(ref props, ref result))
+            {
+                response.Result = OSD.SerializeMembers(props);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        
+        public bool AvatarPropertiesUpdate(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("Avatar Properties Update Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserProfileProperties props = new UserProfileProperties();
+            object Props = (object)props;
+            OSD.DeserializeMembers(ref Props, (OSDMap)json["params"]);
+            if(Service.AvatarPropertiesUpdate(ref props, ref result))
+            {
+                response.Result = OSD.SerializeMembers(props);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        #endregion Profile Properties
+        
+        #region Interests
+        public bool AvatarInterestsUpdate(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("Avatar Interests Update Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserProfileProperties props = new UserProfileProperties();
+            object Props = (object)props;
+            OSD.DeserializeMembers(ref Props, (OSDMap)json["params"]);
+            if(Service.AvatarInterestsUpdate(props, ref result))
+            {
+                response.Result = OSD.SerializeMembers(props);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        #endregion Interests
+
+        #region User Preferences
+        public bool UserPreferencesRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                m_log.DebugFormat ("User Preferences Request");
+                return false;
+            }
+
+            string result = string.Empty;
+            UserPreferences prefs = new UserPreferences();
+            object Prefs = (object)prefs;
+            OSD.DeserializeMembers(ref Prefs, (OSDMap)json["params"]);
+            if(Service.UserPreferencesRequest(ref prefs, ref result))
+            {
+                response.Result = OSD.SerializeMembers(prefs);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+//            m_log.InfoFormat("[PROFILES]: User preferences request error - {0}", response.Error.Message);
+            return false;
+        }
+
+        public bool UserPreferenecesUpdate(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("User Preferences Update Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserPreferences prefs = new UserPreferences();
+            object Prefs = (object)prefs;
+            OSD.DeserializeMembers(ref Prefs, (OSDMap)json["params"]);
+            if(Service.UserPreferencesUpdate(ref prefs, ref result))
+            {
+                response.Result = OSD.SerializeMembers(prefs);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            m_log.InfoFormat("[PROFILES]: User preferences update error - {0}", response.Error.Message);
+            return false;
+        }
+        #endregion User Preferences
+
+        #region Utility
+        public bool AvatarImageAssetsRequest(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                m_log.DebugFormat ("Avatar Image Assets Request");
+                return false;
+            }
+            
+            OSDMap request = (OSDMap)json["params"];
+            UUID avatarId = new UUID(request["avatarId"].AsString());
+
+            OSDArray data = (OSDArray) Service.AvatarImageAssetsRequest(avatarId);
+            response.Result = data;
+            
+            return true;
+        }
+        #endregion Utiltiy
+
+        #region UserData
+        public bool RequestUserAppData(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("User Application Service URL Request: No Parameters!");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserAppData props = new UserAppData();
+            object Props = (object)props;
+            OSD.DeserializeMembers(ref Props, (OSDMap)json["params"]);
+            if(Service.RequestUserAppData(ref props, ref result))
+            {
+                OSDMap res = new OSDMap();
+                res["result"] = OSD.FromString("success");
+                res["token"] = OSD.FromString (result);
+                response.Result = res;
+                
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        
+        public bool UpdateUserAppData(OSDMap json, ref JsonRpcResponse response)
+        {
+            if(!json.ContainsKey("params"))
+            {
+                response.Error.Code = ErrorCode.ParseError;
+                response.Error.Message = "no parameters supplied";
+                m_log.DebugFormat ("User App Data Update Request");
+                return false;
+            }
+            
+            string result = string.Empty;
+            UserAppData props = new UserAppData();
+            object Props = (object)props;
+            OSD.DeserializeMembers(ref Props, (OSDMap)json["params"]);
+            if(Service.SetUserAppData(props, ref result))
+            {
+                response.Result = OSD.SerializeMembers(props);
+                return true;
+            }
+            
+            response.Error.Code = ErrorCode.InternalError;
+            response.Error.Message = string.Format("{0}", result);
+            return false;
+        }
+        #endregion UserData
+    }
+}
+
diff --git a/OpenSim/Server/Handlers/Properties/AssemblyInfo.cs b/OpenSim/Server/Handlers/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..780e454
--- /dev/null
+++ b/OpenSim/Server/Handlers/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Server.Handlers")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("6319afca-d740-4468-a95d-d7f87a081cb3")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.8.2.*")]
+
diff --git a/OpenSim/Server/Handlers/Simulation/AgentHandlers.cs b/OpenSim/Server/Handlers/Simulation/AgentHandlers.cs
new file mode 100644
index 0000000..e7544b5
--- /dev/null
+++ b/OpenSim/Server/Handlers/Simulation/AgentHandlers.cs
@@ -0,0 +1,647 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+using System.IO.Compression;
+using System.Reflection;
+using System.Net;
+using System.Text;
+using System.Web;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Simulation
+{
+    public class AgentHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private ISimulationService m_SimulationService;
+
+        public AgentHandler() { }
+
+        public AgentHandler(ISimulationService sim)
+        {
+            m_SimulationService = sim;
+        }
+
+        public Hashtable Handler(Hashtable request)
+        {
+//            m_log.Debug("[CONNECTION DEBUGGING]: AgentHandler Called");
+//
+//            m_log.Debug("---------------------------");
+//            m_log.Debug(" >> uri=" + request["uri"]);
+//            m_log.Debug(" >> content-type=" + request["content-type"]);
+//            m_log.Debug(" >> http-method=" + request["http-method"]);
+//            m_log.Debug("---------------------------\n");
+
+            Hashtable responsedata = new Hashtable();
+            responsedata["content_type"] = "text/html";
+            responsedata["keepalive"] = false;
+
+
+            UUID agentID;
+            UUID regionID;
+            string action;
+            if (!Utils.GetParams((string)request["uri"], out agentID, out regionID, out action))
+            {
+                m_log.InfoFormat("[AGENT HANDLER]: Invalid parameters for agent message {0}", request["uri"]);
+                responsedata["int_response_code"] = 404;
+                responsedata["str_response_string"] = "false";
+
+                return responsedata;
+            }
+
+            // Next, let's parse the verb
+            string method = (string)request["http-method"];
+            if (method.Equals("DELETE"))
+            {
+                string auth_token = string.Empty;
+                if (request.ContainsKey("auth"))
+                    auth_token = request["auth"].ToString();
+
+                DoAgentDelete(request, responsedata, agentID, action, regionID, auth_token);
+                return responsedata;
+            }
+            else if (method.Equals("QUERYACCESS"))
+            {
+                DoQueryAccess(request, responsedata, agentID, regionID);
+                return responsedata;
+            }
+            else
+            {
+                m_log.ErrorFormat("[AGENT HANDLER]: method {0} not supported in agent message {1} (caller is {2})", method, (string)request["uri"], Util.GetCallerIP(request));
+                responsedata["int_response_code"] = HttpStatusCode.MethodNotAllowed;
+                responsedata["str_response_string"] = "Method not allowed";
+
+                return responsedata;
+            }
+
+        }
+
+        protected virtual void DoQueryAccess(Hashtable request, Hashtable responsedata, UUID agentID, UUID regionID)
+        {
+            if (m_SimulationService == null)
+            {
+                m_log.Debug("[AGENT HANDLER]: Agent QUERY called. Harmless but useless.");
+                responsedata["content_type"] = "application/json";
+                responsedata["int_response_code"] = HttpStatusCode.NotImplemented;
+                responsedata["str_response_string"] = string.Empty;
+
+                return;
+            }
+
+            // m_log.DebugFormat("[AGENT HANDLER]: Received QUERYACCESS with {0}", (string)request["body"]);
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
+
+            bool viaTeleport = true;
+            if (args.ContainsKey("viaTeleport"))
+                viaTeleport = args["viaTeleport"].AsBoolean();
+
+            Vector3 position = Vector3.Zero;
+            if (args.ContainsKey("position"))
+                position = Vector3.Parse(args["position"].AsString());
+
+            string agentHomeURI = null;
+            if (args.ContainsKey("agent_home_uri"))
+                agentHomeURI = args["agent_home_uri"].AsString();
+
+            string theirVersion = string.Empty;
+            if (args.ContainsKey("my_version"))
+                theirVersion = args["my_version"].AsString();
+
+            List<UUID> features = new List<UUID>();
+
+            if (args.ContainsKey("features"))
+            {
+                OSDArray array = (OSDArray)args["features"];
+
+                foreach (OSD o in array)
+                    features.Add(new UUID(o.AsString()));
+            }
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = regionID;
+
+            string reason;
+            string version;
+            bool result = m_SimulationService.QueryAccess(destination, agentID, agentHomeURI, viaTeleport, position, theirVersion, features, out version, out reason);
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+
+            OSDMap resp = new OSDMap(3);
+
+            resp["success"] = OSD.FromBoolean(result);
+            resp["reason"] = OSD.FromString(reason);
+            resp["version"] = OSD.FromString(version);
+
+            OSDArray featuresWanted = new OSDArray();
+            foreach (UUID feature in features)
+                featuresWanted.Add(OSD.FromString(feature.ToString()));
+            
+            resp["features"] = featuresWanted;
+
+            // We must preserve defaults here, otherwise a false "success" will not be put into the JSON map!
+            responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp, true);
+
+//            Console.WriteLine("str_response_string [{0}]", responsedata["str_response_string"]);
+        }
+
+        protected void DoAgentDelete(Hashtable request, Hashtable responsedata, UUID id, string action, UUID regionID, string auth_token)
+        {
+            if (string.IsNullOrEmpty(action))
+                m_log.DebugFormat("[AGENT HANDLER]: >>> DELETE <<< RegionID: {0}; from: {1}; auth_code: {2}", regionID, Util.GetCallerIP(request), auth_token);
+            else
+                m_log.DebugFormat("[AGENT HANDLER]: Release {0} to RegionID: {1}", id, regionID);
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = regionID;
+
+            if (action.Equals("release"))
+                ReleaseAgent(regionID, id);
+            else
+                Util.FireAndForget(
+                    o => m_SimulationService.CloseAgent(destination, id, auth_token), null, "AgentHandler.DoAgentDelete");
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = "OpenSim agent " + id.ToString();
+
+            //m_log.DebugFormat("[AGENT HANDLER]: Agent {0} Released/Deleted from region {1}", id, regionID);
+        }
+
+        protected virtual void ReleaseAgent(UUID regionID, UUID id)
+        {
+            m_SimulationService.ReleaseAgent(regionID, id, "");
+        }
+    }
+
+    public class AgentPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private ISimulationService m_SimulationService;
+        protected bool m_Proxy = false;
+
+        public AgentPostHandler(ISimulationService service) :
+                base("POST", "/agent")
+        {
+            m_SimulationService = service;
+        }
+
+        public AgentPostHandler(string path) :
+                base("POST", path)
+        {
+            m_SimulationService = null;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+//            m_log.DebugFormat("[SIMULATION]: Stream handler called");
+
+            Hashtable keysvals = new Hashtable();
+            Hashtable headervals = new Hashtable();
+
+            string[] querystringkeys = httpRequest.QueryString.AllKeys;
+            string[] rHeaders = httpRequest.Headers.AllKeys;
+
+            keysvals.Add("uri", httpRequest.RawUrl);
+            keysvals.Add("content-type", httpRequest.ContentType);
+            keysvals.Add("http-method", httpRequest.HttpMethod);
+
+            foreach (string queryname in querystringkeys)
+                keysvals.Add(queryname, httpRequest.QueryString[queryname]);
+
+            foreach (string headername in rHeaders)
+                headervals[headername] = httpRequest.Headers[headername];
+
+            keysvals.Add("headers", headervals);
+            keysvals.Add("querystringkeys", querystringkeys);
+
+            httpResponse.StatusCode = 200;
+            httpResponse.ContentType = "text/html";
+            httpResponse.KeepAlive = false;
+            Encoding encoding = Encoding.UTF8;
+
+            if (httpRequest.ContentType != "application/json")
+            {
+                httpResponse.StatusCode = 406;
+                return encoding.GetBytes("false");
+            }
+
+            string requestBody;
+
+            Stream inputStream = request;
+            Stream innerStream = null;
+            try
+            {
+                if ((httpRequest.ContentType == "application/x-gzip" || httpRequest.Headers["Content-Encoding"] == "gzip") || (httpRequest.Headers["X-Content-Encoding"] == "gzip"))
+                {
+                    innerStream = inputStream;
+                    inputStream = new GZipStream(innerStream, CompressionMode.Decompress);
+                }
+
+                using (StreamReader reader = new StreamReader(inputStream, encoding))
+                {
+                    requestBody = reader.ReadToEnd();
+                }
+            }
+            finally
+            {
+                if (innerStream != null)
+                    innerStream.Dispose();
+                inputStream.Dispose();
+            }
+
+            keysvals.Add("body", requestBody);
+
+            Hashtable responsedata = new Hashtable();
+
+            UUID agentID;
+            UUID regionID;
+            string action;
+
+            if (!Utils.GetParams((string)keysvals["uri"], out agentID, out regionID, out action))
+            {
+                m_log.InfoFormat("[AGENT HANDLER]: Invalid parameters for agent message {0}", keysvals["uri"]);
+
+                httpResponse.StatusCode = 404;
+
+                return encoding.GetBytes("false");
+            }
+
+            DoAgentPost(keysvals, responsedata, agentID);
+
+            httpResponse.StatusCode = (int)responsedata["int_response_code"];
+            return encoding.GetBytes((string)responsedata["str_response_string"]);
+        }
+
+        protected void DoAgentPost(Hashtable request, Hashtable responsedata, UUID id)
+        {
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
+            if (args == null)
+            {
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
+            }
+
+            AgentDestinationData data = CreateAgentDestinationData();
+            UnpackData(args, data, request);
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = data.uuid;
+            destination.RegionLocX = data.x;
+            destination.RegionLocY = data.y;
+            destination.RegionName = data.name;
+
+            GridRegion gatekeeper = ExtractGatekeeper(data);
+
+            AgentCircuitData aCircuit = new AgentCircuitData();
+            try
+            {
+                aCircuit.UnpackAgentCircuitData(args);
+            }
+            catch (Exception ex)
+            {
+                m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildCreate message {0}", ex.Message);
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
+            }
+
+            GridRegion source = null;
+
+            if (args.ContainsKey("source_uuid"))
+            {
+                source = new GridRegion();
+                source.RegionLocX = Int32.Parse(args["source_x"].AsString());
+                source.RegionLocY = Int32.Parse(args["source_y"].AsString());
+                source.RegionName = args["source_name"].AsString();
+                source.RegionID = UUID.Parse(args["source_uuid"].AsString());
+                
+                if (args.ContainsKey("source_server_uri"))
+                    source.RawServerURI = args["source_server_uri"].AsString();
+                else
+                    source.RawServerURI = null;
+            }
+
+            OSDMap resp = new OSDMap(2);
+            string reason = String.Empty;
+
+            // This is the meaning of POST agent
+            //m_regionClient.AdjustUserInformation(aCircuit);
+            //bool result = m_SimulationService.CreateAgent(destination, aCircuit, teleportFlags, out reason);
+            bool result = CreateAgent(source, gatekeeper, destination, aCircuit, data.flags, data.fromLogin, out reason);
+
+            resp["reason"] = OSD.FromString(reason);
+            resp["success"] = OSD.FromBoolean(result);
+            // Let's also send out the IP address of the caller back to the caller (HG 1.5)
+            resp["your_ip"] = OSD.FromString(GetCallerIP(request));
+
+            // TODO: add reason if not String.Empty?
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp);
+        }
+
+        protected virtual AgentDestinationData CreateAgentDestinationData()
+        {
+            return new AgentDestinationData();
+        }
+
+        protected virtual void UnpackData(OSDMap args, AgentDestinationData data, Hashtable request)
+        {
+            // retrieve the input arguments
+            if (args.ContainsKey("destination_x") && args["destination_x"] != null)
+                Int32.TryParse(args["destination_x"].AsString(), out data.x);
+            else
+                m_log.WarnFormat("  -- request didn't have destination_x");
+            if (args.ContainsKey("destination_y") && args["destination_y"] != null)
+                Int32.TryParse(args["destination_y"].AsString(), out data.y);
+            else
+                m_log.WarnFormat("  -- request didn't have destination_y");
+            if (args.ContainsKey("destination_uuid") && args["destination_uuid"] != null)
+                UUID.TryParse(args["destination_uuid"].AsString(), out data.uuid);
+            if (args.ContainsKey("destination_name") && args["destination_name"] != null)
+                data.name = args["destination_name"].ToString();
+            if (args.ContainsKey("teleport_flags") && args["teleport_flags"] != null)
+                data.flags = args["teleport_flags"].AsUInteger();
+        }
+
+        protected virtual GridRegion ExtractGatekeeper(AgentDestinationData data)
+        {
+            return null;
+        }
+
+        protected string GetCallerIP(Hashtable request)
+        {
+            if (!m_Proxy)
+                return Util.GetCallerIP(request);
+
+            // We're behind a proxy
+            Hashtable headers = (Hashtable)request["headers"];
+
+            //// DEBUG
+            //foreach (object o in headers.Keys)
+            //    m_log.DebugFormat("XXX {0} = {1}", o.ToString(), (headers[o] == null? "null" : headers[o].ToString()));
+
+            string xff = "X-Forwarded-For";
+            if (headers.ContainsKey(xff.ToLower()))
+                xff = xff.ToLower();
+
+            if (!headers.ContainsKey(xff) || headers[xff] == null)
+            {
+                m_log.WarnFormat("[AGENT HANDLER]: No XFF header");
+                return Util.GetCallerIP(request);
+            }
+
+            m_log.DebugFormat("[AGENT HANDLER]: XFF is {0}", headers[xff]);
+
+            IPEndPoint ep = Util.GetClientIPFromXFF((string)headers[xff]);
+            if (ep != null)
+                return ep.Address.ToString();
+
+            // Oops
+            return Util.GetCallerIP(request);
+        }
+
+        // subclasses can override this
+        protected virtual bool CreateAgent(GridRegion source, GridRegion gatekeeper, GridRegion destination,
+            AgentCircuitData aCircuit, uint teleportFlags, bool fromLogin, out string reason)
+        {
+            return m_SimulationService.CreateAgent(source, destination, aCircuit, teleportFlags, out reason);
+        }
+    }
+
+    public class AgentPutHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private ISimulationService m_SimulationService;
+        protected bool m_Proxy = false;
+
+        public AgentPutHandler(ISimulationService service) :
+                base("PUT", "/agent")
+        {
+            m_SimulationService = service;
+        }
+
+        public AgentPutHandler(string path) :
+                base("PUT", path)
+        {
+            m_SimulationService = null;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+//            m_log.DebugFormat("[SIMULATION]: Stream handler called");
+
+            Hashtable keysvals = new Hashtable();
+            Hashtable headervals = new Hashtable();
+
+            string[] querystringkeys = httpRequest.QueryString.AllKeys;
+            string[] rHeaders = httpRequest.Headers.AllKeys;
+
+            keysvals.Add("uri", httpRequest.RawUrl);
+            keysvals.Add("content-type", httpRequest.ContentType);
+            keysvals.Add("http-method", httpRequest.HttpMethod);
+
+            foreach (string queryname in querystringkeys)
+                keysvals.Add(queryname, httpRequest.QueryString[queryname]);
+
+            foreach (string headername in rHeaders)
+                headervals[headername] = httpRequest.Headers[headername];
+
+            keysvals.Add("headers", headervals);
+            keysvals.Add("querystringkeys", querystringkeys);
+
+            String requestBody;
+            Encoding encoding = Encoding.UTF8;
+
+            Stream inputStream = request;
+            Stream innerStream = null;
+            try
+            {
+                if ((httpRequest.ContentType == "application/x-gzip" || httpRequest.Headers["Content-Encoding"] == "gzip") || (httpRequest.Headers["X-Content-Encoding"] == "gzip"))
+                {
+                    innerStream = inputStream;
+                    inputStream = new GZipStream(innerStream, CompressionMode.Decompress);
+                }
+
+                using (StreamReader reader = new StreamReader(inputStream, encoding))
+                {
+                    requestBody = reader.ReadToEnd();
+                }
+            }
+            finally
+            {
+                if (innerStream != null)
+                    innerStream.Dispose();
+                inputStream.Dispose();
+            }
+
+            keysvals.Add("body", requestBody);
+
+            httpResponse.StatusCode = 200;
+            httpResponse.ContentType = "text/html";
+            httpResponse.KeepAlive = false;
+
+            Hashtable responsedata = new Hashtable();
+
+            UUID agentID;
+            UUID regionID;
+            string action;
+
+            if (!Utils.GetParams((string)keysvals["uri"], out agentID, out regionID, out action))
+            {
+                m_log.InfoFormat("[AGENT HANDLER]: Invalid parameters for agent message {0}", keysvals["uri"]);
+
+                httpResponse.StatusCode = 404;
+
+                return encoding.GetBytes("false");
+            }
+
+            DoAgentPut(keysvals, responsedata);
+
+            httpResponse.StatusCode = (int)responsedata["int_response_code"];
+            return encoding.GetBytes((string)responsedata["str_response_string"]);
+        }
+
+        protected void DoAgentPut(Hashtable request, Hashtable responsedata)
+        {
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
+            if (args == null)
+            {
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
+            }
+
+            // retrieve the input arguments
+            int x = 0, y = 0;
+            UUID uuid = UUID.Zero;
+            string regionname = string.Empty;
+            if (args.ContainsKey("destination_x") && args["destination_x"] != null)
+                Int32.TryParse(args["destination_x"].AsString(), out x);
+            if (args.ContainsKey("destination_y") && args["destination_y"] != null)
+                Int32.TryParse(args["destination_y"].AsString(), out y);
+            if (args.ContainsKey("destination_uuid") && args["destination_uuid"] != null)
+                UUID.TryParse(args["destination_uuid"].AsString(), out uuid);
+            if (args.ContainsKey("destination_name") && args["destination_name"] != null)
+                regionname = args["destination_name"].ToString();
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = uuid;
+            destination.RegionLocX = x;
+            destination.RegionLocY = y;
+            destination.RegionName = regionname;
+
+            string messageType;
+            if (args["message_type"] != null)
+                messageType = args["message_type"].AsString();
+            else
+            {
+                m_log.Warn("[AGENT HANDLER]: Agent Put Message Type not found. ");
+                messageType = "AgentData";
+            }
+
+            bool result = true;
+            if ("AgentData".Equals(messageType))
+            {
+                AgentData agent = new AgentData();
+                try
+                {
+                    agent.Unpack(args, m_SimulationService.GetScene(destination.RegionID));
+                }
+                catch (Exception ex)
+                {
+                    m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
+                    responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                    responsedata["str_response_string"] = "Bad request";
+                    return;
+                }
+
+                //agent.Dump();
+                // This is one of the meanings of PUT agent
+                result = UpdateAgent(destination, agent);
+            }
+            else if ("AgentPosition".Equals(messageType))
+            {
+                AgentPosition agent = new AgentPosition();
+                try
+                {
+                    agent.Unpack(args, m_SimulationService.GetScene(destination.RegionID));
+                }
+                catch (Exception ex)
+                {
+                    m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
+                    return;
+                }
+                //agent.Dump();
+                // This is one of the meanings of PUT agent
+                result = m_SimulationService.UpdateAgent(destination, agent);
+
+            }
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = result.ToString();
+            //responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp); ??? instead
+        }
+
+        // subclasses can override this
+        protected virtual bool UpdateAgent(GridRegion destination, AgentData agent)
+        {
+            return m_SimulationService.UpdateAgent(destination, agent);
+        }
+    }
+
+    public class AgentDestinationData
+    {
+        public int x;
+        public int y;
+        public string name;
+        public UUID uuid;
+        public uint flags;
+        public bool fromLogin;
+    }
+}
diff --git a/OpenSim/Server/Handlers/Simulation/ObjectHandlers.cs b/OpenSim/Server/Handlers/Simulation/ObjectHandlers.cs
new file mode 100644
index 0000000..dbb1a15
--- /dev/null
+++ b/OpenSim/Server/Handlers/Simulation/ObjectHandlers.cs
@@ -0,0 +1,218 @@
+/*
+ * 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;
+using System.IO;
+using System.Reflection;
+using System.Net;
+using System.Text;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Simulation
+{
+    public class ObjectHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private ISimulationService m_SimulationService;
+
+        public ObjectHandler() { }
+
+        public ObjectHandler(ISimulationService sim)
+        {
+            m_SimulationService = sim;
+        }
+
+        public Hashtable Handler(Hashtable request)
+        {
+            //m_log.Debug("[CONNECTION DEBUGGING]: ObjectHandler Called");
+
+            //m_log.Debug("---------------------------");
+            //m_log.Debug(" >> uri=" + request["uri"]);
+            //m_log.Debug(" >> content-type=" + request["content-type"]);
+            //m_log.Debug(" >> http-method=" + request["http-method"]);
+            //m_log.Debug("---------------------------\n");
+
+            Hashtable responsedata = new Hashtable();
+            responsedata["content_type"] = "text/html";
+
+            UUID objectID;
+            UUID regionID;
+            string action;
+            if (!Utils.GetParams((string)request["uri"], out objectID, out regionID, out action))
+            {
+                m_log.InfoFormat("[OBJECT HANDLER]: Invalid parameters for object message {0}", request["uri"]);
+                responsedata["int_response_code"] = 404;
+                responsedata["str_response_string"] = "false";
+
+                return responsedata;
+            }
+
+            try
+            {
+                // Next, let's parse the verb
+                string method = (string)request["http-method"];
+                if (method.Equals("POST"))
+                {
+                    DoObjectPost(request, responsedata, regionID);
+                    return responsedata;
+                }
+                //else if (method.Equals("DELETE"))
+                //{
+                //    DoObjectDelete(request, responsedata, agentID, action, regionHandle);
+                //    return responsedata;
+                //}
+                else
+                {
+                    m_log.InfoFormat("[OBJECT HANDLER]: method {0} not supported in object message", method);
+                    responsedata["int_response_code"] = HttpStatusCode.MethodNotAllowed;
+                    responsedata["str_response_string"] = "Method not allowed";
+
+                    return responsedata;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[OBJECT HANDLER]: Caught exception {0}", e.StackTrace);
+                responsedata["int_response_code"] = HttpStatusCode.InternalServerError;
+                responsedata["str_response_string"] = "Internal server error";
+
+                return responsedata;
+
+            }
+        }
+
+        protected void DoObjectPost(Hashtable request, Hashtable responsedata, UUID regionID)
+        {
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
+            if (args == null)
+            {
+                responsedata["int_response_code"] = 400;
+                responsedata["str_response_string"] = "false";
+                return;
+            }
+            // retrieve the input arguments
+            int x = 0, y = 0;
+            UUID uuid = UUID.Zero;
+            string regionname = string.Empty;
+            Vector3 newPosition = Vector3.Zero;
+
+            if (args.ContainsKey("destination_x") && args["destination_x"] != null)
+                Int32.TryParse(args["destination_x"].AsString(), out x);
+            if (args.ContainsKey("destination_y") && args["destination_y"] != null)
+                Int32.TryParse(args["destination_y"].AsString(), out y);
+            if (args.ContainsKey("destination_uuid") && args["destination_uuid"] != null)
+                UUID.TryParse(args["destination_uuid"].AsString(), out uuid);
+            if (args.ContainsKey("destination_name") && args["destination_name"] != null)
+                regionname = args["destination_name"].ToString();
+            if (args.ContainsKey("new_position") && args["new_position"] != null)
+                Vector3.TryParse(args["new_position"], out newPosition);
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = uuid;
+            destination.RegionLocX = x;
+            destination.RegionLocY = y;
+            destination.RegionName = regionname;
+
+            string sogXmlStr = "", extraStr = "", stateXmlStr = "";
+            if (args.ContainsKey("sog") && args["sog"] != null)
+                sogXmlStr = args["sog"].AsString();
+            if (args.ContainsKey("extra") && args["extra"] != null)
+                extraStr = args["extra"].AsString();
+
+            IScene s = m_SimulationService.GetScene(destination.RegionID);
+            ISceneObject sog = null;
+            try
+            {
+                //m_log.DebugFormat("[OBJECT HANDLER]: received {0}", sogXmlStr);
+                sog = s.DeserializeObject(sogXmlStr);
+                sog.ExtraFromXmlString(extraStr);
+            }
+            catch (Exception ex)
+            {
+                m_log.InfoFormat("[OBJECT HANDLER]: exception on deserializing scene object {0}", ex.Message);
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
+            }
+
+            if (args.ContainsKey("modified"))
+                sog.HasGroupChanged = args["modified"].AsBoolean();
+            else
+                sog.HasGroupChanged = false;
+
+            if ((args["state"] != null) && s.AllowScriptCrossings)
+            {
+                stateXmlStr = args["state"].AsString();
+                if (stateXmlStr != "")
+                {
+                    try
+                    {
+                        sog.SetState(stateXmlStr, s);
+                    }
+                    catch (Exception ex)
+                    {
+                        m_log.InfoFormat("[OBJECT HANDLER]: exception on setting state for scene object {0}", ex.Message);
+                        // ignore and continue
+                    }
+                }
+            }
+
+            bool result = false;
+            try
+            {
+                // This is the meaning of POST object
+                result = CreateObject(destination, newPosition, sog);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[OBJECT HANDLER]: Exception in CreateObject: {0}", e.StackTrace);
+            }
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = result.ToString();
+        }
+
+        // subclasses can override this
+        protected virtual bool CreateObject(GridRegion destination, Vector3 newPosition, ISceneObject sog)
+        {
+            return m_SimulationService.CreateObject(destination, newPosition, sog, false);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Simulation/SimulationServiceInConnector.cs b/OpenSim/Server/Handlers/Simulation/SimulationServiceInConnector.cs
new file mode 100644
index 0000000..0da08f8
--- /dev/null
+++ b/OpenSim/Server/Handlers/Simulation/SimulationServiceInConnector.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;
+using Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.Simulation
+{
+    public class SimulationServiceInConnector : ServiceConnector
+    {
+        private ISimulationService m_LocalSimulationService;
+//        private IAuthenticationService m_AuthenticationService;
+
+        public SimulationServiceInConnector(IConfigSource config, IHttpServer server, IScene scene) :
+                base(config, server, String.Empty)
+        {
+            m_LocalSimulationService = scene.RequestModuleInterface<ISimulationService>();
+            m_LocalSimulationService = m_LocalSimulationService.GetInnerService();
+
+            // This one MUST be a stream handler because compressed fatpacks
+            // are pure binary and shoehorning that into a string with UTF-8
+            // encoding breaks it
+            server.AddStreamHandler(new AgentPostHandler(m_LocalSimulationService));
+            server.AddStreamHandler(new AgentPutHandler(m_LocalSimulationService));
+            server.AddHTTPHandler("/agent/", new AgentHandler(m_LocalSimulationService).Handler);
+            server.AddHTTPHandler("/object/", new ObjectHandler(m_LocalSimulationService).Handler);
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/Simulation/Utils.cs b/OpenSim/Server/Handlers/Simulation/Utils.cs
new file mode 100644
index 0000000..ed379da
--- /dev/null
+++ b/OpenSim/Server/Handlers/Simulation/Utils.cs
@@ -0,0 +1,103 @@
+/*
+ * 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.Reflection;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using log4net;
+
+namespace OpenSim.Server.Handlers.Simulation
+{
+    public class Utils
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Extract the param from an uri.
+        /// </summary>
+        /// <param name="uri">Something like this: /agent/uuid/ or /agent/uuid/handle/release</param>
+        /// <param name="uri">uuid on uuid field</param>
+        /// <param name="action">optional action</param>
+        public static bool GetParams(string uri, out UUID uuid, out UUID regionID, out string action)
+        {
+            uuid = UUID.Zero;
+            regionID = UUID.Zero;
+            action = "";
+
+            uri = uri.Trim(new char[] { '/' });
+            string[] parts = uri.Split('/');
+            if (parts.Length <= 1)
+            {
+                return false;
+            }
+            else
+            {
+                if (!UUID.TryParse(parts[1], out uuid))
+                    return false;
+
+                if (parts.Length >= 3)
+                    UUID.TryParse(parts[2], out regionID);
+                if (parts.Length >= 4)
+                    action = parts[3];
+
+                return true;
+            }
+        }
+
+        public static OSDMap GetOSDMap(string data)
+        {
+            OSDMap args = null;
+            try
+            {
+                OSD buffer;
+                // We should pay attention to the content-type, but let's assume we know it's Json
+                buffer = OSDParser.DeserializeJson(data);
+                if (buffer.Type == OSDType.Map)
+                {
+                    args = (OSDMap)buffer;
+                    return args;
+                }
+                else
+                {
+                    // uh?
+                    m_log.Debug(("[REST COMMS]: Got OSD of unexpected type " + buffer.Type.ToString()));
+                    return null;
+                }
+            }
+            catch (Exception ex)
+            {
+                m_log.Debug("[REST COMMS]: exception on parse of REST message " + ex.Message);
+                return null;
+            }
+        }
+
+    }
+}
diff --git a/OpenSim/Server/Handlers/UserAccounts/UserAccountServerConnector.cs b/OpenSim/Server/Handlers/UserAccounts/UserAccountServerConnector.cs
new file mode 100644
index 0000000..e95e3dc
--- /dev/null
+++ b/OpenSim/Server/Handlers/UserAccounts/UserAccountServerConnector.cs
@@ -0,0 +1,64 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Server.Handlers.Base;
+
+namespace OpenSim.Server.Handlers.UserAccounts
+{
+    public class UserAccountServiceConnector : ServiceConnector
+    {
+        private IUserAccountService m_UserAccountService;
+        private string m_ConfigName = "UserAccountService";
+
+        public UserAccountServiceConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+            string service = serverConfig.GetString("LocalServiceModule",
+                    String.Empty);
+
+            if (service == String.Empty)
+                throw new Exception("No LocalServiceModule in config file");
+
+            Object[] args = new Object[] { config };
+            m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(service, args);
+
+            IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
+
+            server.AddStreamHandler(new UserAccountServerPostHandler(m_UserAccountService, serverConfig, auth));
+        }
+    }
+}
diff --git a/OpenSim/Server/Handlers/UserAccounts/UserAccountServerPostHandler.cs b/OpenSim/Server/Handlers/UserAccounts/UserAccountServerPostHandler.cs
new file mode 100644
index 0000000..21eb790
--- /dev/null
+++ b/OpenSim/Server/Handlers/UserAccounts/UserAccountServerPostHandler.cs
@@ -0,0 +1,348 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System;
+using System.Reflection;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.UserAccountService;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework.ServiceAuth;
+using OpenMetaverse;
+
+namespace OpenSim.Server.Handlers.UserAccounts
+{
+    public class UserAccountServerPostHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IUserAccountService m_UserAccountService;
+        private bool m_AllowCreateUser = false;
+        private bool m_AllowSetAccount = false;
+
+        public UserAccountServerPostHandler(IUserAccountService service)
+            : this(service, null, null) {}
+
+        public UserAccountServerPostHandler(IUserAccountService service, IConfig config, IServiceAuth auth) :
+                base("POST", "/accounts", auth)
+        {
+            m_UserAccountService = service;
+
+            if (config != null)
+            {
+                m_AllowCreateUser = config.GetBoolean("AllowCreateUser", m_AllowCreateUser);
+                m_AllowSetAccount = config.GetBoolean("AllowSetAccount", m_AllowSetAccount);
+            }
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream requestData,
+                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            StreamReader sr = new StreamReader(requestData);
+            string body = sr.ReadToEnd();
+            sr.Close();
+            body = body.Trim();
+
+            // We need to check the authorization header
+            //httpRequest.Headers["authorization"] ...
+
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
+            string method = string.Empty;
+            try
+            {
+                Dictionary<string, object> request =
+                        ServerUtils.ParseQueryString(body);
+
+                if (!request.ContainsKey("METHOD"))
+                    return FailureResult();
+
+                method = request["METHOD"].ToString();
+
+                switch (method)
+                {
+                    case "createuser":
+                        if (m_AllowCreateUser)
+                            return CreateUser(request);
+                        else
+                            break;
+                    case "getaccount":
+                        return GetAccount(request);
+                    case "getaccounts":
+                        return GetAccounts(request);
+                    case "setaccount":
+                        if (m_AllowSetAccount)
+                            return StoreAccount(request);
+                        else
+                            break;
+                }
+
+                m_log.DebugFormat("[USER SERVICE HANDLER]: unknown method request: {0}", method);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[USER SERVICE HANDLER]: Exception in method {0}: {1}", method, e);
+            }
+
+            return FailureResult();
+        }
+
+        byte[] GetAccount(Dictionary<string, object> request)
+        {
+            UserAccount account = null;
+            UUID scopeID = UUID.Zero;
+            Dictionary<string, object> result = new Dictionary<string, object>();
+
+            if (request.ContainsKey("ScopeID") && !UUID.TryParse(request["ScopeID"].ToString(), out scopeID))
+            {
+                result["result"] = "null";
+                return ResultToBytes(result);
+            }
+
+            if (request.ContainsKey("UserID") && request["UserID"] != null)
+            {
+                UUID userID;
+                if (UUID.TryParse(request["UserID"].ToString(), out userID))
+                    account = m_UserAccountService.GetUserAccount(scopeID, userID);
+            }
+            else if (request.ContainsKey("PrincipalID") && request["PrincipalID"] != null)
+            {
+                UUID userID;
+                if (UUID.TryParse(request["PrincipalID"].ToString(), out userID))
+                    account = m_UserAccountService.GetUserAccount(scopeID, userID);
+            }
+            else if (request.ContainsKey("Email") && request["Email"] != null)
+            {
+                account = m_UserAccountService.GetUserAccount(scopeID, request["Email"].ToString());
+            }
+            else if (request.ContainsKey("FirstName") && request.ContainsKey("LastName") &&
+                request["FirstName"] != null && request["LastName"] != null)
+            {
+                account = m_UserAccountService.GetUserAccount(scopeID, request["FirstName"].ToString(), request["LastName"].ToString());
+            }
+
+            if (account == null)
+            {
+                result["result"] = "null";
+            }
+            else
+            {
+                result["result"] = account.ToKeyValuePairs();
+            }
+
+            return ResultToBytes(result);
+        }
+
+        byte[] GetAccounts(Dictionary<string, object> request)
+        {
+            if (!request.ContainsKey("query"))
+                return FailureResult();
+
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("ScopeID") && !UUID.TryParse(request["ScopeID"].ToString(), out scopeID))
+                return FailureResult();
+
+            string query = request["query"].ToString();
+
+            List<UserAccount> accounts = m_UserAccountService.GetUserAccounts(scopeID, query);
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            if ((accounts == null) || ((accounts != null) && (accounts.Count == 0)))
+            {
+                result["result"] = "null";
+            }
+            else
+            {
+                int i = 0;
+                foreach (UserAccount acc in accounts)
+                {
+                    Dictionary<string, object> rinfoDict = acc.ToKeyValuePairs();
+                    result["account" + i] = rinfoDict;
+                    i++;
+                }
+            }
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+
+            //m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
+        byte[] StoreAccount(Dictionary<string, object> request)
+        {
+            UUID principalID = UUID.Zero;
+            if (request.ContainsKey("PrincipalID") && !UUID.TryParse(request["PrincipalID"].ToString(), out principalID))
+                return FailureResult();
+
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("ScopeID") && !UUID.TryParse(request["ScopeID"].ToString(), out scopeID))
+                return FailureResult();
+
+            UserAccount existingAccount = m_UserAccountService.GetUserAccount(scopeID, principalID);
+            if (existingAccount == null)
+                return FailureResult();
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+
+            if (request.ContainsKey("FirstName"))
+                existingAccount.FirstName = request["FirstName"].ToString();
+
+            if (request.ContainsKey("LastName"))
+                existingAccount.LastName = request["LastName"].ToString();
+
+            if (request.ContainsKey("Email"))
+                existingAccount.Email = request["Email"].ToString();
+
+            int created = 0;
+            if (request.ContainsKey("Created") && int.TryParse(request["Created"].ToString(), out created))
+                existingAccount.Created = created;
+
+            int userLevel = 0;
+            if (request.ContainsKey("UserLevel") && int.TryParse(request["UserLevel"].ToString(), out userLevel))
+                existingAccount.UserLevel = userLevel;
+
+            int userFlags = 0;
+            if (request.ContainsKey("UserFlags") && int.TryParse(request["UserFlags"].ToString(), out userFlags))
+                existingAccount.UserFlags = userFlags;
+
+            if (request.ContainsKey("UserTitle"))
+                existingAccount.UserTitle = request["UserTitle"].ToString();
+
+            if (!m_UserAccountService.StoreUserAccount(existingAccount))
+            {
+                m_log.ErrorFormat(
+                    "[USER ACCOUNT SERVER POST HANDLER]: Account store failed for account {0} {1} {2}",
+                    existingAccount.FirstName, existingAccount.LastName, existingAccount.PrincipalID);
+
+                return FailureResult();
+            }
+
+            result["result"] = existingAccount.ToKeyValuePairs();
+
+            return ResultToBytes(result);
+        }
+
+        byte[] CreateUser(Dictionary<string, object> request)
+        {
+            if (! request.ContainsKey("FirstName")
+                    && request.ContainsKey("LastName")
+                    && request.ContainsKey("Password"))
+                return FailureResult();
+
+            Dictionary<string, object> result = new Dictionary<string, object>();
+
+            UUID scopeID = UUID.Zero;
+            if (request.ContainsKey("ScopeID") && !UUID.TryParse(request["ScopeID"].ToString(), out scopeID))
+                return FailureResult();
+
+            UUID principalID = UUID.Random();
+            if (request.ContainsKey("PrincipalID") && !UUID.TryParse(request["PrincipalID"].ToString(), out principalID))
+                return FailureResult();
+
+            string firstName = request["FirstName"].ToString();
+            string lastName = request["LastName"].ToString();
+            string password = request["Password"].ToString();
+
+            string email = "";
+            if (request.ContainsKey("Email"))
+                email = request["Email"].ToString();
+
+            UserAccount createdUserAccount = null;
+
+            if (m_UserAccountService is UserAccountService)
+                createdUserAccount
+                    = ((UserAccountService)m_UserAccountService).CreateUser(
+                        scopeID, principalID, firstName, lastName, password, email);
+
+            if (createdUserAccount == null)
+                return FailureResult();
+
+            result["result"] = createdUserAccount.ToKeyValuePairs();
+
+            return ResultToBytes(result);
+        }
+
+        private byte[] SuccessResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Success"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] FailureResult()
+        {
+            XmlDocument doc = new XmlDocument();
+
+            XmlNode xmlnode = doc.CreateNode(XmlNodeType.XmlDeclaration,
+                    "", "");
+
+            doc.AppendChild(xmlnode);
+
+            XmlElement rootElement = doc.CreateElement("", "ServerResponse",
+                    "");
+
+            doc.AppendChild(rootElement);
+
+            XmlElement result = doc.CreateElement("", "result", "");
+            result.AppendChild(doc.CreateTextNode("Failure"));
+
+            rootElement.AppendChild(result);
+
+            return Util.DocToBytes(doc);
+        }
+
+        private byte[] ResultToBytes(Dictionary<string, object> result)
+        {
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Properties/AssemblyInfo.cs b/OpenSim/Server/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..ee45e10
--- /dev/null
+++ b/OpenSim/Server/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Robust")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("d347c5cb-baf8-4566-a221-35d948e1776f")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Server/ServerMain.cs b/OpenSim/Server/ServerMain.cs
new file mode 100644
index 0000000..65e9287
--- /dev/null
+++ b/OpenSim/Server/ServerMain.cs
@@ -0,0 +1,161 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using System.Reflection;
+using System;
+using System.Collections.Generic;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using Mono.Addins;
+
+namespace OpenSim.Server
+{
+    public class OpenSimServer
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected static HttpServerBase m_Server = null;
+
+        protected static List<IServiceConnector> m_ServiceConnectors =
+                new List<IServiceConnector>();
+
+        protected static PluginLoader loader;
+
+        public static int Main(string[] args)
+        {
+            m_Server = new HttpServerBase("R.O.B.U.S.T.", args);
+            
+            string registryLocation;
+
+            IConfig serverConfig = m_Server.Config.Configs["Startup"];
+            if (serverConfig == null)
+            {
+                System.Console.WriteLine("Startup config section missing in .ini file");
+                throw new Exception("Configuration error");
+            }
+
+            string connList = serverConfig.GetString("ServiceConnectors", String.Empty);
+            
+            registryLocation = serverConfig.GetString("RegistryLocation",".");
+
+            IConfig servicesConfig = m_Server.Config.Configs["ServiceList"];
+            if (servicesConfig != null)
+            {
+                List<string> servicesList = new List<string>();
+                if (connList != String.Empty)
+                    servicesList.Add(connList);
+
+                foreach (string k in servicesConfig.GetKeys())
+                {
+                    string v = servicesConfig.GetString(k);
+                    if (v != String.Empty)
+                        servicesList.Add(v);
+                }
+
+                connList = String.Join(",", servicesList.ToArray());
+            }
+
+            string[] conns = connList.Split(new char[] {',', ' ', '\n', '\r', '\t'});
+
+//            int i = 0;
+            foreach (string c in conns)
+            {
+                if (c == String.Empty)
+                    continue;
+
+                string configName = String.Empty;
+                string conn = c;
+                uint port = 0;
+
+                string[] split1 = conn.Split(new char[] {'/'});
+                if (split1.Length > 1)
+                {
+                    conn = split1[1];
+
+                    string[] split2 = split1[0].Split(new char[] {'@'});
+                    if (split2.Length > 1)
+                    {
+                        configName = split2[0];
+                        port = Convert.ToUInt32(split2[1]);
+                    }
+                    else
+                    {
+                        port = Convert.ToUInt32(split1[0]);
+                    }
+                }
+                string[] parts = conn.Split(new char[] {':'});
+                string friendlyName = parts[0];
+                if (parts.Length > 1)
+                    friendlyName = parts[1];
+
+                IHttpServer server;
+
+                if (port != 0)
+                    server = MainServer.GetHttpServer(port);
+                else
+                    server = MainServer.Instance;
+
+                m_log.InfoFormat("[SERVER]: Loading {0} on port {1}", friendlyName, server.Port);
+
+                IServiceConnector connector = null;
+
+                Object[] modargs = new Object[] { m_Server.Config, server, configName };
+                connector = ServerUtils.LoadPlugin<IServiceConnector>(conn, modargs);
+
+                if (connector == null)
+                {
+                    modargs = new Object[] { m_Server.Config, server };
+                    connector = ServerUtils.LoadPlugin<IServiceConnector>(conn, modargs);
+                }
+
+                if (connector != null)
+                {
+                    m_ServiceConnectors.Add(connector);
+                    m_log.InfoFormat("[SERVER]: {0} loaded successfully", friendlyName);
+                }
+                else
+                {
+                    m_log.ErrorFormat("[SERVER]: Failed to load {0}", conn);
+                }
+            }
+
+            loader = new PluginLoader(m_Server.Config, registryLocation);
+
+            int res = m_Server.Run();
+
+            Environment.Exit(res);
+
+            return 0;
+        }
+    }
+}