Merge branch 'presence-refactor' of melanie@opensimulator.org:/var/git/opensim into presence-refactor

8 files changed, 543 insertions, 26 deletions

diff --git a/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs
new file mode 100644
index 0000000..a8d9292
--- /dev/null
+++ b/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs
@@ -0,0 +1,119 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using OpenMetaverse;
+using Nwc.XmlRpc;
+
+using OpenSim.Services.Connectors.Simulation;
+
+namespace OpenSim.Services.Connectors.Hypergrid
+{
+    public class GatekeeperServiceConnector : SimulationServiceConnector
+    {
+        protected override string AgentPath()
+        {
+            return "/foreignagent/";
+        }
+
+        protected override string ObjectPath()
+        {
+            return "/foreignobject/";
+        }
+
+        public GridRegion GetHomeRegion(GridRegion gatekeeper, UUID userID, out Vector3 position, out Vector3 lookAt)
+        {
+            position = Vector3.UnitY; lookAt = Vector3.UnitY;
+
+            Hashtable hash = new Hashtable();
+            hash["userID"] = userID.ToString();
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("get_home_region", paramList);
+            string uri = "http://" + gatekeeper.ExternalHostName + ":" + gatekeeper.HttpPort + "/";
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(uri, 10000);
+            }
+            catch (Exception e)
+            {
+                return null;
+            }
+
+            if (response.IsFault)
+            {
+                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 (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["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["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;
+                }
+
+            }
+            catch (Exception e)
+            {
+                return null;
+            }
+
+            return null;
+
+        }
+    }
+}
diff --git a/OpenSim/Services/Connectors/Hypergrid/HomeUsersSecurityServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/HomeUsersSecurityServiceConnector.cs
new file mode 100644
index 0000000..150690b
--- /dev/null
+++ b/OpenSim/Services/Connectors/Hypergrid/HomeUsersSecurityServiceConnector.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+
+using OpenSim.Services.Interfaces;
+
+using OpenMetaverse;
+using log4net;
+using Nwc.XmlRpc;
+using Nini.Config;
+
+namespace OpenSim.Services.Connectors.Hypergrid
+{
+    public class HomeUsersSecurityServiceConnector : IHomeUsersSecurityService
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(
+            MethodBase.GetCurrentMethod().DeclaringType);
+
+        string m_ServerURL;
+        public HomeUsersSecurityServiceConnector(string url)
+        {
+            m_ServerURL = url;
+        }
+
+        public HomeUsersSecurityServiceConnector(IConfigSource config)
+        {
+        }
+
+        public void SetEndPoint(UUID sessionID, IPEndPoint ep)
+        {
+            Hashtable hash = new Hashtable();
+            hash["sessionID"] = sessionID.ToString();
+            hash["ep_addr"] = ep.Address.ToString();
+            hash["ep_port"] = ep.Port.ToString();
+
+            Call("ep_set",  hash);
+        }
+
+        public void RemoveEndPoint(UUID sessionID)
+        {
+            Hashtable hash = new Hashtable();
+            hash["sessionID"] = sessionID.ToString();
+
+            Call("ep_remove", hash);
+        }
+
+        public IPEndPoint GetEndPoint(UUID sessionID)
+        {
+            Hashtable hash = new Hashtable();
+            hash["sessionID"] = sessionID.ToString();
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("ep_get", paramList);
+            //m_log.Debug("[HGrid]: Linking to " + uri);
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(m_ServerURL, 10000);
+            }
+            catch (Exception e)
+            {
+                m_log.Debug("[HGrid]: Exception " + e.Message);
+                return null;
+            }
+
+            if (response.IsFault)
+            {
+                m_log.ErrorFormat("[HGrid]: 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 (success)
+                {
+                    IPEndPoint ep = null;
+                    int port = 0;
+                    if (hash["ep_port"] != null)
+                        Int32.TryParse((string)hash["ep_port"], out port);
+                    if (hash["ep_addr"] != null)
+                        ep = new IPEndPoint(IPAddress.Parse((string)hash["ep_addr"]), port);
+
+                    return ep;
+                }
+
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[HGrid]: Got exception while parsing GetEndPoint response " + e.StackTrace);
+                return null;
+            }
+
+            return null;
+        }
+
+        private void Call(string method, Hashtable hash)
+        {
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest(method, paramList);
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(m_ServerURL, 10000);
+            }
+            catch (Exception e)
+            {
+                m_log.Debug("[HGrid]: Exception " + e.Message);
+                return ;
+            }
+
+            if (response.IsFault)
+            {
+                m_log.ErrorFormat("[HGrid]: remote call returned an error: {0}", response.FaultString);
+                return ;
+            }
+
+        }
+
+    }
+}
diff --git a/OpenSim/Services/Connectors/Hypergrid/HypergridServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/HypergridServiceConnector.cs
index 953c7bd..1786d38 100644
--- a/OpenSim/Services/Connectors/Hypergrid/HypergridServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Hypergrid/HypergridServiceConnector.cs
@@ -41,22 +41,49 @@ using OpenMetaverse;
 using OpenMetaverse.Imaging;
 using log4net;
 using Nwc.XmlRpc;
