2 files changed, 538 insertions, 0 deletions

diff --git a/OpenSim/Services/HypergridService/GatekeeperService.cs b/OpenSim/Services/HypergridService/GatekeeperService.cs
new file mode 100644
index 0000000..56744b6
--- /dev/null
+++ b/OpenSim/Services/HypergridService/GatekeeperService.cs
@@ -0,0 +1,321 @@
+/*
+ * 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 OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+using OpenSim.Services.Connectors.Hypergrid;
+
+using OpenMetaverse;
+
+using Nini.Config;
+using log4net;
+
+namespace OpenSim.Services.HypergridService
+{
+    public class GatekeeperService : IGatekeeperService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        IGridService m_GridService;
+        IPresenceService m_PresenceService;
+        IUserAccountService m_UserAccountService;
+        IUserAgentService m_UserAgentService;
+        ISimulationService m_SimulationService;
+
+        string m_AuthDll;
+
+        UUID m_ScopeID;
+        bool m_AllowTeleportsToAnyRegion;
+        string m_ExternalName;
+        GridRegion m_DefaultGatewayRegion;
+
+        public GatekeeperService(IConfigSource config, ISimulationService simService)
+        {
+            IConfig serverConfig = config.Configs["GatekeeperService"];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section GatekeeperService in config file"));
+
+            string accountService = serverConfig.GetString("UserAccountService", String.Empty);
+            string homeUsersService = 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);
+
+            // 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());
+            UUID.TryParse(scope, out m_ScopeID);
+            //m_WelcomeMessage = serverConfig.GetString("WelcomeMessage", "Welcome to OpenSim!");
+            m_AllowTeleportsToAnyRegion = serverConfig.GetBoolean("AllowTeleportsToAnyRegion", true);
+            m_ExternalName = serverConfig.GetString("ExternalName", string.Empty);
+
+            Object[] args = new Object[] { config };
+            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 (homeUsersService != string.Empty)
+                m_UserAgentService = ServerUtils.LoadPlugin<IUserAgentService>(homeUsersService, args);
+
+            if (simService != null)
+                m_SimulationService = simService;
+            else if (simulationService != string.Empty)
+                    m_SimulationService = ServerUtils.LoadPlugin<ISimulationService>(simulationService, args);
+
+            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...");
+        }
+
+        public GatekeeperService(IConfigSource config)
+            : this(config, null)
+        {
+        }
+
+        public bool LinkRegion(string regionName, out UUID regionID, out ulong regionHandle, out string externalName, out string imageURL, out string reason)
+        {
+            regionID = UUID.Zero;
+            regionHandle = 0;
+            externalName = m_ExternalName;
+            imageURL = string.Empty;
+            reason = string.Empty;
+
+            m_log.DebugFormat("[GATEKEEPER SERVICE]: Request to link to {0}", (regionName == string.Empty ? "default region" : regionName));
+            if (!m_AllowTeleportsToAnyRegion || regionName == string.Empty)
+            {
+                List<GridRegion> defs = m_GridService.GetDefaultRegions(m_ScopeID);
+                if (defs != null && defs.Count > 0)
+                    m_DefaultGatewayRegion = defs[0];
+
+                try
+                {
+                    regionID = m_DefaultGatewayRegion.RegionID;
+                    regionHandle = m_DefaultGatewayRegion.RegionHandle;
+                }
+                catch
+                {
+                    reason = "Grid setup problem. Try specifying a particular region here.";
+                    m_log.DebugFormat("[GATEKEEPER SERVICE]: Unable to send information. Please specify a default region for this grid!");
+                    return false;
+                }
+
+                return true;
+            }
+
+            GridRegion region = m_GridService.GetRegionByName(m_ScopeID, regionName);
+            if (region == null)
+            {
+                reason = "Region not found";
+                return false;
+            }
+
+            regionID = region.RegionID;
+            regionHandle = region.RegionHandle;
+            string regionimage = "regionImage" + region.RegionID.ToString();
+            regionimage = regionimage.Replace("-", "");
+
+            imageURL = "http://" + region.ExternalHostName + ":" + region.HttpPort + "/index.php?method=" + regionimage;
+
+            return true;
+        }
+
+        public GridRegion GetHyperlinkRegion(UUID regionID)
+        {
+            m_log.DebugFormat("[GATEKEEPER SERVICE]: Request to get hyperlink region {0}", regionID);
+
+            if (!m_AllowTeleportsToAnyRegion)
+                // Don't even check the given regionID
+                return m_DefaultGatewayRegion;
+
+            GridRegion region = m_GridService.GetRegionByUUID(m_ScopeID, regionID);
+            return region;
+        }
+
+        #region Login Agent
+        public bool LoginAgent(AgentCircuitData aCircuit, GridRegion destination, out string reason)
+        {
+            reason = string.Empty;
+
+            string authURL = string.Empty;
+            if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
+                authURL = aCircuit.ServiceURLs["HomeURI"].ToString();
+            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";
+                m_log.InfoFormat("[GATEKEEPER SERVICE]: Unable to verify identity of agent {0} {1}. Refusing service.", aCircuit.firstname, aCircuit.lastname);
+                return false;
+            }
+            m_log.DebugFormat("[GATEKEEPER SERVICE]: Identity verified for {0} {1} @ {2}", aCircuit.firstname, aCircuit.lastname, authURL);
+            
+            //
+            // Check for impersonations
+            //
+            UserAccount account = null;
+            if (m_UserAccountService != null)
+            {
+                // 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 foreign user with same UUID as a local user
+                    if (m_UserAgentService != null)
+                    {
+                        if (!m_UserAgentService.AgentIsComingHome(aCircuit.SessionID, m_ExternalName))
+                        {
+                            // Can't do, sorry
+                            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 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";
+                m_log.InfoFormat("[GATEKEEPER SERVICE]: Presence login failed for foreign agent {0} {1}. Refusing service.",
+                    aCircuit.firstname, aCircuit.lastname);
+                return false;
+            }
+            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);
+
+            //
+            // 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
+            //
+            return m_SimulationService.CreateAgent(destination, aCircuit, (uint)Constants.TeleportFlags.ViaLogin, out reason);
+        }
+
+        protected bool Authenticate(AgentCircuitData aCircuit)
+        {
+            if (!CheckAddress(aCircuit.ServiceSessionID))
+                return false;
+
+            string userURL = string.Empty;
+            if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
+                userURL = aCircuit.ServiceURLs["HomeURI"].ToString();
+
+            if (userURL == string.Empty)
+            {
+                m_log.DebugFormat("[GATEKEEPER SERVICE]: Agent did not provide an authentication server URL");
+                return false;
+            }
+
+            Object[] args = new Object[] { userURL };
+            IUserAgentService userAgentService = new UserAgentServiceConnector(userURL); //ServerUtils.LoadPlugin<IUserAgentService>(m_AuthDll, args);
+            if (userAgentService != null)
+            {
+                try
+                {
+                    return userAgentService.VerifyAgent(aCircuit.SessionID, aCircuit.ServiceSessionID);
+                }
+                catch
+                {
+                    m_log.DebugFormat("[GATEKEEPER SERVICE]: Unable to contact authentication service at {0}", userURL);
+                    return false;
+                }
+            }
+
+            return false;
+        }
+
+        // Check that the service token was generated for *this* grid.
+        // If it wasn't then that's a fake agent.
+        protected bool CheckAddress(string serviceToken)
+        {
+            string[] parts = serviceToken.Split(new char[] { ';' });
+            if (parts.Length < 2)
+                return false;
+
+            string addressee = parts[0];
+            m_log.DebugFormat("[GATEKEEPER SERVICE]: Verifying {0} against {1}", addressee, m_ExternalName);
+            return (addressee == m_ExternalName);
+        }
+
+        #endregion
+
+
+        #region Misc
+
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Services/HypergridService/UserAgentService.cs b/OpenSim/Services/HypergridService/UserAgentService.cs
new file mode 100644
index 0000000..15379b5
--- /dev/null
+++ b/OpenSim/Services/HypergridService/UserAgentService.cs
@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+
+using OpenSim.Framework;
+using OpenSim.Services.Connectors.Hypergrid;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+
+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 UserAgentService : IUserAgentService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        // This will need to go into a DB table
+        static Dictionary<UUID, TravelingAgentInfo> m_TravelingAgents = new Dictionary<UUID, TravelingAgentInfo>();
+
+        static bool m_Initialized = false;
+
+        protected static IPresenceService m_PresenceService;
+        protected static IGridService m_GridService;
+        protected static GatekeeperServiceConnector m_GatekeeperConnector;
+
+        public UserAgentService(IConfigSource config)
+        {
+            if (!m_Initialized)
+            {
+                m_log.DebugFormat("[HOME USERS SECURITY]: Starting...");
+                
+                IConfig serverConfig = config.Configs["UserAgentService"];
+                if (serverConfig == null)
+                    throw new Exception(String.Format("No section UserAgentService in config file"));
+
+                string gridService = serverConfig.GetString("GridService", String.Empty);
+                string presenceService = serverConfig.GetString("PresenceService", String.Empty);
+
+                if (gridService == string.Empty || presenceService == string.Empty)
+                    throw new Exception(String.Format("Incomplete specifications, UserAgent Service cannot function."));
+
+                Object[] args = new Object[] { config };
+                m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
+                m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(presenceService, args);
+                m_GatekeeperConnector = new GatekeeperServiceConnector();
+
+                m_Initialized = true;
+            }
+        }
+
+        public GridRegion GetHomeRegion(UUID userID, out Vector3 position, out Vector3 lookAt)
+        {
+            position = new Vector3(128, 128, 0); lookAt = Vector3.UnitY;
+
+            m_log.DebugFormat("[USER AGENT 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(UUID.Zero, homeID);
+                    position = presences[0].HomePosition;
+                    lookAt = presences[0].HomeLookAt;
+                }
+                if (home == null)
+                {
+                    List<GridRegion> defs = m_GridService.GetDefaultRegions(UUID.Zero);
+                    if (defs != null && defs.Count > 0)
+                        home = defs[0];
+                }
+            }
+
+            return home;
+        }
+
+        public bool LoginAgentToGrid(AgentCircuitData agentCircuit, GridRegion gatekeeper, GridRegion finalDestination, out string reason)
+        {
+            m_log.DebugFormat("[USER AGENT SERVICE]: Request to login user {0} {1} to grid {2}", 
+                agentCircuit.firstname, agentCircuit.lastname, gatekeeper.ExternalHostName +":"+ gatekeeper.HttpPort);
+
+            // Take the IP address + port of the gatekeeper (reg) plus the info of finalDestination
+            GridRegion region = new GridRegion(gatekeeper);
+            region.RegionName = finalDestination.RegionName;
+            region.RegionID = finalDestination.RegionID;
+            region.RegionLocX = finalDestination.RegionLocX;
+            region.RegionLocY = finalDestination.RegionLocY;
+
+            // Generate a new service session
+            agentCircuit.ServiceSessionID = "http://" + region.ExternalHostName + ":" + region.HttpPort + ";" + UUID.Random();
+            TravelingAgentInfo old = UpdateTravelInfo(agentCircuit, region);
+
+            bool success = m_GatekeeperConnector.CreateAgent(region, agentCircuit, (uint)Constants.TeleportFlags.ViaLogin, out reason);
+
+            if (!success)
+            {
+                m_log.DebugFormat("[USER AGENT SERVICE]: Unable to login user {0} {1} to grid {2}, reason: {3}", 
+                    agentCircuit.firstname, agentCircuit.lastname, region.ExternalHostName + ":" + region.HttpPort, reason);
+
+                // restore the old travel info
+                lock (m_TravelingAgents)
+                    m_TravelingAgents[agentCircuit.SessionID] = old;
+
+                return false;
+            }
+
+            return true;
+        }
+
+        TravelingAgentInfo UpdateTravelInfo(AgentCircuitData agentCircuit, GridRegion region)
+        {
+            TravelingAgentInfo travel = new TravelingAgentInfo();
+            TravelingAgentInfo old = null;
+            lock (m_TravelingAgents)
+            {
+                if (m_TravelingAgents.ContainsKey(agentCircuit.SessionID))
+                {
+                    old = m_TravelingAgents[agentCircuit.SessionID];
+                }
+
+                m_TravelingAgents[agentCircuit.SessionID] = travel;
+            }
+            travel.UserID = agentCircuit.AgentID;
+            travel.GridExternalName = region.ExternalHostName + ":" + region.HttpPort;
+            travel.ServiceToken = agentCircuit.ServiceSessionID;
+            if (old != null)
+                travel.ClientToken = old.ClientToken;
+
+            return old;
+        }
+
+        public void LogoutAgent(UUID userID, UUID sessionID)
+        {
+            m_log.DebugFormat("[USER AGENT SERVICE]: User {0} logged out", userID);
+
+            lock (m_TravelingAgents)
+            {
+                List<UUID> travels = new List<UUID>();
+                foreach (KeyValuePair<UUID, TravelingAgentInfo> kvp in m_TravelingAgents)
+                    if (kvp.Value == null) // do some clean up
+                        travels.Add(kvp.Key);
+                    else if (kvp.Value.UserID == userID)
+                        travels.Add(kvp.Key);
+                foreach (UUID session in travels)
+                    m_TravelingAgents.Remove(session);
+            }
+        }
+
+        // We need to prevent foreign users with the same UUID as a local user
+        public bool AgentIsComingHome(UUID sessionID, string thisGridExternalName)
+        {
+            if (!m_TravelingAgents.ContainsKey(sessionID))
+                return false;
+
+            TravelingAgentInfo travel = m_TravelingAgents[sessionID];
+            return travel.GridExternalName == thisGridExternalName;
+        }
+
+        public bool VerifyClient(UUID sessionID, string token)
+        {
+            return true;
+
+            // Commenting this for now until I understand better what part of a sender's
+            // info stays unchanged throughout a session
+            //
+            //if (m_TravelingAgents.ContainsKey(sessionID))
+            //{
+            //    // Aquiles heel. Must trust the first grid upon login
+            //    if (m_TravelingAgents[sessionID].ClientToken == string.Empty)
+            //    {
+            //        m_TravelingAgents[sessionID].ClientToken = token;
+            //        return true;
+            //    }
+            //    return m_TravelingAgents[sessionID].ClientToken == token;
+            //}
+            //return false;
+        }
+
+        public bool VerifyAgent(UUID sessionID, string token)
+        {
+            if (m_TravelingAgents.ContainsKey(sessionID))
+            {
+                m_log.DebugFormat("[USER AGENT SERVICE]: Verifying agent token {0} against {1}", token, m_TravelingAgents[sessionID].ServiceToken);
+                return m_TravelingAgents[sessionID].ServiceToken == token;
+            }
+
+            m_log.DebugFormat("[USER AGENT SERVICE]: Token verification for session {0}: no such session", sessionID);
+
+            return false;
+        }
+
+    }
+
+    class TravelingAgentInfo
+    {
+        public UUID UserID;
+        public string GridExternalName = string.Empty;
+        public string ServiceToken = string.Empty;
+        public string ClientToken = string.Empty;
+    }
+
+}