39 files changed, 12519 insertions, 0 deletions

diff --git a/OpenSim/Services/Connectors/AgentPreferences/AgentPreferencesConnector.cs b/OpenSim/Services/Connectors/AgentPreferences/AgentPreferencesConnector.cs
new file mode 100644
index 0000000..1dbc0c8
--- /dev/null
+++ b/OpenSim/Services/Connectors/AgentPreferences/AgentPreferencesConnector.cs
@@ -0,0 +1,230 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using IAvatarService = OpenSim.Services.Interfaces.IAvatarService;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class AgentPreferencesServicesConnector : BaseServiceConnector, IAgentPreferencesService
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public AgentPreferencesServicesConnector()
+        {
+        }
+
+        public AgentPreferencesServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public AgentPreferencesServicesConnector(IConfigSource source)
+            : base(source, "AgentPreferencesService")
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["AgentPreferencesService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[AGENT PREFERENCES CONNECTOR]: AgentPreferencesService missing from OpenSim.ini");
+                throw new Exception("Agent Preferences connector init error");
+            }
+
+            string serviceURI = gridConfig.GetString("AgentPreferencesServerURI", String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[AGENT PREFERENCES CONNECTOR]: No Server URI named in section AgentPreferences");
+                throw new Exception("Agent Preferences connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            base.Initialise(source, "AgentPreferencesService");
+        }
+
+        #region IAgentPreferencesService
+
+        public AgentPrefs GetAgentPreferences(UUID principalID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            string reply = string.Empty;
+            string uri = String.Concat(m_ServerURI, "/agentprefs");
+
+            sendData["METHOD"] = "getagentprefs";
+            sendData["UserID"] = principalID;
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            // m_log.DebugFormat("[AGENT PREFS CONNECTOR]: queryString = {0}", reqString);
+
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (String.IsNullOrEmpty(reply))
+                {
+                    m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: GetAgentPreferences received null or empty reply");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: Exception when contacting agent preferences server at {0}: {1}", uri, e.Message);
+            }
+                
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+            if (replyData != null)
+            {
+                if (replyData.ContainsKey("result") &&
+                    (replyData["result"].ToString() == "null" || replyData["result"].ToString() == "Failure"))
+                {
+                    m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: GetAgentPreferences received Failure response");
+                    return null;
+                }
+            }
+            else
+            {
+                m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: GetAgentPreferences received null response");
+                return null;
+            }
+            AgentPrefs prefs = new AgentPrefs(replyData);
+            return prefs;
+        }
+
+        public bool StoreAgentPreferences(AgentPrefs data)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["METHOD"] = "setagentprefs";
+
+            sendData["PrincipalID"] = data.PrincipalID.ToString();
+            sendData["AccessPrefs"] = data.AccessPrefs;
+            sendData["HoverHeight"] = data.HoverHeight.ToString();
+            sendData["Language"] = data.Language;
+            sendData["LanguageIsPublic"] = data.LanguageIsPublic.ToString();
+            sendData["PermEveryone"] = data.PermEveryone.ToString();
+            sendData["PermGroup"] = data.PermGroup.ToString();
+            sendData["PermNextOwner"] = data.PermNextOwner.ToString();
+
+            string uri = String.Concat(m_ServerURI, "/agentprefs");
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            // m_log.DebugFormat("[AGENT PREFS CONNECTOR]: queryString = {0}", reqString);
+
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                    {
+                        m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: StoreAgentPreferences reply data does not contain result field");
+                    }
+
+                }
+                else
+                    m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: StoreAgentPreferences received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: Exception when contacting agent preferences server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public string GetLang(UUID principalID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            string reply = string.Empty;
+
+            sendData["METHOD"] = "getagentlang";
+            sendData["UserID"] = principalID.ToString();
+
+            string uri = String.Concat(m_ServerURI, "/agentprefs");
+            string reqString = ServerUtils.BuildQueryString(sendData);
+
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (String.IsNullOrEmpty(reply))
+                {
+                    m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: GetLang received null or empty reply");
+                    return "en-us"; // I guess? Gotta return somethin'!
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: Exception when contacting agent preferences server at {0}: {1}", uri, e.Message);
+            }
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+            if (replyData != null)
+            {
+                if (replyData.ContainsKey("result") &&
+                    (replyData["result"].ToString() == "null" || replyData["result"].ToString() == "Failure"))
+                {
+                    m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: GetLang received Failure response");
+                    return "en-us";
+                }
+                if (replyData.ContainsKey("Language"))
+                    return replyData["Language"].ToString();
+            }
+            else
+            {
+                m_log.DebugFormat("[AGENT PREFERENCES CONNECTOR]: GetLang received null response");
+
+            }
+            return "en-us";
+        }
+
+        #endregion IAgentPreferencesService
+    }
+}
diff --git a/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
new file mode 100644
index 0000000..badacb7
--- /dev/null
+++ b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
@@ -0,0 +1,373 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Communications;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class AssetServicesConnector : BaseServiceConnector, IAssetService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+        private IImprovedAssetCache m_Cache = null;
+        private int m_maxAssetRequestConcurrency = 30;
+        
+        private delegate void AssetRetrievedEx(AssetBase asset);
+
+        // Keeps track of concurrent requests for the same asset, so that it's only loaded once.
+        // Maps: Asset ID -> Handlers which will be called when the asset has been loaded
+        private Dictionary<string, AssetRetrievedEx> m_AssetHandlers = new Dictionary<string, AssetRetrievedEx>();
+
+        public int MaxAssetRequestConcurrency
+        {
+            get { return m_maxAssetRequestConcurrency; }
+            set { m_maxAssetRequestConcurrency = value; }
+        }
+
+        public AssetServicesConnector()
+        {
+        }
+
+        public AssetServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public AssetServicesConnector(IConfigSource source)
+            : base(source, "AssetService")
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig netconfig = source.Configs["Network"];
+            if (netconfig != null)
+                m_maxAssetRequestConcurrency = netconfig.GetInt("MaxRequestConcurrency",m_maxAssetRequestConcurrency);
+
+            IConfig assetConfig = source.Configs["AssetService"];
+            if (assetConfig == null)
+            {
+                m_log.Error("[ASSET CONNECTOR]: AssetService missing from OpenSim.ini");
+                throw new Exception("Asset connector init error");
+            }
+
+            string serviceURI = assetConfig.GetString("AssetServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[ASSET CONNECTOR]: No Server URI named in section AssetService");
+                throw new Exception("Asset connector init error");
+            }
+
+            m_ServerURI = serviceURI;
+        }
+
+        protected void SetCache(IImprovedAssetCache cache)
+        {
+            m_Cache = cache;
+        }
+
+        public AssetBase Get(string id)
+        {
+//            m_log.DebugFormat("[ASSET SERVICE CONNECTOR]: Synchronous get request for {0}", id);
+
+            string uri = m_ServerURI + "/assets/" + id;
+
+            AssetBase asset = null;
+            if (m_Cache != null)
+                asset = m_Cache.Get(id);
+
+            if (asset == null)
+            {
+                // XXX: Commented out for now since this has either never been properly operational or not for some time
+                // as m_maxAssetRequestConcurrency was being passed as the timeout, not a concurrency limiting option.
+                // Wasn't noticed before because timeout wasn't actually used.
+                // Not attempting concurrency setting for now as this omission was discovered in release candidate
+                // phase for OpenSimulator 0.8.  Need to revisit afterwards.
+//                asset
+//                    = SynchronousRestObjectRequester.MakeRequest<int, AssetBase>(
+//                        "GET", uri, 0, m_maxAssetRequestConcurrency);
+
+                asset = SynchronousRestObjectRequester.MakeRequest<int, AssetBase>("GET", uri, 0, m_Auth);
+
+                if (m_Cache != null)
+                    m_Cache.Cache(asset);
+            }
+            return asset;
+        }
+
+        public AssetBase GetCached(string id)
+        {
+//            m_log.DebugFormat("[ASSET SERVICE CONNECTOR]: Cache request for {0}", id);
+
+            if (m_Cache != null)
+                return m_Cache.Get(id);
+
+            return null;
+        }
+
+        public AssetMetadata GetMetadata(string id)
+        {
+            if (m_Cache != null)
+            {
+                AssetBase fullAsset = m_Cache.Get(id);
+
+                if (fullAsset != null)
+                    return fullAsset.Metadata;
+            }
+
+            string uri = m_ServerURI + "/assets/" + id + "/metadata";
+
+            AssetMetadata asset = SynchronousRestObjectRequester.MakeRequest<int, AssetMetadata>("GET", uri, 0, m_Auth);
+            return asset;
+        }
+
+        public byte[] GetData(string id)
+        {
+            if (m_Cache != null)
+            {
+                AssetBase fullAsset = m_Cache.Get(id);
+
+                if (fullAsset != null)
+                    return fullAsset.Data;
+            }
+
+            using (RestClient rc = new RestClient(m_ServerURI))
+            {
+                rc.AddResourcePath("assets");
+                rc.AddResourcePath(id);
+                rc.AddResourcePath("data");
+
+                rc.RequestMethod = "GET";
+
+                Stream s = rc.Request(m_Auth);
+
+                if (s == null)
+                    return null;
+
+                if (s.Length > 0)
+                {
+                    byte[] ret = new byte[s.Length];
+                    s.Read(ret, 0, (int)s.Length);
+
+                    return ret;
+                }
+
+                return null;
+            }
+        }
+
+        public bool Get(string id, Object sender, AssetRetrieved handler)
+        {
+//            m_log.DebugFormat("[ASSET SERVICE CONNECTOR]: Potentially asynchronous get request for {0}", id);
+
+            string uri = m_ServerURI + "/assets/" + id;
+
+            AssetBase asset = null;
+            if (m_Cache != null)
+                asset = m_Cache.Get(id);
+
+            if (asset == null)
+            {
+                lock (m_AssetHandlers)
+                {
+                    AssetRetrievedEx handlerEx = new AssetRetrievedEx(delegate(AssetBase _asset) { handler(id, sender, _asset); });
+
+                    AssetRetrievedEx handlers;
+                    if (m_AssetHandlers.TryGetValue(id, out handlers))
+                    {
+                        // Someone else is already loading this asset. It will notify our handler when done.
+                        handlers += handlerEx;
+                        return true;
+                    }
+
+                    // Load the asset ourselves
+                    handlers += handlerEx;
+                    m_AssetHandlers.Add(id, handlers);
+                }
+
+                bool success = false;
+                try
+                {
+                    AsynchronousRestObjectRequester.MakeRequest<int, AssetBase>("GET", uri, 0,
+                        delegate(AssetBase a)
+                        {
+                            if (a != null && m_Cache != null)
+                                m_Cache.Cache(a);
+
+                            AssetRetrievedEx handlers;
+                            lock (m_AssetHandlers)
+                            {
+                                handlers = m_AssetHandlers[id];
+                                m_AssetHandlers.Remove(id);
+                            }
+                            handlers.Invoke(a);
+                        }, m_maxAssetRequestConcurrency, m_Auth);
+                    
+                    success = true;
+                }
+                finally
+                {
+                    if (!success)
+                    {
+                        lock (m_AssetHandlers)
+                        {
+                            m_AssetHandlers.Remove(id);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                handler(id, sender, asset);
+            }
+
+            return true;
+        }
+
+        public virtual bool[] AssetsExist(string[] ids)
+        {
+            string uri = m_ServerURI + "/get_assets_exist";
+
+            bool[] exist = null;
+            try
+            {
+                exist = SynchronousRestObjectRequester.MakeRequest<string[], bool[]>("POST", uri, ids, m_Auth);
+            }
+            catch (Exception)
+            {
+                // This is most likely to happen because the server doesn't support this function,
+                // so just silently return "doesn't exist" for all the assets.
+            }
+            
+            if (exist == null)
+                exist = new bool[ids.Length];
+
+            return exist;
+        }
+
+        public string Store(AssetBase asset)
+        {
+            if (asset.Local)
+            {
+                if (m_Cache != null)
+                    m_Cache.Cache(asset);
+
+                return asset.ID;
+            }
+
+            string uri = m_ServerURI + "/assets/";
+
+            string newID;
+            try
+            {
+                newID = SynchronousRestObjectRequester.MakeRequest<AssetBase, string>("POST", uri, asset, m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn(string.Format("[ASSET CONNECTOR]: Unable to send asset {0} to asset server. Reason: {1} ", asset.ID, e.Message), e);
+                return string.Empty;
+            }
+
+            // TEMPORARY: SRAS returns 'null' when it's asked to store existing assets
+            if (newID == null)
+            {
+                m_log.DebugFormat("[ASSET CONNECTOR]: Storing of asset {0} returned null; assuming the asset already exists", asset.ID);
+                return asset.ID;
+            }
+
+            if (string.IsNullOrEmpty(newID))
+                return string.Empty;
+
+            asset.ID = newID;
+
+            if (m_Cache != null)
+                m_Cache.Cache(asset);
+
+            return newID;
+        }
+
+        public bool UpdateContent(string id, byte[] data)
+        {
+            AssetBase asset = null;
+
+            if (m_Cache != null)
+                asset = m_Cache.Get(id);
+
+            if (asset == null)
+            {
+                AssetMetadata metadata = GetMetadata(id);
+                if (metadata == null)
+                    return false;
+
+                asset = new AssetBase(metadata.FullID, metadata.Name, metadata.Type, UUID.Zero.ToString());
+                asset.Metadata = metadata;
+            }
+            asset.Data = data;
+
+            string uri = m_ServerURI + "/assets/" + id;
+
+            if (SynchronousRestObjectRequester.MakeRequest<AssetBase, bool>("POST", uri, asset, m_Auth))
+            {
+                if (m_Cache != null)
+                    m_Cache.Cache(asset);
+
+                return true;
+            }
+            return false;
+        }
+
+        public bool Delete(string id)
+        {
+            string uri = m_ServerURI + "/assets/" + id;
+
+            if (SynchronousRestObjectRequester.MakeRequest<int, bool>("DELETE", uri, 0, m_Auth))
+            {
+                if (m_Cache != null)
+                    m_Cache.Expire(id);
+
+                return true;
+            }
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Asset/HGAssetServiceConnector.cs b/OpenSim/Services/Connectors/Asset/HGAssetServiceConnector.cs
new file mode 100644
index 0000000..3710c86
--- /dev/null
+++ b/OpenSim/Services/Connectors/Asset/HGAssetServiceConnector.cs
@@ -0,0 +1,263 @@
+/*
+ * 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 log4net;
+using Nini.Config;
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.Web;
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors.Hypergrid;
+using OpenSim.Services.Connectors.SimianGrid;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class HGAssetServiceConnector : IAssetService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Dictionary<IAssetService, object> m_endpointSerializer = new Dictionary<IAssetService, object>();
+        private object EndPointLock(IAssetService connector)
+        {
+            lock (m_endpointSerializer)
+            {
+                object eplock = null;
+
+                if (! m_endpointSerializer.TryGetValue(connector, out eplock))
+                {
+                    eplock = new object();
+                    m_endpointSerializer.Add(connector, eplock);
+                    // m_log.WarnFormat("[WEB UTIL] add a new host to end point serializer {0}",endpoint);
+                }
+
+                return eplock;
+            }
+        }
+
+        private Dictionary<string, IAssetService> m_connectors = new Dictionary<string, IAssetService>();
+
+        public HGAssetServiceConnector(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                // string name = moduleConfig.GetString("AssetServices", "");
+
+                IConfig assetConfig = source.Configs["AssetService"];
+                if (assetConfig == null)
+                {
+                    m_log.Error("[HG ASSET SERVICE]: AssetService missing from OpenSim.ini");
+                    return;
+                }
+
+                m_log.Info("[HG ASSET SERVICE]: HG asset service enabled");
+            }
+        }
+
+        private IAssetService GetConnector(string url)
+        {
+            IAssetService connector = null;
+            lock (m_connectors)
+            {
+                if (m_connectors.ContainsKey(url))
+                {
+                    connector = m_connectors[url];
+                }
+                else
+                {
+                    // Still not as flexible as I would like this to be,
+                    // but good enough for now
+                    string connectorType = new HeloServicesConnector(url).Helo();
+                    m_log.DebugFormat("[HG ASSET SERVICE]: HELO returned {0}", connectorType);
+                    if (connectorType == "opensim-simian")
+                    {
+                        connector = new SimianAssetServiceConnector(url);
+                    }
+                    else
+                        connector = new AssetServicesConnector(url);
+
+                    m_connectors.Add(url, connector);
+                }
+            }
+            return connector;
+        }
+
+        public AssetBase Get(string id)
+        {
+            string url = string.Empty;
+            string assetID = string.Empty;
+
+            if (Util.ParseForeignAssetID(id, out url, out assetID))
+            {
+                IAssetService connector = GetConnector(url);
+                return connector.Get(assetID);
+            }
+
+            return null;
+        }
+
+        public AssetBase GetCached(string id)
+        {
+            string url = string.Empty;
+            string assetID = string.Empty;
+
+            if (Util.ParseForeignAssetID(id, out url, out assetID))
+            {
+                IAssetService connector = GetConnector(url);
+                return connector.GetCached(assetID);
+            }
+
+            return null;
+        }
+
+        public AssetMetadata GetMetadata(string id)
+        {
+            string url = string.Empty;
+            string assetID = string.Empty;
+
+            if (Util.ParseForeignAssetID(id, out url, out assetID))
+            {
+                IAssetService connector = GetConnector(url);
+                return connector.GetMetadata(assetID);
+            }
+
+            return null;
+        }
+
+        public byte[] GetData(string id)
+        {
+            return null;
+        }
+
+        public bool Get(string id, Object sender, AssetRetrieved handler)
+        {
+            string url = string.Empty;
+            string assetID = string.Empty;
+
+            if (Util.ParseForeignAssetID(id, out url, out assetID))
+            {
+                IAssetService connector = GetConnector(url);
+                return connector.Get(assetID, sender, handler);
+            }
+
+            return false;
+        }
+
+
+        private struct AssetAndIndex
+        {
+            public UUID assetID;
+            public int index;
+
+            public AssetAndIndex(UUID assetID, int index)
+            {
+                this.assetID = assetID;
+                this.index = index;
+            }
+        }
+
+        public virtual bool[] AssetsExist(string[] ids)
+        {
+            // This method is a bit complicated because it works even if the assets belong to different
+            // servers; that requires sending separate requests to each server.
+
+            // Group the assets by the server they belong to
+
+            var url2assets = new Dictionary<string, List<AssetAndIndex>>();
+
+            for (int i = 0; i < ids.Length; i++)
+            {
+                string url = string.Empty;
+                string assetID = string.Empty;
+
+                if (Util.ParseForeignAssetID(ids[i], out url, out assetID))
+                {
+                    if (!url2assets.ContainsKey(url))
+                        url2assets.Add(url, new List<AssetAndIndex>());
+                    url2assets[url].Add(new AssetAndIndex(UUID.Parse(assetID), i));
+                }
+            }
+
+            // Query each of the servers in turn
+
+            bool[] exist = new bool[ids.Length];
+
+            foreach (string url in url2assets.Keys)
+            {
+                IAssetService connector = GetConnector(url);
+                lock (EndPointLock(connector))
+                {
+                    List<AssetAndIndex> curAssets = url2assets[url];
+                    string[] assetIDs = curAssets.ConvertAll(a => a.assetID.ToString()).ToArray();
+                    bool[] curExist = connector.AssetsExist(assetIDs);
+
+                    int i = 0;
+                    foreach (AssetAndIndex ai in curAssets)
+                    {
+                        exist[ai.index] = curExist[i];
+                        ++i;
+                    }
+                }
+            }
+
+            return exist;
+        }
+
+        public string Store(AssetBase asset)
+        {
+            string url = string.Empty;
+            string assetID = string.Empty;
+
+            if (Util.ParseForeignAssetID(asset.ID, out url, out assetID))
+            {
+                IAssetService connector = GetConnector(url);
+                // Restore the assetID to a simple UUID
+                asset.ID = assetID;
+                lock (EndPointLock(connector))
+                    return connector.Store(asset);
+            }
+
+            return String.Empty;
+        }
+
+        public bool UpdateContent(string id, byte[] data)
+        {
+            return false;
+        }
+
+        public bool Delete(string id)
+        {
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Authentication/AuthenticationServicesConnector.cs b/OpenSim/Services/Connectors/Authentication/AuthenticationServicesConnector.cs
new file mode 100644
index 0000000..c8a4912
--- /dev/null
+++ b/OpenSim/Services/Connectors/Authentication/AuthenticationServicesConnector.cs
@@ -0,0 +1,171 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Services.Interfaces;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class AuthenticationServicesConnector : BaseServiceConnector, IAuthenticationService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public AuthenticationServicesConnector()
+        {
+        }
+
+        public AuthenticationServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public AuthenticationServicesConnector(IConfigSource source)
+            : base(source, "AuthenticationService")
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig assetConfig = source.Configs["AuthenticationService"];
+            if (assetConfig == null)
+            {
+                m_log.Error("[AUTH CONNECTOR]: AuthenticationService missing from OpenSim.ini");
+                throw new Exception("Authentication connector init error");
+            }
+
+            string serviceURI = assetConfig.GetString("AuthenticationServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[AUTH CONNECTOR]: No Server URI named in section AuthenticationService");
+                throw new Exception("Authentication connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            base.Initialise(source, "AuthenticationService");
+        }
+
+        public string Authenticate(UUID principalID, string password, int lifetime)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["LIFETIME"] = lifetime.ToString();
+            sendData["PRINCIPAL"] = principalID.ToString();
+            sendData["PASSWORD"] = password;
+
+            sendData["METHOD"] = "authenticate";
+
+            string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                    m_ServerURI + "/auth/plain",
+                    ServerUtils.BuildQueryString(sendData), m_Auth);
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(
+                    reply);
+
+            if (replyData["Result"].ToString() != "Success")
+                return String.Empty;
+
+            return replyData["Token"].ToString();
+        }
+
+        public bool Verify(UUID principalID, string token, int lifetime)
+        {
+//            m_log.Error("[XXX]: Verify");
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["LIFETIME"] = lifetime.ToString();
+            sendData["PRINCIPAL"] = principalID.ToString();
+            sendData["TOKEN"] = token;
+
+            sendData["METHOD"] = "verify";
+
+            string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                    m_ServerURI + "/auth/plain",
+                    ServerUtils.BuildQueryString(sendData), m_Auth);
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(
+                    reply);
+
+            if (replyData["Result"].ToString() != "Success")
+                return false;
+
+            return true;
+        }
+
+        public bool Release(UUID principalID, string token)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["PRINCIPAL"] = principalID.ToString();
+            sendData["TOKEN"] = token;
+
+            sendData["METHOD"] = "release";
+
+            string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                    m_ServerURI + "/auth/plain",
+                    ServerUtils.BuildQueryString(sendData), m_Auth);
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(
+                    reply);
+
+            if (replyData["Result"].ToString() != "Success")
+                return false;
+
+            return true;
+        }
+
+        public bool SetPassword(UUID principalID, string passwd)
+        {
+            // nope, we don't do this
+            return false;
+        }
+
+        public AuthInfo GetAuthInfo(UUID principalID)
+        {
+            // not done from remote simulators
+            return null;
+        }
+
+        public bool SetAuthInfo(AuthInfo info)
+        {
+            // not done from remote simulators
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Authorization/AuthorizationServicesConnector.cs b/OpenSim/Services/Connectors/Authorization/AuthorizationServicesConnector.cs
new file mode 100644
index 0000000..63730b3
--- /dev/null
+++ b/OpenSim/Services/Connectors/Authorization/AuthorizationServicesConnector.cs
@@ -0,0 +1,123 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class AuthorizationServicesConnector 
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+        private bool m_ResponseOnFailure = true;
+       
+        public AuthorizationServicesConnector()
+        {
+        }
+
+        public AuthorizationServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public AuthorizationServicesConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig authorizationConfig = source.Configs["AuthorizationService"];
+            if (authorizationConfig == null)
+            {
+                //m_log.Info("[AUTHORIZATION CONNECTOR]: AuthorizationService missing from OpenSim.ini");
+                throw new Exception("Authorization connector init error");
+            }
+
+            string serviceURI = authorizationConfig.GetString("AuthorizationServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[AUTHORIZATION CONNECTOR]: No Server URI named in section AuthorizationService");
+                throw new Exception("Authorization connector init error");
+            }
+            m_ServerURI = serviceURI;
+            
+            // this dictates what happens if the remote service fails, if the service fails and the value is true
+            // the user is authorized for the region.
+            bool responseOnFailure = authorizationConfig.GetBoolean("ResponseOnFailure",true);
+                    
+            m_ResponseOnFailure = responseOnFailure;
+            m_log.Info("[AUTHORIZATION CONNECTOR]: AuthorizationService initialized");
+        }
+
+        public bool IsAuthorizedForRegion(string userID, string firstname, string surname, string email, string regionName, string regionID, out string message)
+        {
+            // do a remote call to the authorization server specified in the AuthorizationServerURI
+            m_log.InfoFormat("[AUTHORIZATION CONNECTOR]: IsAuthorizedForRegion checking {0} at remote server {1}", userID, m_ServerURI);
+            
+            string uri = m_ServerURI;
+            
+            AuthorizationRequest req = new AuthorizationRequest(userID, firstname, surname, email, regionName, regionID);
+            
+            AuthorizationResponse response;
+            try
+            {
+                response = SynchronousRestObjectRequester.MakeRequest<AuthorizationRequest, AuthorizationResponse>("POST", uri, req);
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[AUTHORIZATION CONNECTOR]: Unable to send authorize {0} for region {1} error thrown during comms with remote server. Reason: {2}", userID, regionID, e.Message);
+                message = e.Message;
+                return m_ResponseOnFailure;
+            }
+            if (response == null)
+            {
+                message = "Null response";
+                return m_ResponseOnFailure;
+            }
+            m_log.DebugFormat("[AUTHORIZATION CONNECTOR] response from remote service was {0}", response.Message);
+            message = response.Message;
+            
+            return response.IsAuthorized;
+        }
+
+    }
+}
diff --git a/OpenSim/Services/Connectors/Avatar/AvatarServicesConnector.cs b/OpenSim/Services/Connectors/Avatar/AvatarServicesConnector.cs
new file mode 100644
index 0000000..3f44efa
--- /dev/null
+++ b/OpenSim/Services/Connectors/Avatar/AvatarServicesConnector.cs
@@ -0,0 +1,329 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using IAvatarService = OpenSim.Services.Interfaces.IAvatarService;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class AvatarServicesConnector : BaseServiceConnector, IAvatarService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public AvatarServicesConnector()
+        {
+        }
+
+        public AvatarServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public AvatarServicesConnector(IConfigSource source)
+            : base(source, "AvatarService")
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["AvatarService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[AVATAR CONNECTOR]: AvatarService missing from OpenSim.ini");
+                throw new Exception("Avatar connector init error");
+            }
+
+            string serviceURI = gridConfig.GetString("AvatarServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[AVATAR CONNECTOR]: No Server URI named in section AvatarService");
+                throw new Exception("Avatar connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            base.Initialise(source, "AvatarService");
+        }
+
+
+        #region IAvatarService
+
+        public AvatarAppearance GetAppearance(UUID userID)
+        {
+            AvatarData avatar = GetAvatar(userID);
+            return avatar.ToAvatarAppearance();
+        }
+        
+        public bool SetAppearance(UUID userID, AvatarAppearance appearance)
+        {
+            AvatarData avatar = new AvatarData(appearance);
+            return SetAvatar(userID,avatar);
+        }
+            
+        public AvatarData GetAvatar(UUID userID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getavatar";
+
+            sendData["UserID"] = userID;
+
+            string reply = string.Empty;
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/avatar";
+            // m_log.DebugFormat("[AVATAR CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply == null || (reply != null && reply == string.Empty))
+                {
+                    m_log.DebugFormat("[AVATAR CONNECTOR]: GetAgent received null or empty reply");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AVATAR CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+            AvatarData avatar = null;
+
+            if ((replyData != null) && replyData.ContainsKey("result") && (replyData["result"] != null))
+            {
+                if (replyData["result"] is Dictionary<string, object>)
+                {
+                    avatar = new AvatarData((Dictionary<string, object>)replyData["result"]);
+                }
+            }
+
+            return avatar;
+
+        }
+
+        public bool SetAvatar(UUID userID, AvatarData avatar)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "setavatar";
+
+            sendData["UserID"] = userID.ToString();
+
+            Dictionary<string, object> structData = avatar.ToKeyValuePairs();
+
+            foreach (KeyValuePair<string, object> kvp in structData)
+                sendData[kvp.Key] = kvp.Value.ToString();
+
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/avatar";
+            //m_log.DebugFormat("[AVATAR CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                    {
+                        m_log.DebugFormat("[AVATAR CONNECTOR]: SetAvatar reply data does not contain result field");
+                    }
+                }
+                else
+                {
+                    m_log.DebugFormat("[AVATAR CONNECTOR]: SetAvatar received empty reply");
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AVATAR CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public bool ResetAvatar(UUID userID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "resetavatar";
+
+            sendData["UserID"] = userID.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/avatar";
+            // m_log.DebugFormat("[AVATAR CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[AVATAR CONNECTOR]: SetItems reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[AVATAR CONNECTOR]: SetItems received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AVATAR CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public bool SetItems(UUID userID, string[] names, string[] values)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "setitems";
+
+            sendData["UserID"] = userID.ToString();
+            sendData["Names"] = new List<string>(names);
+            sendData["Values"] = new List<string>(values);
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/avatar";
+            // m_log.DebugFormat("[AVATAR CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[AVATAR CONNECTOR]: SetItems reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[AVATAR CONNECTOR]: SetItems received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AVATAR CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public bool RemoveItems(UUID userID, string[] names)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "removeitems";
+
+            sendData["UserID"] = userID.ToString();
+            sendData["Names"] = new List<string>(names);
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/avatar";
+            // m_log.DebugFormat("[AVATAR CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[AVATAR CONNECTOR]: RemoveItems reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[AVATAR CONNECTOR]: RemoveItems received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[AVATAR CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        #endregion
+
+    }
+}
diff --git a/OpenSim/Services/Connectors/BaseServiceConnector.cs b/OpenSim/Services/Connectors/BaseServiceConnector.cs
new file mode 100644
index 0000000..98cd489
--- /dev/null
+++ b/OpenSim/Services/Connectors/BaseServiceConnector.cs
@@ -0,0 +1,33 @@
+using System;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+
+using Nini.Config;
+
+namespace OpenSim.Services.Connectors
+{
+    public class BaseServiceConnector
+    {
+        protected IServiceAuth m_Auth;
+
+        public BaseServiceConnector() { }
+
+        public BaseServiceConnector(IConfigSource config, string section)
+        {
+            Initialise(config, section);
+        }
+
+        public void Initialise(IConfigSource config, string section)
+        {
+            string authType = Util.GetConfigVarFromSections<string>(config, "AuthType", new string[] { "Network", section }, "None");
+
+            switch (authType)
+            {
+                case "BasicHttpAuthentication":
+                    m_Auth = new BasicHttpAuthentication(config, section);
+                    break;
+            }
+
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Estate/EstateDataConnector.cs b/OpenSim/Services/Connectors/Estate/EstateDataConnector.cs
new file mode 100644
index 0000000..6412bcd
--- /dev/null
+++ b/OpenSim/Services/Connectors/Estate/EstateDataConnector.cs
@@ -0,0 +1,338 @@
+/*
+ * 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.Net;
+using System.Reflection;
+
+using log4net;
+
+using OpenMetaverse;
+using Nini.Config;
+
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Services.Connectors;
+using OpenSim.Services.Interfaces;
+using OpenSim.Server.Base;
+
+namespace OpenSim.Services.Connectors
+{
+    public class EstateDataRemoteConnector : BaseServiceConnector, IEstateDataService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+        private ExpiringCache<string, List<EstateSettings>> m_EstateCache = new ExpiringCache<string, List<EstateSettings>>();
+        private const int EXPIRATION = 5 * 60; // 5 minutes in secs
+
+        public EstateDataRemoteConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["EstateService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[ESTATE CONNECTOR]: EstateService missing from OpenSim.ini");
+                throw new Exception("Estate connector init error");
+            }
+
+            string serviceURI = gridConfig.GetString("EstateServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[ESTATE CONNECTOR]: No Server URI named in section EstateService");
+                throw new Exception("Estate connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            base.Initialise(source, "EstateService");
+        }
+
+        #region IEstateDataService
+
+        public List<EstateSettings> LoadEstateSettingsAll()
+        {
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/estates";
+
+            reply = MakeRequest("GET", uri, string.Empty);
+            if (String.IsNullOrEmpty(reply))
+                return new List<EstateSettings>();
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            List<EstateSettings> estates = new List<EstateSettings>();
+            if (replyData != null && replyData.Count > 0)
+            {
+                m_log.DebugFormat("[ESTATE CONNECTOR]: LoadEstateSettingsAll returned {0} elements", replyData.Count);
+                Dictionary<string, object>.ValueCollection estateData = replyData.Values;
+                foreach (object r in estateData)
+                {
+                    if (r is Dictionary<string, object>)
+                    {
+                        EstateSettings es = new EstateSettings((Dictionary<string, object>)r);
+                        estates.Add(es);
+                    }
+                }
+                m_EstateCache.AddOrUpdate("estates", estates, EXPIRATION);
+            }
+            else
+                m_log.DebugFormat("[ESTATE CONNECTOR]: LoadEstateSettingsAll from {0} received null or zero response", uri);
+
+            return estates;
+
+        }
+
+        public List<int> GetEstatesAll()
+        {
+            List<int> eids = new List<int>();
+            // If we don't have them, load them from the server
+            List<EstateSettings> estates = null;
+            if (!m_EstateCache.TryGetValue("estates", out estates))
+                LoadEstateSettingsAll();
+
+            foreach (EstateSettings es in estates)
+                eids.Add((int)es.EstateID);
+
+            return eids;
+        }
+
+        public List<int> GetEstates(string search)
+        {
+            // If we don't have them, load them from the server
+            List<EstateSettings> estates = null;
+            if (!m_EstateCache.TryGetValue("estates", out estates))
+                LoadEstateSettingsAll();
+
+            List<int> eids = new List<int>();
+            foreach (EstateSettings es in estates)
+                if (es.EstateName == search)
+                    eids.Add((int)es.EstateID);
+
+            return eids;
+        }
+
+        public List<int> GetEstatesByOwner(UUID ownerID)
+        {
+            // If we don't have them, load them from the server
+            List<EstateSettings> estates = null;
+            if (!m_EstateCache.TryGetValue("estates", out estates))
+                LoadEstateSettingsAll();
+
+            List<int> eids = new List<int>();
+            foreach (EstateSettings es in estates)
+                if (es.EstateOwner == ownerID)
+                    eids.Add((int)es.EstateID);
+
+            return eids;
+        }
+
+        public List<UUID> GetRegions(int estateID)
+        {
+            string reply = string.Empty;
+            // /estates/regions/?eid=int
+            string uri = m_ServerURI + "/estates/regions/?eid=" + estateID.ToString();
+
+            reply = MakeRequest("GET", uri, string.Empty);
+            if (String.IsNullOrEmpty(reply))
+                return new List<UUID>();
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            List<UUID> regions = new List<UUID>();
+            if (replyData != null && replyData.Count > 0)
+            {
+                m_log.DebugFormat("[ESTATE CONNECTOR]: GetRegions for estate {0} returned {1} elements", estateID, replyData.Count);
+                Dictionary<string, object>.ValueCollection data = replyData.Values;
+                foreach (object r in data)
+                {
+                    UUID uuid = UUID.Zero;
+                    if (UUID.TryParse(r.ToString(), out uuid))
+                        regions.Add(uuid);
+                }
+            }
+            else
+                m_log.DebugFormat("[ESTATE CONNECTOR]: GetRegions from {0} received null or zero response", uri);
+
+            return regions;
+        }
+
+        public EstateSettings LoadEstateSettings(UUID regionID, bool create)
+        {
+            string reply = string.Empty;
+            // /estates/estate/?region=uuid&create=[t|f]
+            string uri = m_ServerURI + string.Format("/estates/estate/?region={0}&create={1}", regionID, create);
+
+            reply = MakeRequest("GET", uri, string.Empty);
+            if (String.IsNullOrEmpty(reply))
+                return null;
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            if (replyData != null && replyData.Count > 0)
+            {
+                m_log.DebugFormat("[ESTATE CONNECTOR]: LoadEstateSettings({0}) returned {1} elements", regionID, replyData.Count);
+                EstateSettings es = new EstateSettings(replyData);
+                return es;
+            }
+            else
+                m_log.DebugFormat("[ESTATE CONNECTOR]: LoadEstateSettings(regionID) from {0} received null or zero response", uri);
+
+            return null;
+        }
+
+        public EstateSettings LoadEstateSettings(int estateID)
+        {
+            string reply = string.Empty;
+            // /estates/estate/?eid=int
+            string uri = m_ServerURI + string.Format("/estates/estate/?eid={0}", estateID);
+
+            reply = MakeRequest("GET", uri, string.Empty);
+            if (String.IsNullOrEmpty(reply))
+                return null;
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            if (replyData != null && replyData.Count > 0)
+            {
+                m_log.DebugFormat("[ESTATE CONNECTOR]: LoadEstateSettings({0}) returned {1} elements", estateID, replyData.Count);
+                EstateSettings es = new EstateSettings(replyData);
+                return es;
+            }
+            else
+                m_log.DebugFormat("[ESTATE CONNECTOR]: LoadEstateSettings(estateID) from {0} received null or zero response", uri);
+
+            return null;
+        }
+
+        /// <summary>
+        /// Forbidden operation
+        /// </summary>
+        /// <returns></returns>
+        public EstateSettings CreateNewEstate()
+        {
+            // No can do
+            return null;
+        }
+
+        public void StoreEstateSettings(EstateSettings es)
+        {
+            // /estates/estate/
+            string uri = m_ServerURI + ("/estates/estate");
+
+            Dictionary<string, object> formdata = es.ToMap();
+            formdata["OP"] = "STORE";
+
+            PostRequest(uri, formdata);
+        }
+
+        public bool LinkRegion(UUID regionID, int estateID)
+        {
+            // /estates/estate/?eid=int&region=uuid
+            string uri = m_ServerURI + String.Format("/estates/estate/?eid={0}&region={1}", estateID, regionID);
+
+            Dictionary<string, object> formdata = new Dictionary<string, object>();
+            formdata["OP"] = "LINK";
+            return PostRequest(uri, formdata);
+        }
+
+        private bool PostRequest(string uri, Dictionary<string, object> sendData)
+        {
+            string reqString = ServerUtils.BuildQueryString(sendData);
+
+            string reply = MakeRequest("POST", uri, reqString);
+            if (String.IsNullOrEmpty(reply))
+                return false;
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            bool result = false;
+            if (replyData != null && replyData.Count > 0)
+            {
+                if (replyData.ContainsKey("Result"))
+                {
+                    if (Boolean.TryParse(replyData["Result"].ToString(), out result))
+                        m_log.DebugFormat("[ESTATE CONNECTOR]: PostRequest {0} returned {1}", uri, result);
+                }
+            }
+            else
+                m_log.DebugFormat("[ESTATE CONNECTOR]: PostRequest {0} received null or zero response", uri);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Forbidden operation
+        /// </summary>
+        /// <returns></returns>
+        public bool DeleteEstate(int estateID)
+        {
+            return false;
+        }
+
+        #endregion
+
+        private string MakeRequest(string verb, string uri, string formdata)
+        {
+            string reply = string.Empty;
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest(verb, uri, formdata, m_Auth);
+            }
+            catch (WebException e)
+            {
+                using (HttpWebResponse hwr = (HttpWebResponse)e.Response)
+                {
+                    if (hwr != null)
+                    {
+                        if (hwr.StatusCode == HttpStatusCode.NotFound)
+                            m_log.Error(string.Format("[ESTATE CONNECTOR]: Resource {0} not found ", uri));
+                        if (hwr.StatusCode == HttpStatusCode.Unauthorized)
+                            m_log.Error(string.Format("[ESTATE CONNECTOR]: Web request {0} requires authentication ", uri));
+                    }
+                    else
+                        m_log.Error(string.Format(
+                            "[ESTATE CONNECTOR]: WebException for {0} {1} {2} ",
+                            verb, uri, formdata, e));
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[ESTATE CONNECTOR]: Exception when contacting estate server at {0}: {1}", uri, e.Message);
+            }
+
+            return reply;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Freeswitch/RemoteFreeswitchConnector.cs b/OpenSim/Services/Connectors/Freeswitch/RemoteFreeswitchConnector.cs
new file mode 100644
index 0000000..d688299
--- /dev/null
+++ b/OpenSim/Services/Connectors/Freeswitch/RemoteFreeswitchConnector.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 log4net;
+using System;
+using System.IO;
+using System.Collections;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Services.Interfaces;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class RemoteFreeswitchConnector : IFreeswitchService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public RemoteFreeswitchConnector()
+        {
+        }
+
+        public RemoteFreeswitchConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/') + "/region-config";
+        }
+
+        public RemoteFreeswitchConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig freeswitchConfig = source.Configs["FreeSwitchVoice"];
+            if (freeswitchConfig == null)
+            {
+                m_log.Error("[FREESWITCH CONNECTOR]: FreeSwitchVoice missing from OpenSim.ini");
+                throw new Exception("Freeswitch connector init error");
+            }
+
+            string serviceURI = freeswitchConfig.GetString("FreeswitchServiceURL",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[FREESWITCH CONNECTOR]: No FreeswitchServiceURL named in section FreeSwitchVoice");
+                throw new Exception("Freeswitch connector init error");
+            }
+            m_ServerURI = serviceURI.TrimEnd('/') + "/region-config";
+        }
+
+        public Hashtable HandleDirectoryRequest(Hashtable requestBody)
+        {
+            // not used here
+            return new Hashtable();
+        }
+
+        public Hashtable HandleDialplanRequest(Hashtable requestBody)
+        {
+            // not used here
+            return new Hashtable();
+        }
+
+        public string GetJsonConfig()
+        {
+            m_log.DebugFormat("[FREESWITCH CONNECTOR]: Requesting config from {0}", m_ServerURI);
+            return SynchronousRestFormsRequester.MakeRequest("GET",
+                    m_ServerURI, String.Empty);
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Friends/FriendsServicesConnector.cs b/OpenSim/Services/Connectors/Friends/FriendsServicesConnector.cs
new file mode 100644
index 0000000..74851a9
--- /dev/null
+++ b/OpenSim/Services/Connectors/Friends/FriendsServicesConnector.cs
@@ -0,0 +1,269 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Framework.Communications;
+using OpenSim.Services.Interfaces;
+using FriendInfo = OpenSim.Services.Interfaces.FriendInfo;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors.Friends
+{
+    public class FriendsServicesConnector : BaseServiceConnector, IFriendsService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public FriendsServicesConnector()
+        {
+        }
+
+        public FriendsServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public FriendsServicesConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["FriendsService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[FRIENDS SERVICE CONNECTOR]: FriendsService missing from OpenSim.ini");
+                throw new Exception("Friends connector init error");
+            }
+
+            string serviceURI = gridConfig.GetString("FriendsServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[FRIENDS SERVICE CONNECTOR]: No Server URI named in section FriendsService");
+                throw new Exception("Friends connector init error");
+            }
+            m_ServerURI = serviceURI;
+            base.Initialise(source, "FriendsService");
+        }
+
+
+        #region IFriendsService
+        
+        public FriendInfo[] GetFriends(UUID PrincipalID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["PRINCIPALID"] = PrincipalID.ToString();
+            sendData["METHOD"] = "getfriends";
+
+            return GetFriends(sendData, PrincipalID.ToString());
+        }
+
+        public FriendInfo[] GetFriends(string PrincipalID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["PRINCIPALID"] = PrincipalID;
+            sendData["METHOD"] = "getfriends_string";
+
+            return GetFriends(sendData, PrincipalID);
+        }
+
+        protected FriendInfo[] GetFriends(Dictionary<string, object> sendData, string PrincipalID)
+        {
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/friends";
+
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData != null)
+                    {
+                        if (replyData.ContainsKey("result") && (replyData["result"].ToString().ToLower() == "null"))
+                        {
+                        return new FriendInfo[0];
+                        }
+
+                        List<FriendInfo> finfos = new List<FriendInfo>();
+                        Dictionary<string, object>.ValueCollection finfosList = replyData.Values;
+                        //m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: get neighbours returned {0} elements", rinfosList.Count);
+                        foreach (object f in finfosList)
+                        {
+                            if (f is Dictionary<string, object>)
+                            {
+                                FriendInfo finfo = new FriendInfo((Dictionary<string, object>)f);
+                                finfos.Add(finfo);
+                            }
+                            else
+                                m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: GetFriends {0} received invalid response type {1}",
+                                    PrincipalID, f.GetType());
+                        }
+
+                        // Success
+                        return finfos.ToArray();
+                    }
+                    else
+                        m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: GetFriends {0} received null response",
+                            PrincipalID);
+
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+            }
+
+            return new FriendInfo[0];
+
+        }
+
+        public bool StoreFriend(string PrincipalID, string Friend, int flags)
+        {
+
+            Dictionary<string, object> sendData = ToKeyValuePairs(PrincipalID, Friend, flags);
+
+            sendData["METHOD"] = "storefriend";
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/friends";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+                return false;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if ((replyData != null) && replyData.ContainsKey("Result") && (replyData["Result"] != null))
+                {
+                    bool success = false;
+                    Boolean.TryParse(replyData["Result"].ToString(), out success);
+                    return success;
+                }
+                else
+                    m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: StoreFriend {0} {1} received null response",
+                        PrincipalID, Friend);
+            }
+            else
+                m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: StoreFriend received null reply");
+
+            return false;
+
+        }
+
+        public bool Delete(string PrincipalID, string Friend)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["PRINCIPALID"] = PrincipalID.ToString();
+            sendData["FRIEND"] = Friend;
+            sendData["METHOD"] = "deletefriend_string";
+
+            return Delete(sendData, PrincipalID, Friend);
+        }
+
+        public bool Delete(UUID PrincipalID, string Friend)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["PRINCIPALID"] = PrincipalID.ToString();
+            sendData["FRIEND"] = Friend;
+            sendData["METHOD"] = "deletefriend";
+
+            return Delete(sendData, PrincipalID.ToString(), Friend);
+        }
+
+        public bool Delete(Dictionary<string, object> sendData, string PrincipalID, string Friend)
+        {
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/friends";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+                return false;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if ((replyData != null) && replyData.ContainsKey("Result") && (replyData["Result"] != null))
+                {
+                    bool success = false;
+                    Boolean.TryParse(replyData["Result"].ToString(), out success);
+                    return success;
+                }
+                else
+                    m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: DeleteFriend {0} {1} received null response",
+                        PrincipalID, Friend);
+            }
+            else
+                m_log.DebugFormat("[FRIENDS SERVICE CONNECTOR]: DeleteFriend received null reply");
+
+            return false;
+        }
+
+        #endregion
+
+        public Dictionary<string, object> ToKeyValuePairs(string principalID, string friend, int flags)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            result["PrincipalID"] = principalID;
+            result["Friend"] = friend;
+            result["MyFlags"] = flags;
+
+            return result;
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/Friends/FriendsSimConnector.cs b/OpenSim/Services/Connectors/Friends/FriendsSimConnector.cs
new file mode 100644
index 0000000..6d5ce4b
--- /dev/null
+++ b/OpenSim/Services/Connectors/Friends/FriendsSimConnector.cs
@@ -0,0 +1,187 @@
+/*
+ * 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 OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+using OpenSim.Framework;
+
+using OpenMetaverse;
+using log4net;
+
+namespace OpenSim.Services.Connectors.Friends
+{
+    public class FriendsSimConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected virtual string ServicePath()
+        {
+            return "friends";
+        }
+
+        public bool FriendshipOffered(GridRegion region, UUID userID, UUID friendID, string message)
+        {
+            return FriendshipOffered(region, userID, friendID, message, String.Empty);
+        }
+
+        public virtual bool FriendshipOffered(GridRegion region, UUID userID, UUID friendID, string message, string userName)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            //sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "friendship_offered";
+
+            sendData["FromID"] = userID.ToString();
+            sendData["ToID"] = friendID.ToString();
+            sendData["Message"] = message;
+            if (userName != String.Empty)
+                sendData["FromName"] = userName;
+
+            return Call(region, sendData);
+        }
+
+        public bool FriendshipApproved(GridRegion region, UUID userID, string userName, UUID friendID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            //sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "friendship_approved";
+
+            sendData["FromID"] = userID.ToString();
+            sendData["FromName"] = userName;
+            sendData["ToID"] = friendID.ToString();
+
+            return Call(region, sendData);
+        }
+
+        public bool FriendshipDenied(GridRegion region, UUID userID, string userName, UUID friendID)
+        {
+            if (region == null)
+                return false;
+
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            //sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "friendship_denied";
+
+            sendData["FromID"] = userID.ToString();
+            sendData["FromName"] = userName;
+            sendData["ToID"] = friendID.ToString();
+
+            return Call(region, sendData);
+        }
+
+        public bool FriendshipTerminated(GridRegion region, UUID userID, UUID friendID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            //sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "friendship_terminated";
+
+            sendData["FromID"] = userID.ToString();
+            sendData["ToID"] = friendID.ToString();
+
+            return Call(region, sendData);
+        }
+
+        public bool GrantRights(GridRegion region, UUID userID, UUID friendID, int userFlags, int rights)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            //sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "grant_rights";
+
+            sendData["FromID"] = userID.ToString();
+            sendData["ToID"] = friendID.ToString();
+            sendData["UserFlags"] = userFlags.ToString();
+            sendData["Rights"] = rights.ToString();
+
+            return Call(region, sendData);
+        }
+
+        public bool StatusNotify(GridRegion region, UUID userID, string friendID, bool online)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            //sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "status";
+
+            sendData["FromID"] = userID.ToString();
+            sendData["ToID"] = friendID;
+            sendData["Online"] = online.ToString();
+
+            return Call(region, sendData);
+        }
+
+        private bool Call(GridRegion region, Dictionary<string, object> sendData)
+        {
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            //m_log.DebugFormat("[FRIENDS SIM CONNECTOR]: queryString = {0}", reqString);
+            if (region == null)
+                return false;
+
+            string path = ServicePath();
+            if (!region.ServerURI.EndsWith("/"))
+                path = "/" + path;
+            string uri = region.ServerURI + path;
+//            m_log.DebugFormat("[FRIENDS SIM CONNECTOR]: calling {0}", uri);
+
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("RESULT"))
+                    {
+                        if (replyData["RESULT"].ToString().ToLower() == "true")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[FRIENDS SIM CONNECTOR]: reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[FRIENDS SIM CONNECTOR]: received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[FRIENDS SIM CONNECTOR]: Exception when contacting remote sim at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Grid/GridServicesConnector.cs b/OpenSim/Services/Connectors/Grid/GridServicesConnector.cs
new file mode 100644
index 0000000..9e55356
--- /dev/null
+++ b/OpenSim/Services/Connectors/Grid/GridServicesConnector.cs
@@ -0,0 +1,764 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class GridServicesConnector : BaseServiceConnector, IGridService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public GridServicesConnector()
+        {
+        }
+
+        public GridServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public GridServicesConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["GridService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[GRID CONNECTOR]: GridService missing from OpenSim.ini");
+                throw new Exception("Grid connector init error");
+            }
+
+            string serviceURI = gridConfig.GetString("GridServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[GRID CONNECTOR]: No Server URI named in section GridService");
+                throw new Exception("Grid connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            base.Initialise(source, "GridService");
+        }
+
+
+        #region IGridService
+
+        public string RegisterRegion(UUID scopeID, GridRegion regionInfo)
+        {
+            Dictionary<string, object> rinfo = regionInfo.ToKeyValuePairs();
+            Dictionary<string, object> sendData = new Dictionary<string,object>();
+            foreach (KeyValuePair<string, object> kvp in rinfo)
+                sendData[kvp.Key] = (string)kvp.Value;
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "register";
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/grid";
+            // m_log.DebugFormat("[GRID CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("Result")&& (replyData["Result"].ToString().ToLower() == "success"))
+                    {
+                        return String.Empty;
+                    }
+                    else if (replyData.ContainsKey("Result")&& (replyData["Result"].ToString().ToLower() == "failure"))
+                    {
+                        m_log.ErrorFormat(
+                            "[GRID CONNECTOR]: Registration failed: {0} when contacting {1}", replyData["Message"], uri);
+
+                        return replyData["Message"].ToString();
+                    }
+                    else if (!replyData.ContainsKey("Result"))
+                    {
+                        m_log.ErrorFormat(
+                            "[GRID CONNECTOR]: reply data does not contain result field when contacting {0}", uri);
+                    }
+                    else
+                    {
+                        m_log.ErrorFormat(
+                            "[GRID CONNECTOR]: unexpected result {0} when contacting {1}", replyData["Result"], uri);
+
+                        return "Unexpected result " + replyData["Result"].ToString();
+                    }
+                }
+                else
+                {
+                    m_log.ErrorFormat(
+                        "[GRID CONNECTOR]: RegisterRegion received null reply when contacting grid server at {0}", uri);
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+            }
+
+            return string.Format("Error communicating with the grid service at {0}", uri);
+        }
+
+        public bool DeregisterRegion(UUID regionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["REGIONID"] = regionID.ToString();
+
+            sendData["METHOD"] = "deregister";
+
+            string uri = m_ServerURI + "/grid";
+
+            try
+            {
+                string reply
+                    = SynchronousRestFormsRequester.MakeRequest("POST", uri, ServerUtils.BuildQueryString(sendData), m_Auth);
+
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if ((replyData["Result"] != null) && (replyData["Result"].ToString().ToLower() == "success"))
+                        return true;
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: DeregisterRegion received null reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["REGIONID"] = regionID.ToString();
+
+            sendData["METHOD"] = "get_neighbours";
+
+            List<GridRegion> rinfos = new List<GridRegion>();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, reqString, m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return rinfos;
+            }
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            if (replyData != null)
+            {
+                Dictionary<string, object>.ValueCollection rinfosList = replyData.Values;
+                //m_log.DebugFormat("[GRID CONNECTOR]: get neighbours returned {0} elements", rinfosList.Count);
+                foreach (object r in rinfosList)
+                {
+                    if (r is Dictionary<string, object>)
+                    {
+                        GridRegion rinfo = new GridRegion((Dictionary<string, object>)r);
+                        rinfos.Add(rinfo);
+                    }
+                }
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetNeighbours {0}, {1} received null response",
+                    scopeID, regionID);
+
+            return rinfos;
+        }
+
+        public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["REGIONID"] = regionID.ToString();
+
+            sendData["METHOD"] = "get_region_by_uuid";
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST", uri, ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return null;
+            }
+
+            GridRegion rinfo = null;
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if ((replyData != null) && (replyData["result"] != null))
+                {
+                    if (replyData["result"] is Dictionary<string, object>)
+                        rinfo = new GridRegion((Dictionary<string, object>)replyData["result"]);
+                    //else
+                    //    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByUUID {0}, {1} received null response",
+                    //        scopeID, regionID);
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByUUID {0}, {1} received null response",
+                        scopeID, regionID);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByUUID received null reply");
+
+            return rinfo;
+        }
+
+        public GridRegion GetRegionByPosition(UUID scopeID, int x, int y)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["X"] = x.ToString();
+            sendData["Y"] = y.ToString();
+
+            sendData["METHOD"] = "get_region_by_position";
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return null;
+            }
+
+            GridRegion rinfo = null;
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if ((replyData != null) && (replyData["result"] != null))
+                {
+                    if (replyData["result"] is Dictionary<string, object>)
+                        rinfo = new GridRegion((Dictionary<string, object>)replyData["result"]);
+                    //else
+                    //    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByPosition {0}, {1}-{2} received no region",
+                    //        scopeID, x, y);
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByPosition {0}, {1}-{2} received null response",
+                        scopeID, x, y);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByPosition received null reply");
+
+            return rinfo;
+        }
+
+        public GridRegion GetRegionByName(UUID scopeID, string regionName)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["NAME"] = regionName;
+
+            sendData["METHOD"] = "get_region_by_name";
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return null;
+            }
+
+            GridRegion rinfo = null;
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if ((replyData != null) && (replyData["result"] != null))
+                {
+                    if (replyData["result"] is Dictionary<string, object>)
+                        rinfo = new GridRegion((Dictionary<string, object>)replyData["result"]);
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByPosition {0}, {1} received null response",
+                        scopeID, regionName);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetRegionByName received null reply");
+
+            return rinfo;
+        }
+
+        public List<GridRegion> GetRegionsByName(UUID scopeID, string name, int maxNumber)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["NAME"] = name;
+            sendData["MAX"] = maxNumber.ToString();
+
+            sendData["METHOD"] = "get_regions_by_name";
+            List<GridRegion> rinfos = new List<GridRegion>();
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return rinfos;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData != null)
+                {
+                    Dictionary<string, object>.ValueCollection rinfosList = replyData.Values;
+                    foreach (object r in rinfosList)
+                    {
+                        if (r is Dictionary<string, object>)
+                        {
+                            GridRegion rinfo = new GridRegion((Dictionary<string, object>)r);
+                            rinfos.Add(rinfo);
+                        }
+                    }
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionsByName {0}, {1}, {2} received null response",
+                        scopeID, name, maxNumber);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetRegionsByName received null reply");
+
+            return rinfos;
+        }
+
+        public List<GridRegion> GetRegionRange(UUID scopeID, int xmin, int xmax, int ymin, int ymax)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["XMIN"] = xmin.ToString();
+            sendData["XMAX"] = xmax.ToString();
+            sendData["YMIN"] = ymin.ToString();
+            sendData["YMAX"] = ymax.ToString();
+
+            sendData["METHOD"] = "get_region_range";
+
+            List<GridRegion> rinfos = new List<GridRegion>();
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+
+                //m_log.DebugFormat("[GRID CONNECTOR]: reply was {0}", reply);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return rinfos;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData != null)
+                {
+                    Dictionary<string, object>.ValueCollection rinfosList = replyData.Values;
+                    foreach (object r in rinfosList)
+                    {
+                        if (r is Dictionary<string, object>)
+                        {
+                            GridRegion rinfo = new GridRegion((Dictionary<string, object>)r);
+                            rinfos.Add(rinfo);
+                        }
+                    }
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionRange {0}, {1}-{2} {3}-{4} received null response",
+                        scopeID, xmin, xmax, ymin, ymax);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetRegionRange received null reply");
+
+            return rinfos;
+        }
+
+        public List<GridRegion> GetDefaultRegions(UUID scopeID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+
+            sendData["METHOD"] = "get_default_regions";
+
+            List<GridRegion> rinfos = new List<GridRegion>();
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+
+                //m_log.DebugFormat("[GRID CONNECTOR]: reply was {0}", reply);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return rinfos;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData != null)
+                {
+                    Dictionary<string, object>.ValueCollection rinfosList = replyData.Values;
+                    foreach (object r in rinfosList)
+                    {
+                        if (r is Dictionary<string, object>)
+                        {
+                            GridRegion rinfo = new GridRegion((Dictionary<string, object>)r);
+                            rinfos.Add(rinfo);
+                        }
+                    }
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetDefaultRegions {0} received null response",
+                        scopeID);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetDefaultRegions received null reply");
+
+            return rinfos;
+        }
+
+        public List<GridRegion> GetDefaultHypergridRegions(UUID scopeID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+
+            sendData["METHOD"] = "get_default_hypergrid_regions";
+
+            List<GridRegion> rinfos = new List<GridRegion>();
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+
+                //m_log.DebugFormat("[GRID CONNECTOR]: reply was {0}", reply);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return rinfos;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData != null)
+                {
+                    Dictionary<string, object>.ValueCollection rinfosList = replyData.Values;
+                    foreach (object r in rinfosList)
+                    {
+                        if (r is Dictionary<string, object>)
+                        {
+                            GridRegion rinfo = new GridRegion((Dictionary<string, object>)r);
+                            rinfos.Add(rinfo);
+                        }
+                    }
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetDefaultHypergridRegions {0} received null response",
+                        scopeID);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetDefaultHypergridRegions received null reply");
+
+            return rinfos;
+        }
+
+        public List<GridRegion> GetFallbackRegions(UUID scopeID, int x, int y)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["X"] = x.ToString();
+            sendData["Y"] = y.ToString();
+
+            sendData["METHOD"] = "get_fallback_regions";
+
+            List<GridRegion> rinfos = new List<GridRegion>();
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+
+                //m_log.DebugFormat("[GRID CONNECTOR]: reply was {0}", reply);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return rinfos;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData != null)
+                {
+                    Dictionary<string, object>.ValueCollection rinfosList = replyData.Values;
+                    foreach (object r in rinfosList)
+                    {
+                        if (r is Dictionary<string, object>)
+                        {
+                            GridRegion rinfo = new GridRegion((Dictionary<string, object>)r);
+                            rinfos.Add(rinfo);
+                        }
+                    }
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetFallbackRegions {0}, {1}-{2} received null response",
+                        scopeID, x, y);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetFallbackRegions received null reply");
+
+            return rinfos;
+        }
+
+        public List<GridRegion> GetHyperlinks(UUID scopeID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+
+            sendData["METHOD"] = "get_hyperlinks";
+
+            List<GridRegion> rinfos = new List<GridRegion>();
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+
+                //m_log.DebugFormat("[GRID CONNECTOR]: reply was {0}", reply);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return rinfos;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData != null)
+                {
+                    Dictionary<string, object>.ValueCollection rinfosList = replyData.Values;
+                    foreach (object r in rinfosList)
+                    {
+                        if (r is Dictionary<string, object>)
+                        {
+                            GridRegion rinfo = new GridRegion((Dictionary<string, object>)r);
+                            rinfos.Add(rinfo);
+                        }
+                    }
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetHyperlinks {0} received null response",
+                        scopeID);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetHyperlinks received null reply");
+
+            return rinfos;
+        }
+        
+        public int GetRegionFlags(UUID scopeID, UUID regionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["SCOPEID"] = scopeID.ToString();
+            sendData["REGIONID"] = regionID.ToString();
+
+            sendData["METHOD"] = "get_region_flags";
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return -1;
+            }
+
+            int flags = -1;
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if ((replyData != null) && replyData.ContainsKey("result") && (replyData["result"] != null))
+                {
+                    Int32.TryParse((string)replyData["result"], out flags);
+                    //else
+                    //    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionFlags {0}, {1} received wrong type {2}",
+                    //        scopeID, regionID, replyData["result"].GetType());
+                }
+                else
+                    m_log.DebugFormat("[GRID CONNECTOR]: GetRegionFlags {0}, {1} received null response",
+                        scopeID, regionID);
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetRegionFlags received null reply");
+
+            return flags;
+        }
+
+        public Dictionary<string, object> GetExtraFeatures()
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            Dictionary<string, object> extraFeatures = new Dictionary<string, object>();
+
+            sendData["METHOD"] = "get_grid_extra_features";
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/grid";
+
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                                                                  uri,
+                                                                  ServerUtils.BuildQueryString(sendData), m_Auth);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID CONNECTOR]: GetExtraFeatures - Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                return extraFeatures;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+                
+                if ((replyData != null) && replyData.Count > 0)
+                {
+                    foreach (string key in replyData.Keys)
+                    {
+                        extraFeatures[key] = replyData[key].ToString();
+                    }
+                }
+            }
+            else
+                m_log.DebugFormat("[GRID CONNECTOR]: GetExtraServiceURLs received null reply");
+
+            return extraFeatures;
+        }
+        #endregion
+
+    }
+}
diff --git a/OpenSim/Services/Connectors/GridUser/GridUserServicesConnector.cs b/OpenSim/Services/Connectors/GridUser/GridUserServicesConnector.cs
new file mode 100644
index 0000000..ffdd94a
--- /dev/null
+++ b/OpenSim/Services/Connectors/GridUser/GridUserServicesConnector.cs
@@ -0,0 +1,300 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class GridUserServicesConnector : BaseServiceConnector, IGridUserService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public GridUserServicesConnector()
+        {
+        }
+
+        public GridUserServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public GridUserServicesConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["GridUserService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[GRID USER CONNECTOR]: GridUserService missing from OpenSim.ini");
+                throw new Exception("GridUser connector init error");
+            }
+
+            string serviceURI = gridConfig.GetString("GridUserServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[GRID USER CONNECTOR]: No Server URI named in section GridUserService");
+                throw new Exception("GridUser connector init error");
+            }
+            m_ServerURI = serviceURI;
+            base.Initialise(source, "GridUserService");
+        }
+
+
+        #region IGridUserService
+
+
+        public GridUserInfo LoggedIn(string userID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "loggedin";
+
+            sendData["UserID"] = userID;
+
+            return Get(sendData);
+
+        }
+
+        public bool LoggedOut(string userID, UUID sessionID, UUID region, Vector3 position, Vector3 lookat)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "loggedout";
+
+            return Set(sendData, userID, region, position, lookat);
+        }
+
+        public bool SetHome(string userID, UUID regionID, Vector3 position, Vector3 lookAt)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "sethome";
+
+            return Set(sendData, userID, regionID, position, lookAt);
+        }
+
+        public bool SetLastPosition(string userID, UUID sessionID, UUID regionID, Vector3 position, Vector3 lookAt)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "setposition";
+
+            return Set(sendData, userID, regionID, position, lookAt);
+        }
+
+        public GridUserInfo GetGridUserInfo(string userID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getgriduserinfo";
+
+            sendData["UserID"] = userID;
+
+            return Get(sendData);
+        }
+
+        #endregion
+
+        protected bool Set(Dictionary<string, object> sendData, string userID, UUID regionID, Vector3 position, Vector3 lookAt)
+        {
+            sendData["UserID"] = userID;
+            sendData["RegionID"] = regionID.ToString();
+            sendData["Position"] = position.ToString();
+            sendData["LookAt"] = lookAt.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/griduser";
+            // m_log.DebugFormat("[GRID USER CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[GRID USER CONNECTOR]: SetPosition reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[GRID USER CONNECTOR]: SetPosition received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID USER CONNECTOR]: Exception when contacting grid user server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        protected GridUserInfo Get(Dictionary<string, object> sendData)
+        {
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/griduser";
+            // m_log.DebugFormat("[GRID USER CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+                    GridUserInfo guinfo = null;
+
+                    if ((replyData != null) && replyData.ContainsKey("result") && (replyData["result"] != null))
+                    {
+                        if (replyData["result"] is Dictionary<string, object>)
+                            guinfo = Create((Dictionary<string, object>)replyData["result"]);
+                    }
+
+                    return guinfo;
+
+                }
+                else
+                    m_log.DebugFormat("[GRID USER CONNECTOR]: Get received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID USER CONNECTOR]: Exception when contacting grid user server at {0}: {1}", uri, e.Message);
+            }
+
+            return null;
+
+        }
+
+        public GridUserInfo[] GetGridUserInfo(string[] userIDs)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getgriduserinfos";
+
+            sendData["AgentIDs"] = new List<string>(userIDs);
+
+            string reply = string.Empty;
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/griduser";
+            //m_log.DebugFormat("[PRESENCE CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply == null || (reply != null && reply == string.Empty))
+                {
+                    m_log.DebugFormat("[GRID USER CONNECTOR]: GetGridUserInfo received null or empty reply");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[GRID USER CONNECTOR]: Exception when contacting grid user server at {0}: {1}", uri, e.Message);
+            }
+
+            List<GridUserInfo> rinfos = new List<GridUserInfo>();
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            if (replyData != null)
+            {
+                if (replyData.ContainsKey("result") &&
+                    (replyData["result"].ToString() == "null" || replyData["result"].ToString() == "Failure"))
+                {
+                    return new GridUserInfo[0];
+                }
+
+                Dictionary<string, object>.ValueCollection pinfosList = replyData.Values;
+                //m_log.DebugFormat("[PRESENCE CONNECTOR]: GetAgents returned {0} elements", pinfosList.Count);
+                foreach (object griduser in pinfosList)
+                {
+                    if (griduser is Dictionary<string, object>)
+                    {
+                        GridUserInfo pinfo = Create((Dictionary<string, object>)griduser);
+                        rinfos.Add(pinfo);
+                    }
+                    else
+                        m_log.DebugFormat("[GRID USER CONNECTOR]: GetGridUserInfo received invalid response type {0}",
+                            griduser.GetType());
+                }
+            }
+            else
+                m_log.DebugFormat("[GRID USER CONNECTOR]: GetGridUserInfo received null response");
+
+            return rinfos.ToArray();
+        }
+
+        protected virtual GridUserInfo Create(Dictionary<string, object> griduser)
+        {
+            return new GridUserInfo(griduser);
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs
new file mode 100644
index 0000000..b1663ee
--- /dev/null
+++ b/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs
@@ -0,0 +1,332 @@
+/*
+ * 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.Drawing;
+using System.IO;
+using System.Net;
+using System.Reflection;
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenMetaverse;
+using OpenMetaverse.Imaging;
+using OpenMetaverse.StructuredData;
+using Nwc.XmlRpc;
+using log4net;
+
+using OpenSim.Services.Connectors.Simulation;
+
+namespace OpenSim.Services.Connectors.Hypergrid
+{
+    public class GatekeeperServiceConnector : SimulationServiceConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static UUID m_HGMapImage = new UUID("00000000-0000-1111-9999-000000000013");
+
+        private IAssetService m_AssetService;
+
+        public GatekeeperServiceConnector()
+            : base()
+        {
+        }
+
+        public GatekeeperServiceConnector(IAssetService assService)
+        {
+            m_AssetService = assService;
+        }
+
+        protected override string AgentPath()
+        {
+            return "foreignagent/";
+        }
+
+        protected override string ObjectPath()
+        {
+            return "foreignobject/";
+        }
+
+        public bool LinkRegion(GridRegion info, out UUID regionID, out ulong realHandle, out string externalName, out string imageURL, out string reason)
+        {
+            regionID = UUID.Zero;
+            imageURL = string.Empty;
+            realHandle = 0;
+            externalName = string.Empty;
+            reason = string.Empty;
+
+            Hashtable hash = new Hashtable();
+            hash["region_name"] = info.RegionName;
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("link_region", paramList);
+            m_log.Debug("[GATEKEEPER SERVICE CONNECTOR]: Linking to " + info.ServerURI);
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(info.ServerURI, 10000);
+            }
+            catch (Exception e)
+            {
+                m_log.Debug("[GATEKEEPER SERVICE CONNECTOR]: Exception " + e.Message);
+                reason = "Error contacting remote server";
+                return false;
+            }
+
+            if (response.IsFault)
+            {
+                reason = response.FaultString;
+                m_log.ErrorFormat("[GATEKEEPER SERVICE CONNECTOR]: remote call returned an error: {0}", response.FaultString);
+                return false;
+            }
+
+            hash = (Hashtable)response.Value;
+            //foreach (Object o in hash)
+            //    m_log.Debug(">> " + ((DictionaryEntry)o).Key + ":" + ((DictionaryEntry)o).Value);
+            try
+            {
+                bool success = false;
+                Boolean.TryParse((string)hash["result"], out success);
+                if (success)
+                {
+                    UUID.TryParse((string)hash["uuid"], out regionID);
+                    //m_log.Debug(">> HERE, uuid: " + regionID);
+                    if ((string)hash["handle"] != null)
+                    {
+                        realHandle = Convert.ToUInt64((string)hash["handle"]);
+                        //m_log.Debug(">> HERE, realHandle: " + realHandle);
+                    }
+                    if (hash["region_image"] != null)
+                    {
+                        imageURL = (string)hash["region_image"];
+                        //m_log.Debug(">> HERE, imageURL: " + imageURL);
+                    }
+                    if (hash["external_name"] != null)
+                    {
+                        externalName = (string)hash["external_name"];
+                        //m_log.Debug(">> HERE, externalName: " + externalName);
+                    }
+                }
+
+            }
+            catch (Exception e)
+            {
+                reason = "Error parsing return arguments";
+                m_log.Error("[GATEKEEPER SERVICE CONNECTOR]: Got exception while parsing hyperlink response " + e.StackTrace);
+                return false;
+            }
+
+            return true;
+        }
+
+        public UUID GetMapImage(UUID regionID, string imageURL, string storagePath)
+        {
+            if (m_AssetService == null)
+            {
+                m_log.DebugFormat("[GATEKEEPER SERVICE CONNECTOR]: No AssetService defined. Map tile not retrieved.");
+                return m_HGMapImage;
+            }
+
+            UUID mapTile = m_HGMapImage;
+            string filename = string.Empty;
+
+            try
+            {
+                WebClient c = new WebClient();
+                string name = regionID.ToString();
+                filename = Path.Combine(storagePath, name + ".jpg");
+                m_log.DebugFormat("[GATEKEEPER SERVICE CONNECTOR]: Map image at {0}, cached at {1}", imageURL, filename);
+                if (!File.Exists(filename))
+                {
+                    m_log.DebugFormat("[GATEKEEPER SERVICE CONNECTOR]: downloading...");
+                    c.DownloadFile(imageURL, filename);
+                }
+                else
+                {
+                    m_log.DebugFormat("[GATEKEEPER SERVICE CONNECTOR]: using cached image");
+                }
+
+                byte[] imageData = null;
+
+                using (Bitmap bitmap = new Bitmap(filename))
+                {
+                    //m_log.Debug("Size: " + m.PhysicalDimension.Height + "-" + m.PhysicalDimension.Width);
+                    imageData = OpenJPEG.EncodeFromImage(bitmap, true);
+                }
+
+                AssetBase ass = new AssetBase(UUID.Random(), "region " + name, (sbyte)AssetType.Texture, regionID.ToString());
+
+                // !!! for now
+                //info.RegionSettings.TerrainImageID = ass.FullID;
+
+                ass.Data = imageData;
+
+                mapTile = ass.FullID;
+
+                // finally
+                m_AssetService.Store(ass);
+
+            }
+            catch // LEGIT: Catching problems caused by OpenJPEG p/invoke
+            {
+                m_log.Info("[GATEKEEPER SERVICE CONNECTOR]: Failed getting/storing map image, because it is probably already in the cache");
+            }
+            return mapTile;
+        }
+
+        public GridRegion GetHyperlinkRegion(GridRegion gatekeeper, UUID regionID, UUID agentID, string agentHomeURI, out string message)
+        {
+            Hashtable hash = new Hashtable();
+            hash["region_uuid"] = regionID.ToString();
+            if (agentID != UUID.Zero)
+            {
+                hash["agent_id"] = agentID.ToString();
+                if (agentHomeURI != null)
+                    hash["agent_home_uri"] = agentHomeURI;
+            }
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("get_region", paramList);
+            m_log.Debug("[GATEKEEPER SERVICE CONNECTOR]: contacting " + gatekeeper.ServerURI);
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(gatekeeper.ServerURI, 10000);
+            }
+            catch (Exception e)
+            {
+                message = "Error contacting grid.";
+                m_log.Debug("[GATEKEEPER SERVICE CONNECTOR]: Exception " + e.Message);
+                return null;
+            }
+
+            if (response.IsFault)
+            {
+                message = "Error contacting grid.";
+                m_log.ErrorFormat("[GATEKEEPER SERVICE CONNECTOR]: remote call returned an error: {0}", response.FaultString);
+                return null;
+            }
+
+            hash = (Hashtable)response.Value;
+            //foreach (Object o in hash)
+            //    m_log.Debug(">> " + ((DictionaryEntry)o).Key + ":" + ((DictionaryEntry)o).Value);
+            try
+            {
+                bool success = false;
+                Boolean.TryParse((string)hash["result"], out success);
+
+                if (hash["message"] != null)
+                    message = (string)hash["message"];
+                else if (success)
+                    message = null;
+                else
+                    message = "The teleport destination could not be found.";   // probably the dest grid is old and doesn't send 'message', but the most common problem is that the region is unavailable
+
+                if (success)
+                {
+                    GridRegion region = new GridRegion();
+
+                    UUID.TryParse((string)hash["uuid"], out region.RegionID);
+                    //m_log.Debug(">> HERE, uuid: " + region.RegionID);
+                    int n = 0;
+                    if (hash["x"] != null)
+                    {
+                        Int32.TryParse((string)hash["x"], out n);
+                        region.RegionLocX = n;
+                        //m_log.Debug(">> HERE, x: " + region.RegionLocX);
+                    }
+                    if (hash["y"] != null)
+                    {
+                        Int32.TryParse((string)hash["y"], out n);
+                        region.RegionLocY = n;
+                        //m_log.Debug(">> HERE, y: " + region.RegionLocY);
+                    }
+                    if (hash["size_x"] != null)
+                    {
+                        Int32.TryParse((string)hash["size_x"], out n);
+                        region.RegionSizeX = n;
+                        //m_log.Debug(">> HERE, x: " + region.RegionLocX);
+                    }
+                    if (hash["size_y"] != null)
+                    {
+                        Int32.TryParse((string)hash["size_y"], out n);
+                        region.RegionSizeY = n;
+                        //m_log.Debug(">> HERE, y: " + region.RegionLocY);
+                    }
+                    if (hash["region_name"] != null)
+                    {
+                        region.RegionName = (string)hash["region_name"];
+                        //m_log.Debug(">> HERE, region_name: " + region.RegionName);
+                    }
+                    if (hash["hostname"] != null)
+                    {
+                        region.ExternalHostName = (string)hash["hostname"];
+                        //m_log.Debug(">> HERE, hostname: " + region.ExternalHostName);
+                    }
+                    if (hash["http_port"] != null)
+                    {
+                        uint p = 0;
+                        UInt32.TryParse((string)hash["http_port"], out p);
+                        region.HttpPort = p;
+                        //m_log.Debug(">> HERE, http_port: " + region.HttpPort);
+                    }
+                    if (hash["internal_port"] != null)
+                    {
+                        int p = 0;
+                        Int32.TryParse((string)hash["internal_port"], out p);
+                        region.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), p);
+                        //m_log.Debug(">> HERE, internal_port: " + region.InternalEndPoint);
+                    }
+
+                    if (hash["server_uri"] != null)
+                    {
+                        region.ServerURI = (string)hash["server_uri"];
+                        //m_log.Debug(">> HERE, server_uri: " + region.ServerURI);
+                    }
+
+                    // Successful return
+                    return region;
+                }
+
+            }
+            catch (Exception e)
+            {
+                message = "Error parsing response from grid.";
+                m_log.Error("[GATEKEEPER SERVICE CONNECTOR]: Got exception while parsing hyperlink response " + e.StackTrace);
+                return null;
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Hypergrid/HGFriendsServicesConnector.cs b/OpenSim/Services/Connectors/Hypergrid/HGFriendsServicesConnector.cs
new file mode 100644
index 0000000..622d4e1
--- /dev/null
+++ b/OpenSim/Services/Connectors/Hypergrid/HGFriendsServicesConnector.cs
@@ -0,0 +1,312 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors.Friends;
+using FriendInfo = OpenSim.Services.Interfaces.FriendInfo;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors.Hypergrid
+{
+    public class HGFriendsServicesConnector : FriendsSimConnector
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+        private string m_ServiceKey = String.Empty;
+        private UUID m_SessionID;
+
+        public HGFriendsServicesConnector()
+        {
+        }
+
+        public HGFriendsServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public HGFriendsServicesConnector(string serverURI, UUID sessionID, string serviceKey)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+            m_ServiceKey = serviceKey;
+            m_SessionID = sessionID;
+        }
+
+        protected override string ServicePath()
+        {
+            return "hgfriends";
+        }
+
+        #region IFriendsService
+
+        public uint GetFriendPerms(UUID PrincipalID, UUID friendID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+
+            sendData["PRINCIPALID"] = PrincipalID.ToString();
+            sendData["FRIENDID"] = friendID.ToString();
+            sendData["METHOD"] = "getfriendperms";
+            sendData["KEY"] = m_ServiceKey;
+            sendData["SESSIONID"] = m_SessionID.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/hgfriends";
+
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if ((replyData != null) && replyData.ContainsKey("Value") && (replyData["Value"] != null))
+                    {
+                        uint perms = 0;
+                        uint.TryParse(replyData["Value"].ToString(), out perms);
+                        return perms;
+                    }
+                    else
+                        m_log.DebugFormat("[HGFRIENDS CONNECTOR]: GetFriendPerms {0} received null response",
+                            PrincipalID);
+
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+            }
+
+            return 0;
+
+        }
+
+        public bool NewFriendship(UUID PrincipalID, string Friend)
+        {
+            FriendInfo finfo = new FriendInfo();
+            finfo.PrincipalID = PrincipalID;
+            finfo.Friend = Friend;
+
+            Dictionary<string, object> sendData = finfo.ToKeyValuePairs();
+
+            sendData["METHOD"] = "newfriendship";
+            sendData["KEY"] = m_ServiceKey;
+            sendData["SESSIONID"] = m_SessionID.ToString();
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/hgfriends";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData));
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+                return false;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if ((replyData != null) && replyData.ContainsKey("Result") && (replyData["Result"] != null))
+                {
+                    bool success = false;
+                    Boolean.TryParse(replyData["Result"].ToString(), out success);
+                    return success;
+                }
+                else
+                    m_log.DebugFormat("[HGFRIENDS CONNECTOR]: StoreFriend {0} {1} received null response",
+                        PrincipalID, Friend);
+            }
+            else
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: StoreFriend received null reply");
+
+            return false;
+
+        }
+
+        public bool DeleteFriendship(UUID PrincipalID, UUID Friend, string secret)
+        {
+            FriendInfo finfo = new FriendInfo();
+            finfo.PrincipalID = PrincipalID;
+            finfo.Friend = Friend.ToString();
+
+            Dictionary<string, object> sendData = finfo.ToKeyValuePairs();
+
+            sendData["METHOD"] = "deletefriendship";
+            sendData["SECRET"] = secret;
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/hgfriends";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData));
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+                return false;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData.ContainsKey("RESULT"))
+                {
+                    if (replyData["RESULT"].ToString().ToLower() == "true")
+                        return true;
+                    else
+                        return false;
+                }
+                else
+                    m_log.DebugFormat("[HGFRIENDS CONNECTOR]: reply data does not contain result field");
+
+            }
+            else
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: received empty reply");
+
+            return false;
+
+        }
+
+        public bool ValidateFriendshipOffered(UUID fromID, UUID toID)
+        {
+            FriendInfo finfo = new FriendInfo();
+            finfo.PrincipalID = fromID;
+            finfo.Friend = toID.ToString();
+
+            Dictionary<string, object> sendData = finfo.ToKeyValuePairs();
+
+            sendData["METHOD"] = "validate_friendship_offered";
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/hgfriends";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData));
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+                return false;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                if (replyData.ContainsKey("RESULT"))
+                {
+                    if (replyData["RESULT"].ToString().ToLower() == "true")
+                        return true;
+                    else
+                        return false;
+                }
+                else
+                    m_log.DebugFormat("[HGFRIENDS CONNECTOR]: reply data does not contain result field");
+
+            }
+            else
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: received empty reply");
+
+            return false;
+
+        }
+
+        public List<UUID> StatusNotification(List<string> friends, UUID userID, bool online)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            List<UUID> friendsOnline = new List<UUID>();
+
+            sendData["METHOD"] = "statusnotification";
+            sendData["userID"] = userID.ToString();
+            sendData["online"] = online.ToString();
+            int i = 0;
+            foreach (string s in friends)
+            {
+                sendData["friend_" + i.ToString()] = s;
+                i++;
+            }
+
+            string reply = string.Empty;
+            string uri = m_ServerURI + "/hgfriends";
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        ServerUtils.BuildQueryString(sendData), 15);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: Exception when contacting friends server at {0}: {1}", uri, e.Message);
+                return friendsOnline;
+            }
+
+            if (reply != string.Empty)
+            {
+                Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                // Here is the actual response
+                foreach (string key in replyData.Keys)
+                {
+                    if (key.StartsWith("friend_") && replyData[key] != null)
+                    {
+                        UUID uuid;
+                        if (UUID.TryParse(replyData[key].ToString(), out uuid))
+                            friendsOnline.Add(uuid);
+                    }
+                }
+            }
+            else
+                m_log.DebugFormat("[HGFRIENDS CONNECTOR]: Received empty reply from remote StatusNotify");
+
+            return friendsOnline;
+
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/Hypergrid/HeloServicesConnector.cs b/OpenSim/Services/Connectors/Hypergrid/HeloServicesConnector.cs
new file mode 100644
index 0000000..b5e6d69
--- /dev/null
+++ b/OpenSim/Services/Connectors/Hypergrid/HeloServicesConnector.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 log4net;
+using System;
+using System.Net;
+using System.Reflection;
+using Nini.Config;
+
+namespace OpenSim.Services.Connectors
+{
+    public class HeloServicesConnector 
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public HeloServicesConnector()
+        {
+        }
+
+        public HeloServicesConnector(string serverURI)
+        {
+            try
+            {
+                Uri uri;
+
+                if (!serverURI.EndsWith("="))
+                {
+                    // Let's check if this is a valid URI, because it may not be
+                    uri = new Uri(serverURI);
+                    m_ServerURI = serverURI.TrimEnd('/') + "/helo/";
+                }
+                else
+                {
+                    // Simian sends malformed urls like this:
+                    // http://valley.virtualportland.org/simtest/Grid/?id=
+                    //
+                    uri = new Uri(serverURI + "xxx");
+                    if (uri.Query == string.Empty)
+                        m_ServerURI = serverURI.TrimEnd('/') + "/helo/";
+                    else
+                    {
+                        serverURI = serverURI + "xxx";
+                        m_ServerURI = serverURI.Replace(uri.Query, "");
+                        m_ServerURI = m_ServerURI.TrimEnd('/') + "/helo/";
+                    }
+                }
+
+            }
+            catch (UriFormatException)
+            {
+                m_log.WarnFormat("[HELO SERVICE]: Malformed URL {0}", serverURI);
+            }
+        }
+
+        public virtual string Helo()
+        {
+            if (String.IsNullOrEmpty(m_ServerURI))
+            {
+                m_log.WarnFormat("[HELO SERVICE]: Unable to invoke HELO due to empty URL");
+                return String.Empty;
+            }
+
+            try
+            {
+                HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(m_ServerURI);
+                // Eventually we need to switch to HEAD
+                /* req.Method = "HEAD"; */
+
+                using (WebResponse response = req.GetResponse())
+                {
+                    if (response.Headers.Get("X-Handlers-Provided") == null) // just in case this ever returns a null
+                        return string.Empty;
+                    return response.Headers.Get("X-Handlers-Provided");
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[HELO SERVICE]: Unable to perform HELO request to {0}: {1}", m_ServerURI, e.Message);
+            }
+
+            // fail
+            return string.Empty;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/Hypergrid/UserAgentServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/UserAgentServiceConnector.cs
new file mode 100644
index 0000000..8abd046
--- /dev/null
+++ b/OpenSim/Services/Connectors/Hypergrid/UserAgentServiceConnector.cs
@@ -0,0 +1,625 @@
+/*
+ * 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.IO;
+using System.Net;
+using System.Reflection;
+using System.Text;
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors.Simulation;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using log4net;
+using Nwc.XmlRpc;
+using Nini.Config;
+
+namespace OpenSim.Services.Connectors.Hypergrid
+{
+    public class UserAgentServiceConnector : SimulationServiceConnector, IUserAgentService
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(
+            MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURLHost;
+        private string m_ServerURL;
+        private GridRegion m_Gatekeeper;
+
+        public UserAgentServiceConnector(string url) : this(url, true)
+        {
+        }
+
+        public UserAgentServiceConnector(string url, bool dnsLookup)
+        {
+            m_ServerURL = m_ServerURLHost = url;
+
+            if (dnsLookup)
+            {
+                // Doing this here, because XML-RPC or mono have some strong ideas about
+                // caching DNS translations.
+                try
+                {
+                    Uri m_Uri = new Uri(m_ServerURL);
+                    IPAddress ip = Util.GetHostFromDNS(m_Uri.Host);
+                    m_ServerURL = m_ServerURL.Replace(m_Uri.Host, ip.ToString());
+                    if (!m_ServerURL.EndsWith("/"))
+                        m_ServerURL += "/";
+                }
+                catch (Exception e)
+                {
+                    m_log.DebugFormat("[USER AGENT CONNECTOR]: Malformed Uri {0}: {1}", url, e.Message);
+                }
+            }
+
+            //m_log.DebugFormat("[USER AGENT CONNECTOR]: new connector to {0} ({1})", url, m_ServerURL);
+        }
+
+        public UserAgentServiceConnector(IConfigSource config)
+        {
+            IConfig serviceConfig = config.Configs["UserAgentService"];
+            if (serviceConfig == null)
+            {
+                m_log.Error("[USER AGENT CONNECTOR]: UserAgentService missing from ini");
+                throw new Exception("UserAgent connector init error");
+            }
+
+            string serviceURI = serviceConfig.GetString("UserAgentServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[USER AGENT CONNECTOR]: No Server URI named in section UserAgentService");
+                throw new Exception("UserAgent connector init error");
+            }
+
+            m_ServerURL = m_ServerURLHost = serviceURI;
+            if (!m_ServerURL.EndsWith("/"))
+                m_ServerURL += "/";
+
+            //m_log.DebugFormat("[USER AGENT CONNECTOR]: new connector to {0}", m_ServerURL);
+        }
+
+        protected override string AgentPath()
+        {
+            return "homeagent/";
+        }
+
+        // The Login service calls this interface with fromLogin=true 
+        // Sims call it with fromLogin=false
+        // Either way, this is verified by the handler
+        public bool LoginAgentToGrid(GridRegion source, AgentCircuitData aCircuit, GridRegion gatekeeper, GridRegion destination, bool fromLogin, out string reason)
+        {
+            reason = String.Empty;
+
+            if (destination == null)
+            {
+                reason = "Destination is null";
+                m_log.Debug("[USER AGENT CONNECTOR]: Given destination is null");
+                return false;
+            }
+
+            GridRegion home = new GridRegion();
+            home.ServerURI = m_ServerURL;
+            home.RegionID = destination.RegionID;
+            home.RegionLocX = destination.RegionLocX;
+            home.RegionLocY = destination.RegionLocY;
+
+            m_Gatekeeper = gatekeeper;
+
+            Console.WriteLine("   >>> LoginAgentToGrid <<< " + home.ServerURI);
+
+            uint flags = fromLogin ? (uint)TeleportFlags.ViaLogin : (uint)TeleportFlags.ViaHome;
+            return CreateAgent(source, home, aCircuit, flags, out reason);
+        }
+
+
+        // The simulators call this interface
+        public bool LoginAgentToGrid(GridRegion source, AgentCircuitData aCircuit, GridRegion gatekeeper, GridRegion destination, out string reason)
+        {
+            return LoginAgentToGrid(source, aCircuit, gatekeeper, destination, false, out reason);
+        }
+
+        protected override void PackData(OSDMap args, GridRegion source, AgentCircuitData aCircuit, GridRegion destination, uint flags)
+        {
+            base.PackData(args, source, aCircuit, destination, flags);
+            args["gatekeeper_serveruri"] = OSD.FromString(m_Gatekeeper.ServerURI);
+            args["gatekeeper_host"] = OSD.FromString(m_Gatekeeper.ExternalHostName);
+            args["gatekeeper_port"] = OSD.FromString(m_Gatekeeper.HttpPort.ToString());
+            args["destination_serveruri"] = OSD.FromString(destination.ServerURI);
+        }
+
+        public void SetClientToken(UUID sessionID, string token)
+        { 
+            // no-op
+        }
+
+        private Hashtable CallServer(string methodName, Hashtable hash)
+        {
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest(methodName, paramList);
+
+            // Send and get reply
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(m_ServerURL, 10000);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[USER AGENT CONNECTOR]: {0} call to {1} failed: {2}", methodName, m_ServerURLHost, e.Message);
+                throw;
+            }
+
+            if (response.IsFault)
+            {
+                throw new Exception(string.Format("[USER AGENT CONNECTOR]: {0} call to {1} returned an error: {2}", methodName, m_ServerURLHost, response.FaultString));
+            }
+
+            hash = (Hashtable)response.Value;
+
+            if (hash == null)
+            {
+                throw new Exception(string.Format("[USER AGENT CONNECTOR]: {0} call to {1} returned null", methodName, m_ServerURLHost));
+            }
+
+            return hash;
+        }
+
+        public GridRegion GetHomeRegion(UUID userID, out Vector3 position, out Vector3 lookAt)
+        {
+            position = Vector3.UnitY; lookAt = Vector3.UnitY;
+
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+
+            hash = CallServer("get_home_region", hash);
+
+            bool success;
+            if (!Boolean.TryParse((string)hash["result"], out success) || !success)
+                return null;
+
+            GridRegion region = new GridRegion();
+
+            UUID.TryParse((string)hash["uuid"], out region.RegionID);
+            //m_log.Debug(">> HERE, uuid: " + region.RegionID);
+            int n = 0;
+            if (hash["x"] != null)
+            {
+                Int32.TryParse((string)hash["x"], out n);
+                region.RegionLocX = n;
+                //m_log.Debug(">> HERE, x: " + region.RegionLocX);
+            }
+            if (hash["y"] != null)
+            {
+                Int32.TryParse((string)hash["y"], out n);
+                region.RegionLocY = n;
+                //m_log.Debug(">> HERE, y: " + region.RegionLocY);
+            }
+            if (hash["size_x"] != null)
+            {
+                Int32.TryParse((string)hash["size_x"], out n);
+                region.RegionSizeX = n;
+                //m_log.Debug(">> HERE, x: " + region.RegionLocX);
+            }
+            if (hash["size_y"] != null)
+            {
+                Int32.TryParse((string)hash["size_y"], out n);
+                region.RegionSizeY = n;
+                //m_log.Debug(">> HERE, y: " + region.RegionLocY);
+            }
+            if (hash["region_name"] != null)
+            {
+                region.RegionName = (string)hash["region_name"];
+                //m_log.Debug(">> HERE, name: " + region.RegionName);
+            }
+            if (hash["hostname"] != null)
+                region.ExternalHostName = (string)hash["hostname"];
+            if (hash["http_port"] != null)
+            {
+                uint p = 0;
+                UInt32.TryParse((string)hash["http_port"], out p);
+                region.HttpPort = p;
+            }
+            if (hash.ContainsKey("server_uri") && hash["server_uri"] != null)
+                region.ServerURI = (string)hash["server_uri"];
+
+            if (hash["internal_port"] != null)
+            {
+                int p = 0;
+                Int32.TryParse((string)hash["internal_port"], out p);
+                region.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), p);
+            }
+            if (hash["position"] != null)
+                Vector3.TryParse((string)hash["position"], out position);
+            if (hash["lookAt"] != null)
+                Vector3.TryParse((string)hash["lookAt"], out lookAt);
+
+            // Successful return
+            return region;
+        }
+
+        public bool IsAgentComingHome(UUID sessionID, string thisGridExternalName)
+        {
+            Hashtable hash = new Hashtable();
+            hash["sessionID"] = sessionID.ToString();
+            hash["externalName"] = thisGridExternalName;
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("agent_is_coming_home", paramList);
+            string reason = string.Empty;
+            return GetBoolResponse(request, out reason);
+        }
+
+        public bool VerifyAgent(UUID sessionID, string token)
+        {
+            Hashtable hash = new Hashtable();
+            hash["sessionID"] = sessionID.ToString();
+            hash["token"] = token;
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("verify_agent", paramList);
+            string reason = string.Empty;
+            return GetBoolResponse(request, out reason);
+        }
+
+        public bool VerifyClient(UUID sessionID, string token)
+        {
+            Hashtable hash = new Hashtable();
+            hash["sessionID"] = sessionID.ToString();
+            hash["token"] = token;
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("verify_client", paramList);
+            string reason = string.Empty;
+            return GetBoolResponse(request, out reason);
+        }
+
+        public void LogoutAgent(UUID userID, UUID sessionID)
+        {
+            Hashtable hash = new Hashtable();
+            hash["sessionID"] = sessionID.ToString();
+            hash["userID"] = userID.ToString();
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("logout_agent", paramList);
+            string reason = string.Empty;
+            GetBoolResponse(request, out reason);
+        }
+
+        [Obsolete]
+        public List<UUID> StatusNotification(List<string> friends, UUID userID, bool online)
+        {
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+            hash["online"] = online.ToString();
+            int i = 0;
+            foreach (string s in friends)
+            {
+                hash["friend_" + i.ToString()] = s;
+                i++;
+            }
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("status_notification", paramList);
+//            string reason = string.Empty;
+
+            // Send and get reply
+            List<UUID> friendsOnline = new List<UUID>();
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(m_ServerURL, 6000);
+            }
+            catch
+            {
+                m_log.DebugFormat("[USER AGENT CONNECTOR]: Unable to contact remote server {0} for StatusNotification", m_ServerURLHost);
+//                reason = "Exception: " + e.Message;
+                return friendsOnline;
+            }
+
+            if (response.IsFault)
+            {
+                m_log.ErrorFormat("[USER AGENT CONNECTOR]: remote call to {0} for StatusNotification returned an error: {1}", m_ServerURLHost, response.FaultString);
+//                reason = "XMLRPC Fault";
+                return friendsOnline;
+            }
+
+            hash = (Hashtable)response.Value;
+            //foreach (Object o in hash)
+            //    m_log.Debug(">> " + ((DictionaryEntry)o).Key + ":" + ((DictionaryEntry)o).Value);
+            try
+            {
+                if (hash == null)
+                {
+                    m_log.ErrorFormat("[USER AGENT CONNECTOR]: GetOnlineFriends Got null response from {0}! THIS IS BAAAAD", m_ServerURLHost);
+//                    reason = "Internal error 1";
+                    return friendsOnline;
+                }
+
+                // Here is the actual response
+                foreach (object key in hash.Keys)
+                {
+                    if (key is string && ((string)key).StartsWith("friend_") && hash[key] != null)
+                    {
+                        UUID uuid;
+                        if (UUID.TryParse(hash[key].ToString(), out uuid))
+                            friendsOnline.Add(uuid);
+                    }
+                }
+
+            }
+            catch
+            {
+                m_log.ErrorFormat("[USER AGENT CONNECTOR]: Got exception on GetOnlineFriends response.");
+//                reason = "Exception: " + e.Message;
+            }
+
+            return friendsOnline;
+        }
+
+        [Obsolete]
+        public List<UUID> GetOnlineFriends(UUID userID, List<string> friends)
+        {
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+            int i = 0;
+            foreach (string s in friends)
+            {
+                hash["friend_" + i.ToString()] = s;
+                i++;
+            }
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("get_online_friends", paramList);
+//            string reason = string.Empty;
+            
+            // Send and get reply
+            List<UUID> online = new List<UUID>();
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(m_ServerURL, 10000);
+            }
+            catch
+            {
+                m_log.DebugFormat("[USER AGENT CONNECTOR]: Unable to contact remote server {0} for GetOnlineFriends", m_ServerURLHost);
+//                reason = "Exception: " + e.Message;
+                return online;
+            }
+
+            if (response.IsFault)
+            {
+                m_log.ErrorFormat("[USER AGENT CONNECTOR]: remote call to {0} for GetOnlineFriends returned an error: {1}", m_ServerURLHost, response.FaultString);
+//                reason = "XMLRPC Fault";
+                return online;
+            }
+
+            hash = (Hashtable)response.Value;
+            //foreach (Object o in hash)
+            //    m_log.Debug(">> " + ((DictionaryEntry)o).Key + ":" + ((DictionaryEntry)o).Value);
+            try
+            {
+                if (hash == null)
+                {
+                    m_log.ErrorFormat("[USER AGENT CONNECTOR]: GetOnlineFriends Got null response from {0}! THIS IS BAAAAD", m_ServerURLHost);
+//                    reason = "Internal error 1";
+                    return online;
+                }
+
+                // Here is the actual response
+                foreach (object key in hash.Keys)
+                {
+                    if (key is string && ((string)key).StartsWith("friend_") && hash[key] != null)
+                    {
+                        UUID uuid;
+                        if (UUID.TryParse(hash[key].ToString(), out uuid))
+                            online.Add(uuid);
+                    }
+                }
+
+            }
+            catch
+            {
+                m_log.ErrorFormat("[USER AGENT CONNECTOR]: Got exception on GetOnlineFriends response.");
+//                reason = "Exception: " + e.Message;
+            }
+
+            return online;
+        }
+
+        public Dictionary<string,object> GetUserInfo (UUID userID)
+        {
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+
+            hash = CallServer("get_user_info", hash);
+
+            Dictionary<string, object> info = new Dictionary<string, object>();
+
+            foreach (object key in hash.Keys)
+            {
+                if (hash[key] != null)
+                {
+                    info.Add(key.ToString(), hash[key]);
+                }
+            }
+
+            return info;
+        }
+
+        public Dictionary<string, object> GetServerURLs(UUID userID)
+        {
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+
+            hash = CallServer("get_server_urls", hash);
+           
+            Dictionary<string, object> serverURLs = new Dictionary<string, object>();
+            foreach (object key in hash.Keys)
+            {
+                if (key is string && ((string)key).StartsWith("SRV_") && hash[key] != null)
+                {
+                    string serverType = key.ToString().Substring(4); // remove "SRV_"
+                    serverURLs.Add(serverType, hash[key].ToString());
+                }
+            }
+
+            return serverURLs;
+        }
+
+        public string LocateUser(UUID userID)
+        {
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+
+            hash = CallServer("locate_user", hash);           
+
+            string url = string.Empty;
+
+            // Here's the actual response
+            if (hash.ContainsKey("URL"))
+                url = hash["URL"].ToString();
+
+            return url;
+        }
+
+        public string GetUUI(UUID userID, UUID targetUserID)
+        {
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+            hash["targetUserID"] = targetUserID.ToString();
+
+            hash = CallServer("get_uui", hash);
+
+            string uui = string.Empty;
+
+            // Here's the actual response
+            if (hash.ContainsKey("UUI"))
+                uui = hash["UUI"].ToString();
+
+            return uui;
+        }
+
+        public UUID GetUUID(String first, String last)
+        {
+            Hashtable hash = new Hashtable();
+            hash["first"] = first;
+            hash["last"] = last;
+
+            hash = CallServer("get_uuid", hash);
+
+            if (!hash.ContainsKey("UUID"))
+            {
+                throw new Exception(string.Format("[USER AGENT CONNECTOR]: get_uuid call to {0} didn't return a UUID", m_ServerURLHost));
+            }
+
+            UUID uuid;
+            if (!UUID.TryParse(hash["UUID"].ToString(), out uuid))
+            {
+                throw new Exception(string.Format("[USER AGENT CONNECTOR]: get_uuid call to {0} returned an invalid UUID: {1}", m_ServerURLHost, hash["UUID"].ToString()));
+            }
+
+            return uuid;
+        }
+
+        private bool GetBoolResponse(XmlRpcRequest request, out string reason)
+        {
+            //m_log.Debug("[USER AGENT CONNECTOR]: GetBoolResponse from/to " + m_ServerURLHost);
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(m_ServerURL, 10000);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[USER AGENT CONNECTOR]: Unable to contact remote server {0} for GetBoolResponse", m_ServerURLHost);
+                reason = "Exception: " + e.Message;
+                return false;
+            }
+
+            if (response.IsFault)
+            {
+                m_log.ErrorFormat("[USER AGENT CONNECTOR]: remote call to {0} for GetBoolResponse returned an error: {1}", m_ServerURLHost, response.FaultString);
+                reason = "XMLRPC Fault";
+                return false;
+            }
+
+            Hashtable hash = (Hashtable)response.Value;
+            //foreach (Object o in hash)
+            //    m_log.Debug(">> " + ((DictionaryEntry)o).Key + ":" + ((DictionaryEntry)o).Value);
+            try
+            {
+                if (hash == null)
+                {
+                    m_log.ErrorFormat("[USER AGENT CONNECTOR]: Got null response from {0}! THIS IS BAAAAD", m_ServerURLHost);
+                    reason = "Internal error 1";
+                    return false;
+                }
+                bool success = false;
+                reason = string.Empty;
+                if (hash.ContainsKey("result"))
+                    Boolean.TryParse((string)hash["result"], out success);
+                else
+                {
+                    reason = "Internal error 2";
+                    m_log.WarnFormat("[USER AGENT CONNECTOR]: response from {0} does not have expected key 'result'", m_ServerURLHost);
+                }
+
+                return success;
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[USER AGENT CONNECTOR]: Got exception on GetBoolResponse response.");
+                if (hash.ContainsKey("result") && hash["result"] != null)
+                    m_log.ErrorFormat("Reply was ", (string)hash["result"]);
+                reason = "Exception: " + e.Message;
+                return false;
+            }
+
+        }
+
+    }
+}
diff --git a/OpenSim/Services/Connectors/InstantMessage/InstantMessageServiceConnector.cs b/OpenSim/Services/Connectors/InstantMessage/InstantMessageServiceConnector.cs
new file mode 100644
index 0000000..e19c23d
--- /dev/null
+++ b/OpenSim/Services/Connectors/InstantMessage/InstantMessageServiceConnector.cs
@@ -0,0 +1,132 @@
+/*
+ * 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 OpenMetaverse;
+using Nwc.XmlRpc;
+using log4net;
+
+using OpenSim.Framework;
+
+namespace OpenSim.Services.Connectors.InstantMessage
+{
+    public class InstantMessageServiceConnector
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(
+            MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// This actually does the XMLRPC Request
+        /// </summary>
+        /// <param name="url">URL we pull the data out of to send the request to</param>
+        /// <param name="im">The Instant Message </param>
+        /// <returns>Bool if the message was successfully delivered at the other side.</returns>
+        public static bool SendInstantMessage(string url, GridInstantMessage im)
+        {
+            Hashtable xmlrpcdata = ConvertGridInstantMessageToXMLRPC(im);
+            xmlrpcdata["region_handle"] = 0;
+
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(xmlrpcdata);
+            XmlRpcRequest GridReq = new XmlRpcRequest("grid_instant_message", SendParams);
+            try
+            {
+
+                XmlRpcResponse GridResp = GridReq.Send(url, 10000);
+
+                Hashtable responseData = (Hashtable)GridResp.Value;
+
+                if (responseData.ContainsKey("success"))
+                {
+                    if ((string)responseData["success"] == "TRUE")
+                    {
+                        //m_log.DebugFormat("[XXX] Success");
+                        return true;
+                    }
+                    else
+                    {
+                        //m_log.DebugFormat("[XXX] Fail");
+                        return false;
+                    }
+                }
+                else
+                {
+                    m_log.DebugFormat("[GRID INSTANT MESSAGE]: No response from {0}", url);
+                    return false;
+                }
+            }
+            catch (WebException e)
+            {
+                m_log.ErrorFormat("[GRID INSTANT MESSAGE]: Error sending message to {0} the host didn't respond " + e.ToString(), url);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Takes a GridInstantMessage and converts it into a Hashtable for XMLRPC
+        /// </summary>
+        /// <param name="msg">The GridInstantMessage object</param>
+        /// <returns>Hashtable containing the XMLRPC request</returns>
+        protected static Hashtable ConvertGridInstantMessageToXMLRPC(GridInstantMessage msg)
+        {
+            Hashtable gim = new Hashtable();
+            gim["from_agent_id"] = msg.fromAgentID.ToString();
+            // Kept for compatibility
+            gim["from_agent_session"] = UUID.Zero.ToString();
+            gim["to_agent_id"] = msg.toAgentID.ToString();
+            gim["im_session_id"] = msg.imSessionID.ToString();
+            gim["timestamp"] = msg.timestamp.ToString();
+            gim["from_agent_name"] = msg.fromAgentName;
+            gim["message"] = msg.message;
+            byte[] dialogdata = new byte[1]; dialogdata[0] = msg.dialog;
+            gim["dialog"] = Convert.ToBase64String(dialogdata, Base64FormattingOptions.None);
+
+            if (msg.fromGroup)
+                gim["from_group"] = "TRUE";
+            else
+                gim["from_group"] = "FALSE";
+            byte[] offlinedata = new byte[1]; offlinedata[0] = msg.offline;
+            gim["offline"] = Convert.ToBase64String(offlinedata, Base64FormattingOptions.None);
+            gim["parent_estate_id"] = msg.ParentEstateID.ToString();
+            gim["position_x"] = msg.Position.X.ToString();
+            gim["position_y"] = msg.Position.Y.ToString();
+            gim["position_z"] = msg.Position.Z.ToString();
+            gim["region_id"] = msg.RegionID.ToString();
+            gim["binary_bucket"] = Convert.ToBase64String(msg.binaryBucket, Base64FormattingOptions.None);
+            gim["region_id"] = new UUID(msg.RegionID).ToString();
+
+            return gim;
+        }
+
+    }
+}
diff --git a/OpenSim/Services/Connectors/Inventory/XInventoryServicesConnector.cs b/OpenSim/Services/Connectors/Inventory/XInventoryServicesConnector.cs
new file mode 100644
index 0000000..b0615b8
--- /dev/null
+++ b/OpenSim/Services/Connectors/Inventory/XInventoryServicesConnector.cs
@@ -0,0 +1,763 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Monitoring;
+using OpenSim.Services.Interfaces;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class XInventoryServicesConnector : BaseServiceConnector, IInventoryService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Number of requests made to the remote inventory service.
+        /// </summary>
+        public int RequestsMade { get; private set; }
+
+        private string m_ServerURI = String.Empty;
+
+        /// <summary>
+        /// Timeout for remote requests.
+        /// </summary>
+        /// <remarks>
+        /// In this case, -1 is default timeout (100 seconds), not infinite.
+        /// </remarks>
+        private int m_requestTimeoutSecs = -1;
+
+        private const double CACHE_EXPIRATION_SECONDS = 20.0;
+        private static ExpiringCache<UUID, InventoryItemBase> m_ItemCache = new ExpiringCache<UUID,InventoryItemBase>();
+
+        public XInventoryServicesConnector()
+        {
+        }
+
+        public XInventoryServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public XInventoryServicesConnector(IConfigSource source)
+            : base(source, "InventoryService")
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["InventoryService"];
+            if (config == null)
+            {
+                m_log.Error("[INVENTORY CONNECTOR]: InventoryService missing from OpenSim.ini");
+                throw new Exception("Inventory connector init error");
+            }
+
+            string serviceURI = config.GetString("InventoryServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[INVENTORY CONNECTOR]: No Server URI named in section InventoryService");
+                throw new Exception("Inventory connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            m_requestTimeoutSecs = config.GetInt("RemoteRequestTimeout", m_requestTimeoutSecs);
+
+            StatsManager.RegisterStat(
+                new Stat(
+                "RequestsMade", 
+                "Requests made", 
+                "Number of requests made to the remove inventory service", 
+                "requests", 
+                "inventory", 
+                serviceURI, 
+                StatType.Pull, 
+                MeasuresOfInterest.AverageChangeOverTime,
+                s => s.Value = RequestsMade,
+                StatVerbosity.Debug));
+        }
+
+        private bool CheckReturn(Dictionary<string, object> ret)
+        {
+            if (ret == null)
+                return false;
+
+            if (ret.Count == 0)
+                return false;
+
+            if (ret.ContainsKey("RESULT"))
+            {
+                if (ret["RESULT"] is string)
+                {
+                    bool result;
+
+                    if (bool.TryParse((string)ret["RESULT"], out result))
+                        return result;
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public bool CreateUserInventory(UUID principalID)
+        {
+            Dictionary<string,object> ret = MakeRequest("CREATEUSERINVENTORY",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public List<InventoryFolderBase> GetInventorySkeleton(UUID principalID)
+        {
+            Dictionary<string,object> ret = MakeRequest("GETINVENTORYSKELETON",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() }
+                    });
+
+            if (!CheckReturn(ret))
+                return null;
+
+            Dictionary<string, object> folders = (Dictionary<string, object>)ret["FOLDERS"];
+
+            List<InventoryFolderBase> fldrs = new List<InventoryFolderBase>();
+
+            try
+            {
+                foreach (Object o in folders.Values)
+                    fldrs.Add(BuildFolder((Dictionary<string, object>)o));
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[XINVENTORY SERVICES CONNECTOR]: Exception unwrapping folder list: ", e);
+            }
+
+            return fldrs;
+        }
+
+        public InventoryFolderBase GetRootFolder(UUID principalID)
+        {
+            Dictionary<string,object> ret = MakeRequest("GETROOTFOLDER",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() }
+                    });
+
+            if (!CheckReturn(ret))
+                return null;
+
+            return BuildFolder((Dictionary<string, object>)ret["folder"]);
+        }
+
+        public InventoryFolderBase GetFolderForType(UUID principalID, FolderType type)
+        {
+            Dictionary<string,object> ret = MakeRequest("GETFOLDERFORTYPE",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() },
+                        { "TYPE", ((int)type).ToString() }
+                    });
+
+            if (!CheckReturn(ret))
+                return null;
+
+            return BuildFolder((Dictionary<string, object>)ret["folder"]);
+        }
+
+        public InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
+        {
+            InventoryCollection inventory = new InventoryCollection();
+            inventory.Folders = new List<InventoryFolderBase>();
+            inventory.Items = new List<InventoryItemBase>();
+            inventory.OwnerID = principalID;
+
+            try
+            {
+                Dictionary<string,object> ret = MakeRequest("GETFOLDERCONTENT",
+                        new Dictionary<string,object> {
+                            { "PRINCIPAL", principalID.ToString() },
+                            { "FOLDER", folderID.ToString() }
+                        });
+
+                if (!CheckReturn(ret))
+                    return null;
+
+                Dictionary<string,object> folders = ret.ContainsKey("FOLDERS") ?
+                    (Dictionary<string,object>)ret["FOLDERS"] : null;
+                Dictionary<string,object> items = ret.ContainsKey("ITEMS") ?
+                    (Dictionary<string, object>)ret["ITEMS"] : null;
+
+                if (folders != null)
+                    foreach (Object o in folders.Values) // getting the values directly, we don't care about the keys folder_i
+                        inventory.Folders.Add(BuildFolder((Dictionary<string, object>)o));
+                if (items != null)
+                    foreach (Object o in items.Values) // getting the values directly, we don't care about the keys item_i
+                        inventory.Items.Add(BuildItem((Dictionary<string, object>)o));
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: Exception in GetFolderContent: {0}", e.Message);
+            }
+
+            return inventory;
+        }
+        
+        public virtual InventoryCollection[] GetMultipleFoldersContent(UUID principalID, UUID[] folderIDs)
+        {
+            InventoryCollection[] inventoryArr = new InventoryCollection[folderIDs.Length];
+            // m_log.DebugFormat("[XXX]: In GetMultipleFoldersContent {0}", String.Join(",", folderIDs));
+            try
+            {
+                Dictionary<string, object> resultSet = MakeRequest("GETMULTIPLEFOLDERSCONTENT",
+                        new Dictionary<string, object> {
+                            { "PRINCIPAL", principalID.ToString() },
+                            { "FOLDERS", String.Join(",", folderIDs) },
+                            { "COUNT", folderIDs.Length.ToString() }
+                        });
+
+                if (!CheckReturn(resultSet))
+                    return null;
+
+                int i = 0;
+                foreach (KeyValuePair<string, object> kvp in resultSet)
+                {
+                    InventoryCollection inventory = new InventoryCollection();
+                    if (kvp.Key.StartsWith("F_"))
+                    {
+                        UUID fid = UUID.Zero;
+                        if (UUID.TryParse(kvp.Key.Substring(2), out fid) && fid == folderIDs[i])
+                        {
+                            inventory.Folders = new List<InventoryFolderBase>();
+                            inventory.Items = new List<InventoryItemBase>();
+
+                            Dictionary<string, object> ret = (Dictionary<string, object>)kvp.Value;
+
+                            if (ret.ContainsKey("FID"))
+                            {
+                                if (!UUID.TryParse(ret["FID"].ToString(), out inventory.FolderID))
+                                    m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: Could not parse folder id {0}", ret["FID"].ToString());
+                            }
+                            else
+                                m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: FID key not present in response");
+
+                            inventory.Version = -1;
+                            if (ret.ContainsKey("VERSION"))
+                                Int32.TryParse(ret["VERSION"].ToString(), out inventory.Version);
+                            if (ret.ContainsKey("OWNER"))
+                                UUID.TryParse(ret["OWNER"].ToString(), out inventory.OwnerID);
+
+                            //m_log.DebugFormat("[XXX]: Received {0} ({1}) {2} {3}", inventory.FolderID, fid, inventory.Version, inventory.OwnerID);
+
+                            Dictionary<string, object> folders =
+                                    (Dictionary<string, object>)ret["FOLDERS"];
+                            Dictionary<string, object> items =
+                                    (Dictionary<string, object>)ret["ITEMS"];
+
+                            foreach (Object o in folders.Values) // getting the values directly, we don't care about the keys folder_i
+                            {
+                                inventory.Folders.Add(BuildFolder((Dictionary<string, object>)o));
+                            }
+                            foreach (Object o in items.Values) // getting the values directly, we don't care about the keys item_i
+                            {
+                                inventory.Items.Add(BuildItem((Dictionary<string, object>)o));
+                            }
+
+                            inventoryArr[i] = inventory;
+                        }
+                        else
+                        {
+                            m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: Folder id does not match. Expected {0} got {1}",
+                                folderIDs[i], fid);
+                            m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: {0} {1}", String.Join(",", folderIDs), String.Join(",", resultSet.Keys));
+                        }
+
+                        i += 1;
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: Exception in GetMultipleFoldersContent: {0}", e.Message);
+            }
+
+            return inventoryArr;
+        }
+
+        public List<InventoryItemBase> GetFolderItems(UUID principalID, UUID folderID)
+        {
+            Dictionary<string,object> ret = MakeRequest("GETFOLDERITEMS",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() },
+                        { "FOLDER", folderID.ToString() }
+                    });
+
+            if (!CheckReturn(ret))
+                return null;
+
+            Dictionary<string, object> items = (Dictionary<string, object>)ret["ITEMS"];
+            List<InventoryItemBase> fitems = new List<InventoryItemBase>();
+            foreach (Object o in items.Values) // getting the values directly, we don't care about the keys item_i
+                fitems.Add(BuildItem((Dictionary<string, object>)o));
+
+            return fitems;
+        }
+
+        public bool AddFolder(InventoryFolderBase folder)
+        {
+            Dictionary<string,object> ret = MakeRequest("ADDFOLDER",
+                    new Dictionary<string,object> {
+                        { "ParentID", folder.ParentID.ToString() },
+                        { "Type", folder.Type.ToString() },
+                        { "Version", folder.Version.ToString() },
+                        { "Name", folder.Name.ToString() },
+                        { "Owner", folder.Owner.ToString() },
+                        { "ID", folder.ID.ToString() }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool UpdateFolder(InventoryFolderBase folder)
+        {
+            Dictionary<string,object> ret = MakeRequest("UPDATEFOLDER",
+                    new Dictionary<string,object> {
+                        { "ParentID", folder.ParentID.ToString() },
+                        { "Type", folder.Type.ToString() },
+                        { "Version", folder.Version.ToString() },
+                        { "Name", folder.Name.ToString() },
+                        { "Owner", folder.Owner.ToString() },
+                        { "ID", folder.ID.ToString() }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool MoveFolder(InventoryFolderBase folder)
+        {
+            Dictionary<string,object> ret = MakeRequest("MOVEFOLDER",
+                    new Dictionary<string,object> {
+                        { "ParentID", folder.ParentID.ToString() },
+                        { "ID", folder.ID.ToString() },
+                        { "PRINCIPAL", folder.Owner.ToString() }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool DeleteFolders(UUID principalID, List<UUID> folderIDs)
+        {
+            List<string> slist = new List<string>();
+
+            foreach (UUID f in folderIDs)
+                slist.Add(f.ToString());
+
+            Dictionary<string,object> ret = MakeRequest("DELETEFOLDERS",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() },
+                        { "FOLDERS", slist }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool PurgeFolder(InventoryFolderBase folder)
+        {
+            Dictionary<string,object> ret = MakeRequest("PURGEFOLDER",
+                    new Dictionary<string,object> {
+                        { "ID", folder.ID.ToString() }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool AddItem(InventoryItemBase item)
+        {
+            if (item.Description == null)
+                item.Description = String.Empty;
+            if (item.CreatorData == null)
+                item.CreatorData = String.Empty;
+            if (item.CreatorId == null)
+                item.CreatorId = String.Empty;
+            Dictionary<string, object> ret = MakeRequest("ADDITEM",
+                    new Dictionary<string,object> {
+                        { "AssetID", item.AssetID.ToString() },
+                        { "AssetType", item.AssetType.ToString() },
+                        { "Name", item.Name.ToString() },
+                        { "Owner", item.Owner.ToString() },
+                        { "ID", item.ID.ToString() },
+                        { "InvType", item.InvType.ToString() },
+                        { "Folder", item.Folder.ToString() },
+                        { "CreatorId", item.CreatorId.ToString() },
+                        { "CreatorData", item.CreatorData.ToString() },
+                        { "Description", item.Description.ToString() },
+                        { "NextPermissions", item.NextPermissions.ToString() },
+                        { "CurrentPermissions", item.CurrentPermissions.ToString() },
+                        { "BasePermissions", item.BasePermissions.ToString() },
+                        { "EveryOnePermissions", item.EveryOnePermissions.ToString() },
+                        { "GroupPermissions", item.GroupPermissions.ToString() },
+                        { "GroupID", item.GroupID.ToString() },
+                        { "GroupOwned", item.GroupOwned.ToString() },
+                        { "SalePrice", item.SalePrice.ToString() },
+                        { "SaleType", item.SaleType.ToString() },
+                        { "Flags", item.Flags.ToString() },
+                        { "CreationDate", item.CreationDate.ToString() }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool UpdateItem(InventoryItemBase item)
+        {
+            if (item.CreatorData == null)
+                item.CreatorData = String.Empty;
+            Dictionary<string,object> ret = MakeRequest("UPDATEITEM",
+                    new Dictionary<string,object> {
+                        { "AssetID", item.AssetID.ToString() },
+                        { "AssetType", item.AssetType.ToString() },
+                        { "Name", item.Name.ToString() },
+                        { "Owner", item.Owner.ToString() },
+                        { "ID", item.ID.ToString() },
+                        { "InvType", item.InvType.ToString() },
+                        { "Folder", item.Folder.ToString() },
+                        { "CreatorId", item.CreatorId.ToString() },
+                        { "CreatorData", item.CreatorData.ToString() },
+                        { "Description", item.Description.ToString() },
+                        { "NextPermissions", item.NextPermissions.ToString() },
+                        { "CurrentPermissions", item.CurrentPermissions.ToString() },
+                        { "BasePermissions", item.BasePermissions.ToString() },
+                        { "EveryOnePermissions", item.EveryOnePermissions.ToString() },
+                        { "GroupPermissions", item.GroupPermissions.ToString() },
+                        { "GroupID", item.GroupID.ToString() },
+                        { "GroupOwned", item.GroupOwned.ToString() },
+                        { "SalePrice", item.SalePrice.ToString() },
+                        { "SaleType", item.SaleType.ToString() },
+                        { "Flags", item.Flags.ToString() },
+                        { "CreationDate", item.CreationDate.ToString() }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool MoveItems(UUID principalID, List<InventoryItemBase> items)
+        {
+            List<string> idlist = new List<string>();
+            List<string> destlist = new List<string>();
+
+            foreach (InventoryItemBase item in items)
+            {
+                idlist.Add(item.ID.ToString());
+                destlist.Add(item.Folder.ToString());
+            }
+
+            Dictionary<string,object> ret = MakeRequest("MOVEITEMS",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() },
+                        { "IDLIST", idlist },
+                        { "DESTLIST", destlist }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public bool DeleteItems(UUID principalID, List<UUID> itemIDs)
+        {
+            List<string> slist = new List<string>();
+
+            foreach (UUID f in itemIDs)
+                slist.Add(f.ToString());
+
+            Dictionary<string,object> ret = MakeRequest("DELETEITEMS",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() },
+                        { "ITEMS", slist }
+                    });
+
+            return CheckReturn(ret);
+        }
+
+        public InventoryItemBase GetItem(InventoryItemBase item)
+        {
+            InventoryItemBase retrieved = null;
+            if (m_ItemCache.TryGetValue(item.ID, out retrieved))
+                return retrieved;
+
+            try
+            {
+                Dictionary<string, object> ret = MakeRequest("GETITEM",
+                        new Dictionary<string, object> {
+                        { "ID", item.ID.ToString() }
+                    });
+
+                if (!CheckReturn(ret))
+                    return null;
+
+                retrieved = BuildItem((Dictionary<string, object>)ret["item"]);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[XINVENTORY SERVICES CONNECTOR]: Exception in GetItem: ", e);
+            }
+
+            m_ItemCache.AddOrUpdate(item.ID, retrieved, CACHE_EXPIRATION_SECONDS);
+
+            return retrieved;
+        }
+
+        public virtual InventoryItemBase[] GetMultipleItems(UUID principalID, UUID[] itemIDs)
+        {
+            //m_log.DebugFormat("[XXX]: In GetMultipleItems {0}", String.Join(",", itemIDs));
+
+            InventoryItemBase[] itemArr = new InventoryItemBase[itemIDs.Length];
+            // Try to get them from the cache
+            List<UUID> pending = new List<UUID>();
+            InventoryItemBase item = null;
+            int i = 0;
+            foreach (UUID id in itemIDs)
+            {
+                if (m_ItemCache.TryGetValue(id, out item))
+                    itemArr[i++] = item;
+                else
+                    pending.Add(id);
+            }
+
+            if (pending.Count == 0) // we're done, everything was in the cache
+                return itemArr;
+
+            try
+            {
+                Dictionary<string, object> resultSet = MakeRequest("GETMULTIPLEITEMS",
+                        new Dictionary<string, object> {
+                            { "PRINCIPAL", principalID.ToString() },
+                            { "ITEMS", String.Join(",", pending.ToArray()) },
+                            { "COUNT", pending.Count.ToString() }
+                        });
+
+                if (!CheckReturn(resultSet))
+                {
+                    if (i == 0)
+                        return null;
+                    else
+                        return itemArr;
+                }
+
+                // carry over index i where we left above
+                foreach (KeyValuePair<string, object> kvp in resultSet)
+                {
+                    InventoryCollection inventory = new InventoryCollection();
+                    if (kvp.Key.StartsWith("item_"))
+                    {
+                        if (kvp.Value is Dictionary<string, object>)
+                        {
+                            item = BuildItem((Dictionary<string, object>)kvp.Value);
+                            m_ItemCache.AddOrUpdate(item.ID, item, CACHE_EXPIRATION_SECONDS);
+                            itemArr[i++] = item;
+                        }
+                        else
+                            itemArr[i++] = null;
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[XINVENTORY SERVICES CONNECTOR]: Exception in GetMultipleItems: {0}", e.Message);
+            }
+
+            return itemArr;
+        }
+
+        public InventoryFolderBase GetFolder(InventoryFolderBase folder)
+        {
+            try
+            {
+                Dictionary<string, object> ret = MakeRequest("GETFOLDER",
+                        new Dictionary<string, object> {
+                        { "ID", folder.ID.ToString() }
+                    });
+
+                if (!CheckReturn(ret))
+                    return null;
+
+                return BuildFolder((Dictionary<string, object>)ret["folder"]);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[XINVENTORY SERVICES CONNECTOR]: Exception in GetFolder: ", e);
+            }
+
+            return null;
+        }
+
+        public List<InventoryItemBase> GetActiveGestures(UUID principalID)
+        {
+            Dictionary<string,object> ret = MakeRequest("GETACTIVEGESTURES",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() }
+                    });
+
+            if (!CheckReturn(ret))
+                return null;
+
+            List<InventoryItemBase> items = new List<InventoryItemBase>();
+
+            foreach (Object o in ((Dictionary<string,object>)ret["ITEMS"]).Values)
+                items.Add(BuildItem((Dictionary<string, object>)o));
+
+            return items;
+        }
+
+        public int GetAssetPermissions(UUID principalID, UUID assetID)
+        {
+            Dictionary<string,object> ret = MakeRequest("GETASSETPERMISSIONS",
+                    new Dictionary<string,object> {
+                        { "PRINCIPAL", principalID.ToString() },
+                        { "ASSET", assetID.ToString() }
+                    });
+
+            // We cannot use CheckReturn() here because valid values for RESULT are "false" (in the case of request failure) or an int           
+            if (ret == null)
+                return 0;
+
+            if (ret.ContainsKey("RESULT"))
+            {
+                if (ret["RESULT"] is string)
+                {
+                    int intResult;
+
+                    if (int.TryParse ((string)ret["RESULT"], out intResult))
+                        return intResult;
+                }
+            }
+
+            return 0;
+        }
+
+        public bool HasInventoryForUser(UUID principalID)
+        {
+            return false;
+        }
+
+        // Helpers
+        //
+        private Dictionary<string,object> MakeRequest(string method,
+                Dictionary<string,object> sendData)
+        {
+            // Add "METHOD" as the first key in the dictionary. This ensures that it will be
+            // visible even when using partial logging ("debug http all 5").
+            Dictionary<string, object> temp = sendData;
+            sendData = new Dictionary<string,object>{ { "METHOD", method } };
+            foreach (KeyValuePair<string, object> kvp in temp)
+                sendData.Add(kvp.Key, kvp.Value);
+
+            RequestsMade++;
+
+            string reply 
+                = SynchronousRestFormsRequester.MakeRequest(
+                    "POST", m_ServerURI + "/xinventory",
+                     ServerUtils.BuildQueryString(sendData), m_requestTimeoutSecs, m_Auth);
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(
+                    reply);
+
+            return replyData;
+        }
+
+        private InventoryFolderBase BuildFolder(Dictionary<string,object> data)
+        {
+            InventoryFolderBase folder = new InventoryFolderBase();
+
+            try
+            {
+                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());
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[XINVENTORY SERVICES CONNECTOR]: Exception building folder: ", e);
+            }
+
+            return folder;
+        }
+
+        private InventoryItemBase BuildItem(Dictionary<string,object> data)
+        {
+            InventoryItemBase item = new InventoryItemBase();
+
+            try
+            {
+                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();
+                if (data.ContainsKey("CreatorData"))
+                    item.CreatorData = data["CreatorData"].ToString();
+                else
+                    item.CreatorData = String.Empty;
+                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());
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[XINVENTORY CONNECTOR]: Exception building item: ", e);
+            }
+
+            return item;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Land/LandServicesConnector.cs b/OpenSim/Services/Connectors/Land/LandServicesConnector.cs
new file mode 100644
index 0000000..644331a
--- /dev/null
+++ b/OpenSim/Services/Connectors/Land/LandServicesConnector.cs
@@ -0,0 +1,133 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using Nwc.XmlRpc;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+namespace OpenSim.Services.Connectors
+{
+    public class LandServicesConnector : ILandService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected IGridService m_GridService = null;
+
+        public LandServicesConnector()
+        {
+        }
+
+        public LandServicesConnector(IGridService gridServices)
+        {
+            Initialise(gridServices);
+        }
+
+        public virtual void Initialise(IGridService gridServices)
+        {
+            m_GridService = gridServices;
+        }
+
+        public virtual LandData GetLandData(UUID scopeID, ulong regionHandle, uint x, uint y, out byte regionAccess)
+        {
+            LandData landData = null;
+            Hashtable hash = new Hashtable();
+            hash["region_handle"] = regionHandle.ToString();
+            hash["x"] = x.ToString();
+            hash["y"] = y.ToString();
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+            regionAccess = 42; // Default to adult. Better safe...
+
+            try
+            {
+                uint xpos = 0, ypos = 0;
+                Util.RegionHandleToWorldLoc(regionHandle, out xpos, out ypos);
+                GridRegion info = m_GridService.GetRegionByPosition(scopeID, (int)xpos, (int)ypos);
+                if (info != null) // just to be sure
+                {
+                    XmlRpcRequest request = new XmlRpcRequest("land_data", paramList);
+                    XmlRpcResponse response = request.Send(info.ServerURI, 10000);
+                    if (response.IsFault)
+                    {
+                        m_log.ErrorFormat("[LAND CONNECTOR]: remote call returned an error: {0}", response.FaultString);
+                    }
+                    else
+                    {
+                        hash = (Hashtable)response.Value;
+                        try
+                        {
+                            landData = new LandData();
+                            landData.AABBMax = Vector3.Parse((string)hash["AABBMax"]);
+                            landData.AABBMin = Vector3.Parse((string)hash["AABBMin"]);
+                            landData.Area = Convert.ToInt32(hash["Area"]);
+                            landData.AuctionID = Convert.ToUInt32(hash["AuctionID"]);
+                            landData.Description = (string)hash["Description"];
+                            landData.Flags = Convert.ToUInt32(hash["Flags"]);
+                            landData.GlobalID = new UUID((string)hash["GlobalID"]);
+                            landData.Name = (string)hash["Name"];
+                            landData.OwnerID = new UUID((string)hash["OwnerID"]);
+                            landData.SalePrice = Convert.ToInt32(hash["SalePrice"]);
+                            landData.SnapshotID = new UUID((string)hash["SnapshotID"]);
+                            landData.UserLocation = Vector3.Parse((string)hash["UserLocation"]);
+                            if (hash["RegionAccess"] != null)
+                                regionAccess = (byte)Convert.ToInt32((string)hash["RegionAccess"]);
+                            m_log.DebugFormat("[LAND CONNECTOR]: Got land data for parcel {0}", landData.Name);
+                        }
+                        catch (Exception e)
+                        {
+                            m_log.ErrorFormat(
+                                "[LAND CONNECTOR]: Got exception while parsing land-data: {0} {1}", 
+                                e.Message, e.StackTrace);
+                        }
+                    }
+                }
+                else 
+                    m_log.WarnFormat("[LAND CONNECTOR]: Couldn't find region with handle {0}", regionHandle);
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat(
+                    "[LAND CONNECTOR]: Couldn't contact region {0}: {1} {2}", regionHandle, e.Message, e.StackTrace);
+            }
+        
+            return landData;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs b/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs
new file mode 100644
index 0000000..677825e
--- /dev/null
+++ b/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs
@@ -0,0 +1,226 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Reflection;
+
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Services.Connectors
+{
+    public class MapImageServicesConnector : BaseServiceConnector, IMapImageService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public MapImageServicesConnector()
+        {
+        }
+
+        public MapImageServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public MapImageServicesConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["MapImageService"];
+            if (config == null)
+            {
+                m_log.Error("[MAP IMAGE CONNECTOR]: MapImageService missing");
+                throw new Exception("MapImage connector init error");
+            }
+
+            string serviceURI = config.GetString("MapImageServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[MAP IMAGE CONNECTOR]: No Server URI named in section MapImageService");
+                throw new Exception("MapImage connector init error");
+            }
+            m_ServerURI = serviceURI;
+            m_ServerURI = serviceURI.TrimEnd('/');
+            base.Initialise(source, "MapImageService");
+        }
+
+        public bool RemoveMapTile(int x, int y, out string reason)
+        {
+            reason = string.Empty;
+            int tickstart = Util.EnvironmentTickCount();
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["X"] = x.ToString();
+            sendData["Y"] = y.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/removemap";
+
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("Result") && (replyData["Result"].ToString().ToLower() == "success"))
+                    {
+                        return true;
+                    }
+                    else if (replyData.ContainsKey("Result") && (replyData["Result"].ToString().ToLower() == "failure"))
+                    {
+                        m_log.DebugFormat("[MAP IMAGE CONNECTOR]: Delete failed: {0}", replyData["Message"].ToString());
+                        reason = replyData["Message"].ToString();
+                        return false;
+                    }
+                    else if (!replyData.ContainsKey("Result"))
+                    {
+                        m_log.DebugFormat("[MAP IMAGE CONNECTOR]: reply data does not contain result field");
+                    }
+                    else
+                    {
+                        m_log.DebugFormat("[MAP IMAGE CONNECTOR]: unexpected result {0}", replyData["Result"].ToString());
+                        reason = "Unexpected result " + replyData["Result"].ToString();
+                    }
+
+                }
+                else
+                {
+                    m_log.DebugFormat("[MAP IMAGE CONNECTOR]: Map post received null reply");
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[MAP IMAGE CONNECTOR]: Exception when contacting map server at {0}: {1}", uri, e.Message);
+            }
+            finally
+            {
+                // This just dumps a warning for any operation that takes more than 100 ms
+                int tickdiff = Util.EnvironmentTickCountSubtract(tickstart);
+                m_log.DebugFormat("[MAP IMAGE CONNECTOR]: map tile deleted in {0}ms", tickdiff);
+            }
+
+            return false;
+        }
+
+        public bool AddMapTile(int x, int y, byte[] jpgData, out string reason)
+        {
+            reason = string.Empty;
+            int tickstart = Util.EnvironmentTickCount();
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["X"] = x.ToString();
+            sendData["Y"] = y.ToString();
+            sendData["TYPE"] = "image/jpeg";
+            sendData["DATA"] = Convert.ToBase64String(jpgData);
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/map";
+
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("Result") && (replyData["Result"].ToString().ToLower() == "success"))
+                    {
+                        return true;
+                    }
+                    else if (replyData.ContainsKey("Result") && (replyData["Result"].ToString().ToLower() == "failure"))
+                    {
+                        reason = string.Format("Map post to {0} failed: {1}", uri, replyData["Message"].ToString());
+                        m_log.WarnFormat("[MAP IMAGE CONNECTOR]: {0}", reason);
+
+                        return false;
+                    }
+                    else if (!replyData.ContainsKey("Result"))
+                    {
+                        reason = string.Format("Reply data from {0} does not contain result field", uri);
+                        m_log.WarnFormat("[MAP IMAGE CONNECTOR]: {0}", reason);
+                    }
+                    else
+                    {
+                        reason = string.Format("Unexpected result {0} from {1}" + replyData["Result"].ToString(), uri);
+                        m_log.WarnFormat("[MAP IMAGE CONNECTOR]: {0}", reason);
+                    }
+                }
+                else
+                {
+                    reason = string.Format("Map post received null reply from {0}", uri);
+                    m_log.WarnFormat("[MAP IMAGE CONNECTOR]: {0}", reason);
+                }
+            }
+            catch (Exception e)
+            {
+                reason = string.Format("Exception when posting to map server at {0}: {1}", uri, e.Message);
+                m_log.WarnFormat("[MAP IMAGE CONNECTOR]: {0}", reason);
+            }
+            finally
+            {
+                // This just dumps a warning for any operation that takes more than 100 ms
+                int tickdiff = Util.EnvironmentTickCountSubtract(tickstart);
+                m_log.DebugFormat("[MAP IMAGE CONNECTOR]: map tile uploaded in {0}ms", tickdiff);
+            }
+
+            return false;
+
+        }
+
+        public byte[] GetMapTile(string fileName, out string format)
+        {
+            format = string.Empty;
+            new Exception("GetMapTile method not Implemented");
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs b/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs
new file mode 100644
index 0000000..eecf096
--- /dev/null
+++ b/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs
@@ -0,0 +1,205 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Reflection;
+using System.Text;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+namespace OpenSim.Services.Connectors
+{
+    public class NeighbourServicesConnector : INeighbourService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected IGridService m_GridService = null;
+
+        public NeighbourServicesConnector()
+        {
+        }
+
+        public NeighbourServicesConnector(IGridService gridServices)
+        {
+            Initialise(gridServices);
+        }
+
+        public virtual void Initialise(IGridService gridServices)
+        {
+            m_GridService = gridServices;
+        }
+
+        public virtual GridRegion HelloNeighbour(ulong regionHandle, RegionInfo thisRegion)
+        {
+            uint x = 0, y = 0;
+            Util.RegionHandleToWorldLoc(regionHandle, out x, out y);
+            GridRegion regInfo = m_GridService.GetRegionByPosition(thisRegion.ScopeID, (int)x, (int)y);
+            if ((regInfo != null) &&
+                // Don't remote-call this instance; that's a startup hickup
+                !((regInfo.ExternalHostName == thisRegion.ExternalHostName) && (regInfo.HttpPort == thisRegion.HttpPort)))
+            {
+                if (!DoHelloNeighbourCall(regInfo, thisRegion))
+                    return null;
+            }
+            else
+                return null;
+
+            return regInfo;
+        }
+
+        public bool DoHelloNeighbourCall(GridRegion region, RegionInfo thisRegion)
+        {
+            string uri = region.ServerURI + "region/" + thisRegion.RegionID + "/";
+//            m_log.Debug("   >>> DoHelloNeighbourCall <<< " + uri);
+
+            WebRequest helloNeighbourRequest;
+
+            try
+            {
+                helloNeighbourRequest = WebRequest.Create(uri);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn(string.Format(
+                    "[NEIGHBOUR SERVICES CONNECTOR]: Unable to parse uri {0} to send HelloNeighbour from {1} to {2}.  Exception {3} ",
+                    uri, thisRegion.RegionName, region.RegionName, e.Message), e);
+
+                return false;
+            }
+
+            helloNeighbourRequest.Method = "POST";
+            helloNeighbourRequest.ContentType = "application/json";
+            helloNeighbourRequest.Timeout = 10000;
+
+            // Fill it in
+            OSDMap args = null;
+            try
+            {
+                args = thisRegion.PackRegionInfoData();
+            }
+            catch (Exception e)
+            {
+                m_log.Warn(string.Format(
+                    "[NEIGHBOUR SERVICES CONNECTOR]: PackRegionInfoData failed for HelloNeighbour from {0} to {1}.  Exception {2} ",
+                    thisRegion.RegionName, region.RegionName, e.Message), e);
+
+                return false;
+            }
+
+            // Add the regionhandle of the destination region
+            args["destination_handle"] = OSD.FromString(region.RegionHandle.ToString());
+
+            string strBuffer = "";
+            byte[] buffer = new byte[1];
+
+            try
+            {
+                strBuffer = OSDParser.SerializeJsonString(args);
+                buffer = Util.UTF8NoBomEncoding.GetBytes(strBuffer);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn(string.Format(
+                    "[NEIGHBOUR SERVICES CONNECTOR]: Exception thrown on serialization of HelloNeighbour from {0} to {1}.  Exception {2} ",
+                    thisRegion.RegionName, region.RegionName, e.Message), e);
+
+                return false;
+            }
+
+            Stream os = null;
+            try
+            { // send the Post
+                helloNeighbourRequest.ContentLength = buffer.Length;   //Count bytes to send
+                os = helloNeighbourRequest.GetRequestStream();
+                os.Write(buffer, 0, strBuffer.Length);         //Send it
+                //m_log.InfoFormat("[REST COMMS]: Posted HelloNeighbour request to remote sim {0}", uri);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn(string.Format(
+                    "[NEIGHBOUR SERVICES CONNECTOR]: Unable to send HelloNeighbour from {0} to {1} (uri {2}).  Exception {3} ",
+                    thisRegion.RegionName, region.RegionName, uri, e.Message), e);
+
+                return false;
+            }
+            finally
+            {
+                if (os != null)
+                    os.Dispose();
+            }
+
+            // Let's wait for the response
+            //m_log.Info("[REST COMMS]: Waiting for a reply after DoHelloNeighbourCall");
+
+            try
+            {
+                using (WebResponse webResponse = helloNeighbourRequest.GetResponse())
+                {
+                    if (webResponse == null)
+                    {
+                        m_log.DebugFormat(
+                            "[NEIGHBOUR SERVICES CONNECTOR]: Null reply on DoHelloNeighbourCall post from {0} to {1}",
+                            thisRegion.RegionName, region.RegionName);
+                    }
+
+                    using (Stream s = webResponse.GetResponseStream())
+                    {
+                        using (StreamReader sr = new StreamReader(s))
+                        {
+                            //reply = sr.ReadToEnd().Trim();
+                            sr.ReadToEnd().Trim();
+                            //m_log.InfoFormat("[REST COMMS]: DoHelloNeighbourCall reply was {0} ", reply);
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.Warn(string.Format(
+                    "[NEIGHBOUR SERVICES CONNECTOR]: Exception on reply of DoHelloNeighbourCall from {0} back to {1}.  Exception {2} ",
+                    region.RegionName, thisRegion.RegionName, e.Message), e);
+
+                return false;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Presence/PresenceServicesConnector.cs b/OpenSim/Services/Connectors/Presence/PresenceServicesConnector.cs
new file mode 100644
index 0000000..63f3f37
--- /dev/null
+++ b/OpenSim/Services/Connectors/Presence/PresenceServicesConnector.cs
@@ -0,0 +1,388 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class PresenceServicesConnector : BaseServiceConnector, IPresenceService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public PresenceServicesConnector()
+        {
+        }
+
+        public PresenceServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public PresenceServicesConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["PresenceService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[PRESENCE CONNECTOR]: PresenceService missing from OpenSim.ini");
+                throw new Exception("Presence connector init error");
+            }
+
+            string serviceURI = gridConfig.GetString("PresenceServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[PRESENCE CONNECTOR]: No Server URI named in section PresenceService");
+                throw new Exception("Presence connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            base.Initialise(source, "PresenceService");
+        }
+
+
+        #region IPresenceService
+
+        public bool LoginAgent(string userID, UUID sessionID, UUID secureSessionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "login";
+
+            sendData["UserID"] = userID;
+            sendData["SessionID"] = sessionID.ToString();
+            sendData["SecureSessionID"] = secureSessionID.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/presence";
+            // m_log.DebugFormat("[PRESENCE CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString, 
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[PRESENCE CONNECTOR]: LoginAgent reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[PRESENCE CONNECTOR]: LoginAgent received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[PRESENCE CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+
+        }
+
+        public bool LogoutAgent(UUID sessionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "logout";
+
+            sendData["SessionID"] = sessionID.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/presence";
+            // m_log.DebugFormat("[PRESENCE CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[PRESENCE CONNECTOR]: LogoutAgent reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[PRESENCE CONNECTOR]: LogoutAgent received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[PRESENCE CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public bool LogoutRegionAgents(UUID regionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "logoutregion";
+
+            sendData["RegionID"] = regionID.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/presence";
+            // m_log.DebugFormat("[PRESENCE CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[PRESENCE CONNECTOR]: LogoutRegionAgents reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[PRESENCE CONNECTOR]: LogoutRegionAgents received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[PRESENCE CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public bool ReportAgent(UUID sessionID, UUID regionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "report";
+
+            sendData["SessionID"] = sessionID.ToString();
+            sendData["RegionID"] = regionID.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/presence";
+            // m_log.DebugFormat("[PRESENCE CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[PRESENCE CONNECTOR]: ReportAgent reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[PRESENCE CONNECTOR]: ReportAgent received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[PRESENCE CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+        public PresenceInfo GetAgent(UUID sessionID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getagent";
+
+            sendData["SessionID"] = sessionID.ToString();
+
+            string reply = string.Empty;
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/presence";
+            // m_log.DebugFormat("[PRESENCE CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply == null || (reply != null && reply == string.Empty))
+                {
+                    m_log.DebugFormat("[PRESENCE CONNECTOR]: GetAgent received null or empty reply");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[PRESENCE CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+                return null;
+            }
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+            PresenceInfo pinfo = null;
+
+            if ((replyData != null) && replyData.ContainsKey("result") && (replyData["result"] != null))
+            {
+                if (replyData["result"] is Dictionary<string, object>)
+                {
+                    pinfo = new PresenceInfo((Dictionary<string, object>)replyData["result"]);
+                }
+            }
+
+            return pinfo;
+        }
+
+        public PresenceInfo[] GetAgents(string[] userIDs)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getagents";
+
+            sendData["uuids"] = new List<string>(userIDs);
+
+            string reply = string.Empty;
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/presence";
+            //m_log.DebugFormat("[PRESENCE CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply == null || (reply != null && reply == string.Empty))
+                {
+                    m_log.DebugFormat("[PRESENCE CONNECTOR]: GetAgents received null or empty reply");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[PRESENCE CONNECTOR]: Exception when contacting presence server at {0}: {1}", uri, e.Message);
+            }
+
+            List<PresenceInfo> rinfos = new List<PresenceInfo>();
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            if (replyData != null)
+            {
+                if (replyData.ContainsKey("result") && 
+                    (replyData["result"].ToString() == "null" || replyData["result"].ToString() == "Failure"))
+                {
+                    return new PresenceInfo[0];
+                }
+
+                Dictionary<string, object>.ValueCollection pinfosList = replyData.Values;
+                //m_log.DebugFormat("[PRESENCE CONNECTOR]: GetAgents returned {0} elements", pinfosList.Count);
+                foreach (object presence in pinfosList)
+                {
+                    if (presence is Dictionary<string, object>)
+                    {
+                        PresenceInfo pinfo = new PresenceInfo((Dictionary<string, object>)presence);
+                        rinfos.Add(pinfo);
+                    }
+                    else
+                        m_log.DebugFormat("[PRESENCE CONNECTOR]: GetAgents received invalid response type {0}",
+                            presence.GetType());
+                }
+            }
+            else
+                m_log.DebugFormat("[PRESENCE CONNECTOR]: GetAgents received null response");
+
+            return rinfos.ToArray();
+        }
+
+
+        #endregion
+
+    }
+}
diff --git a/OpenSim/Services/Connectors/Properties/AssemblyInfo.cs b/OpenSim/Services/Connectors/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..2af2ec1
--- /dev/null
+++ b/OpenSim/Services/Connectors/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.Services.Connectors")]
+[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("3ab0a9a1-3f45-4c07-a892-3848df8c0173")]
+
+// 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/Services/Connectors/SimianGrid/SimianActivityDetector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianActivityDetector.cs
new file mode 100644
index 0000000..cd4781d
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianActivityDetector.cs
@@ -0,0 +1,100 @@
+/*
+ * 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 OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using log4net;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    public class SimianActivityDetector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IGridUserService m_GridUserService;
+
+        public SimianActivityDetector(IGridUserService guService)
+        {
+            m_GridUserService = guService;
+            m_log.DebugFormat("[SIMIAN ACTIVITY DETECTOR]: Started");
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            // For now the only events we listen to are these
+            // But we could trigger the position update more often
+            scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+            scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnAvatarEnteringNewParcel += OnEnteringNewParcel;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            scene.EventManager.OnMakeRootAgent -= OnMakeRootAgent;
+            scene.EventManager.OnNewClient -= OnNewClient;
+            scene.EventManager.OnAvatarEnteringNewParcel -= OnEnteringNewParcel;
+        }
+
+        public void OnMakeRootAgent(ScenePresence sp)
+        {
+            m_log.DebugFormat("[SIMIAN ACTIVITY DETECTOR]: Detected root presence {0} in {1}", sp.UUID, sp.Scene.RegionInfo.RegionName);
+            Util.FireAndForget(delegate(object o)
+            {
+                m_GridUserService.SetLastPosition(sp.UUID.ToString(), sp.ControllingClient.SessionId, sp.Scene.RegionInfo.RegionID, sp.AbsolutePosition, sp.Lookat);
+            }, null, "SimianActivityDetector.SetLastPositionOnMakeRootAgent");
+        }
+
+        public void OnNewClient(IClientAPI client)
+        {
+            client.OnConnectionClosed += OnConnectionClose;
+        }
+
+        public void OnConnectionClose(IClientAPI client)
+        {
+            if (client.SceneAgent.IsChildAgent)
+                return;
+
+//            m_log.DebugFormat("[ACTIVITY DETECTOR]: Detected client logout {0} in {1}", client.AgentId, client.Scene.RegionInfo.RegionName);
+            m_GridUserService.LoggedOut(
+                client.AgentId.ToString(), client.SessionId, client.Scene.RegionInfo.RegionID,
+                client.SceneAgent.AbsolutePosition, client.SceneAgent.Lookat);
+        }
+
+        void OnEnteringNewParcel(ScenePresence sp, int localLandID, UUID regionID)
+        {
+            // Asynchronously update the position stored in the session table for this agent
+            Util.FireAndForget(delegate(object o)
+            {
+                m_GridUserService.SetLastPosition(sp.UUID.ToString(), sp.ControllingClient.SessionId, sp.Scene.RegionInfo.RegionID, sp.AbsolutePosition, sp.Lookat);
+            }, null, "SimianActivityDetector.SetLastPositionOnEnteringNewParcel");
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianAssetServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianAssetServiceConnector.cs
new file mode 100644
index 0000000..9ad4a7a
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianAssetServiceConnector.cs
@@ -0,0 +1,685 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Connects to the SimianGrid asset service
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianAssetServiceConnector")]
+    public class SimianAssetServiceConnector : IAssetService, ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+        private static string ZeroID = UUID.Zero.ToString();
+
+        private string m_serverUrl = String.Empty;
+        private IImprovedAssetCache m_cache;
+        private bool m_Enabled = false;
+
+        #region ISharedRegionModule
+
+        public Type ReplaceableInterface { get { return null; } }
+        public void RegionLoaded(Scene scene)
+        {
+            if (m_cache == null)
+            {
+                IImprovedAssetCache cache = scene.RequestModuleInterface<IImprovedAssetCache>();
+                if (cache is ISharedRegionModule)
+                    m_cache = cache;
+            }
+        }
+        public void PostInitialise() { }
+        public void Close() { }
+
+        public SimianAssetServiceConnector() { }
+        public string Name { get { return "SimianAssetServiceConnector"; } }
+        public void AddRegion(Scene scene) { if (m_Enabled) { scene.RegisterModuleInterface<IAssetService>(this); } }
+        public void RemoveRegion(Scene scene) { if (m_Enabled) { scene.UnregisterModuleInterface<IAssetService>(this); } }
+        
+        #endregion ISharedRegionModule
+
+        public SimianAssetServiceConnector(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        public SimianAssetServiceConnector(string url)
+        {
+            if (!url.EndsWith("/") && !url.EndsWith("="))
+                url = url + '/';
+            m_serverUrl = url;
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("AssetServices", "");
+                if (name == Name)
+                    CommonInit(source);
+            }
+        }
+
+        private void CommonInit(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["AssetService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("AssetServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN ASSET CONNECTOR]: No AssetServerURI specified, disabling connector");
+            else
+                m_Enabled = true;
+        }
+
+#region IAssetService
+
+        public AssetBase Get(string id)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            // Cache fetch
+            if (m_cache != null)
+            {
+                AssetBase asset = m_cache.Get(id);
+                if (asset != null)
+                    return asset;
+            }
+
+            return SimianGetOperation(id);
+        }
+        
+
+        public AssetBase GetCached(string id)
+        {
+            if (m_cache != null)
+                return m_cache.Get(id);
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get an asset's metadata
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public AssetMetadata GetMetadata(string id)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            // Cache fetch
+            if (m_cache != null)
+            {
+                AssetBase asset = m_cache.Get(id);
+                if (asset != null)
+                    return asset.Metadata;
+            }
+
+            // return GetRemoteMetadata(id);
+            return SimianGetMetadataOperation(id);
+        }
+        
+        public byte[] GetData(string id)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            AssetBase asset = Get(id);
+
+            if (asset != null)
+                return asset.Data;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get an asset asynchronously
+        /// </summary>
+        /// <param name="id">The asset id</param>
+        /// <param name="sender">Represents the requester.  Passed back via the handler</param>
+        /// <param name="handler">The handler to call back once the asset has been retrieved</param>
+        /// <returns>True if the id was parseable, false otherwise</returns>
+        public bool Get(string id, Object sender, AssetRetrieved handler)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            // Cache fetch
+            if (m_cache != null)
+            {
+                AssetBase asset = m_cache.Get(id);
+                if (asset != null)
+                {
+                    handler(id, sender, asset);
+                    return true;
+                }
+            }
+
+            Util.FireAndForget(
+                delegate(object o)
+                {
+                    AssetBase asset = SimianGetOperation(id);
+                    handler(id, sender, asset);
+                }, null, "SimianAssetServiceConnector.GetFromService"
+            );
+
+            return true;
+        }
+
+        public bool[] AssetsExist(string[] ids)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            bool[] exist = new bool[ids.Length];
+
+            for (int i = 0; i < ids.Length; i++)
+            {
+                AssetMetadata metadata = GetMetadata(ids[i]);
+                if (metadata != null)
+                    exist[i] = true;
+            }
+
+            return exist;
+        }
+
+        /// <summary>
+        /// Creates a new asset
+        /// </summary>
+        /// Returns a random ID if none is passed into it
+        /// <param name="asset"></param>
+        /// <returns></returns>
+        public string Store(AssetBase asset)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            bool storedInCache = false;
+
+            // AssetID handling
+            if (String.IsNullOrEmpty(asset.ID) || asset.ID == ZeroID)
+            {
+                asset.FullID = UUID.Random();
+                asset.ID = asset.FullID.ToString();
+            }
+
+            // Cache handling
+            if (m_cache != null)
+            {
+                m_cache.Cache(asset);
+                storedInCache = true;
+            }
+
+            // Local asset handling
+            if (asset.Local)
+            {
+                if (!storedInCache)
+                {
+                    m_log.Error("Cannot store local " + asset.Metadata.ContentType + " asset without an asset cache");
+                    asset.ID = null;
+                    asset.FullID = UUID.Zero;
+                }
+
+                return asset.ID;
+            }
+
+            return SimianStoreOperation(asset);
+        }
+        
+        /// <summary>
+        /// Update an asset's content
+        /// </summary>
+        /// Attachments and bare scripts need this!!
+        /// <param name="id"> </param>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public bool UpdateContent(string id, byte[] data)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            AssetBase asset = Get(id);
+
+            if (asset == null)
+            {
+                m_log.WarnFormat("[SIMIAN ASSET CONNECTOR]: Failed to fetch asset {0} for updating", id);
+                return false;
+            }
+
+            asset.Data = data;
+
+            string result = Store(asset);
+            return !String.IsNullOrEmpty(result);
+        }
+
+        /// <summary>
+        /// Delete an asset
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public bool Delete(string id)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+            {
+                m_log.Error("[SIMIAN ASSET CONNECTOR]: No AssetServerURI configured");
+                throw new InvalidOperationException();
+            }
+
+            if (m_cache != null)
+                m_cache.Expire(id);
+
+            return SimianDeleteOperation(id);
+        }
+        
+#endregion IAssetService
+
+#region SimianOperations
+        /// <summary>
+        /// Invokes the xRemoveAsset operation on the simian server to delete an asset
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        private bool SimianDeleteOperation(string id)
+        {
+            try
+            {
+                NameValueCollection requestArgs = new NameValueCollection
+                    {
+                            { "RequestMethod", "xRemoveAsset" },
+                            { "AssetID", id }
+                    };
+
+                OSDMap response = SimianGrid.PostToService(m_serverUrl,requestArgs);
+                if (! response["Success"].AsBoolean())
+                {
+                    m_log.WarnFormat("[SIMIAN ASSET CONNECTOR]: failed to delete asset; {0}",response["Message"].AsString());
+                    return false;
+                }
+                
+                return true;
+                
+            }
+            catch (Exception ex)
+            {
+                m_log.WarnFormat("[SIMIAN ASSET CONNECTOR]: failed to delete asset {0}; {1}", id, ex.Message);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Invokes the xAddAsset operation on the simian server to create or update an asset
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        private string SimianStoreOperation(AssetBase asset)
+        {
+            try
+            {
+                NameValueCollection requestArgs = new NameValueCollection
+                    {
+                            { "RequestMethod", "xAddAsset" },
+                            { "ContentType", asset.Metadata.ContentType },
+                            { "EncodedData", Convert.ToBase64String(asset.Data) },
+                            { "AssetID", asset.FullID.ToString() },
+                            { "CreatorID", asset.Metadata.CreatorID },
+                            { "Temporary", asset.Temporary ? "1" : "0" },
+                            { "Name", asset.Name }
+                    };
+                
+                OSDMap response = SimianGrid.PostToService(m_serverUrl,requestArgs);
+                if (! response["Success"].AsBoolean())
+                {
+                    m_log.WarnFormat("[SIMIAN ASSET CONNECTOR] failed to store asset; {0}",response["Message"].AsString());
+                    return null;
+                }
+
+                // asset.ID is always set before calling this function
+                return asset.ID;
+                
+            }
+            catch (Exception ex)
+            {
+                m_log.ErrorFormat("[SIMIAN ASSET CONNECTOR] failed to store asset; {0}",ex.Message);
+            }
+            
+            return null;
+        }
+
+        /// <summary>
+        /// Invokes the xGetAsset operation on the simian server to get data associated with an asset
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        private AssetBase SimianGetOperation(string id)
+        {
+            try 
+            {
+                NameValueCollection requestArgs = new NameValueCollection
+                    {
+                            { "RequestMethod", "xGetAsset" },
+                            { "ID", id } 
+                    };
+
+                OSDMap response = SimianGrid.PostToService(m_serverUrl,requestArgs);
+                if (! response["Success"].AsBoolean())
+                {
+                    m_log.WarnFormat("[SIMIAN ASSET CONNECTOR] Failed to get asset; {0}",response["Message"].AsString());
+                    return null;
+                }
+            
+                AssetBase asset = new AssetBase();
+
+                asset.ID = id;
+                asset.Name = String.Empty;
+                asset.Metadata.ContentType = response["ContentType"].AsString(); // this will also set the asset Type property
+                asset.CreatorID = response["CreatorID"].AsString();
+                asset.Data = System.Convert.FromBase64String(response["EncodedData"].AsString());
+                asset.Local = false;
+                asset.Temporary = response["Temporary"];
+
+                return asset;
+            }
+            catch (Exception ex)
+            {
+                m_log.WarnFormat("[SIMIAN ASSET CONNECTOR]: failed to retrieve asset {0}; {1}", id, ex.Message);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Invokes the xGetAssetMetadata operation on the simian server to retrieve metadata for an asset
+        /// This operation is generally used to determine if an asset exists in the database
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        private AssetMetadata SimianGetMetadataOperation(string id)
+        {
+            try
+            {
+                NameValueCollection requestArgs = new NameValueCollection
+                    {
+                            { "RequestMethod", "xGetAssetMetadata" },
+                            { "ID", id } 
+                    };
+
+                OSDMap response = SimianGrid.PostToService(m_serverUrl,requestArgs);
+                if (! response["Success"].AsBoolean())
+                {
+                    // this is not really an error, this call is used to test existence
+                    // m_log.DebugFormat("[SIMIAN ASSET CONNECTOR] Failed to get asset metadata; {0}",response["Message"].AsString());
+                    return null;
+                }
+            
+                AssetMetadata metadata = new AssetMetadata();
+                metadata.ID = id;
+                metadata.ContentType = response["ContentType"].AsString();
+                metadata.CreatorID = response["CreatorID"].AsString();
+                metadata.Local = false;
+                metadata.Temporary = response["Temporary"];
+
+                string lastModifiedStr = response["Last-Modified"].AsString();
+                if (! String.IsNullOrEmpty(lastModifiedStr))
+                {
+                    DateTime lastModified;
+                    if (DateTime.TryParse(lastModifiedStr, out lastModified))
+                        metadata.CreationDate = lastModified;
+                }
+
+                return metadata;
+            }
+            catch (Exception ex)
+            {
+                m_log.WarnFormat("[SIMIAN ASSET CONNECTOR]: Failed to get asset metadata; {0}", ex.Message);
+            }
+
+            return null;
+        }
+#endregion
+
+        // private AssetMetadata GetRemoteMetadata(string id)
+        // {
+        //     Uri url;
+        //     AssetMetadata metadata = null;
+
+        //     // Determine if id is an absolute URL or a grid-relative UUID
+        //     if (!Uri.TryCreate(id, UriKind.Absolute, out url))
+        //         url = new Uri(m_serverUrl + id);
+
+        //     try
+        //     {
+        //         HttpWebRequest request = UntrustedHttpWebRequest.Create(url);
+        //         request.Method = "HEAD";
+
+        //         using (WebResponse response = request.GetResponse())
+        //         {
+        //             using (Stream responseStream = response.GetResponseStream())
+        //             {
+        //                 // Create the metadata object
+        //                 metadata = new AssetMetadata();
+        //                 metadata.ContentType = response.ContentType;
+        //                 metadata.ID = id;
+
+        //                 UUID uuid;
+        //                 if (UUID.TryParse(id, out uuid))
+        //                     metadata.FullID = uuid;
+
+        //                 string lastModifiedStr = response.Headers.Get("Last-Modified");
+        //                 if (!String.IsNullOrEmpty(lastModifiedStr))
+        //                 {
+        //                     DateTime lastModified;
+        //                     if (DateTime.TryParse(lastModifiedStr, out lastModified))
+        //                         metadata.CreationDate = lastModified;
+        //                 }
+        //             }
+        //         }
+        //     }
+        //     catch (Exception ex)
+        //     {
+        //         m_log.Warn("[SIMIAN ASSET CONNECTOR]: Asset HEAD from " + url + " failed: " + ex.Message);
+        //     }
+
+        //     return metadata;
+        // }
+
+        // private AssetBase GetRemote(string id)
+        // {
+        //     AssetBase asset = null;
+        //     Uri url;
+
+        //     // Determine if id is an absolute URL or a grid-relative UUID
+        //     if (!Uri.TryCreate(id, UriKind.Absolute, out url))
+        //         url = new Uri(m_serverUrl + id);
+
+        //     try
+        //     {
+        //         HttpWebRequest request = UntrustedHttpWebRequest.Create(url);
+
+        //         using (WebResponse response = request.GetResponse())
+        //         {
+        //             using (Stream responseStream = response.GetResponseStream())
+        //             {
+        //                 string creatorID = response.Headers.GetOne("X-Asset-Creator-Id") ?? String.Empty;
+
+        //                 // Create the asset object
+        //                 asset = new AssetBase(id, String.Empty, SLUtil.ContentTypeToSLAssetType(response.ContentType), creatorID);
+
+        //                 UUID assetID;
+        //                 if (UUID.TryParse(id, out assetID))
+        //                     asset.FullID = assetID;
+
+        //                 // Grab the asset data from the response stream
+        //                 using (MemoryStream stream = new MemoryStream())
+        //                 {
+        //                     responseStream.CopyStream(stream, Int32.MaxValue);
+        //                     asset.Data = stream.ToArray();
+        //                 }
+        //             }
+        //         }
+
+        //         // Cache store
+        //         if (m_cache != null && asset != null)
+        //             m_cache.Cache(asset);
+
+        //         return asset;
+        //     }
+        //     catch (Exception ex)
+        //     {
+        //         m_log.Warn("[SIMIAN ASSET CONNECTOR]: Asset GET from " + url + " failed: " + ex.Message);
+        //         return null;
+        //     }
+        // }
+
+        // private string StoreRemote(AssetBase asset)
+        // {
+        //     // Distinguish public and private assets
+        //     bool isPublic = true;
+        //     switch ((AssetType)asset.Type)
+        //     {
+        //         case AssetType.CallingCard:
+        //         case AssetType.Gesture:
+        //         case AssetType.LSLBytecode:
+        //         case AssetType.LSLText:
+        //             isPublic = false;
+        //             break;
+        //     }
+
+        //     string errorMessage = null;
+            
+        //     // Build the remote storage request
+        //     List<MultipartForm.Element> postParameters = new List<MultipartForm.Element>()
+        //     {
+        //         new MultipartForm.Parameter("AssetID", asset.FullID.ToString()),
+        //         new MultipartForm.Parameter("CreatorID", asset.Metadata.CreatorID),
+        //         new MultipartForm.Parameter("Temporary", asset.Temporary ? "1" : "0"),
+        //         new MultipartForm.Parameter("Public", isPublic ? "1" : "0"),
+        //         new MultipartForm.File("Asset", asset.Name, asset.Metadata.ContentType, asset.Data)
+        //     };
+
+        //     // Make the remote storage request
+        //     try
+        //     {
+        //         // Simian does not require the asset ID to be in the URL because it's in the post data.
+        //         // By appending it to the URL also, we allow caching proxies (squid) to invalidate asset URLs
+        //         HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(m_serverUrl + asset.FullID.ToString());
+
+        //         using (HttpWebResponse response = MultipartForm.Post(request, postParameters))
+        //         {
+        //             using (Stream responseStream = response.GetResponseStream())
+        //             {
+        //                 string responseStr = null;
+
+        //                 try
+        //                 {
+        //                     responseStr = responseStream.GetStreamString();
+        //                     OSD responseOSD = OSDParser.Deserialize(responseStr);
+        //                     if (responseOSD.Type == OSDType.Map)
+        //                     {
+        //                         OSDMap responseMap = (OSDMap)responseOSD;
+        //                         if (responseMap["Success"].AsBoolean())
+        //                             return asset.ID;
+        //                         else
+        //                             errorMessage = "Upload failed: " + responseMap["Message"].AsString();
+        //                     }
+        //                     else
+        //                     {
+        //                         errorMessage = "Response format was invalid:\n" + responseStr;
+        //                     }
+        //                 }
+        //                 catch (Exception ex)
+        //                 {
+        //                     if (!String.IsNullOrEmpty(responseStr))
+        //                         errorMessage = "Failed to parse the response:\n" + responseStr;
+        //                     else
+        //                         errorMessage = "Failed to retrieve the response: " + ex.Message;
+        //                 }
+        //             }
+        //         }
+        //     }
+        //     catch (WebException ex)
+        //     {
+        //         errorMessage = ex.Message;
+        //     }
+
+        //     m_log.WarnFormat("[SIMIAN ASSET CONNECTOR]: Failed to store asset \"{0}\" ({1}, {2}): {3}",
+        //         asset.Name, asset.ID, asset.Metadata.ContentType, errorMessage);
+
+        //     return null;
+        // }
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianAuthenticationServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianAuthenticationServiceConnector.cs
new file mode 100644
index 0000000..3bd11d9
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianAuthenticationServiceConnector.cs
@@ -0,0 +1,307 @@
+/*
+ * 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.Specialized;
+using System.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Connects authentication/authorization to the SimianGrid backend
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianAuthenticationServiceConnector")]
+    public class SimianAuthenticationServiceConnector : IAuthenticationService, ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_serverUrl = String.Empty;
+        private bool m_Enabled = false;
+
+        #region ISharedRegionModule
+
+        public Type ReplaceableInterface { get { return null; } }
+        public void RegionLoaded(Scene scene) { }
+        public void PostInitialise() { }
+        public void Close() { }
+
+        public SimianAuthenticationServiceConnector() { }
+        public string Name { get { return "SimianAuthenticationServiceConnector"; } }
+        public void AddRegion(Scene scene) { if (m_Enabled) { scene.RegisterModuleInterface<IAuthenticationService>(this); } }
+        public void RemoveRegion(Scene scene) { if (m_Enabled) { scene.UnregisterModuleInterface<IAuthenticationService>(this); } }
+
+        #endregion ISharedRegionModule
+
+        public SimianAuthenticationServiceConnector(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("AuthenticationServices", "");
+                if (name == Name)
+                    CommonInit(source);
+            }
+        }
+
+        private void CommonInit(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["AuthenticationService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("AuthenticationServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+                    m_Enabled = true;
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN AUTH CONNECTOR]: No AuthenticationServerURI specified, disabling connector");
+        }
+
+        public string Authenticate(UUID principalID, string password, int lifetime)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetIdentities" },
+                { "UserID", principalID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Identities"] is OSDArray)
+            {
+                bool md5hashFound = false;
+
+                OSDArray identities = (OSDArray)response["Identities"];
+                for (int i = 0; i < identities.Count; i++)
+                {
+                    OSDMap identity = identities[i] as OSDMap;
+                    if (identity != null)
+                    {
+                        if (identity["Type"].AsString() == "md5hash")
+                        {
+                            string authorizeResult;
+                            if (CheckPassword(principalID, password, identity["Credential"].AsString(), out authorizeResult))
+                                return authorizeResult;
+
+                            md5hashFound = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (!md5hashFound)
+                    m_log.Warn("[SIMIAN AUTH CONNECTOR]: Authentication failed for " + principalID + ", no md5hash identity found");
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN AUTH CONNECTOR]: Failed to retrieve identities for " + principalID + ": "  +
+                    response["Message"].AsString());
+            }
+
+            return String.Empty;
+        }
+
+        public bool Verify(UUID principalID, string token, int lifetime)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetSession" },
+                { "SessionID", token }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                return true;
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN AUTH CONNECTOR]: Could not verify session for " + principalID + ": " +
+                    response["Message"].AsString());
+            }
+
+            return false;
+        }
+
+        public bool Release(UUID principalID, string token)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "RemoveSession" },
+                { "UserID", principalID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                return true;
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN AUTH CONNECTOR]: Failed to remove session for " + principalID + ": " +
+                    response["Message"].AsString());
+            }
+
+            return false;
+        }
+
+        public bool SetPassword(UUID principalID, string passwd)
+        {
+            // Fetch the user name first
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "UserID", principalID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["User"] is OSDMap)
+            {
+                OSDMap userMap = (OSDMap)response["User"];
+                string identifier = userMap["Name"].AsString();
+
+                if (!String.IsNullOrEmpty(identifier))
+                {
+                    // Add/update the md5hash identity
+                    // TODO: Support salts when AddIdentity does
+                    // TODO: Create an a1hash too for WebDAV logins
+                    requestArgs = new NameValueCollection
+                    {
+                        { "RequestMethod", "AddIdentity" },
+                        { "Identifier", identifier },
+                        { "Credential", "$1$" + Utils.MD5String(passwd) },
+                        { "Type", "md5hash" },
+                        { "UserID", principalID.ToString() }
+                    };
+
+                    response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+                    bool success = response["Success"].AsBoolean();
+
+                    if (!success)
+                        m_log.WarnFormat("[SIMIAN AUTH CONNECTOR]: Failed to set password for {0} ({1})", identifier, principalID);
+
+                    return success;
+                }
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN AUTH CONNECTOR]: Failed to retrieve identities for " + principalID + ": " +
+                    response["Message"].AsString());
+            }
+
+            return false;
+        }
+
+        public AuthInfo GetAuthInfo(UUID principalID)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool SetAuthInfo(AuthInfo info)
+        {
+            throw new NotImplementedException();
+        }
+
+        private bool CheckPassword(UUID userID, string password, string simianGridCredential, out string authorizeResult)
+        {
+            if (simianGridCredential.Contains(":"))
+            {
+                // Salted version
+                int idx = simianGridCredential.IndexOf(':');
+                string finalhash = simianGridCredential.Substring(0, idx);
+                string salt = simianGridCredential.Substring(idx + 1);
+
+                if (finalhash == Utils.MD5String(password + ":" + salt))
+                {
+                    authorizeResult = Authorize(userID);
+                    return true;
+                }
+                else
+                {
+                    m_log.Warn("[SIMIAN AUTH CONNECTOR]: Authentication failed for " + userID +
+                        " using md5hash " + Utils.MD5String(password) + ":" + salt);
+                }
+            }
+            else
+            {
+                // Unsalted version
+                if (password == simianGridCredential ||
+                    "$1$" + password == simianGridCredential ||
+                    "$1$" + Utils.MD5String(password) == simianGridCredential ||
+                    Utils.MD5String(password) == simianGridCredential ||
+                    "$1$" + Utils.MD5String(password + ":") == simianGridCredential)
+                {
+                    authorizeResult = Authorize(userID);
+                    return true;
+                }
+                else
+                {
+                    m_log.Warn("[SIMIAN AUTH CONNECTOR]: Authentication failed for " + userID +
+                        " using md5hash $1$" + Utils.MD5String(password));
+                }
+            }
+
+            authorizeResult = null;
+            return false;
+        }
+
+        private string Authorize(UUID userID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddSession" },
+                { "UserID", userID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+                return response["SessionID"].AsUUID().ToString();
+            else
+                return String.Empty;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianAvatarServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianAvatarServiceConnector.cs
new file mode 100644
index 0000000..a397740
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianAvatarServiceConnector.cs
@@ -0,0 +1,344 @@
+/*
+ * 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;
+// DEBUG ON
+using System.Diagnostics;
+// DEBUG OFF
+using System.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Connects avatar appearance data to the SimianGrid backend
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianAvatarServiceConnector")]
+    public class SimianAvatarServiceConnector : IAvatarService, ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+//        private static string ZeroID = UUID.Zero.ToString();
+
+        private string m_serverUrl = String.Empty;
+        private bool m_Enabled = false;
+
+        #region ISharedRegionModule
+
+        public Type ReplaceableInterface { get { return null; } }
+        public void RegionLoaded(Scene scene) { }
+        public void PostInitialise() { }
+        public void Close() { }
+
+        public SimianAvatarServiceConnector() { }
+        public string Name { get { return "SimianAvatarServiceConnector"; } }
+        public void AddRegion(Scene scene) { if (m_Enabled) { scene.RegisterModuleInterface<IAvatarService>(this); } }
+        public void RemoveRegion(Scene scene) { if (m_Enabled) { scene.UnregisterModuleInterface<IAvatarService>(this); } }
+
+        #endregion ISharedRegionModule
+
+        public SimianAvatarServiceConnector(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("AvatarServices", "");
+                if (name == Name)
+                    CommonInit(source);
+            }
+        }
+
+        private void CommonInit(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["AvatarService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("AvatarServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+                    m_Enabled = true;
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN AVATAR CONNECTOR]: No AvatarServerURI specified, disabling connector");
+        }
+
+        #region IAvatarService
+
+        // <summary>
+        // Retrieves the LLPackedAppearance field from user data and unpacks
+        // it into an AvatarAppearance structure
+        // </summary>
+        // <param name="userID"></param>
+        public AvatarAppearance GetAppearance(UUID userID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "UserID", userID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                OSDMap map = null;
+                try { map = OSDParser.DeserializeJson(response["LLPackedAppearance"].AsString()) as OSDMap; }
+                catch { }
+
+                if (map != null)
+                {
+                    AvatarAppearance appearance = new AvatarAppearance(map);
+// DEBUG ON
+                    m_log.WarnFormat("[SIMIAN AVATAR CONNECTOR] retrieved appearance for {0}:\n{1}",userID,appearance.ToString());
+// DEBUG OFF
+                    return appearance;
+                }
+
+                m_log.WarnFormat("[SIMIAN AVATAR CONNECTOR]: Failed to decode appearance for {0}",userID);
+                return null;
+            }
+
+            m_log.WarnFormat("[SIMIAN AVATAR CONNECTOR]: Failed to get appearance for {0}: {1}",
+                             userID,response["Message"].AsString());
+            return null;
+        }
+        
+        // <summary>
+        // </summary>
+        // <param name=""></param>
+        public bool SetAppearance(UUID userID, AvatarAppearance appearance)
+        {
+            OSDMap map = appearance.Pack();
+            if (map == null)
+            {
+                m_log.WarnFormat("[SIMIAN AVATAR CONNECTOR]: Failed to encode appearance for {0}",userID);
+                return false;
+            }
+
+            // m_log.DebugFormat("[SIMIAN AVATAR CONNECTOR] save appearance for {0}",userID);
+
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "AddUserData" },
+                        { "UserID", userID.ToString() },
+                        { "LLPackedAppearance", OSDParser.SerializeJsonString(map) }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (! success)
+                m_log.WarnFormat("[SIMIAN AVATAR CONNECTOR]: Failed to save appearance for {0}: {1}",
+                                 userID,response["Message"].AsString());
+
+            return success;
+        }
+            
+        // <summary>
+        // </summary>
+        // <param name=""></param>
+        public AvatarData GetAvatar(UUID userID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "UserID", userID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                OSDMap map = null;
+                try { map = OSDParser.DeserializeJson(response["LLAppearance"].AsString()) as OSDMap; }
+                catch { }
+
+                if (map != null)
+                {
+                    AvatarWearable[] wearables = new AvatarWearable[13];
+                    wearables[0] = new AvatarWearable(map["ShapeItem"].AsUUID(), map["ShapeAsset"].AsUUID());
+                    wearables[1] = new AvatarWearable(map["SkinItem"].AsUUID(), map["SkinAsset"].AsUUID());
+                    wearables[2] = new AvatarWearable(map["HairItem"].AsUUID(), map["HairAsset"].AsUUID());
+                    wearables[3] = new AvatarWearable(map["EyesItem"].AsUUID(), map["EyesAsset"].AsUUID());
+                    wearables[4] = new AvatarWearable(map["ShirtItem"].AsUUID(), map["ShirtAsset"].AsUUID());
+                    wearables[5] = new AvatarWearable(map["PantsItem"].AsUUID(), map["PantsAsset"].AsUUID());
+                    wearables[6] = new AvatarWearable(map["ShoesItem"].AsUUID(), map["ShoesAsset"].AsUUID());
+                    wearables[7] = new AvatarWearable(map["SocksItem"].AsUUID(), map["SocksAsset"].AsUUID());
+                    wearables[8] = new AvatarWearable(map["JacketItem"].AsUUID(), map["JacketAsset"].AsUUID());
+                    wearables[9] = new AvatarWearable(map["GlovesItem"].AsUUID(), map["GlovesAsset"].AsUUID());
+                    wearables[10] = new AvatarWearable(map["UndershirtItem"].AsUUID(), map["UndershirtAsset"].AsUUID());
+                    wearables[11] = new AvatarWearable(map["UnderpantsItem"].AsUUID(), map["UnderpantsAsset"].AsUUID());
+                    wearables[12] = new AvatarWearable(map["SkirtItem"].AsUUID(), map["SkirtAsset"].AsUUID());
+
+                    AvatarAppearance appearance = new AvatarAppearance();
+                    appearance.Wearables = wearables;
+                    appearance.AvatarHeight = (float)map["Height"].AsReal();
+
+                    AvatarData avatar = new AvatarData(appearance);
+                    
+                    // Get attachments
+                    map = null;
+                    try { map = OSDParser.DeserializeJson(response["LLAttachments"].AsString()) as OSDMap; }
+                    catch { }
+
+                    if (map != null)
+                    {
+                        foreach (KeyValuePair<string, OSD> kvp in map)
+                            avatar.Data[kvp.Key] = kvp.Value.AsString();
+                    }
+                
+                    return avatar;
+                }
+                else
+                {
+                    m_log.Warn("[SIMIAN AVATAR CONNECTOR]: Failed to get user appearance for " + userID +
+                        ", LLAppearance is missing or invalid");
+                    return null;
+                }
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN AVATAR CONNECTOR]: Failed to get user appearance for " + userID + ": " +
+                    response["Message"].AsString());
+            }
+
+            return null;
+        }
+
+        // <summary>
+        // </summary>
+        // <param name=""></param>
+        public bool SetAvatar(UUID userID, AvatarData avatar)
+        {
+            m_log.Debug("[SIMIAN AVATAR CONNECTOR]: SetAvatar called for " + userID);
+
+            if (avatar.AvatarType == 1) // LLAvatar
+            {
+                AvatarAppearance appearance = avatar.ToAvatarAppearance();
+
+                OSDMap map = new OSDMap();
+
+                map["Height"] = OSD.FromReal(appearance.AvatarHeight);
+
+                map["BodyItem"] = appearance.Wearables[AvatarWearable.BODY][0].ItemID.ToString();
+                map["EyesItem"] = appearance.Wearables[AvatarWearable.EYES][0].ItemID.ToString();
+                map["GlovesItem"] = appearance.Wearables[AvatarWearable.GLOVES][0].ItemID.ToString();
+                map["HairItem"] = appearance.Wearables[AvatarWearable.HAIR][0].ItemID.ToString();
+                map["JacketItem"] = appearance.Wearables[AvatarWearable.JACKET][0].ItemID.ToString();
+                map["PantsItem"] = appearance.Wearables[AvatarWearable.PANTS][0].ItemID.ToString();
+                map["ShirtItem"] = appearance.Wearables[AvatarWearable.SHIRT][0].ItemID.ToString();
+                map["ShoesItem"] = appearance.Wearables[AvatarWearable.SHOES][0].ItemID.ToString();
+                map["SkinItem"] = appearance.Wearables[AvatarWearable.SKIN][0].ItemID.ToString();
+                map["SkirtItem"] = appearance.Wearables[AvatarWearable.SKIRT][0].ItemID.ToString();
+                map["SocksItem"] = appearance.Wearables[AvatarWearable.SOCKS][0].ItemID.ToString();
+                map["UnderPantsItem"] = appearance.Wearables[AvatarWearable.UNDERPANTS][0].ItemID.ToString();
+                map["UnderShirtItem"] = appearance.Wearables[AvatarWearable.UNDERSHIRT][0].ItemID.ToString();
+                map["BodyAsset"] = appearance.Wearables[AvatarWearable.BODY][0].AssetID.ToString();
+                map["EyesAsset"] = appearance.Wearables[AvatarWearable.EYES][0].AssetID.ToString();
+                map["GlovesAsset"] = appearance.Wearables[AvatarWearable.GLOVES][0].AssetID.ToString();
+                map["HairAsset"] = appearance.Wearables[AvatarWearable.HAIR][0].AssetID.ToString();
+                map["JacketAsset"] = appearance.Wearables[AvatarWearable.JACKET][0].AssetID.ToString();
+                map["PantsAsset"] = appearance.Wearables[AvatarWearable.PANTS][0].AssetID.ToString();
+                map["ShirtAsset"] = appearance.Wearables[AvatarWearable.SHIRT][0].AssetID.ToString();
+                map["ShoesAsset"] = appearance.Wearables[AvatarWearable.SHOES][0].AssetID.ToString();
+                map["SkinAsset"] = appearance.Wearables[AvatarWearable.SKIN][0].AssetID.ToString();
+                map["SkirtAsset"] = appearance.Wearables[AvatarWearable.SKIRT][0].AssetID.ToString();
+                map["SocksAsset"] = appearance.Wearables[AvatarWearable.SOCKS][0].AssetID.ToString();
+                map["UnderPantsAsset"] = appearance.Wearables[AvatarWearable.UNDERPANTS][0].AssetID.ToString();
+                map["UnderShirtAsset"] = appearance.Wearables[AvatarWearable.UNDERSHIRT][0].AssetID.ToString();
+
+
+                OSDMap items = new OSDMap();
+                foreach (KeyValuePair<string, string> kvp in avatar.Data)
+                {
+                    if (kvp.Key.StartsWith("_ap_"))
+                        items.Add(kvp.Key, OSD.FromString(kvp.Value));
+                }
+
+                NameValueCollection requestArgs = new NameValueCollection
+                {
+                    { "RequestMethod", "AddUserData" },
+                    { "UserID", userID.ToString() },
+                    { "LLAppearance", OSDParser.SerializeJsonString(map) },
+                    { "LLAttachments", OSDParser.SerializeJsonString(items) }
+                };
+
+                OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+                bool success = response["Success"].AsBoolean();
+
+                if (!success)
+                    m_log.Warn("[SIMIAN AVATAR CONNECTOR]: Failed saving appearance for " + userID + ": " + response["Message"].AsString());
+
+                return success;
+            }
+            else
+            {
+                m_log.Error("[SIMIAN AVATAR CONNECTOR]: Can't save appearance for " + userID + ". Unhandled avatar type " + avatar.AvatarType);
+                return false;
+            }
+        }
+
+        public bool ResetAvatar(UUID userID)
+        {
+            m_log.Error("[SIMIAN AVATAR CONNECTOR]: ResetAvatar called for " + userID + ", implement this");
+            return false;
+        }
+
+        public bool SetItems(UUID userID, string[] names, string[] values)
+        {
+            m_log.Error("[SIMIAN AVATAR CONNECTOR]: SetItems called for " + userID + " with " + names.Length + " names and " + values.Length + " values, implement this");
+            return false;
+        }
+
+        public bool RemoveItems(UUID userID, string[] names)
+        {
+            m_log.Error("[SIMIAN AVATAR CONNECTOR]: RemoveItems called for " + userID + " with " + names.Length + " names, implement this");
+            return false;
+        }
+
+        #endregion IAvatarService
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianExternalCapsModule.cs b/OpenSim/Services/Connectors/SimianGrid/SimianExternalCapsModule.cs
new file mode 100644
index 0000000..764e71f
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianExternalCapsModule.cs
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.IO;
+using System.Web;
+
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianExternalCapsModule")]
+    public class SimianExternalCapsModule : INonSharedRegionModule, IExternalCapsModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_enabled = true;
+        private Scene m_scene;
+        private String m_simianURL;
+        
+#region IRegionModule Members
+
+        public string Name
+        {
+            get { return this.GetType().Name; }
+        }
+
+        public void Initialise(IConfigSource config)
+        {
+            try 
+            {
+                IConfig m_config;
+               
+                if ((m_config = config.Configs["SimianExternalCaps"]) != null)
+                {
+                    m_enabled = m_config.GetBoolean("Enabled", m_enabled);
+                    if ((m_config = config.Configs["SimianGrid"]) != null)
+                    {
+                        m_simianURL = m_config.GetString("SimianServiceURL");
+                        if (String.IsNullOrEmpty(m_simianURL))
+                        {
+                            //m_log.DebugFormat("[SimianGrid] service URL is not defined");
+                            m_enabled = false;
+                            return;
+                        }
+                    }
+                }
+                else
+                    m_enabled = false;
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[SimianExternalCaps] initialization error: {0}",e.Message);
+                return;
+            }
+        }
+
+        public void PostInitialise() { }
+        public void Close() { }
+
+        public void AddRegion(Scene scene)
+        { 
+            if (! m_enabled)
+                return;
+            
+            m_scene = scene;
+            m_scene.RegisterModuleInterface<IExternalCapsModule>(this);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (! m_enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCapsEventHandler;
+            m_scene.EventManager.OnDeregisterCaps -= DeregisterCapsEventHandler;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (! m_enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps += RegisterCapsEventHandler;
+            m_scene.EventManager.OnDeregisterCaps += DeregisterCapsEventHandler;
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+#endregion
+
+#region IExternalCapsModule
+        // Eg http://grid.sciencesim.com/GridPublic/%CAP%/%OP%/"
+        public bool RegisterExternalUserCapsHandler(UUID agentID, Caps caps, String capName, String urlSkel)
+        {
+            UUID cap = UUID.Random();
+
+            // Call to simian to register the cap we generated
+            // NameValueCollection requestArgs = new NameValueCollection
+            // {
+            //     { "RequestMethod", "AddCapability" },
+            //     { "Resource", "user" },
+            //     { "Expiration", 0 },
+            //     { "OwnerID", agentID.ToString() },
+            //     { "CapabilityID", cap.ToString() }
+            // };
+
+            // OSDMap response = SimianGrid.PostToService(m_simianURL, requestArgs);
+
+            Dictionary<String,String> subs = new Dictionary<String,String>();
+            subs["%OP%"] = capName;
+            subs["%USR%"] = agentID.ToString();
+            subs["%CAP%"] = cap.ToString();
+            subs["%SIM%"] = m_scene.RegionInfo.RegionID.ToString();
+            
+            caps.RegisterHandler(capName,ExpandSkeletonURL(urlSkel,subs));
+            return true;
+        }
+
+#endregion
+
+#region EventHandlers
+        public void RegisterCapsEventHandler(UUID agentID, Caps caps) { }
+        public void DeregisterCapsEventHandler(UUID agentID, Caps caps) { }
+#endregion
+
+        private String ExpandSkeletonURL(String urlSkel, Dictionary<String,String> subs)
+        {
+            String result = urlSkel;
+            
+            foreach (KeyValuePair<String,String> kvp in subs)
+            {
+                result = result.Replace(kvp.Key,kvp.Value);
+            }
+            
+            return result;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianFriendsServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianFriendsServiceConnector.cs
new file mode 100644
index 0000000..9a8164c
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianFriendsServiceConnector.cs
@@ -0,0 +1,236 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+
+using FriendInfo = OpenSim.Services.Interfaces.FriendInfo;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Stores and retrieves friend lists from the SimianGrid backend
+    /// </summary>
+    public class SimianFriendsServiceConnector : IFriendsService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_serverUrl = String.Empty;
+
+        public SimianFriendsServiceConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["FriendsService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("FriendsServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN FRIENDS CONNECTOR]: No FriendsServerURI specified, disabling connector");
+        }
+
+        #region IFriendsService
+
+        public FriendInfo[] GetFriends(UUID principalID)
+        {
+            return GetFriends(principalID.ToString());
+        }
+
+        public FriendInfo[] GetFriends(string principalID)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+                return new FriendInfo[0];
+
+            Dictionary<UUID, FriendInfo> friends = new Dictionary<UUID, FriendInfo>();
+
+            OSDArray friendsArray = GetFriended(principalID);
+            OSDArray friendedMeArray = GetFriendedBy(principalID);
+
+            // Load the list of friends and their granted permissions
+            for (int i = 0; i < friendsArray.Count; i++)
+            {
+                OSDMap friendEntry = friendsArray[i] as OSDMap;
+                if (friendEntry != null)
+                {
+                    UUID friendID = friendEntry["Key"].AsUUID();
+
+                    FriendInfo friend = new FriendInfo();
+                    if (!UUID.TryParse(principalID, out friend.PrincipalID))
+                    {
+                        string tmp = string.Empty;
+                        if (!Util.ParseUniversalUserIdentifier(principalID, out friend.PrincipalID, out tmp, out tmp, out tmp, out tmp))
+                            // bad record. ignore this entry
+                            continue;
+                    }
+
+                    friend.Friend = friendID.ToString();
+                    friend.MyFlags = friendEntry["Value"].AsInteger();
+                    friend.TheirFlags = -1;
+
+                    friends[friendID] = friend;
+                }
+            }
+
+            // Load the permissions those friends have granted to this user
+            for (int i = 0; i < friendedMeArray.Count; i++)
+            {
+                OSDMap friendedMeEntry = friendedMeArray[i] as OSDMap;
+                if (friendedMeEntry != null)
+                {
+                    UUID friendID = friendedMeEntry["OwnerID"].AsUUID();
+
+                    FriendInfo friend;
+                    if (friends.TryGetValue(friendID, out friend))
+                        friend.TheirFlags = friendedMeEntry["Value"].AsInteger();
+                }
+            }
+
+            // Convert the dictionary of friends to an array and return it
+            FriendInfo[] array = new FriendInfo[friends.Count];
+            int j = 0;
+            foreach (FriendInfo friend in friends.Values)
+                array[j++] = friend;
+
+            return array;
+        }
+
+        public bool StoreFriend(string principalID, string friend, int flags)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+                return true;
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddGeneric" },
+                { "OwnerID", principalID.ToString() },
+                { "Type", "Friend" },
+                { "Key", friend },
+                { "Value", flags.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Error("[SIMIAN FRIENDS CONNECTOR]: Failed to store friend " + friend + " for user " + principalID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        public bool Delete(UUID principalID, string friend)
+        {
+            return Delete(principalID.ToString(), friend);
+        }
+
+        public bool Delete(string principalID, string friend)
+        {
+            if (String.IsNullOrEmpty(m_serverUrl))
+                return true;
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "RemoveGeneric" },
+                { "OwnerID", principalID.ToString() },
+                { "Type", "Friend" },
+                { "Key", friend }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Error("[SIMIAN FRIENDS CONNECTOR]: Failed to remove friend " + friend + " for user " + principalID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        #endregion IFriendsService
+
+        private OSDArray GetFriended(string ownerID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "OwnerID", ownerID.ToString() },
+                { "Type", "Friend" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Entries"] is OSDArray)
+            {
+                return (OSDArray)response["Entries"];
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN FRIENDS CONNECTOR]: Failed to retrieve friends for user " + ownerID + ": " + response["Message"].AsString());
+                return new OSDArray(0);
+            }
+        }
+
+        private OSDArray GetFriendedBy(string ownerID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "Key", ownerID.ToString() },
+                { "Type", "Friend" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Entries"] is OSDArray)
+            {
+                return (OSDArray)response["Entries"];
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN FRIENDS CONNECTOR]: Failed to retrieve reverse friends for user " + ownerID + ": " + response["Message"].AsString());
+                return new OSDArray(0);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianGrid.cs b/OpenSim/Services/Connectors/SimianGrid/SimianGrid.cs
new file mode 100644
index 0000000..a35d749
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianGrid.cs
@@ -0,0 +1,147 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+[assembly: Addin("SimianGrid", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianExternalCapsModule")]
+    public class SimianGrid : ISharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IConfig m_config = null;
+
+        private String m_simianURL;
+        
+#region IRegionModule Members
+
+        public string Name
+        {
+            get { return this.GetType().Name; }
+        }
+           
+        public void Initialise(IConfigSource config)
+        {
+            try 
+            {
+                m_config = config.Configs["SimianGrid"];
+               
+                if (m_config != null)
+                {
+                    m_simianURL = m_config.GetString("SimianServiceURL");
+                    if (String.IsNullOrEmpty(m_simianURL))
+                    {
+                        // m_log.DebugFormat("[SimianGrid] service URL is not defined");
+                        return;
+                    }
+                    
+                    InitialiseSimCap();
+                    SimulatorCapability = SimulatorCapability.Trim();
+                    m_log.InfoFormat("[SimianExternalCaps] using {0} as simulator capability",SimulatorCapability);
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[SimianExternalCaps] initialization error: {0}",e.Message);
+                return;
+            }
+        }
+
+        public void PostInitialise() { }
+        public void Close() { }
+        public void AddRegion(Scene scene) { }
+        public void RemoveRegion(Scene scene) { }
+        public void RegionLoaded(Scene scene) { }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        ///<summary>
+        /// Try a variety of methods for finding the simian simulator capability; first check the
+        /// configuration itself, then look for a file that contains the cap, then finally look 
+        /// for an environment variable that contains it.
+        ///</summary>
+        private void InitialiseSimCap()
+        {
+            if (m_config.Contains("SimulatorCapability"))
+            {
+                SimulatorCapability = m_config.GetString("SimulatorCapability");
+                return;
+            }
+            
+            if (m_config.Contains("SimulatorCapabilityFile"))
+            {
+                String filename = m_config.GetString("SimulatorCapabilityFile");
+                if (System.IO.File.Exists(filename))
+                {
+                    SimulatorCapability = System.IO.File.ReadAllText(filename);
+                    return;
+                }
+            }
+            
+            if (m_config.Contains("SimulatorCapabilityVariable"))
+            {
+                String envname = m_config.GetString("SimulatorCapabilityVariable");
+                String envvalue = System.Environment.GetEnvironmentVariable(envname);
+                if (envvalue != null)
+                {
+                    SimulatorCapability = envvalue;
+                    return;
+                }
+            }
+
+            m_log.WarnFormat("[SimianExternalCaps] no method specified for simulator capability");
+        }
+        
+#endregion
+
+        public static String SimulatorCapability = UUID.Zero.ToString();
+        public static OSDMap PostToService(string url, NameValueCollection data)
+        {
+            data["cap"] = SimulatorCapability;
+            return WebUtil.PostToService(url, data);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianGridMaptileModule.cs b/OpenSim/Services/Connectors/SimianGrid/SimianGridMaptileModule.cs
new file mode 100644
index 0000000..8375c95
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianGridMaptileModule.cs
@@ -0,0 +1,266 @@
+/*
+ * 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.Reflection;
+using System.Net;
+using System.IO;
+using System.Timers;
+using System.Drawing;
+using System.Drawing.Imaging;
+
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+//namespace OpenSim.Region.OptionalModules.Simian
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// </summary>
+    /// <remarks>
+    /// </remarks>
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianGridMaptile")]
+    public class SimianGridMaptile : ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_enabled = false;
+        private string m_serverUrl = String.Empty;
+        private Dictionary<UUID, Scene> m_scenes = new Dictionary<UUID, Scene>();
+
+        private int m_refreshtime = 0;
+        private int m_lastrefresh = 0;
+        private System.Timers.Timer m_refreshTimer = new System.Timers.Timer();
+        
+        #region ISharedRegionModule
+        
+        public Type ReplaceableInterface { get { return null; } }
+        public string Name { get { return "SimianGridMaptile"; } }        
+        public void RegionLoaded(Scene scene) { }
+        public void Close() { }
+        
+        ///<summary>
+        ///
+        ///</summary>
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["SimianGridMaptiles"];
+            if (config == null)
+                return;
+            
+            if (! config.GetBoolean("Enabled", false))
+                return;
+
+            m_serverUrl = config.GetString("MaptileURL");
+            if (String.IsNullOrEmpty(m_serverUrl))
+                return;
+
+            int refreshseconds = Convert.ToInt32(config.GetString("RefreshTime"));
+            if (refreshseconds <= 0)
+                return;
+
+            m_refreshtime = refreshseconds * 1000; // convert from seconds to ms
+            m_log.InfoFormat("[SIMIAN MAPTILE] enabled with refresh timeout {0} and URL {1}",
+                             m_refreshtime,m_serverUrl);
+
+            m_enabled = true;
+        }
+
+        ///<summary>
+        ///
+        ///</summary>
+        public void PostInitialise()
+        {
+            if (m_enabled)
+            {
+                m_refreshTimer.Enabled = true;
+                m_refreshTimer.AutoReset = true;
+                m_refreshTimer.Interval = 5 * 60 * 1000; // every 5 minutes
+                m_refreshTimer.Elapsed += new ElapsedEventHandler(HandleMaptileRefresh);
+            }
+        }
+
+
+        ///<summary>
+        ///
+        ///</summary>
+        public void AddRegion(Scene scene)
+        {
+            if (! m_enabled)
+                return;
+
+            // Every shared region module has to maintain an indepedent list of
+            // currently running regions
+            lock (m_scenes)
+                m_scenes[scene.RegionInfo.RegionID] = scene;
+        }
+
+        ///<summary>
+        ///
+        ///</summary>
+        public void RemoveRegion(Scene scene)
+        {
+            if (! m_enabled)
+                return;
+
+            lock (m_scenes)
+                m_scenes.Remove(scene.RegionInfo.RegionID);
+        }
+
+        #endregion ISharedRegionModule
+
+        ///<summary>
+        ///
+        ///</summary>
+        private void HandleMaptileRefresh(object sender, EventArgs ea)
+        {
+            // this approach is a bit convoluted becase we want to wait for the
+            // first upload to happen on startup but after all the objects are
+            // loaded and initialized
+            if (m_lastrefresh > 0 && Util.EnvironmentTickCountSubtract(m_lastrefresh) < m_refreshtime)
+                return;
+
+            m_log.DebugFormat("[SIMIAN MAPTILE] map refresh fired");
+            lock (m_scenes)
+            {
+                foreach (IScene scene in m_scenes.Values)
+                {
+                    try
+                    {
+                        UploadMapTile(scene);
+                    }
+                    catch (Exception ex)
+                    {
+                        m_log.WarnFormat("[SIMIAN MAPTILE] something bad happened {0}",ex.Message);
+                    }
+                }
+            }
+
+            m_lastrefresh = Util.EnvironmentTickCount();
+        }
+
+        ///<summary>
+        ///
+        ///</summary>
+        private void UploadMapTile(IScene scene)
+        {
+            m_log.DebugFormat("[SIMIAN MAPTILE]: upload maptile for {0}",scene.RegionInfo.RegionName);
+
+            // Create a PNG map tile and upload it to the AddMapTile API
+            IMapImageGenerator tileGenerator = scene.RequestModuleInterface<IMapImageGenerator>();
+            if (tileGenerator == null)
+            {
+                m_log.Warn("[SIMIAN MAPTILE]: Cannot upload PNG map tile without an ImageGenerator");
+                return;
+            }
+
+            using (Bitmap mapTile = tileGenerator.CreateMapTile())
+            {
+                if (mapTile != null)
+                {
+                    // If the region/maptile is legacy sized, just upload the one tile like it has always been done
+                    if (mapTile.Width == Constants.RegionSize && mapTile.Height == Constants.RegionSize)
+                    {
+                        ConvertAndUploadMaptile(mapTile, scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY);
+                    }
+                    else
+                    {
+                        // For larger regions (varregion) we must cut the region image into legacy sized
+                        //    pieces since that is how the maptile system works.
+                        // Note the assumption that varregions are always a multiple of legacy size.
+                        for (uint xx = 0; xx < mapTile.Width; xx += Constants.RegionSize)
+                        {
+                            for (uint yy = 0; yy < mapTile.Height; yy += Constants.RegionSize)
+                            {
+                                // Images are addressed from the upper left corner so have to do funny
+                                //     math to pick out the sub-tile since regions are numbered from
+                                //     the lower left.
+                                Rectangle rect = new Rectangle(
+                                            (int)xx,
+                                            mapTile.Height - (int)yy - (int)Constants.RegionSize,
+                                            (int)Constants.RegionSize, (int)Constants.RegionSize);
+
+                                using (Bitmap subMapTile = mapTile.Clone(rect, mapTile.PixelFormat))
+                                {
+                                    uint locX = scene.RegionInfo.RegionLocX + (xx / Constants.RegionSize);
+                                    uint locY = scene.RegionInfo.RegionLocY + (yy / Constants.RegionSize);
+                                    
+                                    ConvertAndUploadMaptile(subMapTile, locX, locY);
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    m_log.WarnFormat("[SIMIAN MAPTILE] Tile image generation failed");
+                }
+            }
+
+        }
+        
+        ///<summary>
+        ///
+        ///</summary>
+        private void ConvertAndUploadMaptile(Image mapTile, uint locX, uint locY)
+        {
+            //m_log.DebugFormat("[SIMIAN MAPTILE]: upload maptile for location {0}, {1}", locX, locY);
+
+            byte[] pngData = Utils.EmptyBytes;
+            using (MemoryStream stream = new MemoryStream())
+            {
+                mapTile.Save(stream, ImageFormat.Png);
+                pngData = stream.ToArray();
+            }
+
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                    { "RequestMethod", "xAddMapTile" },
+                    { "X", locX.ToString() },
+                    { "Y", locY.ToString() },
+                    { "ContentType", "image/png" },
+                    { "EncodedData", System.Convert.ToBase64String(pngData) }
+                };
+                            
+            OSDMap response = SimianGrid.PostToService(m_serverUrl,requestArgs);
+            if (! response["Success"].AsBoolean())
+            {
+                m_log.WarnFormat("[SIMIAN MAPTILE] failed to store map tile; {0}",response["Message"].AsString());
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs
new file mode 100644
index 0000000..b031f21
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs
@@ -0,0 +1,484 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Connects region registration and neighbor lookups to the SimianGrid
+    /// backend
+    /// </summary>
+    public class SimianGridServiceConnector : IGridService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+//        private bool m_Enabled = false;
+
+        public SimianGridServiceConnector() { }
+        public SimianGridServiceConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public SimianGridServiceConnector(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        private void CommonInit(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["GridService"];
+            if (gridConfig == null)
+            {
+                m_log.Error("[SIMIAN GRID CONNECTOR]: GridService missing from OpenSim.ini");
+                throw new Exception("Grid connector init error");
+            }
+
+            string serviceUrl = gridConfig.GetString("GridServerURI");
+            if (String.IsNullOrEmpty(serviceUrl))
+            {
+                m_log.Error("[SIMIAN GRID CONNECTOR]: No Server URI named in section GridService");
+                throw new Exception("Grid connector init error");
+            }
+            
+            if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                serviceUrl = serviceUrl + '/';
+            m_ServerURI = serviceUrl;
+//            m_Enabled = true;
+        }
+
+        #region IGridService
+
+        public string RegisterRegion(UUID scopeID, GridRegion regionInfo)
+        {
+            Vector3d minPosition = new Vector3d(regionInfo.RegionLocX, regionInfo.RegionLocY, 0.0);
+            Vector3d maxPosition = minPosition + new Vector3d(regionInfo.RegionSizeX, regionInfo.RegionSizeY, Constants.RegionHeight);
+
+            OSDMap extraData = new OSDMap
+            {
+                { "ServerURI", OSD.FromString(regionInfo.ServerURI) },
+                { "InternalAddress", OSD.FromString(regionInfo.InternalEndPoint.Address.ToString()) },
+                { "InternalPort", OSD.FromInteger(regionInfo.InternalEndPoint.Port) },
+                { "ExternalAddress", OSD.FromString(regionInfo.ExternalEndPoint.Address.ToString()) },
+                { "ExternalPort", OSD.FromInteger(regionInfo.ExternalEndPoint.Port) },
+                { "MapTexture", OSD.FromUUID(regionInfo.TerrainImage) },
+                { "Access", OSD.FromInteger(regionInfo.Access) },
+                { "RegionSecret", OSD.FromString(regionInfo.RegionSecret) },
+                { "EstateOwner", OSD.FromUUID(regionInfo.EstateOwner) },
+                { "Token", OSD.FromString(regionInfo.Token) }
+            };
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddScene" },
+                { "SceneID", regionInfo.RegionID.ToString() },
+                { "Name", regionInfo.RegionName },
+                { "MinPosition", minPosition.ToString() },
+                { "MaxPosition", maxPosition.ToString() },
+                { "Address", regionInfo.ServerURI },
+                { "Enabled", "1" },
+                { "ExtraData", OSDParser.SerializeJsonString(extraData) }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+                return String.Empty;
+            else
+                return "Region registration for " + regionInfo.RegionName + " failed: " + response["Message"].AsString();
+        }
+
+        public bool DeregisterRegion(UUID regionID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddScene" },
+                { "SceneID", regionID.ToString() },
+                { "Enabled", "0" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN GRID CONNECTOR]: Region deregistration for " + regionID + " failed: " + response["Message"].AsString());
+
+            return success;
+        }
+
+        public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
+        {
+            GridRegion region = GetRegionByUUID(scopeID, regionID);
+
+            int NEIGHBOR_RADIUS = Math.Max(region.RegionSizeX, region.RegionSizeY) / 2;
+
+            if (region != null)
+            {
+                List<GridRegion> regions = GetRegionRange(scopeID,
+                    region.RegionLocX - NEIGHBOR_RADIUS, region.RegionLocX + region.RegionSizeX + NEIGHBOR_RADIUS,
+                    region.RegionLocY - NEIGHBOR_RADIUS, region.RegionLocY + region.RegionSizeY + NEIGHBOR_RADIUS);
+
+                for (int i = 0; i < regions.Count; i++)
+                {
+                    if (regions[i].RegionID == regionID)
+                    {
+                        regions.RemoveAt(i);
+                        break;
+                    }
+                }
+
+//                m_log.Debug("[SIMIAN GRID CONNECTOR]: Found " + regions.Count + " neighbors for region " + regionID);
+                return regions;
+            }
+
+            return new List<GridRegion>(0);
+        }
+
+        public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetScene" },
+                { "SceneID", regionID.ToString() }
+            };
+
+            // m_log.DebugFormat("[SIMIAN GRID CONNECTOR] request region with uuid {0}",regionID.ToString());
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                // m_log.DebugFormat("[SIMIAN GRID CONNECTOR] uuid request successful {0}",response["Name"].AsString());
+                return ResponseToGridRegion(response);
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN GRID CONNECTOR]: Grid service did not find a match for region " + regionID);
+                return null;
+            }
+        }
+
+        public GridRegion GetRegionByPosition(UUID scopeID, int x, int y)
+        {
+            // Go one meter in from the requested x/y coords to avoid requesting a position
+            // that falls on the border of two sims
+            Vector3d position = new Vector3d(x + 1, y + 1, 0.0);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetScene" },
+                { "Position", position.ToString() },
+                { "Enabled", "1" }
+            };
+
+            // m_log.DebugFormat("[SIMIAN GRID CONNECTOR] request grid at {0}",position.ToString());
+            
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                // m_log.DebugFormat("[SIMIAN GRID CONNECTOR] position request successful {0}",response["Name"].AsString());
+                return ResponseToGridRegion(response);
+            }
+            else
+            {
+                // m_log.InfoFormat("[SIMIAN GRID CONNECTOR]: Grid service did not find a match for region at {0},{1}",
+                //     Util.WorldToRegionLoc(x), Util.WorldToRegionLoc(y));
+                return null;
+            }
+        }
+
+        public GridRegion GetRegionByName(UUID scopeID, string regionName)
+        {
+            List<GridRegion> regions = GetRegionsByName(scopeID, regionName, 1);
+
+            m_log.Debug("[SIMIAN GRID CONNECTOR]: Got " + regions.Count + " matches for region name " + regionName);
+
+            if (regions.Count > 0)
+                return regions[0];
+
+            return null;
+        }
+
+        public List<GridRegion> GetRegionsByName(UUID scopeID, string name, int maxNumber)
+        {
+            List<GridRegion> foundRegions = new List<GridRegion>();
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetScenes" },
+                { "NameQuery", name },
+                { "Enabled", "1" }
+            };
+            if (maxNumber > 0)
+                requestArgs["MaxNumber"] = maxNumber.ToString();
+
+            // m_log.DebugFormat("[SIMIAN GRID CONNECTOR] request regions with name {0}",name);
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                // m_log.DebugFormat("[SIMIAN GRID CONNECTOR] found regions with name {0}",name);
+
+                OSDArray array = response["Scenes"] as OSDArray;
+                if (array != null)
+                {
+                    for (int i = 0; i < array.Count; i++)
+                    {
+                        GridRegion region = ResponseToGridRegion(array[i] as OSDMap);
+                        if (region != null)
+                            foundRegions.Add(region);
+                    }
+                }
+            }
+
+            return foundRegions;
+        }
+
+        public List<GridRegion> GetRegionRange(UUID scopeID, int xmin, int xmax, int ymin, int ymax)
+        {
+            List<GridRegion> foundRegions = new List<GridRegion>();
+
+            Vector3d minPosition = new Vector3d(xmin, ymin, 0.0);
+            Vector3d maxPosition = new Vector3d(xmax, ymax, Constants.RegionHeight);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetScenes" },
+                { "MinPosition", minPosition.ToString() },
+                { "MaxPosition", maxPosition.ToString() },
+                { "Enabled", "1" }
+            };
+
+            //m_log.DebugFormat("[SIMIAN GRID CONNECTOR] request regions by range {0} to {1}",minPosition.ToString(),maxPosition.ToString());
+            
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                OSDArray array = response["Scenes"] as OSDArray;
+                if (array != null)
+                {
+                    for (int i = 0; i < array.Count; i++)
+                    {
+                        GridRegion region = ResponseToGridRegion(array[i] as OSDMap);
+                        if (region != null)
+                            foundRegions.Add(region);
+                    }
+                }
+            }
+
+            return foundRegions;
+        }
+
+        public List<GridRegion> GetDefaultRegions(UUID scopeID)
+        {
+            // TODO: Allow specifying the default grid location
+            const int DEFAULT_X = 1000 * 256;
+            const int DEFAULT_Y = 1000 * 256;
+
+            GridRegion defRegion = GetNearestRegion(new Vector3d(DEFAULT_X, DEFAULT_Y, 0.0), true);
+            if (defRegion != null)
+                return new List<GridRegion>(1) { defRegion };
+            else
+                return new List<GridRegion>(0);
+        }
+
+        public List<GridRegion> GetDefaultHypergridRegions(UUID scopeID)
+        {
+            // TODO: Allow specifying the default grid location
+            return GetDefaultRegions(scopeID);
+        }
+
+        public List<GridRegion> GetFallbackRegions(UUID scopeID, int x, int y)
+        {
+            GridRegion defRegion = GetNearestRegion(new Vector3d(x, y, 0.0), true);
+            if (defRegion != null)
+                return new List<GridRegion>(1) { defRegion };
+            else
+                return new List<GridRegion>(0);
+        }
+
+        public List<GridRegion> GetHyperlinks(UUID scopeID)
+        {
+            List<GridRegion> foundRegions = new List<GridRegion>();
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetScenes" },
+                { "HyperGrid", "true" },
+                { "Enabled", "1" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                // m_log.DebugFormat("[SIMIAN GRID CONNECTOR] found regions with name {0}",name);
+
+                OSDArray array = response["Scenes"] as OSDArray;
+                if (array != null)
+                {
+                    for (int i = 0; i < array.Count; i++)
+                    {
+                        GridRegion region = ResponseToGridRegion(array[i] as OSDMap);
+                        if (region != null)
+                            foundRegions.Add(region);
+                    }
+                }
+            }
+
+            return foundRegions;
+        }
+
+        public int GetRegionFlags(UUID scopeID, UUID regionID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetScene" },
+                { "SceneID", regionID.ToString() }
+            };
+
+            m_log.DebugFormat("[SIMIAN GRID CONNECTOR] request region flags for {0}",regionID.ToString());
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                OSDMap extraData = response["ExtraData"] as OSDMap;
+                int enabled = response["Enabled"].AsBoolean() ? (int)OpenSim.Framework.RegionFlags.RegionOnline : 0;
+                int hypergrid = extraData["HyperGrid"].AsBoolean() ? (int)OpenSim.Framework.RegionFlags.Hyperlink : 0;
+                int flags =  enabled | hypergrid;
+                m_log.DebugFormat("[SGGC] enabled - {0} hg - {1} flags - {2}", enabled, hypergrid, flags);
+                return flags;
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN GRID CONNECTOR]: Grid service did not find a match for region " + regionID + " during region flags check");
+                return -1;
+            }
+        }
+        
+        public Dictionary<string, object> GetExtraFeatures()
+        {
+            /// See SimulatorFeaturesModule - Need to get map, search and destination guide
+            Dictionary<string, object> extraFeatures = new Dictionary<string, object>();
+            return extraFeatures;
+        }
+
+        #endregion IGridService
+
+        private GridRegion GetNearestRegion(Vector3d position, bool onlyEnabled)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetScene" },
+                { "Position", position.ToString() },
+                { "FindClosest", "1" }
+            };
+            if (onlyEnabled)
+                requestArgs["Enabled"] = "1";
+
+            OSDMap response = SimianGrid.PostToService(m_ServerURI, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                return ResponseToGridRegion(response);
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN GRID CONNECTOR]: Grid service did not find a match for region at " + position);
+                return null;
+            }
+        }
+
+        private GridRegion ResponseToGridRegion(OSDMap response)
+        {
+            if (response == null)
+                return null;
+
+            OSDMap extraData = response["ExtraData"] as OSDMap;
+            if (extraData == null)
+                return null;
+
+            GridRegion region = new GridRegion();
+
+            region.RegionID = response["SceneID"].AsUUID();
+            region.RegionName = response["Name"].AsString();
+
+            Vector3d minPosition = response["MinPosition"].AsVector3d();
+            Vector3d maxPosition = response["MaxPosition"].AsVector3d();
+            region.RegionLocX = (int)minPosition.X;
+            region.RegionLocY = (int)minPosition.Y;
+
+            region.RegionSizeX = (int)maxPosition.X - (int)minPosition.X;
+            region.RegionSizeY = (int)maxPosition.Y - (int)minPosition.Y;
+
+            if ( ! extraData["HyperGrid"] ) {
+                Uri httpAddress = response["Address"].AsUri();
+                region.ExternalHostName = httpAddress.Host;
+                region.HttpPort = (uint)httpAddress.Port;
+
+                IPAddress internalAddress;
+                IPAddress.TryParse(extraData["InternalAddress"].AsString(), out internalAddress);
+                if (internalAddress == null)
+                    internalAddress = IPAddress.Any;
+
+                region.InternalEndPoint = new IPEndPoint(internalAddress, extraData["InternalPort"].AsInteger());
+                region.TerrainImage = extraData["MapTexture"].AsUUID();
+                region.Access = (byte)extraData["Access"].AsInteger();
+                region.RegionSecret = extraData["RegionSecret"].AsString();
+                region.EstateOwner = extraData["EstateOwner"].AsUUID();
+                region.Token = extraData["Token"].AsString();
+                region.ServerURI = extraData["ServerURI"].AsString();
+            } else {
+                region.ServerURI = response["Address"];
+            }
+
+            return region;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs
new file mode 100644
index 0000000..e793420
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs
@@ -0,0 +1,941 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using PermissionMask = OpenSim.Framework.PermissionMask;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Permissions bitflags
+    /// </summary>
+    /*
+    [Flags]
+    public enum PermissionMask : uint
+    {
+        None = 0,
+        Transfer = 1 << 13,
+        Modify = 1 << 14,
+        Copy = 1 << 15,
+        Move = 1 << 19,
+        Damage = 1 << 20,
+        All = 0x7FFFFFFF
+    }
+    */
+
+    /// <summary>
+    /// Connects avatar inventories to the SimianGrid backend
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianInventoryServiceConnector")]
+    public class SimianInventoryServiceConnector : IInventoryService, ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_serverUrl = String.Empty;
+        private string m_userServerUrl = String.Empty;
+//        private object m_gestureSyncRoot = new object();
+        private bool m_Enabled = false;
+
+        private const double CACHE_EXPIRATION_SECONDS = 20.0;
+        private static ExpiringCache<UUID, InventoryItemBase> m_ItemCache;
+
+        #region ISharedRegionModule
+
+        public Type ReplaceableInterface { get { return null; } }
+        public void RegionLoaded(Scene scene) { }
+        public void PostInitialise() { }
+        public void Close() { }
+
+        public SimianInventoryServiceConnector() { }
+        public string Name { get { return "SimianInventoryServiceConnector"; } }
+        public void AddRegion(Scene scene) { if (m_Enabled) { scene.RegisterModuleInterface<IInventoryService>(this); } }
+        public void RemoveRegion(Scene scene) { if (m_Enabled) { scene.UnregisterModuleInterface<IInventoryService>(this); } }
+
+        #endregion ISharedRegionModule
+
+        public SimianInventoryServiceConnector(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        public SimianInventoryServiceConnector(string url)
+        {
+            if (!url.EndsWith("/") && !url.EndsWith("="))
+                url = url + '/';
+            m_serverUrl = url;
+
+            if (m_ItemCache == null)
+                m_ItemCache = new ExpiringCache<UUID, InventoryItemBase>();
+
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("InventoryServices", "");
+                if (name == Name)
+                    CommonInit(source);
+            }
+        }
+
+        private void CommonInit(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["InventoryService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("InventoryServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+
+                    gridConfig = source.Configs["UserAccountService"];
+                    if (gridConfig != null)
+                    {
+                        serviceUrl = gridConfig.GetString("UserAccountServerURI");
+                        if (!String.IsNullOrEmpty(serviceUrl))
+                        {
+                            m_userServerUrl = serviceUrl;
+                            m_Enabled = true;
+                            if (m_ItemCache == null)
+                                m_ItemCache = new ExpiringCache<UUID, InventoryItemBase>();
+                        }
+                    }
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN INVENTORY CONNECTOR]: No InventoryServerURI specified, disabling connector");
+            else if (String.IsNullOrEmpty(m_userServerUrl))
+                m_log.Info("[SIMIAN INVENTORY CONNECTOR]: No UserAccountServerURI specified, disabling connector");
+        }
+
+        /// <summary>
+        /// Create the entire inventory for a given user
+        /// </summary>
+        /// <param name="user"></param>
+        /// <returns></returns>
+        public bool CreateUserInventory(UUID userID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddInventory" },
+                { "OwnerID", userID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Inventory creation for " + userID + " failed: " + response["Message"].AsString());
+
+            return success;
+        }
+
+        /// <summary>
+        /// Gets the skeleton of the inventory -- folders only
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <returns></returns>
+        public List<InventoryFolderBase> GetInventorySkeleton(UUID userID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetInventoryNode" },
+                { "ItemID", userID.ToString() },
+                { "OwnerID", userID.ToString() },
+                { "IncludeFolders", "1" },
+                { "IncludeItems", "0" },
+                { "ChildrenOnly", "0" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Items"] is OSDArray)
+            {
+                OSDArray items = (OSDArray)response["Items"];
+                return GetFoldersFromResponse(items, userID, true);
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Failed to retrieve inventory skeleton for " + userID + ": " +
+                    response["Message"].AsString());
+                return new List<InventoryFolderBase>(0);
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the root inventory folder for the given user.
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <returns>null if no root folder was found</returns>
+        public InventoryFolderBase GetRootFolder(UUID userID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetInventoryNode" },
+                { "ItemID", userID.ToString() },
+                { "OwnerID", userID.ToString() },
+                { "IncludeFolders", "1" },
+                { "IncludeItems", "0" },
+                { "ChildrenOnly", "1" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Items"] is OSDArray)
+            {
+                OSDArray items = (OSDArray)response["Items"];
+                List<InventoryFolderBase> folders = GetFoldersFromResponse(items, userID, true);
+
+                if (folders.Count > 0)
+                    return folders[0];
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the user folder for the given folder-type
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public InventoryFolderBase GetFolderForType(UUID userID, FolderType type)
+        {
+            string contentType = SLUtil.SLAssetTypeToContentType((int)type);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetFolderForType" },
+                { "ContentType", contentType },
+                { "OwnerID", userID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Folder"] is OSDMap)
+            {
+                OSDMap folder = (OSDMap)response["Folder"];
+
+                return new InventoryFolderBase(
+                    folder["ID"].AsUUID(),
+                    folder["Name"].AsString(),
+                    folder["OwnerID"].AsUUID(),
+                    (short)SLUtil.ContentTypeToSLAssetType(folder["ContentType"].AsString()),
+                    folder["ParentID"].AsUUID(),
+                    (ushort)folder["Version"].AsInteger()
+                );
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Default folder not found for content type " + contentType + ": " + response["Message"].AsString());
+                return GetRootFolder(userID);
+            }
+        }
+
+        /// <summary>
+        /// Get an item, given by its UUID
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns></returns>
+        public InventoryItemBase GetItem(InventoryItemBase item)
+        {
+            InventoryItemBase retrieved = null;
+            if (m_ItemCache.TryGetValue(item.ID, out retrieved))
+                return retrieved;
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetInventoryNode" },
+                { "ItemID", item.ID.ToString() },
+                { "OwnerID", item.Owner.ToString() },
+                { "IncludeFolders", "1" },
+                { "IncludeItems", "1" },
+                { "ChildrenOnly", "1" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Items"] is OSDArray)
+            {
+                List<InventoryItemBase> items = GetItemsFromResponse((OSDArray)response["Items"]);
+                if (items.Count > 0)
+                {
+                    // The requested item should be the first in this list, but loop through
+                    // and sanity check just in case
+                    for (int i = 0; i < items.Count; i++)
+                    {
+                        if (items[i].ID == item.ID)
+                        {
+                            retrieved = items[i];
+                            m_ItemCache.AddOrUpdate(item.ID, retrieved, CACHE_EXPIRATION_SECONDS);
+                            return retrieved;
+                        }
+                    }
+                }
+            }
+
+            m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Item " + item.ID + " owned by " + item.Owner + " not found");
+            return null;
+        }
+
+        public InventoryItemBase[] GetMultipleItems(UUID principalID, UUID[] itemIDs)
+        {
+            InventoryItemBase[] result = new InventoryItemBase[itemIDs.Length];
+            int i = 0;
+            InventoryItemBase item = new InventoryItemBase();
+            item.Owner = principalID;
+            foreach (UUID id in itemIDs)
+            {
+                item.ID = id;
+                result[i++] = GetItem(item);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Get a folder, given by its UUID
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <returns></returns>
+        public InventoryFolderBase GetFolder(InventoryFolderBase folder)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetInventoryNode" },
+                { "ItemID", folder.ID.ToString() },
+                { "OwnerID", folder.Owner.ToString() },
+                { "IncludeFolders", "1" },
+                { "IncludeItems", "0" },
+                { "ChildrenOnly", "1" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Items"] is OSDArray)
+            {
+                OSDArray items = (OSDArray)response["Items"];
+                List<InventoryFolderBase> folders = GetFoldersFromResponse(items, folder.ID, true);
+
+                if (folders.Count > 0)
+                    return folders[0];
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets everything (folders and items) inside a folder
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <param name="folderID"></param>
+        /// <returns></returns>
+        public InventoryCollection GetFolderContent(UUID userID, UUID folderID)
+        {
+            InventoryCollection inventory = new InventoryCollection();
+            inventory.OwnerID = userID;
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetInventoryNode" },
+                { "ItemID", folderID.ToString() },
+                { "OwnerID", userID.ToString() },
+                { "IncludeFolders", "1" },
+                { "IncludeItems", "1" },
+                { "ChildrenOnly", "1" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Items"] is OSDArray)
+            {
+                OSDArray items = (OSDArray)response["Items"];
+
+                inventory.Folders = GetFoldersFromResponse(items, folderID, false);
+                inventory.Items = GetItemsFromResponse(items);
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Error fetching folder " + folderID + " content for " + userID + ": " +
+                    response["Message"].AsString());
+                inventory.Folders = new List<InventoryFolderBase>(0);
+                inventory.Items = new List<InventoryItemBase>(0);
+            }
+
+            return inventory;
+        }
+
+        public virtual InventoryCollection[] GetMultipleFoldersContent(UUID principalID, UUID[] folderIDs)
+        {
+            InventoryCollection[] invColl = new InventoryCollection[folderIDs.Length];
+            int i = 0;
+            foreach (UUID fid in folderIDs)
+            {
+                invColl[i++] = GetFolderContent(principalID, fid);
+            }
+
+            return invColl;
+        }
+
+        /// <summary>
+        /// Gets the items inside a folder
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <param name="folderID"></param>
+        /// <returns></returns>
+        public List<InventoryItemBase> GetFolderItems(UUID userID, UUID folderID)
+        {
+            InventoryCollection inventory = new InventoryCollection();
+            inventory.OwnerID = userID;
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetInventoryNode" },
+                { "ItemID", folderID.ToString() },
+                { "OwnerID", userID.ToString() },
+                { "IncludeFolders", "0" },
+                { "IncludeItems", "1" },
+                { "ChildrenOnly", "1" }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["Items"] is OSDArray)
+            {
+                OSDArray items = (OSDArray)response["Items"];
+                return GetItemsFromResponse(items);
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Error fetching folder " + folderID + " for " + userID + ": " +
+                    response["Message"].AsString());
+                return new List<InventoryItemBase>(0);
+            }
+        }
+
+        /// <summary>
+        /// Add a new folder to the user's inventory
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <returns>true if the folder was successfully added</returns>
+        public bool AddFolder(InventoryFolderBase folder)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddInventoryFolder" },
+                { "FolderID", folder.ID.ToString() },
+                { "ParentID", folder.ParentID.ToString() },
+                { "OwnerID", folder.Owner.ToString() },
+                { "Name", folder.Name },
+                { "ContentType", SLUtil.SLAssetTypeToContentType(folder.Type) }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Error creating folder " + folder.Name + " for " + folder.Owner + ": " +
+                    response["Message"].AsString());
+            }
+
+            return success;
+        }
+
+        /// <summary>
+        /// Update a folder in the user's inventory
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <returns>true if the folder was successfully updated</returns>
+        public bool UpdateFolder(InventoryFolderBase folder)
+        {
+            return AddFolder(folder);
+        }
+
+        /// <summary>
+        /// Move an inventory folder to a new location
+        /// </summary>
+        /// <param name="folder">A folder containing the details of the new location</param>
+        /// <returns>true if the folder was successfully moved</returns>
+        public bool MoveFolder(InventoryFolderBase folder)
+        {
+            return AddFolder(folder);
+        }
+
+        /// <summary>
+        /// Delete an item from the user's inventory
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns>true if the item was successfully deleted</returns>
+        //bool DeleteItem(InventoryItemBase item);
+        public bool DeleteFolders(UUID userID, List<UUID> folderIDs)
+        {
+            return DeleteItems(userID, folderIDs);
+        }
+
+        /// <summary>
+        /// Delete an item from the user's inventory
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns>true if the item was successfully deleted</returns>
+        public bool DeleteItems(UUID userID, List<UUID> itemIDs)
+        {
+            // TODO: RemoveInventoryNode should be replaced with RemoveInventoryNodes
+            bool allSuccess = true;
+
+            for (int i = 0; i < itemIDs.Count; i++)
+            {
+                UUID itemID = itemIDs[i];
+
+                NameValueCollection requestArgs = new NameValueCollection
+                {
+                    { "RequestMethod", "RemoveInventoryNode" },
+                    { "OwnerID", userID.ToString() },
+                    { "ItemID", itemID.ToString() }
+                };
+
+                OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+                bool success = response["Success"].AsBoolean();
+
+                if (!success)
+                {
+                    m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Error removing item " + itemID + " for " + userID + ": " +
+                        response["Message"].AsString());
+                    allSuccess = false;
+                }
+            }
+            
+            return allSuccess;
+        }
+
+        /// <summary>
+        /// Purge an inventory folder of all its items and subfolders.
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <returns>true if the folder was successfully purged</returns>
+        public bool PurgeFolder(InventoryFolderBase folder)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "PurgeInventoryFolder" },
+                { "OwnerID", folder.Owner.ToString() },
+                { "FolderID", folder.ID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Error purging folder " + folder.ID + " for " + folder.Owner + ": " +
+                    response["Message"].AsString());
+            }
+
+            return success;
+        }
+
+        /// <summary>
+        /// Add a new item to the user's inventory
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns>true if the item was successfully added</returns>
+        public bool AddItem(InventoryItemBase item)
+        {
+            // A folder of UUID.Zero means we need to find the most appropriate home for this item
+            if (item.Folder == UUID.Zero)
+            {
+                InventoryFolderBase folder = null;
+                if (Enum.IsDefined(typeof(FolderType), (sbyte)item.AssetType))
+                    folder = GetFolderForType(item.Owner, (FolderType)item.AssetType);
+                if (folder != null && folder.ID != UUID.Zero)
+                    item.Folder = folder.ID;
+                else
+                    item.Folder = item.Owner; // Root folder
+            }
+
+            if ((AssetType)item.AssetType == AssetType.Gesture)
+                UpdateGesture(item.Owner, item.ID, item.Flags == 1);
+
+            if (item.BasePermissions == 0)
+                m_log.WarnFormat("[SIMIAN INVENTORY CONNECTOR]: Adding inventory item {0} ({1}) with no base permissions", item.Name, item.ID);
+
+            OSDMap permissions = new OSDMap
+            {
+                { "BaseMask", OSD.FromInteger(item.BasePermissions) },
+                { "EveryoneMask", OSD.FromInteger(item.EveryOnePermissions) },
+                { "GroupMask", OSD.FromInteger(item.GroupPermissions) },
+                { "NextOwnerMask", OSD.FromInteger(item.NextPermissions) },
+                { "OwnerMask", OSD.FromInteger(item.CurrentPermissions) }
+            };
+
+            OSDMap extraData = new OSDMap()
+            {
+                { "Flags", OSD.FromInteger(item.Flags) },
+                { "GroupID", OSD.FromUUID(item.GroupID) },
+                { "GroupOwned", OSD.FromBoolean(item.GroupOwned) },
+                { "SalePrice", OSD.FromInteger(item.SalePrice) },
+                { "SaleType", OSD.FromInteger(item.SaleType) },
+                { "Permissions", permissions }
+            };
+
+            // Add different asset type only if it differs from inventory type
+            // (needed for links)
+            string invContentType = SLUtil.SLInvTypeToContentType(item.InvType);
+            string assetContentType = SLUtil.SLAssetTypeToContentType(item.AssetType);
+
+            if (invContentType != assetContentType)
+                extraData["LinkedItemType"] = OSD.FromString(assetContentType);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddInventoryItem" },
+                { "ItemID", item.ID.ToString() },
+                { "AssetID", item.AssetID.ToString() },
+                { "ParentID", item.Folder.ToString() },
+                { "OwnerID", item.Owner.ToString() },
+                { "Name", item.Name },
+                { "Description", item.Description },
+                { "CreatorID", item.CreatorId },
+                { "CreatorData", item.CreatorData },
+                { "ContentType", invContentType },
+                { "ExtraData", OSDParser.SerializeJsonString(extraData) }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Error creating item " + item.Name + " for " + item.Owner + ": " +
+                    response["Message"].AsString());
+            }
+
+            return success;
+        }
+
+        /// <summary>
+        /// Update an item in the user's inventory
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns>true if the item was successfully updated</returns>
+        public bool UpdateItem(InventoryItemBase item)
+        {
+            if (item.AssetID != UUID.Zero)
+            {
+                return AddItem(item);
+            }
+            else
+            {
+                // This is actually a folder update
+                InventoryFolderBase folder = new InventoryFolderBase(item.ID, item.Name, item.Owner, (short)item.AssetType, item.Folder, 0);
+                return UpdateFolder(folder);
+            }
+        }
+
+        public bool MoveItems(UUID ownerID, List<InventoryItemBase> items)
+        {
+            bool success = true;
+
+            while (items.Count > 0)
+            {
+                List<InventoryItemBase> currentItems = new List<InventoryItemBase>();
+                UUID destFolderID = items[0].Folder;
+
+                // Find all of the items being moved to the current destination folder
+                for (int i = 0; i < items.Count; i++)
+                {
+                    InventoryItemBase item = items[i];
+                    if (item.Folder == destFolderID)
+                        currentItems.Add(item);
+                }
+
+                // Do the inventory move for the current items
+                success &= MoveItems(ownerID, items, destFolderID);
+
+                // Remove the processed items from the list
+                for (int i = 0; i < currentItems.Count; i++)
+                    items.Remove(currentItems[i]);
+            }
+
+            return success;
+        }
+
+        /// <summary>
+        /// Does the given user have an inventory structure?
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <returns></returns>
+        public bool HasInventoryForUser(UUID userID)
+        {
+            return GetRootFolder(userID) != null;
+        }
+
+        /// <summary>
+        /// Get the active gestures of the agent.
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <returns></returns>
+        public List<InventoryItemBase> GetActiveGestures(UUID userID)
+        {
+            OSDArray items = FetchGestures(userID);
+
+            string[] itemIDs = new string[items.Count];
+            for (int i = 0; i < items.Count; i++)
+                itemIDs[i] = items[i].AsUUID().ToString();
+
+//            NameValueCollection requestArgs = new NameValueCollection
+//            {
+//                { "RequestMethod", "GetInventoryNodes" },
+//                { "OwnerID", userID.ToString() },
+//                { "Items", String.Join(",", itemIDs) }
+//            };
+
+            // FIXME: Implement this in SimianGrid
+            return new List<InventoryItemBase>(0);
+        }
+
+        /// <summary>
+        /// Get the union of permissions of all inventory items
+        /// that hold the given assetID. 
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <param name="assetID"></param>
+        /// <returns>The permissions or 0 if no such asset is found in 
+        /// the user's inventory</returns>
+        public int GetAssetPermissions(UUID userID, UUID assetID)
+        {
+//            NameValueCollection requestArgs = new NameValueCollection
+//            {
+//                { "RequestMethod", "GetInventoryNodes" },
+//                { "OwnerID", userID.ToString() },
+//                { "AssetID", assetID.ToString() }
+//            };
+
+            // FIXME: Implement this in SimianGrid
+            return (int)PermissionMask.All;
+        }
+
+        private List<InventoryFolderBase> GetFoldersFromResponse(OSDArray items, UUID baseFolder, bool includeBaseFolder)
+        {
+            List<InventoryFolderBase> invFolders = new List<InventoryFolderBase>(items.Count);
+
+            for (int i = 0; i < items.Count; i++)
+            {
+                OSDMap item = items[i] as OSDMap;
+
+                if (item != null && item["Type"].AsString() == "Folder")
+                {
+                    UUID folderID = item["ID"].AsUUID();
+
+                    if (folderID == baseFolder && !includeBaseFolder)
+                        continue;
+
+                    invFolders.Add(new InventoryFolderBase(
+                        folderID,
+                        item["Name"].AsString(),
+                        item["OwnerID"].AsUUID(),
+                        (short)SLUtil.ContentTypeToSLAssetType(item["ContentType"].AsString()),
+                        item["ParentID"].AsUUID(),
+                        (ushort)item["Version"].AsInteger()
+                    ));
+                }
+            }
+
+//            m_log.Debug("[SIMIAN INVENTORY CONNECTOR]: Parsed " + invFolders.Count + " folders from SimianGrid response");
+            return invFolders;
+        }
+
+        private List<InventoryItemBase> GetItemsFromResponse(OSDArray items)
+        {
+            List<InventoryItemBase> invItems = new List<InventoryItemBase>(items.Count);
+
+            for (int i = 0; i < items.Count; i++)
+            {
+                OSDMap item = items[i] as OSDMap;
+
+                if (item != null && item["Type"].AsString() == "Item")
+                {
+                    InventoryItemBase invItem = new InventoryItemBase();
+                    
+                    invItem.AssetID = item["AssetID"].AsUUID();
+                    invItem.AssetType = SLUtil.ContentTypeToSLAssetType(item["ContentType"].AsString());
+                    invItem.CreationDate = item["CreationDate"].AsInteger();
+                    invItem.CreatorId = item["CreatorID"].AsString();
+                    invItem.CreatorData = item["CreatorData"].AsString();
+                    invItem.Description = item["Description"].AsString();
+                    invItem.Folder = item["ParentID"].AsUUID();
+                    invItem.ID = item["ID"].AsUUID();
+                    invItem.InvType = SLUtil.ContentTypeToSLInvType(item["ContentType"].AsString());
+                    invItem.Name = item["Name"].AsString();
+                    invItem.Owner = item["OwnerID"].AsUUID();
+
+                    OSDMap extraData = item["ExtraData"] as OSDMap;
+                    if (extraData != null && extraData.Count > 0)
+                    {
+                        invItem.Flags = extraData["Flags"].AsUInteger();
+                        invItem.GroupID = extraData["GroupID"].AsUUID();
+                        invItem.GroupOwned = extraData["GroupOwned"].AsBoolean();
+                        invItem.SalePrice = extraData["SalePrice"].AsInteger();
+                        invItem.SaleType = (byte)extraData["SaleType"].AsInteger();
+
+                        OSDMap perms = extraData["Permissions"] as OSDMap;
+                        if (perms != null)
+                        {
+                            invItem.BasePermissions = perms["BaseMask"].AsUInteger();
+                            invItem.CurrentPermissions = perms["OwnerMask"].AsUInteger();
+                            invItem.EveryOnePermissions = perms["EveryoneMask"].AsUInteger();
+                            invItem.GroupPermissions = perms["GroupMask"].AsUInteger();
+                            invItem.NextPermissions = perms["NextOwnerMask"].AsUInteger();
+                        }
+
+                        if (extraData.ContainsKey("LinkedItemType"))
+                            invItem.AssetType = SLUtil.ContentTypeToSLAssetType(extraData["LinkedItemType"].AsString());
+                    }
+
+                    if (invItem.BasePermissions == 0)
+                    {
+                        m_log.InfoFormat("[SIMIAN INVENTORY CONNECTOR]: Forcing item permissions to full for item {0} ({1})",
+                            invItem.Name, invItem.ID);
+                        invItem.BasePermissions = (uint)PermissionMask.All;
+                        invItem.CurrentPermissions = (uint)PermissionMask.All;
+                        invItem.EveryOnePermissions = (uint)PermissionMask.All;
+                        invItem.GroupPermissions = (uint)PermissionMask.All;
+                        invItem.NextPermissions = (uint)PermissionMask.All;
+                    }
+
+                    invItems.Add(invItem);
+                }
+            }
+
+//            m_log.Debug("[SIMIAN INVENTORY CONNECTOR]: Parsed " + invItems.Count + " items from SimianGrid response");
+            return invItems;
+        }
+
+        private bool MoveItems(UUID ownerID, List<InventoryItemBase> items, UUID destFolderID)
+        {
+            string[] itemIDs = new string[items.Count];
+            for (int i = 0; i < items.Count; i++)
+                itemIDs[i] = items[i].ID.ToString();
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "MoveInventoryNodes" },
+                { "OwnerID", ownerID.ToString() },
+                { "FolderID", destFolderID.ToString() },
+                { "Items", String.Join(",", itemIDs) }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Failed to move " + items.Count + " items to " +
+                    destFolderID + ": " + response["Message"].AsString());
+            }
+
+            return success;
+        }
+
+        private void UpdateGesture(UUID userID, UUID itemID, bool enabled)
+        {
+            OSDArray gestures = FetchGestures(userID);
+            OSDArray newGestures = new OSDArray();
+
+            for (int i = 0; i < gestures.Count; i++)
+            {
+                UUID gesture = gestures[i].AsUUID();
+                if (gesture != itemID)
+                    newGestures.Add(OSD.FromUUID(gesture));
+            }
+
+            if (enabled)
+                newGestures.Add(OSD.FromUUID(itemID));
+
+            SaveGestures(userID, newGestures);
+        }
+
+        private OSDArray FetchGestures(UUID userID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "UserID", userID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_userServerUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                OSDMap user = response["User"] as OSDMap;
+                if (user != null && response.ContainsKey("Gestures"))
+                {
+                    OSD gestures = OSDParser.DeserializeJson(response["Gestures"].AsString());
+                    if (gestures != null && gestures is OSDArray)
+                        return (OSDArray)gestures;
+                    else
+                        m_log.Error("[SIMIAN INVENTORY CONNECTOR]: Unrecognized active gestures data for " + userID);
+                }
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Failed to fetch active gestures for " + userID + ": " +
+                    response["Message"].AsString());
+            }
+
+            return new OSDArray();
+        }
+
+        private void SaveGestures(UUID userID, OSDArray gestures)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddUserData" },
+                { "UserID", userID.ToString() },
+                { "Gestures", OSDParser.SerializeJsonString(gestures) }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_userServerUrl, requestArgs);
+            if (!response["Success"].AsBoolean())
+            {
+                m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Failed to save active gestures for " + userID + ": " +
+                    response["Message"].AsString());
+            }
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianPresenceServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianPresenceServiceConnector.cs
new file mode 100644
index 0000000..211b775
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianPresenceServiceConnector.cs
@@ -0,0 +1,459 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Connects avatar presence information (for tracking current location and
+    /// message routing) to the SimianGrid backend
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianPresenceServiceConnector")]
+    public class SimianPresenceServiceConnector : IPresenceService, IGridUserService, ISharedRegionModule
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_serverUrl = String.Empty;
+        private SimianActivityDetector m_activityDetector;
+        private bool m_Enabled = false;
+
+        #region ISharedRegionModule
+
+        public Type ReplaceableInterface { get { return null; } }
+        public void RegionLoaded(Scene scene) { }
+        public void PostInitialise() { }
+        public void Close() { }
+
+        public SimianPresenceServiceConnector() { }
+        public string Name { get { return "SimianPresenceServiceConnector"; } }
+        public void AddRegion(Scene scene)
+        {
+            if (m_Enabled)
+            {
+                scene.RegisterModuleInterface<IPresenceService>(this);
+                scene.RegisterModuleInterface<IGridUserService>(this);
+
+                m_activityDetector.AddRegion(scene);
+
+                LogoutRegionAgents(scene.RegionInfo.RegionID);
+            }
+        }
+        public void RemoveRegion(Scene scene)
+        {
+            if (m_Enabled)
+            {
+                scene.UnregisterModuleInterface<IPresenceService>(this);
+                scene.UnregisterModuleInterface<IGridUserService>(this);
+
+                m_activityDetector.RemoveRegion(scene);
+
+                LogoutRegionAgents(scene.RegionInfo.RegionID);
+            }
+        }
+
+        #endregion ISharedRegionModule
+
+        public SimianPresenceServiceConnector(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("PresenceServices", "");
+                if (name == Name)
+                    CommonInit(source);
+            }
+        }
+
+        private void CommonInit(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["PresenceService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("PresenceServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+                    m_activityDetector = new SimianActivityDetector(this); 
+                    m_Enabled = true;
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN PRESENCE CONNECTOR]: No PresenceServerURI specified, disabling connector");
+        }
+
+        #region IPresenceService
+
+        public bool LoginAgent(string userID, UUID sessionID, UUID secureSessionID)
+        {
+            m_log.ErrorFormat("[SIMIAN PRESENCE CONNECTOR]: Login requested, UserID={0}, SessionID={1}, SecureSessionID={2}",
+                userID, sessionID, secureSessionID);
+
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "AddSession" },
+                        { "UserID", userID.ToString() }
+                };
+
+            if (sessionID != UUID.Zero)
+            {
+                requestArgs["SessionID"] = sessionID.ToString();
+                requestArgs["SecureSessionID"] = secureSessionID.ToString();
+            }
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN PRESENCE CONNECTOR]: Failed to login agent " + userID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        public bool LogoutAgent(UUID sessionID)
+        {
+            // m_log.InfoFormat("[SIMIAN PRESENCE CONNECTOR]: Logout requested for agent with sessionID " + sessionID);
+
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "RemoveSession" },
+                        { "SessionID", sessionID.ToString() }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN PRESENCE CONNECTOR]: Failed to logout agent with sessionID " + sessionID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        public bool LogoutRegionAgents(UUID regionID)
+        {
+            // m_log.InfoFormat("[SIMIAN PRESENCE CONNECTOR]: Logout requested for all agents in region " + regionID);
+
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "RemoveSessions" },
+                        { "SceneID", regionID.ToString() }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN PRESENCE CONNECTOR]: Failed to logout agents from region " + regionID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        public bool ReportAgent(UUID sessionID, UUID regionID)
+        {
+            // Not needed for SimianGrid
+            return true;
+        }
+
+        public PresenceInfo GetAgent(UUID sessionID)
+        {
+            OSDMap sessionResponse = GetSessionDataFromSessionID(sessionID);
+            if (sessionResponse == null)
+            {
+                m_log.WarnFormat("[SIMIAN PRESENCE CONNECTOR]: Failed to retrieve session {0}: {1}",sessionID.ToString(),sessionResponse["Message"].AsString());
+                return null;
+            }
+            
+            UUID userID = sessionResponse["UserID"].AsUUID();
+            OSDMap userResponse = GetUserData(userID);
+            if (userResponse == null)
+            {
+                m_log.WarnFormat("[SIMIAN PRESENCE CONNECTOR]: Failed to retrieve user data for {0}: {1}",userID.ToString(),userResponse["Message"].AsString());
+                return null;
+            }
+
+            return ResponseToPresenceInfo(sessionResponse);
+        }
+
+        public PresenceInfo[] GetAgents(string[] userIDs)
+        {
+            List<PresenceInfo> presences = new List<PresenceInfo>();
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetSessions" },
+                { "UserIDList", String.Join(",",userIDs) }
+            };
+
+            OSDMap sessionListResponse = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (! sessionListResponse["Success"].AsBoolean())
+            {
+                m_log.WarnFormat("[SIMIAN PRESENCE CONNECTOR]: Failed to retrieve sessions: {0}",sessionListResponse["Message"].AsString());
+                return null;
+            }
+            
+            OSDArray sessionList = sessionListResponse["Sessions"] as OSDArray;
+            for (int i = 0; i < sessionList.Count; i++)
+            {
+                OSDMap sessionInfo = sessionList[i] as OSDMap;
+                presences.Add(ResponseToPresenceInfo(sessionInfo));
+            }
+
+            return presences.ToArray();
+        }
+
+        #endregion IPresenceService
+
+        #region IGridUserService
+
+        public GridUserInfo LoggedIn(string userID)
+        {
+            // Never implemented at the sim
+            return null;
+        }
+
+        public bool LoggedOut(string userID, UUID sessionID, UUID regionID, Vector3 lastPosition, Vector3 lastLookAt)
+        {
+            // m_log.DebugFormat("[SIMIAN PRESENCE CONNECTOR]: Logging out user " + userID);
+
+            // Remove the session to mark this user offline
+            if (!LogoutAgent(sessionID))
+                return false;
+
+            // Save our last position as user data
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "AddUserData" },
+                        { "UserID", userID.ToString() },
+                        { "LastLocation", SerializeLocation(regionID, lastPosition, lastLookAt) }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN PRESENCE CONNECTOR]: Failed to set last location for " + userID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        public bool SetHome(string userID, UUID regionID, Vector3 position, Vector3 lookAt)
+        {
+            // m_log.DebugFormat("[SIMIAN PRESENCE CONNECTOR]: Setting home location for user  " + userID);
+
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "AddUserData" },
+                        { "UserID", userID.ToString() },
+                        { "HomeLocation", SerializeLocation(regionID, position, lookAt) }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN PRESENCE CONNECTOR]: Failed to set home location for " + userID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        public bool SetLastPosition(string userID, UUID sessionID, UUID regionID, Vector3 lastPosition, Vector3 lastLookAt)
+        {
+            return UpdateSession(sessionID, regionID, lastPosition, lastLookAt);
+        }
+
+        public GridUserInfo GetGridUserInfo(string user)
+        {
+            // m_log.DebugFormat("[SIMIAN PRESENCE CONNECTOR]: Requesting session data for agent " + user); 
+
+            UUID userID = new UUID(user);
+            OSDMap userResponse = GetUserData(userID);
+
+            if (userResponse == null)
+            {
+                m_log.WarnFormat("[SIMIAN PRESENCE CONNECTOR]: Failed to retrieve user data for {0}", userID);
+            }
+
+            // Note that ResponseToGridUserInfo properly checks for and returns a null if passed a null.
+            return ResponseToGridUserInfo(userResponse);
+
+        }
+
+        #endregion
+
+        #region Helpers
+
+        private OSDMap GetUserData(UUID userID)
+        {
+            // m_log.DebugFormat("[SIMIAN PRESENCE CONNECTOR]: Requesting user data for " + userID);
+
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "GetUser" },
+                        { "UserID", userID.ToString() }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["User"] is OSDMap)
+                return response;
+
+            m_log.WarnFormat("[SIMIAN PRESENCE CONNECTOR]: Failed to retrieve user data for {0}; {1}",userID.ToString(),response["Message"].AsString());
+            return null;
+        }
+
+        private OSDMap GetSessionDataFromSessionID(UUID sessionID)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "GetSession" },
+                        { "SessionID", sessionID.ToString() }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+                return response;
+
+            m_log.WarnFormat("[SIMIAN PRESENCE CONNECTOR]: Failed to retrieve session data for {0}; {1}",sessionID.ToString(),response["Message"].AsString());
+            return null;
+        }
+
+        private bool UpdateSession(UUID sessionID, UUID regionID, Vector3 lastPosition, Vector3 lastLookAt)
+        {
+            // Save our current location as session data
+            NameValueCollection requestArgs = new NameValueCollection
+                {
+                        { "RequestMethod", "UpdateSession" },
+                        { "SessionID", sessionID.ToString() },
+                        { "SceneID", regionID.ToString() },
+                        { "ScenePosition", lastPosition.ToString() },
+                        { "SceneLookAt", lastLookAt.ToString() }
+                };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.Warn("[SIMIAN PRESENCE CONNECTOR]: Failed to update agent session " + sessionID + ": " + response["Message"].AsString());
+
+            return success;
+        }
+
+        private PresenceInfo ResponseToPresenceInfo(OSDMap sessionResponse)
+        {
+            if (sessionResponse == null)
+                return null;
+
+            PresenceInfo info = new PresenceInfo();
+
+            info.UserID = sessionResponse["UserID"].AsUUID().ToString();
+            info.RegionID = sessionResponse["SceneID"].AsUUID();
+
+            return info;
+        }
+
+        private GridUserInfo ResponseToGridUserInfo(OSDMap userResponse)
+        {
+            if (userResponse != null && userResponse["User"] is OSDMap)
+            {
+                GridUserInfo info = new GridUserInfo();
+
+                info.Online = true;
+                info.UserID = userResponse["UserID"].AsUUID().ToString();
+                info.LastRegionID = userResponse["SceneID"].AsUUID();
+                info.LastPosition = userResponse["ScenePosition"].AsVector3();
+                info.LastLookAt = userResponse["SceneLookAt"].AsVector3();
+
+                OSDMap user = (OSDMap)userResponse["User"];
+
+                info.Login = user["LastLoginDate"].AsDate();
+                info.Logout = user["LastLogoutDate"].AsDate();
+                DeserializeLocation(user["HomeLocation"].AsString(), out info.HomeRegionID, out info.HomePosition, out info.HomeLookAt);
+
+                return info;
+            }
+
+            return null;
+        }
+        
+        private string SerializeLocation(UUID regionID, Vector3 position, Vector3 lookAt)
+        {
+            return "{" + String.Format("\"SceneID\":\"{0}\",\"Position\":\"{1}\",\"LookAt\":\"{2}\"", regionID, position, lookAt) + "}";
+        }
+
+        private bool DeserializeLocation(string location, out UUID regionID, out Vector3 position, out Vector3 lookAt)
+        {
+            OSDMap map = null;
+
+            try { map = OSDParser.DeserializeJson(location) as OSDMap; }
+            catch { }
+
+            if (map != null)
+            {
+                regionID = map["SceneID"].AsUUID();
+                if (Vector3.TryParse(map["Position"].AsString(), out position) &&
+                    Vector3.TryParse(map["LookAt"].AsString(), out lookAt))
+                {
+                    return true;
+                }
+            }
+
+            regionID = UUID.Zero;
+            position = Vector3.Zero;
+            lookAt = Vector3.Zero;
+            return false;
+        }
+
+        public GridUserInfo[] GetGridUserInfo(string[] userIDs)
+        {
+            return new GridUserInfo[0];
+         }
+        #endregion Helpers
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianProfiles.cs b/OpenSim/Services/Connectors/SimianGrid/SimianProfiles.cs
new file mode 100644
index 0000000..8fc766d
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianProfiles.cs
@@ -0,0 +1,478 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Avatar profile flags
+    /// </summary>
+    [Flags]
+    public enum ProfileFlags : uint
+    {
+        AllowPublish = 1,
+        MaturePublish = 2,
+        Identified = 4,
+        Transacted = 8,
+        Online = 16
+    }
+
+    /// <summary>
+    /// Connects avatar profile and classified queries to the SimianGrid
+    /// backend
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianProfiles")]
+    public class SimianProfiles : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_serverUrl = String.Empty;
+        private bool m_Enabled = false;
+
+        #region INonSharedRegionModule
+        
+        public Type ReplaceableInterface { get { return null; } }
+        public void RegionLoaded(Scene scene) { }
+        public void Close() { }
+
+        public SimianProfiles() { }
+        public string Name { get { return "SimianProfiles"; } }
+
+        public void AddRegion(Scene scene)
+        {
+            if (m_Enabled)
+            {
+                CheckEstateManager(scene);
+                scene.EventManager.OnClientConnect += ClientConnectHandler;
+            }
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (m_Enabled)
+            {
+                scene.EventManager.OnClientConnect -= ClientConnectHandler;
+            }
+        }
+
+        #endregion INonSharedRegionModule
+
+        public SimianProfiles(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig profileConfig = source.Configs["Profiles"];
+            if (profileConfig == null)
+                return;
+
+            if (profileConfig.GetString("Module", String.Empty) != Name)
+                return;
+
+            m_log.DebugFormat("[SIMIAN PROFILES] module enabled");
+            m_Enabled = true;
+
+            IConfig gridConfig = source.Configs["UserAccountService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("UserAccountServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN PROFILES]: No UserAccountServerURI specified, disabling connector");
+        }
+
+        private void ClientConnectHandler(IClientCore clientCore)
+        {
+            if (clientCore is IClientAPI)
+            {
+                IClientAPI client = (IClientAPI)clientCore;
+
+                // Classifieds
+                client.AddGenericPacketHandler("avatarclassifiedsrequest", AvatarClassifiedsRequestHandler);
+                client.OnClassifiedInfoRequest += ClassifiedInfoRequestHandler;
+                client.OnClassifiedInfoUpdate += ClassifiedInfoUpdateHandler;
+                client.OnClassifiedDelete += ClassifiedDeleteHandler;
+
+                // Picks
+                client.AddGenericPacketHandler("avatarpicksrequest", HandleAvatarPicksRequest);
+                client.AddGenericPacketHandler("pickinforequest", HandlePickInfoRequest);
+                client.OnPickInfoUpdate += PickInfoUpdateHandler;
+                client.OnPickDelete += PickDeleteHandler;
+
+                // Notes
+                client.AddGenericPacketHandler("avatarnotesrequest", HandleAvatarNotesRequest);
+                client.OnAvatarNotesUpdate += AvatarNotesUpdateHandler;
+
+                // Profiles
+                client.OnRequestAvatarProperties += RequestAvatarPropertiesHandler;
+
+                client.OnUpdateAvatarProperties += UpdateAvatarPropertiesHandler;
+                client.OnAvatarInterestUpdate += AvatarInterestUpdateHandler;
+                client.OnUserInfoRequest += UserInfoRequestHandler;
+                client.OnUpdateUserInfo += UpdateUserInfoHandler;
+            }
+        }
+
+        #region Classifieds
+
+        private void AvatarClassifiedsRequestHandler(Object sender, string method, List<String> args)
+        {
+            if (!(sender is IClientAPI))
+                return;
+            IClientAPI client = (IClientAPI)sender;
+
+            UUID targetAvatarID;
+            if (args.Count < 1 || !UUID.TryParse(args[0], out targetAvatarID))
+            {
+                m_log.Error("[SIMIAN PROFILES]: Unrecognized arguments for " + method);
+                return;
+            }
+
+            // FIXME: Query the generic key/value store for classifieds
+            client.SendAvatarClassifiedReply(targetAvatarID, new Dictionary<UUID, string>(0));
+        }
+
+        private void ClassifiedInfoRequestHandler(UUID classifiedID, IClientAPI client)
+        {
+            // FIXME: Fetch this info
+            client.SendClassifiedInfoReply(classifiedID, UUID.Zero, 0, Utils.DateTimeToUnixTime(DateTime.UtcNow + TimeSpan.FromDays(1)),
+                0, String.Empty, String.Empty, UUID.Zero, 0, UUID.Zero, String.Empty, Vector3.Zero, String.Empty, 0, 0);
+        }
+
+        private void ClassifiedInfoUpdateHandler(UUID classifiedID, uint category, string name, string description,
+            UUID parcelID, uint parentEstate, UUID snapshotID, Vector3 globalPos, byte classifiedFlags, int price,
+            IClientAPI client)
+        {
+            // FIXME: Save this info
+        }
+
+        private void ClassifiedDeleteHandler(UUID classifiedID, IClientAPI client)
+        {
+            // FIXME: Delete the specified classified ad
+        }
+
+        #endregion Classifieds
+
+        #region Picks
+
+        private void HandleAvatarPicksRequest(Object sender, string method, List<String> args)
+        {
+            if (!(sender is IClientAPI))
+                return;
+            IClientAPI client = (IClientAPI)sender;
+
+            UUID targetAvatarID;
+            if (args.Count < 1 || !UUID.TryParse(args[0], out targetAvatarID))
+            {
+                m_log.Error("[SIMIAN PROFILES]: Unrecognized arguments for " + method);
+                return;
+            }
+
+            // FIXME: Fetch these
+            client.SendAvatarPicksReply(targetAvatarID, new Dictionary<UUID, string>(0));
+        }
+
+        private void HandlePickInfoRequest(Object sender, string method, List<String> args)
+        {
+            if (!(sender is IClientAPI))
+                return;
+            IClientAPI client = (IClientAPI)sender;
+
+            UUID avatarID;
+            UUID pickID;
+            if (args.Count < 2 || !UUID.TryParse(args[0], out avatarID) || !UUID.TryParse(args[1], out pickID))
+            {
+                m_log.Error("[SIMIAN PROFILES]: Unrecognized arguments for " + method);
+                return;
+            }
+
+            // FIXME: Fetch this
+            client.SendPickInfoReply(pickID, avatarID, false, UUID.Zero, String.Empty, String.Empty, UUID.Zero, String.Empty,
+                String.Empty, String.Empty, Vector3.Zero, 0, false);
+        }
+
+        private void PickInfoUpdateHandler(IClientAPI client, UUID pickID, UUID creatorID, bool topPick, string name,
+            string desc, UUID snapshotID, int sortOrder, bool enabled)
+        {
+            // FIXME: Save this
+        }
+
+        private void PickDeleteHandler(IClientAPI client, UUID pickID)
+        {
+            // FIXME: Delete
+        }
+
+        #endregion Picks
+
+        #region Notes
+
+        private void HandleAvatarNotesRequest(Object sender, string method, List<String> args)
+        {
+            if (!(sender is IClientAPI))
+                return;
+            IClientAPI client = (IClientAPI)sender;
+
+            UUID targetAvatarID;
+            if (args.Count < 1 || !UUID.TryParse(args[0], out targetAvatarID))
+            {
+                m_log.Error("[SIMIAN PROFILES]: Unrecognized arguments for " + method);
+                return;
+            }
+
+            // FIXME: Fetch this
+            client.SendAvatarNotesReply(targetAvatarID, String.Empty);
+        }
+
+        private void AvatarNotesUpdateHandler(IClientAPI client, UUID targetID, string notes)
+        {
+            // FIXME: Save this
+        }
+
+        #endregion Notes
+
+        #region Profiles
+
+        private void RequestAvatarPropertiesHandler(IClientAPI client, UUID avatarID)
+        {
+            m_log.DebugFormat("[SIMIAN PROFILES]: Request avatar properties for {0}",avatarID);
+            
+            OSDMap user = FetchUserData(avatarID);
+
+            ProfileFlags flags = ProfileFlags.AllowPublish | ProfileFlags.MaturePublish;
+
+            if (user != null)
+            {
+                OSDMap about = null;
+                if (user.ContainsKey("LLAbout"))
+                {
+                    try
+                    {
+                        about = OSDParser.DeserializeJson(user["LLAbout"].AsString()) as OSDMap;
+                    }
+                    catch
+                    {
+                        m_log.WarnFormat("[SIMIAN PROFILES]: Unable to decode LLAbout");
+                    }
+                }
+
+                if (about == null)
+                    about = new OSDMap(0);
+
+                // Check if this user is a grid operator
+                byte[] charterMember;
+                if (user["AccessLevel"].AsInteger() >= 200)
+                    charterMember = Utils.StringToBytes("Operator");
+                else
+                    charterMember = Utils.EmptyBytes;
+
+                // Check if the user is online
+                if (client.Scene is Scene)
+                {
+                    OpenSim.Services.Interfaces.PresenceInfo[] presences = ((Scene)client.Scene).PresenceService.GetAgents(new string[] { avatarID.ToString() });
+                    if (presences != null && presences.Length > 0)
+                        flags |= ProfileFlags.Online;
+                }
+
+                // Check if the user is identified
+                if (user["Identified"].AsBoolean())
+                    flags |= ProfileFlags.Identified;
+
+                client.SendAvatarProperties(avatarID, about["About"].AsString(), user["CreationDate"].AsDate().ToString("M/d/yyyy",
+                    System.Globalization.CultureInfo.InvariantCulture), charterMember, about["FLAbout"].AsString(), (uint)flags,
+                    about["FLImage"].AsUUID(), about["Image"].AsUUID(), about["URL"].AsString(), user["Partner"].AsUUID());
+
+                OSDMap interests = null;
+                if (user.ContainsKey("LLInterests"))
+                {
+                    try
+                    {
+                        interests = OSDParser.DeserializeJson(user["LLInterests"].AsString()) as OSDMap;
+                        client.SendAvatarInterestsReply(avatarID, interests["WantMask"].AsUInteger(), interests["WantText"].AsString(), interests["SkillsMask"].AsUInteger(), interests["SkillsText"].AsString(), interests["Languages"].AsString());
+                    }
+                    catch { }
+                }
+
+                if (about == null)
+                    about = new OSDMap(0);
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN PROFILES]: Failed to fetch profile information for " + client.Name + ", returning default values");
+                client.SendAvatarProperties(avatarID, String.Empty, "1/1/1970", Utils.EmptyBytes,
+                        String.Empty, (uint)flags, UUID.Zero, UUID.Zero, String.Empty, UUID.Zero);
+            }
+        }
+
+        private void UpdateAvatarPropertiesHandler(IClientAPI client, UserProfileData profileData)
+        {
+            OSDMap map = new OSDMap
+            {
+                { "About", OSD.FromString(profileData.AboutText) },
+                { "Image", OSD.FromUUID(profileData.Image) },
+                { "FLAbout", OSD.FromString(profileData.FirstLifeAboutText) },
+                { "FLImage", OSD.FromUUID(profileData.FirstLifeImage) },
+                { "URL", OSD.FromString(profileData.ProfileUrl) }
+            };
+
+            AddUserData(client.AgentId, "LLAbout", map);
+        }
+
+        private void AvatarInterestUpdateHandler(IClientAPI client, uint wantmask, string wanttext, uint skillsmask,
+            string skillstext, string languages)
+        {
+            OSDMap map = new OSDMap
+            {
+                { "WantMask", OSD.FromInteger(wantmask) },
+                { "WantText", OSD.FromString(wanttext) },
+                { "SkillsMask", OSD.FromInteger(skillsmask) },
+                { "SkillsText", OSD.FromString(skillstext) },
+                { "Languages", OSD.FromString(languages) }
+            };
+
+            AddUserData(client.AgentId, "LLInterests", map);
+        }
+
+        private void UserInfoRequestHandler(IClientAPI client)
+        {
+            m_log.Error("[SIMIAN PROFILES]: UserInfoRequestHandler");
+
+            // Fetch this user's e-mail address
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "UserID", client.AgentId.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            string email = response["Email"].AsString();
+
+            if (!response["Success"].AsBoolean())
+                m_log.Warn("[SIMIAN PROFILES]: GetUser failed during a user info request for " + client.Name);
+
+            client.SendUserInfoReply(false, true, email);
+        }
+
+        private void UpdateUserInfoHandler(bool imViaEmail, bool visible, IClientAPI client)
+        {
+            m_log.Info("[SIMIAN PROFILES]: Ignoring user info update from " + client.Name);
+        }
+
+        #endregion Profiles
+
+        /// <summary>
+        /// Sanity checks regions for a valid estate owner at startup
+        /// </summary>
+        private void CheckEstateManager(Scene scene)
+        {
+            EstateSettings estate = scene.RegionInfo.EstateSettings;
+
+            if (estate.EstateOwner == UUID.Zero)
+            {
+                // Attempt to lookup the grid admin
+                UserAccount admin = scene.UserAccountService.GetUserAccount(scene.RegionInfo.ScopeID, UUID.Zero);
+                if (admin != null)
+                {
+                    m_log.InfoFormat("[SIMIAN PROFILES]: Setting estate {0} (ID: {1}) owner to {2}", estate.EstateName,
+                        estate.EstateID, admin.Name);
+
+                    estate.EstateOwner = admin.PrincipalID;
+                    scene.EstateDataService.StoreEstateSettings(estate);
+                }
+                else
+                {
+                    m_log.WarnFormat("[SIMIAN PROFILES]: Estate {0} (ID: {1}) does not have an owner", estate.EstateName, estate.EstateID);
+                }
+            }
+        }
+
+        private bool AddUserData(UUID userID, string key, OSDMap value)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddUserData" },
+                { "UserID", userID.ToString() },
+                { key, OSDParser.SerializeJsonString(value) }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            bool success = response["Success"].AsBoolean();
+
+            if (!success)
+                m_log.WarnFormat("[SIMIAN PROFILES]: Failed to add user data with key {0} for {1}: {2}", key, userID, response["Message"].AsString());
+
+            return success;
+        }
+
+        private OSDMap FetchUserData(UUID userID)
+        {
+            m_log.DebugFormat("[SIMIAN PROFILES]: Fetch information about {0}",userID);
+            
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "UserID", userID.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean() && response["User"] is OSDMap)
+            {
+                return (OSDMap)response["User"];
+            }
+            else
+            {
+                m_log.Error("[SIMIAN PROFILES]: Failed to fetch user data for " + userID + ": " + response["Message"].AsString());
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianUserAccountServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianUserAccountServiceConnector.cs
new file mode 100644
index 0000000..698c4c0
--- /dev/null
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianUserAccountServiceConnector.cs
@@ -0,0 +1,337 @@
+/*
+ * 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.Reflection;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Services.Connectors.SimianGrid
+{
+    /// <summary>
+    /// Connects user account data (creating new users, looking up existing 
+    /// users) to the SimianGrid backend
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianUserAccountServiceConnector")]
+    public class SimianUserAccountServiceConnector : IUserAccountService, ISharedRegionModule
+    {
+        private const double CACHE_EXPIRATION_SECONDS = 120.0;
+
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_serverUrl = String.Empty;
+        private ExpiringCache<UUID, UserAccount> m_accountCache = new ExpiringCache<UUID,UserAccount>();
+        private bool m_Enabled;
+
+        #region ISharedRegionModule
+
+        public Type ReplaceableInterface { get { return null; } }
+        public void RegionLoaded(Scene scene) { }
+        public void PostInitialise() { }
+        public void Close() { }
+
+        public SimianUserAccountServiceConnector() { }
+        public string Name { get { return "SimianUserAccountServiceConnector"; } }
+        public void AddRegion(Scene scene) { if (m_Enabled) { scene.RegisterModuleInterface<IUserAccountService>(this); } }
+        public void RemoveRegion(Scene scene) { if (m_Enabled) { scene.UnregisterModuleInterface<IUserAccountService>(this); } }
+
+        #endregion ISharedRegionModule
+
+        public SimianUserAccountServiceConnector(IConfigSource source)
+        {
+            CommonInit(source);
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("UserAccountServices", "");
+                if (name == Name)
+                    CommonInit(source);
+            }
+        }
+
+        private void CommonInit(IConfigSource source)
+        {
+            IConfig gridConfig = source.Configs["UserAccountService"];
+            if (gridConfig != null)
+            {
+                string serviceUrl = gridConfig.GetString("UserAccountServerURI");
+                if (!String.IsNullOrEmpty(serviceUrl))
+                {
+                    if (!serviceUrl.EndsWith("/") && !serviceUrl.EndsWith("="))
+                        serviceUrl = serviceUrl + '/';
+                    m_serverUrl = serviceUrl;
+                    m_Enabled = true;
+                }
+            }
+
+            if (String.IsNullOrEmpty(m_serverUrl))
+                m_log.Info("[SIMIAN ACCOUNT CONNECTOR]: No UserAccountServerURI specified, disabling connector");
+        }
+
+        public UserAccount GetUserAccount(UUID scopeID, string firstName, string lastName)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "Name", firstName + ' ' + lastName }
+            };
+
+            return GetUser(requestArgs);
+        }
+
+        public UserAccount GetUserAccount(UUID scopeID, string email)
+        {
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "Email", email }
+            };
+
+            return GetUser(requestArgs);
+        }
+
+        public UserAccount GetUserAccount(UUID scopeID, UUID userID)
+        {
+            // Cache check
+            UserAccount account;
+            if (m_accountCache.TryGetValue(userID, out account))
+                return account;
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUser" },
+                { "UserID", userID.ToString() }
+            };
+
+            account = GetUser(requestArgs);
+
+            if (account == null)
+            {
+                // Store null responses too, to avoid repeated lookups for missing accounts
+                m_accountCache.AddOrUpdate(userID, null, CACHE_EXPIRATION_SECONDS);
+            }
+
+            return account;
+        }
+
+        public List<UserAccount> GetUserAccounts(UUID scopeID, string query)
+        {
+            List<UserAccount> accounts = new List<UserAccount>();
+
+//            m_log.DebugFormat("[SIMIAN ACCOUNT CONNECTOR]: Searching for user accounts with name query " + query);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetUsers" },
+                { "NameQuery", query }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                OSDArray array = response["Users"] as OSDArray;
+                if (array != null && array.Count > 0)
+                {
+                    for (int i = 0; i < array.Count; i++)
+                    {
+                        UserAccount account = ResponseToUserAccount(array[i] as OSDMap);
+                        if (account != null)
+                            accounts.Add(account);
+                    }
+                }
+                else
+                {
+                    m_log.Warn("[SIMIAN ACCOUNT CONNECTOR]: Account search failed, response data was in an invalid format");
+                }
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN ACCOUNT CONNECTOR]: Failed to search for account data by name " + query);
+            }
+
+            return accounts;
+        }
+
+        public void InvalidateCache(UUID userID)
+        {
+            m_accountCache.Remove(userID);
+        }
+
+        public bool StoreUserAccount(UserAccount data)
+        {
+//            m_log.InfoFormat("[SIMIAN ACCOUNT CONNECTOR]: Storing user account for " + data.Name);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddUser" },
+                { "UserID", data.PrincipalID.ToString() },
+                { "Name", data.Name },
+                { "Email", data.Email },
+                { "AccessLevel", data.UserLevel.ToString() }
+            };
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            
+            if (response["Success"].AsBoolean())
+            {
+                m_log.InfoFormat("[SIMIAN ACCOUNT CONNECTOR]: Storing user account data for " + data.Name);
+
+                requestArgs = new NameValueCollection
+                {
+                    { "RequestMethod", "AddUserData" },
+                    { "UserID", data.PrincipalID.ToString() },
+                    { "CreationDate", data.Created.ToString() },
+                    { "UserFlags", data.UserFlags.ToString() },
+                    { "UserTitle", data.UserTitle }
+                };
+
+                response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+                bool success = response["Success"].AsBoolean();
+
+                if (success)
+                {
+                    // Cache the user account info
+                    m_accountCache.AddOrUpdate(data.PrincipalID, data, CACHE_EXPIRATION_SECONDS);
+                }
+                else
+                {
+                    m_log.Warn("[SIMIAN ACCOUNT CONNECTOR]: Failed to store user account data for " + data.Name + ": " + response["Message"].AsString());
+                }
+
+                return success;
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN ACCOUNT CONNECTOR]: Failed to store user account for " + data.Name + ": " + response["Message"].AsString());
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Helper method for the various ways of retrieving a user account
+        /// </summary>
+        /// <param name="requestArgs">Service query parameters</param>
+        /// <returns>A UserAccount object on success, null on failure</returns>
+        private UserAccount GetUser(NameValueCollection requestArgs)
+        {
+            string lookupValue = (requestArgs.Count > 1) ? requestArgs[1] : "(Unknown)";
+//            m_log.DebugFormat("[SIMIAN ACCOUNT CONNECTOR]: Looking up user account with query: " + lookupValue);
+
+            OSDMap response = SimianGrid.PostToService(m_serverUrl, requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                OSDMap user = response["User"] as OSDMap;
+                if (user != null)
+                    return ResponseToUserAccount(user);
+                else
+                    m_log.Warn("[SIMIAN ACCOUNT CONNECTOR]: Account search failed, response data was in an invalid format");
+            }
+            else
+            {
+                m_log.Warn("[SIMIAN ACCOUNT CONNECTOR]: Failed to lookup user account with query: " + lookupValue);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Convert a User object in LLSD format to a UserAccount
+        /// </summary>
+        /// <param name="response">LLSD containing user account data</param>
+        /// <returns>A UserAccount object on success, null on failure</returns>
+        private UserAccount ResponseToUserAccount(OSDMap response)
+        {
+            if (response == null)
+                return null;
+
+            UserAccount account = new UserAccount();
+            account.PrincipalID = response["UserID"].AsUUID();
+            account.Created = response["CreationDate"].AsInteger();
+            account.Email = response["Email"].AsString();
+            account.ServiceURLs = new Dictionary<string, object>(0);
+            account.UserFlags = response["UserFlags"].AsInteger();
+            account.UserLevel = response["AccessLevel"].AsInteger();
+            account.UserTitle = response["UserTitle"].AsString();
+            account.LocalToGrid = true;
+            if (response.ContainsKey("LocalToGrid"))
+                account.LocalToGrid = (response["LocalToGrid"].AsString() == "true" ? true : false);
+                
+            GetFirstLastName(response["Name"].AsString(), out account.FirstName, out account.LastName);
+
+            // Cache the user account info
+            m_accountCache.AddOrUpdate(account.PrincipalID, account, CACHE_EXPIRATION_SECONDS);
+
+            return account;
+        }
+
+        /// <summary>
+        /// Convert a name with a single space in it to a first and last name
+        /// </summary>
+        /// <param name="name">A full name such as "John Doe"</param>
+        /// <param name="firstName">First name</param>
+        /// <param name="lastName">Last name (surname)</param>
+        private static void GetFirstLastName(string name, out string firstName, out string lastName)
+        {
+            if (String.IsNullOrEmpty(name))
+            {
+                firstName = String.Empty;
+                lastName = String.Empty;
+            }
+            else
+            {
+                string[] names = name.Split(' ');
+
+                if (names.Length == 2)
+                {
+                    firstName = names[0];
+                    lastName = names[1];
+                }
+                else
+                {
+                    firstName = String.Empty;
+                    lastName = name;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs b/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
new file mode 100644
index 0000000..1eedbef
--- /dev/null
+++ b/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
@@ -0,0 +1,482 @@
+/*
+ * 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 System.Text;
+using System.Collections;
+
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Services.Connectors.Simulation
+{
+    public class SimulationServiceConnector : ISimulationService
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // we use this dictionary to track the pending updateagent requests, maps URI --> position update
+        private Dictionary<string,AgentPosition> m_updateAgentQueue = new Dictionary<string,AgentPosition>();
+        
+        //private GridRegion m_Region;
+
+        public SimulationServiceConnector()
+        {
+        }
+
+        public SimulationServiceConnector(IConfigSource config)
+        {
+            //m_Region = region;
+        }
+
+        public IScene GetScene(UUID regionId)
+        {
+            return null;
+        }
+
+        public ISimulationService GetInnerService()
+        {
+            return null;
+        }
+
+        #region Agents
+
+        protected virtual string AgentPath()
+        {
+            return "agent/";
+        }
+
+        protected virtual void PackData(OSDMap args, GridRegion source, AgentCircuitData aCircuit, GridRegion destination, uint flags)
+        {
+            if (source != null)
+            {
+                args["source_x"] = OSD.FromString(source.RegionLocX.ToString());
+                args["source_y"] = OSD.FromString(source.RegionLocY.ToString());
+                args["source_name"] = OSD.FromString(source.RegionName);
+                args["source_uuid"] = OSD.FromString(source.RegionID.ToString());
+                if (!String.IsNullOrEmpty(source.RawServerURI))
+                    args["source_server_uri"] = OSD.FromString(source.RawServerURI);
+            }
+
+            args["destination_x"] = OSD.FromString(destination.RegionLocX.ToString());
+            args["destination_y"] = OSD.FromString(destination.RegionLocY.ToString());
+            args["destination_name"] = OSD.FromString(destination.RegionName);
+            args["destination_uuid"] = OSD.FromString(destination.RegionID.ToString());
+            args["teleport_flags"] = OSD.FromString(flags.ToString());
+        }
+
+        public bool CreateAgent(GridRegion source, GridRegion destination, AgentCircuitData aCircuit, uint flags, out string reason)
+        {
+            string tmp = String.Empty;
+            return CreateAgent(source, destination, aCircuit, flags, out tmp, out reason);
+        }
+
+        public bool CreateAgent(GridRegion source, GridRegion destination, AgentCircuitData aCircuit, uint flags, out string myipaddress, out string reason)
+        {
+            m_log.DebugFormat("[REMOTE SIMULATION CONNECTOR]: Creating agent at {0}", destination.ServerURI);
+            reason = String.Empty;
+            myipaddress = String.Empty;
+
+            if (destination == null)
+            {
+                m_log.Debug("[REMOTE SIMULATION CONNECTOR]: Given destination is null");
+                return false;
+            }
+
+            string uri = destination.ServerURI + AgentPath() + aCircuit.AgentID + "/";
+            
+            try
+            {
+                OSDMap args = aCircuit.PackAgentCircuitData();
+                PackData(args, source, aCircuit, destination, flags);
+
+                OSDMap result = WebUtil.PostToServiceCompressed(uri, args, 30000);
+                bool success = result["success"].AsBoolean();
+                if (success && result.ContainsKey("_Result"))
+                {
+                    OSDMap data = (OSDMap)result["_Result"];
+
+                    reason = data["reason"].AsString();
+                    success = data["success"].AsBoolean();
+                    myipaddress = data["your_ip"].AsString();
+                    return success;
+                }
+              
+                // Try the old version, uncompressed
+                result = WebUtil.PostToService(uri, args, 30000, false);
+
+                if (result["Success"].AsBoolean())
+                {
+                    if (result.ContainsKey("_Result"))
+                    {
+                        OSDMap data = (OSDMap)result["_Result"];
+
+                        reason = data["reason"].AsString();
+                        success = data["success"].AsBoolean();
+                        myipaddress = data["your_ip"].AsString();
+                        m_log.WarnFormat(
+                            "[REMOTE SIMULATION CONNECTOR]: Remote simulator {0} did not accept compressed transfer, suggest updating it.", destination.RegionName);
+                        return success;
+                    }
+                }
+                
+                m_log.WarnFormat(
+                    "[REMOTE SIMULATION CONNECTOR]: Failed to create agent {0} {1} at remote simulator {2}", 
+                    aCircuit.firstname, aCircuit.lastname, destination.RegionName);                       
+                reason = result["Message"] != null ? result["Message"].AsString() : "error";
+                return false;
+            }
+            catch (Exception e)
+            {
+                m_log.Warn("[REMOTE SIMULATION CONNECTOR]: CreateAgent failed with exception: " + e.ToString());
+                reason = e.Message;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Send complete data about an agent in this region to a neighbor
+        /// </summary>
+        public bool UpdateAgent(GridRegion destination, AgentData data)
+        {
+            return UpdateAgent(destination, (IAgentData)data, 200000); // yes, 200 seconds
+        }
+
+        private ExpiringCache<string, bool> _failedSims = new ExpiringCache<string, bool>();
+        /// <summary>
+        /// Send updated position information about an agent in this region to a neighbor
+        /// This operation may be called very frequently if an avatar is moving about in
+        /// the region.
+        /// </summary>
+        public bool UpdateAgent(GridRegion destination, AgentPosition data)
+        {
+            bool v = true;
+            if (_failedSims.TryGetValue(destination.ServerURI, out v))
+                return false;
+
+            // The basic idea of this code is that the first thread that needs to
+            // send an update for a specific avatar becomes the worker for any subsequent
+            // requests until there are no more outstanding requests. Further, only send the most
+            // recent update; this *should* never be needed but some requests get
+            // slowed down and once that happens the problem with service end point
+            // limits kicks in and nothing proceeds
+            string uri = destination.ServerURI + AgentPath() + data.AgentID + "/";
+            lock (m_updateAgentQueue)
+            {
+                if (m_updateAgentQueue.ContainsKey(uri))
+                {
+                    // Another thread is already handling 
+                    // updates for this simulator, just update 
+                    // the position and return, overwrites are
+                    // not a problem since we only care about the
+                    // last update anyway
+                    m_updateAgentQueue[uri] = data;
+                    return true;
+                }
+
+                // Otherwise update the reference and start processing
+                m_updateAgentQueue[uri] = data;
+            }
+
+            AgentPosition pos = null;
+            bool success = true;
+            while (success)
+            {
+                lock (m_updateAgentQueue)
+                {
+                    // save the position
+                    AgentPosition lastpos = pos;
+
+                    pos = m_updateAgentQueue[uri];
+
+                    // this is true if no one put a new
+                    // update in the map since the last
+                    // one we processed, if thats the
+                    // case then we are done
+                    if (pos == lastpos)
+                    {
+                        m_updateAgentQueue.Remove(uri);
+                        return true;
+                    }
+                }
+
+                success = UpdateAgent(destination, (IAgentData)pos, 10000);
+            }
+            // we get here iff success == false
+            // blacklist sim for 2 minutes
+            lock (m_updateAgentQueue)
+            {
+                _failedSims.AddOrUpdate(destination.ServerURI, true, 120);
+                m_updateAgentQueue.Remove(uri);
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// This is the worker function to send AgentData to a neighbor region
+        /// </summary>
+        private bool UpdateAgent(GridRegion destination, IAgentData cAgentData, int timeout)
+        {
+            // m_log.DebugFormat("[REMOTE SIMULATION CONNECTOR]: UpdateAgent in {0}", destination.ServerURI);
+
+            // Eventually, we want to use a caps url instead of the agentID
+            string uri = destination.ServerURI + AgentPath() + cAgentData.AgentID + "/";
+
+            try
+            {
+                OSDMap args = cAgentData.Pack();
+
+                args["destination_x"] = OSD.FromString(destination.RegionLocX.ToString());
+                args["destination_y"] = OSD.FromString(destination.RegionLocY.ToString());
+                args["destination_name"] = OSD.FromString(destination.RegionName);
+                args["destination_uuid"] = OSD.FromString(destination.RegionID.ToString());
+
+                OSDMap result = WebUtil.PutToServiceCompressed(uri, args, timeout);
+                if (result["Success"].AsBoolean())
+                    return true;
+
+                result = WebUtil.PutToService(uri, args, timeout);
+
+                return result["Success"].AsBoolean();
+            }
+            catch (Exception e)
+            {
+                m_log.Warn("[REMOTE SIMULATION CONNECTOR]: UpdateAgent failed with exception: " + e.ToString());
+            }
+
+            return false;
+        }
+
+
+        public bool QueryAccess(GridRegion destination, UUID agentID, string agentHomeURI, bool viaTeleport, Vector3 position, string myversion, List<UUID> featuresAvailable, out string version, out string reason)
+        {
+            reason = "Failed to contact destination";
+            version = "Unknown";
+
+            // m_log.DebugFormat("[REMOTE SIMULATION CONNECTOR]: QueryAccess start, position={0}", position);
+
+            IPEndPoint ext = destination.ExternalEndPoint;
+            if (ext == null) return false;
+
+            // Eventually, we want to use a caps url instead of the agentID
+            string uri = destination.ServerURI + AgentPath() + agentID + "/" + destination.RegionID.ToString() + "/";
+
+            OSDMap request = new OSDMap();
+            request.Add("viaTeleport", OSD.FromBoolean(viaTeleport));
+            request.Add("position", OSD.FromString(position.ToString()));
+            request.Add("my_version", OSD.FromString(myversion));
+
+            OSDArray features = new OSDArray();
+            foreach (UUID feature in featuresAvailable)
+                features.Add(OSD.FromString(feature.ToString()));
+
+            request.Add("features", features);
+
+            if (agentHomeURI != null)
+                request.Add("agent_home_uri", OSD.FromString(agentHomeURI));
+
+            try
+            {
+                OSDMap result = WebUtil.ServiceOSDRequest(uri, request, "QUERYACCESS", 30000, false, false);
+                bool success = result["success"].AsBoolean();
+                if (result.ContainsKey("_Result"))
+                {
+                    OSDMap data = (OSDMap)result["_Result"];
+
+                    // FIXME: If there is a _Result map then it's the success key here that indicates the true success
+                    // or failure, not the sibling result node.
+                    success = data["success"];
+
+                    reason = data["reason"].AsString();
+                    if (data["version"] != null && data["version"].AsString() != string.Empty)
+                        version = data["version"].AsString();
+
+                    m_log.DebugFormat(
+                        "[REMOTE SIMULATION CONNECTOR]: QueryAccess to {0} returned {1}, reason {2}, version {3} ({4})",
+                        uri, success, reason, version, data["version"].AsString());
+                }
+
+                if (!success)
+                {
+                    // If we don't check this then OpenSimulator 0.7.3.1 and some period before will never see the
+                    // actual failure message
+                    if (!result.ContainsKey("_Result"))
+                    {
+                        if (result.ContainsKey("Message"))
+                        {
+                            string message = result["Message"].AsString();
+                            if (message == "Service request failed: [MethodNotAllowed] MethodNotAllowed") // Old style region
+                            {
+                                m_log.Info("[REMOTE SIMULATION CONNECTOR]: The above web util error was caused by a TP to a sim that doesn't support QUERYACCESS and can be ignored");
+                                return true;
+                            }
+    
+                            reason = result["Message"];
+                        }
+                        else
+                        {
+                            reason = "Communications failure";
+                        }
+                    }
+
+                    return false;
+                }
+
+
+                featuresAvailable.Clear();
+
+                if (result.ContainsKey("features"))
+                {
+                    OSDArray array = (OSDArray)result["features"];
+
+                    foreach (OSD o in array)
+                        featuresAvailable.Add(new UUID(o.AsString()));
+                }
+
+                return success;
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR] QueryAcesss failed with exception; {0}",e.ToString());
+            }
+            
+            return false;
+        }
+
+        /// <summary>
+        /// </summary>
+        public bool ReleaseAgent(UUID origin, UUID id, string uri)
+        {
+            // m_log.DebugFormat("[REMOTE SIMULATION CONNECTOR]: ReleaseAgent start");
+
+            try
+            {
+                WebUtil.ServiceOSDRequest(uri, null, "DELETE", 10000, false, false);
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR] ReleaseAgent failed with exception; {0}",e.ToString());
+            }
+            
+            return true;
+        }
+
+        /// <summary>
+        /// </summary>
+        public bool CloseAgent(GridRegion destination, UUID id, string auth_code)
+        {
+            string uri = destination.ServerURI + AgentPath() + id + "/" + destination.RegionID.ToString() + "/?auth=" + auth_code;
+            m_log.DebugFormat("[REMOTE SIMULATION CONNECTOR]: CloseAgent {0}", uri);
+
+            try
+            {
+                WebUtil.ServiceOSDRequest(uri, null, "DELETE", 10000, false, false);
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR] CloseAgent failed with exception; {0}",e.ToString());
+            }
+
+            return true;
+        }
+
+        #endregion Agents
+
+        #region Objects
+
+        protected virtual string ObjectPath()
+        {
+            return "object/";
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public bool CreateObject(GridRegion destination, Vector3 newPosition, ISceneObject sog, bool isLocalCall)
+        {
+            // m_log.DebugFormat("[REMOTE SIMULATION CONNECTOR]: CreateObject start");
+
+            string uri = destination.ServerURI + ObjectPath() + sog.UUID + "/";
+
+            try
+            {
+                OSDMap args = new OSDMap(2);
+
+                args["sog"] = OSD.FromString(sog.ToXml2());
+                args["extra"] = OSD.FromString(sog.ExtraToXmlString());
+                args["modified"] = OSD.FromBoolean(sog.HasGroupChanged);
+                args["new_position"] = newPosition.ToString();
+
+                string state = sog.GetStateSnapshot();
+                if (state.Length > 0)
+                    args["state"] = OSD.FromString(state);
+
+                // Add the input general arguments
+                args["destination_x"] = OSD.FromString(destination.RegionLocX.ToString());
+                args["destination_y"] = OSD.FromString(destination.RegionLocY.ToString());
+                args["destination_name"] = OSD.FromString(destination.RegionName);
+                args["destination_uuid"] = OSD.FromString(destination.RegionID.ToString());
+
+                OSDMap result = WebUtil.PostToService(uri, args, 40000, false);
+
+                if (result == null)
+                    return false;
+                bool success = result["success"].AsBoolean();
+                if (!success)
+                    return false;
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR] CreateObject failed with exception; {0}",e.ToString());
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public bool CreateObject(GridRegion destination, UUID userID, UUID itemID)
+        {
+            // TODO, not that urgent
+            return false;
+        }
+
+        #endregion Objects
+    }
+}
diff --git a/OpenSim/Services/Connectors/UserAccounts/UserAccountServicesConnector.cs b/OpenSim/Services/Connectors/UserAccounts/UserAccountServicesConnector.cs
new file mode 100644
index 0000000..560e6c4
--- /dev/null
+++ b/OpenSim/Services/Connectors/UserAccounts/UserAccountServicesConnector.cs
@@ -0,0 +1,328 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+
+namespace OpenSim.Services.Connectors
+{
+    public class UserAccountServicesConnector : BaseServiceConnector, IUserAccountService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_ServerURI = String.Empty;
+
+        public UserAccountServicesConnector()
+        {
+        }
+
+        public UserAccountServicesConnector(string serverURI)
+        {
+            m_ServerURI = serverURI.TrimEnd('/');
+        }
+
+        public UserAccountServicesConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig assetConfig = source.Configs["UserAccountService"];
+            if (assetConfig == null)
+            {
+                m_log.Error("[ACCOUNT CONNECTOR]: UserAccountService missing from OpenSim.ini");
+                throw new Exception("User account connector init error");
+            }
+
+            string serviceURI = assetConfig.GetString("UserAccountServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[ACCOUNT CONNECTOR]: No Server URI named in section UserAccountService");
+                throw new Exception("User account connector init error");
+            }
+            m_ServerURI = serviceURI;
+
+            base.Initialise(source, "UserAccountService");
+        }
+
+        public virtual UserAccount GetUserAccount(UUID scopeID, string firstName, string lastName)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getaccount";
+
+            sendData["ScopeID"] = scopeID;
+            sendData["FirstName"] = firstName.ToString();
+            sendData["LastName"] = lastName.ToString();
+
+            return SendAndGetReply(sendData);
+        }
+
+        public virtual UserAccount GetUserAccount(UUID scopeID, string email)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getaccount";
+
+            sendData["ScopeID"] = scopeID;
+            sendData["Email"] = email;
+
+            return SendAndGetReply(sendData);
+        }
+
+        public virtual UserAccount GetUserAccount(UUID scopeID, UUID userID)
+        {
+            //m_log.DebugFormat("[ACCOUNTS CONNECTOR]: GetUserAccount {0}", userID);
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getaccount";
+
+            sendData["ScopeID"] = scopeID;
+            sendData["UserID"] = userID.ToString();
+
+            return SendAndGetReply(sendData);
+        }
+
+        public List<UserAccount> GetUserAccounts(UUID scopeID, string query)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "getaccounts";
+
+            sendData["ScopeID"] = scopeID.ToString();
+            sendData["query"] = query;
+
+            string reply = string.Empty;
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/accounts";
+            // m_log.DebugFormat("[ACCOUNTS CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply == null || (reply != null && reply == string.Empty))
+                {
+                    m_log.DebugFormat("[ACCOUNT CONNECTOR]: GetUserAccounts received null or empty reply");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[ACCOUNT CONNECTOR]: Exception when contacting user accounts server at {0}: {1}", uri, e.Message);
+            }
+
+            List<UserAccount> accounts = new List<UserAccount>();
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+            if (replyData != null)
+            {
+                if (replyData.ContainsKey("result") && replyData["result"].ToString() == "null")
+                {
+                    return accounts;
+                }
+
+                Dictionary<string, object>.ValueCollection accountList = replyData.Values;
+                //m_log.DebugFormat("[ACCOUNTS CONNECTOR]: GetAgents returned {0} elements", pinfosList.Count);
+                foreach (object acc in accountList)
+                {
+                    if (acc is Dictionary<string, object>)
+                    {
+                        UserAccount pinfo = new UserAccount((Dictionary<string, object>)acc);
+                        accounts.Add(pinfo);
+                    }
+                    else
+                        m_log.DebugFormat("[ACCOUNT CONNECTOR]: GetUserAccounts received invalid response type {0}",
+                            acc.GetType());
+                }
+            }
+            else
+                m_log.DebugFormat("[ACCOUNTS CONNECTOR]: GetUserAccounts received null response");
+
+            return accounts;
+        }
+
+        public void InvalidateCache(UUID userID)
+        {
+        }
+
+        public virtual bool StoreUserAccount(UserAccount data)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "setaccount";
+
+            Dictionary<string, object> structData = data.ToKeyValuePairs();
+
+            foreach (KeyValuePair<string, object> kvp in structData)
+            {
+                if (kvp.Value == null)
+                {
+                    m_log.DebugFormat("[ACCOUNTS CONNECTOR]: Null value for {0}", kvp.Key);
+                    continue;
+                }
+                sendData[kvp.Key] = kvp.Value.ToString();
+            }
+
+            if (SendAndGetReply(sendData) != null)
+                return true;
+            else
+                return false;
+        }
+
+        /// <summary>
+        /// Create user remotely. Note this this is not part of the IUserAccountsService
+        /// </summary>
+        /// <param name="first"></param>
+        /// <param name="last"></param>
+        /// <param name="password"></param>
+        /// <param name="email"></param>
+        /// <param name="scopeID"></param>
+        /// <returns></returns>
+        public virtual UserAccount CreateUser(string first, string last, string password, string email, UUID scopeID)
+        {
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            //sendData["SCOPEID"] = scopeID.ToString();
+            sendData["VERSIONMIN"] = ProtocolVersions.ClientProtocolVersionMin.ToString();
+            sendData["VERSIONMAX"] = ProtocolVersions.ClientProtocolVersionMax.ToString();
+            sendData["METHOD"] = "createuser";
+
+            sendData["FirstName"] = first;
+            sendData["LastName"] = last;
+            sendData["Password"] = password;
+            if (!string.IsNullOrEmpty(email))
+                sendData["Email"] = first;
+            sendData["ScopeID"] = scopeID.ToString();
+
+            return SendAndGetReply(sendData);
+        }
+        
+        private UserAccount SendAndGetReply(Dictionary<string, object> sendData)
+        {
+            string reply = string.Empty;
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/accounts";
+            // m_log.DebugFormat("[ACCOUNTS CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply == null || (reply != null && reply == string.Empty))
+                {
+                    m_log.DebugFormat("[ACCOUNT CONNECTOR]: GetUserAccount received null or empty reply");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[ACCOUNT CONNECTOR]: Exception when contacting user accounts server at {0}: {1}", uri, e.Message);
+            }
+
+            Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+            UserAccount account = null;
+
+            if ((replyData != null) && replyData.ContainsKey("result") && (replyData["result"] != null))
+            {
+                if (replyData["result"] is Dictionary<string, object>)
+                {
+                    account = new UserAccount((Dictionary<string, object>)replyData["result"]);
+                }
+            }
+
+            return account;
+
+        }
+
+        private bool SendAndGetBoolReply(Dictionary<string, object> sendData)
+        {
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/accounts";
+            //m_log.DebugFormat("[ACCOUNTS CONNECTOR]: queryString = {0}", reqString);
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString,
+                        m_Auth);
+                if (reply != string.Empty)
+                {
+                    //m_log.DebugFormat("[ACCOUNTS CONNECTOR]: reply = {0}", reply);
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("result"))
+                    {
+                        if (replyData["result"].ToString().ToLower() == "success")
+                            return true;
+                        else
+                            return false;
+                    }
+                    else
+                        m_log.DebugFormat("[ACCOUNTS CONNECTOR]: Set or Create UserAccount reply data does not contain result field");
+
+                }
+                else
+                    m_log.DebugFormat("[ACCOUNTS CONNECTOR]: Set or Create UserAccount received empty reply");
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[ACCOUNT CONNECTOR]: Exception when contacting user accounts server at {0}: {1}", uri, e.Message);
+            }
+
+            return false;
+        }
+
+    }
+}