+using Nini.Config;
 
 namespace OpenSim.Services.Connectors.Hypergrid
 {
-    public class HypergridServiceConnector
+    public class HypergridServiceConnector : IHypergridService
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private IAssetService m_AssetService;
+        private string m_ServerURL;
 
-        public HypergridServiceConnector() : this(null) { }
+        public HypergridServiceConnector() { }
 
-        public HypergridServiceConnector(IAssetService assService)
+        public HypergridServiceConnector(IAssetService assService) 
         {
             m_AssetService = assService;
         }
 
+        public HypergridServiceConnector(IConfigSource source)
+        {
+            Initialise(source);
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig hgConfig = source.Configs["HypergridService"];
+            if (hgConfig == null)
+            {
+                m_log.Error("[HYPERGRID CONNECTOR]: HypergridService missing from OpenSim.ini");
+                throw new Exception("Hypergrid connector init error");
+            }
+
+            string serviceURI = hgConfig.GetString("HypergridServerURI",
+                    String.Empty);
+
+            if (serviceURI == String.Empty)
+            {
+                m_log.Error("[HYPERGRID CONNECTOR]: No Server URI named in section HypergridService");
+                throw new Exception("Hypergrid connector init error");
+            }
+            m_ServerURL = serviceURI;
+        }
+
         public bool LinkRegion(GridRegion info, out UUID regionID, out ulong realHandle, out string imageURL, out string reason)
         {
             regionID = UUID.Zero;
@@ -246,5 +273,82 @@ namespace OpenSim.Services.Connectors.Hypergrid
 
             return null;
         }
+
+        #region From local regions to grid-wide hypergrid service
+
+        public bool LinkRegion(string regionDescriptor, out UUID regionID, out ulong realHandle, out string imageURL, out string reason)
+        {
+            regionID = UUID.Zero;
+            imageURL = string.Empty;
+            realHandle = 0;
+            reason = string.Empty;
+
+            Hashtable hash = new Hashtable();
+            hash["region_desc"] = regionDescriptor;
+
+            IList paramList = new ArrayList();
+            paramList.Add(hash);
+
+            XmlRpcRequest request = new XmlRpcRequest("link_region_by_desc", paramList);
+            XmlRpcResponse response = null;
+            try
+            {
+                response = request.Send(m_ServerURL, 10000);
+            }
+            catch (Exception e)
+            {
+                m_log.Debug("[HGrid]: Exception " + e.Message);
+                reason = "Error contacting remote server";
+                return false;
+            }
+
+            if (response.IsFault)
+            {
+                reason = response.FaultString;
+                m_log.ErrorFormat("[HGrid]: 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: " + uuid);
+                    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"];
+                    }
+                }
+
+            }
+            catch (Exception e)
+            {
+                reason = "Error parsing return arguments";
+                m_log.Error("[HGrid]: Got exception while parsing hyperlink response " + e.StackTrace);
+                return false;
+            }
+
+            return true;
+        }
+
+        // TODO !!!
+        public GridRegion GetRegionByUUID(UUID regionID) { return null; }
+        public GridRegion GetRegionByPosition(int x, int y) { return null; }
+        public GridRegion GetRegionByName(string name) { return null; }
+        public List<GridRegion> GetRegionsByName(string name) { return null; }
+        public List<GridRegion> GetRegionRange(int xmin, int xmax, int ymin, int ymax) { return null; }
+
+        #endregion
     }
 }
diff --git a/OpenSim/Services/HypergridService/GatekeeperService.cs b/OpenSim/Services/HypergridService/GatekeeperService.cs
index 72db93f..283ab3e 100644
--- a/OpenSim/Services/HypergridService/GatekeeperService.cs
+++ b/OpenSim/Services/HypergridService/GatekeeperService.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Net;
 using System.Reflection;
 
 using OpenSim.Framework;
@@ -51,6 +52,7 @@ namespace OpenSim.Services.HypergridService
         IPresenceService m_PresenceService;
         IAuthenticationService m_AuthenticationService;
         IUserAccountService m_UserAccountService;
+        IHomeUsersSecurityService m_HomeUsersSecurityService;
         ISimulationService m_SimulationService;
 
         string m_AuthDll;
@@ -66,14 +68,15 @@ namespace OpenSim.Services.HypergridService
                 throw new Exception(String.Format("No section GatekeeperService in config file"));
 
             string accountService = serverConfig.GetString("UserAccountService", String.Empty);
+            string homeUsersSecurityService = serverConfig.GetString("HomeUsersSecurityService", string.Empty);
             string gridService = serverConfig.GetString("GridService", String.Empty);
             string presenceService = serverConfig.GetString("PresenceService", String.Empty);
             string simulationService = serverConfig.GetString("SimulationService", String.Empty);
 
             m_AuthDll = serverConfig.GetString("AuthenticationService", String.Empty);
 
-            if (accountService == string.Empty || gridService == string.Empty ||
-                presenceService == string.Empty || m_AuthDll == string.Empty)
+            // These 3 are mandatory, the others aren't
+            if (gridService == string.Empty || presenceService == string.Empty || m_AuthDll == string.Empty)
                 throw new Exception("Incomplete specifications, Gatekeeper Service cannot function.");
             
             string scope = serverConfig.GetString("ScopeID", UUID.Zero.ToString());
@@ -82,16 +85,20 @@ namespace OpenSim.Services.HypergridService
             m_AllowTeleportsToAnyRegion = serverConfig.GetBoolean("AllowTeleportsToAnyRegion", true);
 
             Object[] args = new Object[] { config };
-            m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(accountService, args);
             m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
             m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(presenceService, args);
+
+            if (accountService != string.Empty)
+                m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(accountService, args);
+            if (homeUsersSecurityService != string.Empty)
+                m_HomeUsersSecurityService = ServerUtils.LoadPlugin<IHomeUsersSecurityService>(homeUsersSecurityService, args);
+
             if (simService != null)
                 m_SimulationService = simService;
             else if (simulationService != string.Empty)
                     m_SimulationService = ServerUtils.LoadPlugin<ISimulationService>(simulationService, args);
 
-            if (m_UserAccountService == null || m_GridService == null ||
-                m_PresenceService == null || m_SimulationService == null)
+            if (m_GridService == null || m_PresenceService == null || m_SimulationService == null)
                 throw new Exception("Unable to load a required plugin, Gatekeeper Service cannot function.");
 
             m_log.Debug("[GATEKEEPER SERVICE]: Starting...");
@@ -164,6 +171,7 @@ namespace OpenSim.Services.HypergridService
             return region;
         }
 
+        #region Login Agent
         public bool LoginAgent(AgentCircuitData aCircuit, GridRegion destination, out string reason)
         {
             reason = string.Empty;
@@ -174,6 +182,9 @@ namespace OpenSim.Services.HypergridService
             m_log.DebugFormat("[GATEKEEPER SERVICE]: Request to login foreign agent {0} {1} @ {2} ({3}) at destination {4}", 
                 aCircuit.firstname, aCircuit.lastname, authURL, aCircuit.AgentID, destination.RegionName);
 
+            //
+            // Authenticate the user
+            //
             if (!Authenticate(aCircuit))
             {
                 reason = "Unable to verify identity";
@@ -181,22 +192,40 @@ namespace OpenSim.Services.HypergridService
                 return false;
             }
             m_log.DebugFormat("[GATEKEEPER SERVICE]: Identity verified for {0} {1} @ {2}", aCircuit.firstname, aCircuit.lastname, authURL);
-
-            // Check to see if we have a local user with that UUID
-            UserAccount account = m_UserAccountService.GetUserAccount(m_ScopeID, aCircuit.AgentID);
-            if (account != null)
+            
+            //
+            // Check for impersonations
+            //
+            UserAccount account = null;
+            if (m_UserAccountService != null)
             {
-                // No, sorry; go away
-                reason = "User identifier not allowed on this grid";
-                m_log.InfoFormat("[GATEKEEPER SERVICE]: Foreign agent {0} {1} has UUID of local user {3}. Refusing service.", 
-                    aCircuit.firstname, aCircuit.lastname, aCircuit.AgentID);
-                return false;
+                // Check to see if we have a local user with that UUID
+                account = m_UserAccountService.GetUserAccount(m_ScopeID, aCircuit.AgentID);
+                if (account != null)
+                {
+                    // Make sure this is the user coming home, and not a fake
+                    if (m_HomeUsersSecurityService != null)
+                    {
+                        Object ep = m_HomeUsersSecurityService.GetEndPoint(aCircuit.SessionID);
+                        if (ep == null)
+                        {
+                            // This is a fake, this session never left this grid
+                            reason = "Unauthorized";
+                            m_log.InfoFormat("[GATEKEEPER SERVICE]: Foreign agent {0} {1} has same ID as local user. Refusing service.",
+                                aCircuit.firstname, aCircuit.lastname);
+                            return false;
+
+                        }
+                    }
+                }
             }
-            m_log.DebugFormat("[GATEKEEPER SERVICE]: User ID ok");
+            m_log.DebugFormat("[GATEKEEPER SERVICE]: User is ok");
 
             // May want to authorize
 
+            //
             // Login the presence
+            //
             if (!m_PresenceService.LoginAgent(aCircuit.AgentID.ToString(), aCircuit.SessionID, aCircuit.SecureSessionID))
             {
                 reason = "Unable to login presence";
@@ -206,22 +235,38 @@ namespace OpenSim.Services.HypergridService
             }
             m_log.DebugFormat("[GATEKEEPER SERVICE]: Login presence ok");
 
+            //
             // Get the region
+            //
             destination = m_GridService.GetRegionByUUID(m_ScopeID, destination.RegionID);
             if (destination == null)
             {
                 reason = "Destination region not found";
                 return false;
             }
-            m_log.DebugFormat("[GATEKEEPER SERVICE]: destination ok : {0}", destination.RegionName);
+            m_log.DebugFormat("[GATEKEEPER SERVICE]: destination ok: {0}", destination.RegionName);
 
+            //
+            // Adjust the visible name
+            //
+            if (account != null)
+            {
+                aCircuit.firstname = account.FirstName;
+                aCircuit.lastname = account.LastName;
+            }
+            if (account == null && !aCircuit.lastname.StartsWith("@"))
+            {
+                aCircuit.firstname = aCircuit.firstname + "." + aCircuit.lastname;
+                aCircuit.lastname = "@" + aCircuit.ServiceURLs["HomeURI"].ToString();
+            }
+
+            //
             // Finally launch the agent at the destination
-            aCircuit.firstname = aCircuit.firstname + "." + aCircuit.lastname;
-            aCircuit.lastname = "@" + aCircuit.ServiceURLs["HomeURI"].ToString();
+            //
             return m_SimulationService.CreateAgent(destination, aCircuit, 0, out reason);
         }
 
-         protected bool Authenticate(AgentCircuitData aCircuit)
+        protected bool Authenticate(AgentCircuitData aCircuit)
         {
             string authURL = string.Empty;
             if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
@@ -250,5 +295,40 @@ namespace OpenSim.Services.HypergridService
 
             return false;
         }
+
+        #endregion
+
+        public GridRegion GetHomeRegion(UUID userID, out Vector3 position, out Vector3 lookAt)
+        {
+            position = new Vector3(128, 128, 0); lookAt = Vector3.UnitY;
+
+            m_log.DebugFormat("[GATEKEEPER SERVICE]: Request to get home region of user {0}", userID);
+
+            GridRegion home = null;
+            PresenceInfo[] presences = m_PresenceService.GetAgents(new string[] { userID.ToString() });
+            if (presences != null && presences.Length > 0)
+            {
+                UUID homeID = presences[0].HomeRegionID;
+                if (homeID != UUID.Zero)
+                {
+                    home = m_GridService.GetRegionByUUID(m_ScopeID, homeID);
+                    position = presences[0].HomePosition;
+                    lookAt = presences[0].HomeLookAt;
+                }
+                if (home == null)
+                {
+                    List<GridRegion> defs = m_GridService.GetDefaultRegions(m_ScopeID);
+                    if (defs != null && defs.Count > 0)
+                        home = defs[0];
+                }
+            }
+
+            return home;
+        }
+
+        #region Misc
+
+
+        #endregion
     }
 }
diff --git a/OpenSim/Services/HypergridService/HomeUsersSecurityService.cs b/OpenSim/Services/HypergridService/HomeUsersSecurityService.cs
new file mode 100644
index 0000000..a7adfc1
--- /dev/null
+++ b/OpenSim/Services/HypergridService/HomeUsersSecurityService.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+
+using OpenSim.Services.Interfaces;
+
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Services.HypergridService
+{
+    /// <summary>
+    /// This service is for HG1.5 only, to make up for the fact that clients don't
+    /// keep any private information in themselves, and that their 'home service'
+    /// needs to do it for them.
+    /// Once we have better clients, this shouldn't be needed.
+    /// </summary>
+    public class HomeUsersSecurityService : IHomeUsersSecurityService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        //
+        // This is a persistent storage wannabe for dealing with the
+        // quirks of HG1.5. We don't really want to store this in a table.
+        // But this is the necessary information for securing clients
+        // coming home.
+        //
+        protected static Dictionary<UUID, IPEndPoint> m_ClientEndPoints = new Dictionary<UUID, IPEndPoint>();
+
+        public HomeUsersSecurityService(IConfigSource config)
+        {
+            m_log.DebugFormat("[HOME USERS SECURITY]: Starting...");
+        }
+
+        public void SetEndPoint(UUID sessionID, IPEndPoint ep)
+        {
+            m_log.DebugFormat("[HOME USERS SECURITY]: Set EndPoint {0} for session {1}", ep.ToString(), sessionID);
+
+            lock (m_ClientEndPoints)
+                m_ClientEndPoints[sessionID] = ep;
+        }
+
+        public IPEndPoint GetEndPoint(UUID sessionID)
+        {
+            lock (m_ClientEndPoints)
+                if (m_ClientEndPoints.ContainsKey(sessionID))
+                {
+                    m_log.DebugFormat("[HOME USERS SECURITY]: Get EndPoint {0} for session {1}", m_ClientEndPoints[sessionID].ToString(), sessionID);
+                    return m_ClientEndPoints[sessionID];
+                }
+
+            return null;
+        }
+
+        public void RemoveEndPoint(UUID sessionID)
+        {
+            m_log.DebugFormat("[HOME USERS SECURITY]: Remove EndPoint for session {0}", sessionID);
+            lock (m_ClientEndPoints)
+                if (m_ClientEndPoints.ContainsKey(sessionID))
+                    m_ClientEndPoints.Remove(sessionID);
+        }
+    }
+}
diff --git a/OpenSim/Services/HypergridService/HypergridService.cs b/OpenSim/Services/HypergridService/HypergridService.cs
index 734931d..ac0f5ac 100644
--- a/OpenSim/Services/HypergridService/HypergridService.cs
+++ b/OpenSim/Services/HypergridService/HypergridService.cs
@@ -51,7 +51,7 @@ namespace OpenSim.Services.HypergridService
         private static HypergridService m_RootInstance = null;
         protected IConfigSource m_config;
 
-        protected IAuthenticationService m_AuthenticationService = null;
+        protected IPresenceService m_PresenceService = null;
         protected IGridService m_GridService;
         protected IAssetService m_AssetService;
         protected HypergridServiceConnector m_HypergridConnector;
@@ -94,7 +94,7 @@ namespace OpenSim.Services.HypergridService
             if (gridConfig != null)
             {
                 string gridService = gridConfig.GetString("GridService", string.Empty);                
-                string authService = gridConfig.GetString("AuthenticationService", String.Empty);
+                string presenceService = gridConfig.GetString("PresenceService", String.Empty);
                 string assetService = gridConfig.GetString("AssetService", string.Empty);
 
                 Object[] args = new Object[] { config };
@@ -104,8 +104,8 @@ namespace OpenSim.Services.HypergridService
                 if (m_GridService == null)
                     throw new Exception("HypergridService cannot function without a GridService");
 
-                if (authService != String.Empty)
-                    m_AuthenticationService = ServerUtils.LoadPlugin<IAuthenticationService>(authService, args);
+                if (presenceService != String.Empty)
+                    m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(presenceService, args);
 
                 if (assetService != string.Empty)
                     m_AssetService = ServerUtils.LoadPlugin<IAssetService>(assetService, args);
diff --git a/OpenSim/Services/Interfaces/IGatekeeperService.cs b/OpenSim/Services/Interfaces/IGatekeeperService.cs
index d41df75..5b5c9d1 100644
--- a/OpenSim/Services/Interfaces/IGatekeeperService.cs
+++ b/OpenSim/Services/Interfaces/IGatekeeperService.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.Net;
 using System.Collections.Generic;
 
 using OpenSim.Framework;
@@ -39,5 +40,18 @@ namespace OpenSim.Services.Interfaces
         GridRegion GetHyperlinkRegion(UUID regionID);
 
         bool LoginAgent(AgentCircuitData aCircuit, GridRegion destination, out string reason);
+
+        GridRegion GetHomeRegion(UUID userID, out Vector3 position, out Vector3 lookAt);
+
+    }
+
+    /// <summary>
+    /// HG1.5 only
+    /// </summary>
+    public interface IHomeUsersSecurityService
+    {
+        void SetEndPoint(UUID sessionID, IPEndPoint ep);
+        IPEndPoint GetEndPoint(UUID sessionID);
+        void RemoveEndPoint(UUID sessionID);
     }
 }
diff --git a/OpenSim/Services/Interfaces/IHypergridService.cs b/OpenSim/Services/Interfaces/IHypergridService.cs
index dd3c053..86ef1b4 100644
--- a/OpenSim/Services/Interfaces/IHypergridService.cs
+++ b/OpenSim/Services/Interfaces/IHypergridService.cs
@@ -43,6 +43,7 @@ namespace OpenSim.Services.Interfaces
         GridRegion GetRegionByName(string name);
         List<GridRegion> GetRegionsByName(string name);
         List<GridRegion> GetRegionRange(int xmin, int xmax, int ymin, int ymax);
+
     }
 
 }