Beginning of rewriting HG. Compiles, and runs, but HG functions not restored yet.

4 files changed, 718 insertions, 38 deletions

diff --git a/OpenSim/Services/HypergridService/GatekeeperService.cs b/OpenSim/Services/HypergridService/GatekeeperService.cs
new file mode 100644
index 0000000..174174c
--- /dev/null
+++ b/OpenSim/Services/HypergridService/GatekeeperService.cs
@@ -0,0 +1,167 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+
+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;
+        IAuthenticationService m_AuthenticationService;
+        IUserAccountService m_UserAccountService;
+        ISimulationService m_SimulationService;
+
+        string m_AuthDll;
+
+        UUID m_ScopeID;
+        bool m_AllowTeleportsToAnyRegion;
+        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 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)
+                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);
+
+            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 (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)
+                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 imageURL, out string reason)
+        {
+            regionID = m_DefaultGatewayRegion.RegionID;
+            regionHandle = m_DefaultGatewayRegion.RegionHandle;
+            imageURL = string.Empty;
+            reason = string.Empty;
+
+            if (!m_AllowTeleportsToAnyRegion)
+            {
+                regionID = m_DefaultGatewayRegion.RegionID;
+                regionHandle = m_DefaultGatewayRegion.RegionHandle;
+                if (regionName != string.Empty)
+                {
+                    reason = "Direct links to regions not allowed";
+                    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)
+        {
+            if (!m_AllowTeleportsToAnyRegion)
+                // Don't even check the given regionID
+                return m_DefaultGatewayRegion;
+
+            GridRegion region = m_GridService.GetRegionByUUID(m_ScopeID, regionID);
+            return region;
+        }
+
+        public bool LoginAgent(AgentCircuitData aCircuit, GridRegion destination)
+        {
+            if (!Authenticate(aCircuit))
+                return false;
+
+            // Check to see if we have a local user with that UUID
+            UserAccount account = m_UserAccountService.GetUserAccount(m_ScopeID, aCircuit.AgentID);
+            if (account != null)
+                // No, sorry; go away
+                return false;
+
+            // May want to authorize
+
+            // Login the presence
+            if (!m_PresenceService.LoginAgent(aCircuit.AgentID.ToString(), aCircuit.SessionID, aCircuit.SecureSessionID))
+                return false;
+
+            // Finally launch the agent at the destination
+            string reason = string.Empty;
+            return m_SimulationService.CreateAgent(destination, aCircuit, 0, out reason);
+        }
+
+        public bool LoginAttachments(ISceneObject sog, GridRegion destination)
+        {
+            // May want to filter attachments
+            return m_SimulationService.CreateObject(destination, sog, false);
+        }
+
+        protected bool Authenticate(AgentCircuitData aCircuit)
+        {
+            string authURL = string.Empty; // GetAuthURL(aCircuit);
+            if (authURL == string.Empty)
+                return false;
+
+            Object[] args = new Object[] { authURL };
+            IAuthenticationService authService = ServerUtils.LoadPlugin<IAuthenticationService>(m_AuthDll, args);
+            if (authService != null)
+                return authService.Verify(aCircuit.AgentID, aCircuit.SecureSessionID.ToString(), 30);
+
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/HGCommands.cs b/OpenSim/Services/HypergridService/HGCommands.cs
index 0974372..10d04ff 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/HGCommands.cs
+++ b/OpenSim/Services/HypergridService/HGCommands.cs
@@ -34,41 +34,52 @@ using Nini.Config;
 using OpenSim.Framework;
 //using OpenSim.Framework.Communications;
 using OpenSim.Framework.Console;
-using OpenSim.Region.Framework;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Framework.Scenes.Hypergrid;
+using OpenSim.Services.Interfaces;
 using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
-namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
+namespace OpenSim.Services.HypergridService
 {
     public class HGCommands
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        private HGGridConnector m_HGGridConnector;
-        private Scene m_scene;
+        private HypergridService m_HypergridService;
 
         private static uint m_autoMappingX = 0;
         private static uint m_autoMappingY = 0;
         private static bool m_enableAutoMapping = false;
 
-        public HGCommands(HGGridConnector hgConnector, Scene scene)
+        public HGCommands(HypergridService service)
         {
-            m_HGGridConnector = hgConnector;
-            m_scene = scene;
+            m_HypergridService = service;
         }
 
-        //public static Scene CreateScene(RegionInfo regionInfo, AgentCircuitManager circuitManager, CommunicationsManager m_commsManager,
-        //    StorageManager storageManager, ModuleLoader m_moduleLoader, ConfigSettings m_configSettings, OpenSimConfigSource m_config, string m_version)
-        //{
-        //    HGSceneCommunicationService sceneGridService = new HGSceneCommunicationService(m_commsManager, HGServices);
-
-        //    return
-        //        new HGScene(
-        //            regionInfo, circuitManager, m_commsManager, sceneGridService, storageManager,
-        //            m_moduleLoader, false, m_configSettings.PhysicalPrim,
-        //            m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version);
-        //}
+        public void HandleShow(string module, string[] cmd)
+        {
+            if (cmd.Length != 2)
+            {
+                MainConsole.Instance.Output("Syntax: show hyperlinks");
+                return;
+            }
+            List<GridRegion> regions = new List<GridRegion>(m_HypergridService.m_HyperlinkRegions.Values);
+            if (regions == null || regions.Count < 1)
+            {
+                MainConsole.Instance.Output("No hyperlinks");
+                return;
+            }
 
+            MainConsole.Instance.Output("Region Name          Region UUID");
+            MainConsole.Instance.Output("Location             URI");
+            MainConsole.Instance.Output("Owner ID                                Flags");
+            MainConsole.Instance.Output("-------------------------------------------------------------------------------");
+            foreach (GridRegion r in regions)
+            {
+                MainConsole.Instance.Output(String.Format("{0,-20} {1}\n{2,-20} {3}\n{4,-39} \n\n",
+                        r.RegionName, r.RegionID,
+                        String.Format("{0},{1}", r.RegionLocX, r.RegionLocY), "http://" + r.ExternalHostName + ":" + r.HttpPort.ToString(),
+                        r.EstateOwner.ToString()));
+            }
+            return;
+        }
         public void RunCommand(string module, string[] cmdparams)
         {
             List<string> args = new List<string>(cmdparams);
@@ -133,13 +144,11 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                             for (int i = 3; i < cmdparams.Length; i++)
                                 mapName += " " + cmdparams[i];
 
-                        m_log.Info(">> MapName: " + mapName);
-                        //internalPort = Convert.ToUInt32(cmdparams[4]);
-                        //remotingPort = Convert.ToUInt32(cmdparams[5]);
+                        //m_log.Info(">> MapName: " + mapName);
                     }
                     catch (Exception e)
                     {
-                        m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
+                        MainConsole.Instance.Output("[HGrid] Wrong format for link-region command: " + e.Message);
                         LinkRegionCmdUsage();
                         return;
                     }
@@ -147,7 +156,9 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                     // Convert cell coordinates given by the user to meters
                     xloc = xloc * (int)Constants.RegionSize;
                     yloc = yloc * (int)Constants.RegionSize;
-                    m_HGGridConnector.TryLinkRegionToCoords(m_scene, null, mapName, xloc, yloc);
+                    string reason = string.Empty;
+                    if (m_HypergridService.TryLinkRegionToCoords(mapName, xloc, yloc, out reason) == null)
+                        MainConsole.Instance.Output("Failed to link region: " + reason);
                 }
                 else
                 {
@@ -167,7 +178,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                     }
                     catch (Exception e)
                     {
-                        m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
+                        MainConsole.Instance.Output("[HGrid] Wrong format for link-region command: " + e.Message);
                         LinkRegionCmdUsage();
                         return;
                     }
@@ -175,7 +186,8 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                     // Convert cell coordinates given by the user to meters
                     xloc = xloc * (int)Constants.RegionSize;
                     yloc = yloc * (int)Constants.RegionSize;
-                    if (m_HGGridConnector.TryCreateLink(m_scene, null, xloc, yloc, "", externalPort, externalHostName, out regInfo))
+                    string reason = string.Empty;
+                    if (m_HypergridService.TryCreateLink(xloc, yloc, "", externalPort, externalHostName, out regInfo, out reason))
                     {
                         if (cmdparams.Length >= 5)
                         {
@@ -194,10 +206,10 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                     UnlinkRegionCmdUsage();
                     return;
                 }
-                if (m_HGGridConnector.TryUnlinkRegion(m_scene, cmdparams[0]))
-                    m_log.InfoFormat("[HGrid]: Successfully unlinked {0}", cmdparams[0]);
+                if (m_HypergridService.TryUnlinkRegion(cmdparams[0]))
+                    MainConsole.Instance.Output("Successfully unlinked " + cmdparams[0]);
                 else
-                    m_log.InfoFormat("[HGrid]: Unable to unlink {0}, region not found", cmdparams[0]);
+                    MainConsole.Instance.Output("Unable to unlink " + cmdparams[0] + ", region not found.");
             }
         }
 
@@ -276,27 +288,29 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             {
                 xloc = xloc * (int)Constants.RegionSize;
                 yloc = yloc * (int)Constants.RegionSize;
-                if (
-                    m_HGGridConnector.TryCreateLink(m_scene, null, xloc, yloc, "", externalPort,
-                                              externalHostName, out regInfo))
+                string reason = string.Empty;
+                if (m_HypergridService.TryCreateLink(xloc, yloc, "", externalPort,
+                                                     externalHostName, out regInfo, out reason))
                 {
                     regInfo.RegionName = config.GetString("localName", "");
                 }
+                else
+                    MainConsole.Instance.Output("Unable to link " + externalHostName + ": " + reason);
             }
         }
 
 
         private void LinkRegionCmdUsage()
         {
-            m_log.Info("Usage: link-region <Xloc> <Yloc> <HostName>:<HttpPort>[:<RemoteRegionName>]");
-            m_log.Info("Usage: link-region <Xloc> <Yloc> <HostName> <HttpPort> [<LocalName>]");
-            m_log.Info("Usage: link-region <URI_of_xml> [<exclude>]");
+            MainConsole.Instance.Output("Usage: link-region <Xloc> <Yloc> <HostName>:<HttpPort>[:<RemoteRegionName>]");
+            MainConsole.Instance.Output("Usage: link-region <Xloc> <Yloc> <HostName> <HttpPort> [<LocalName>]");
+            MainConsole.Instance.Output("Usage: link-region <URI_of_xml> [<exclude>]");
         }
 
         private void UnlinkRegionCmdUsage()
         {
-            m_log.Info("Usage: unlink-region <HostName>:<HttpPort>");
-            m_log.Info("Usage: unlink-region <LocalName>");
+            MainConsole.Instance.Output("Usage: unlink-region <HostName>:<HttpPort>");
+            MainConsole.Instance.Output("Usage: unlink-region <LocalName>");
         }
 
     }
diff --git a/OpenSim/Services/HypergridService/HypergridService.cs b/OpenSim/Services/HypergridService/HypergridService.cs
new file mode 100644
index 0000000..747b98a
--- /dev/null
+++ b/OpenSim/Services/HypergridService/HypergridService.cs
@@ -0,0 +1,415 @@
+/*
+ * 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 Nini.Config;
+using log4net;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Data;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors.Hypergrid;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenMetaverse;
+
+namespace OpenSim.Services.HypergridService
+{
+    public class HypergridService : HypergridServiceBase, IHypergridService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static HypergridService m_RootInstance = null;
+        protected IConfigSource m_config;
+
+        protected IAuthenticationService m_AuthenticationService = null;
+        protected IGridService m_GridService;
+        protected IAssetService m_AssetService;
+        protected HypergridServiceConnector m_HypergridConnector;
+
+        protected bool m_AllowDuplicateNames = false;
+        protected UUID m_ScopeID = UUID.Zero;
+
+        // Hyperlink regions are hyperlinks on the map
+        public readonly Dictionary<UUID, GridRegion> m_HyperlinkRegions = new Dictionary<UUID, GridRegion>();
+        protected Dictionary<UUID, ulong> m_HyperlinkHandles = new Dictionary<UUID, ulong>();
+
+        protected GridRegion m_DefaultRegion;
+        protected GridRegion DefaultRegion
+        {
+            get
+            {
+                if (m_DefaultRegion == null)
+                {
+                    List<GridRegion> defs = m_GridService.GetDefaultRegions(m_ScopeID);
+                    if (defs != null && defs.Count > 0)
+                        m_DefaultRegion = defs[0];
+                    else
+                    {
+                        // Best guess, may be totally off
+                        m_DefaultRegion = new GridRegion(1000, 1000);
+                        m_log.WarnFormat("[HYPERGRID SERVICE]: This grid does not have a default region. Assuming default coordinates at 1000, 1000.");
+                    }
+                }
+                return m_DefaultRegion;
+            }
+        }
+
+        public HypergridService(IConfigSource config)
+            : base(config)
+        {
+            m_log.DebugFormat("[HYPERGRID SERVICE]: Starting...");
+
+            m_config = config;
+            IConfig gridConfig = config.Configs["HypergridService"];
+            if (gridConfig != null)
+            {
+                string gridService = gridConfig.GetString("GridService", string.Empty);                
+                string authService = gridConfig.GetString("AuthenticationService", String.Empty);
+                string assetService = gridConfig.GetString("AssetService", string.Empty);
+
+                Object[] args = new Object[] { config };
+                if (gridService != string.Empty)
+                    m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
+
+                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 (assetService != string.Empty)
+                    m_AssetService = ServerUtils.LoadPlugin<IAssetService>(assetService, args);
+
+                m_AllowDuplicateNames = gridConfig.GetBoolean("AllowDuplicateNames", m_AllowDuplicateNames);
+
+                string scope = gridConfig.GetString("ScopeID", string.Empty);
+                if (scope != string.Empty)
+                    UUID.TryParse(scope, out m_ScopeID);
+
+                m_HypergridConnector = new HypergridServiceConnector(m_AssetService);
+
+                m_log.DebugFormat("[HYPERGRID SERVICE]: Loaded all services...");
+            }
+            
+            if (m_RootInstance == null)
+            {
+                m_RootInstance = this;
+
+                HGCommands hgCommands = new HGCommands(this);
+                MainConsole.Instance.Commands.AddCommand("hypergrid", false, "link-region",
+                    "link-region <Xloc> <Yloc> <HostName>:<HttpPort>[:<RemoteRegionName>] <cr>",
+                    "Link a hypergrid region", hgCommands.RunCommand);
+                MainConsole.Instance.Commands.AddCommand("hypergrid", false, "unlink-region",
+                    "unlink-region <local name> or <HostName>:<HttpPort> <cr>",
+                    "Unlink a hypergrid region", hgCommands.RunCommand);
+                MainConsole.Instance.Commands.AddCommand("hypergrid", false, "link-mapping", "link-mapping [<x> <y>] <cr>",
+                    "Set local coordinate to map HG regions to", hgCommands.RunCommand);
+                MainConsole.Instance.Commands.AddCommand("hypergrid", false, "show hyperlinks", "show hyperlinks <cr>",
+                    "List the HG regions", hgCommands.HandleShow);
+            }
+        }
+
+        #region Link Region
+
+        public bool LinkRegion(string regionDescriptor, out UUID regionID, out ulong regionHandle, out string imageURL, out string reason)
+        {
+            regionID = UUID.Zero;
+            imageURL = string.Empty;
+            regionHandle = 0;
+            reason = string.Empty;
+            int xloc = random.Next(0, Int16.MaxValue) * (int)Constants.RegionSize;
+            GridRegion region = TryLinkRegionToCoords(regionDescriptor, xloc, 0, out reason);
+            if (region == null)
+                return false;
+
+            regionID = region.RegionID;
+            regionHandle = region.RegionHandle;
+            return true;
+        }
+
+        private static Random random = new Random();
+
+        // From the command line link-region
+        public GridRegion TryLinkRegionToCoords(string mapName, int xloc, int yloc, out string reason)
+        {
+            reason = string.Empty;
+            string host = "127.0.0.1";
+            string portstr;
+            string regionName = "";
+            uint port = 9000;
+            string[] parts = mapName.Split(new char[] { ':' });
+            if (parts.Length >= 1)
+            {
+                host = parts[0];
+            }
+            if (parts.Length >= 2)
+            {
+                portstr = parts[1];
+                //m_log.Debug("-- port = " + portstr);
+                if (!UInt32.TryParse(portstr, out port))
+                    regionName = parts[1];
+            }
+            // always take the last one
+            if (parts.Length >= 3)
+            {
+                regionName = parts[2];
+            }
+
+            // Sanity check. Don't ever link to this sim.
+            IPAddress ipaddr = null;
+            try
+            {
+                ipaddr = Util.GetHostFromDNS(host);
+            }
+            catch { }
+
+            GridRegion regInfo;
+            bool success = TryCreateLink(xloc, yloc, regionName, port, host, out regInfo, out reason);
+            if (success)
+            {
+                regInfo.RegionName = mapName;
+                return regInfo;
+            }
+
+            return null;
+        }
+
+
+        // From the command line and the 2 above
+        public bool TryCreateLink(int xloc, int yloc,
+            string externalRegionName, uint externalPort, string externalHostName, out GridRegion regInfo, out string reason)
+        {
+            m_log.DebugFormat("[HYPERGRID SERVICE]: Link to {0}:{1}, in {2}-{3}", externalHostName, externalPort, xloc, yloc);
+
+            reason = string.Empty;
+            regInfo = new GridRegion();
+            regInfo.RegionName = externalRegionName;
+            regInfo.HttpPort = externalPort;
+            regInfo.ExternalHostName = externalHostName;
+            regInfo.RegionLocX = xloc;
+            regInfo.RegionLocY = yloc;
+
+            try
+            {
+                regInfo.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), (int)0);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn("[HYPERGRID SERVICE]: Wrong format for link-region: " + e.Message);
+                reason = "Internal error";
+                return false;
+            }
+
+            // Finally, link it
+            ulong handle = 0;
+            UUID regionID = UUID.Zero;
+            string imageURL = string.Empty;
+            if (!m_HypergridConnector.LinkRegion(regInfo, out regionID, out handle, out imageURL, out reason))
+                return false;
+
+            if (regionID != UUID.Zero)
+            {
+                regInfo.RegionID = regionID;
+
+                AddHyperlinkRegion(regInfo, handle);
+                m_log.Info("[HYPERGRID SERVICE]: Successfully linked to region_uuid " + regInfo.RegionID);
+
+                // Try get the map image
+                regInfo.TerrainImage = m_HypergridConnector.GetMapImage(regionID, imageURL);
+            }
+            else
+            {
+                m_log.Warn("[HYPERGRID SERVICE]: Unable to link region");
+                reason = "Remote region could not be found";
+                return false;
+            }
+
+            uint x, y;
+            if (!Check4096(regInfo, out x, out y))
+            {
+                RemoveHyperlinkRegion(regInfo.RegionID);
+                reason = "Region is too far (" + x + ", " + y + ")";
+                m_log.Info("[HYPERGRID SERVICE]: Unable to link, region is too far (" + x + ", " + y + ")");
+                return false;
+            }
+
+            m_log.Debug("[HYPERGRID SERVICE]: link region succeeded");
+            return true;
+        }
+
+        public bool TryUnlinkRegion(string mapName)
+        {
+            GridRegion regInfo = null;
+            if (mapName.Contains(":"))
+            {
+                string host = "127.0.0.1";
+                //string portstr;
+                //string regionName = "";
+                uint port = 9000;
+                string[] parts = mapName.Split(new char[] { ':' });
+                if (parts.Length >= 1)
+                {
+                    host = parts[0];
+                }
+
+                foreach (GridRegion r in m_HyperlinkRegions.Values)
+                    if (host.Equals(r.ExternalHostName) && (port == r.HttpPort))
+                        regInfo = r;
+            }
+            else
+            {
+                foreach (GridRegion r in m_HyperlinkRegions.Values)
+                    if (r.RegionName.Equals(mapName))
+                        regInfo = r;
+            }
+            if (regInfo != null)
+            {
+                RemoveHyperlinkRegion(regInfo.RegionID);
+                return true;
+            }
+            else
+            {
+                m_log.InfoFormat("[HYPERGRID SERVICE]: Region {0} not found", mapName);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Cope with this viewer limitation.
+        /// </summary>
+        /// <param name="regInfo"></param>
+        /// <returns></returns>
+        public bool Check4096(GridRegion regInfo, out uint x, out uint y)
+        {
+            GridRegion defRegion = DefaultRegion;
+
+            ulong realHandle = m_HyperlinkHandles[regInfo.RegionID];
+            uint ux = 0, uy = 0;
+            Utils.LongToUInts(realHandle, out ux, out uy);
+            x = ux / Constants.RegionSize;
+            y = uy / Constants.RegionSize;
+
+            if ((Math.Abs((int)defRegion.RegionLocX - ux) >= 4096 * Constants.RegionSize) ||
+                (Math.Abs((int)defRegion.RegionLocY - uy) >= 4096 * Constants.RegionSize))
+            {
+                return false;
+            }
+            return true;
+        }
+
+        private void AddHyperlinkRegion(GridRegion regionInfo, ulong regionHandle)
+        {
+            m_HyperlinkRegions[regionInfo.RegionID] = regionInfo;
+            m_HyperlinkHandles[regionInfo.RegionID] = regionHandle;
+        }
+
+        private void RemoveHyperlinkRegion(UUID regionID)
+        {
+            // Try the hyperlink collection
+            if (m_HyperlinkRegions.ContainsKey(regionID))
+            {
+                m_HyperlinkRegions.Remove(regionID);
+                m_HyperlinkHandles.Remove(regionID);
+            }
+        }
+
+        #endregion
+
+        #region Get Hyperlinks
+
+        public GridRegion GetHyperlinkRegion(UUID regionID)
+        {
+            //GridRegion region = m_HypergridConnector.
+            return null;
+        }
+
+        #endregion
+
+        #region GetRegionBy X
+
+        public GridRegion GetRegionByUUID(UUID regionID)
+        {
+            if (m_HyperlinkRegions.ContainsKey(regionID))
+                return m_HyperlinkRegions[regionID];
+
+            return null;
+        }
+
+        public GridRegion GetRegionByPosition(int x, int y)
+        {
+            foreach (GridRegion r in m_HyperlinkRegions.Values)
+                if (r.RegionLocX == x && r.RegionLocY == y)
+                    return r;
+
+            return null;
+        }
+
+        public GridRegion GetRegionByName(string name)
+        {
+            foreach (GridRegion r in m_HyperlinkRegions.Values)
+                if (r.RegionName.ToLower() == name.ToLower())
+                    return r;
+
+            return null;
+        }
+
+        public List<GridRegion> GetRegionsByName(string name)
+        {
+            List<GridRegion> regions = new List<GridRegion>();
+
+            foreach (GridRegion r in m_HyperlinkRegions.Values)
+                if ((r.RegionName != null) && r.RegionName.ToLower().StartsWith(name.ToLower()))
+                    regions.Add(r);
+
+            return regions;
+
+        }
+
+        public List<GridRegion> GetRegionRange(int xmin, int xmax, int ymin, int ymax)
+        {
+            List<GridRegion> regions = new List<GridRegion>();
+
+            foreach (GridRegion r in m_HyperlinkRegions.Values)
+                if ((r.RegionLocX > xmin) && (r.RegionLocX < xmax) &&
+                    (r.RegionLocY > ymin) && (r.RegionLocY < ymax))
+                    regions.Add(r);
+
+            return regions;
+        }
+
+        #endregion
+
+
+
+    }
+}
diff --git a/OpenSim/Services/HypergridService/HypergridServiceBase.cs b/OpenSim/Services/HypergridService/HypergridServiceBase.cs
new file mode 100644
index 0000000..4f91f64
--- /dev/null
+++ b/OpenSim/Services/HypergridService/HypergridServiceBase.cs
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Data;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Base;
+
+namespace OpenSim.Services.HypergridService
+{
+    public class HypergridServiceBase : ServiceBase
+    {
+        protected IRegionData m_Database = null;
+
+        public HypergridServiceBase(IConfigSource config)
+            : base(config)
+        {
+            string dllName = String.Empty;
+            string connString = String.Empty;
+            string realm = "TBD";
+
+            //
+            // Try reading the [DatabaseService] section, if it exists
+            //
+            IConfig dbConfig = config.Configs["DatabaseService"];
+            if (dbConfig != null)
+            {
+                if (dllName == String.Empty)
+                    dllName = dbConfig.GetString("StorageProvider", String.Empty);
+                if (connString == String.Empty)
+                    connString = dbConfig.GetString("ConnectionString", String.Empty);
+            }
+
+            //
+            // [HypergridService] section overrides [DatabaseService], if it exists
+            //
+            IConfig gridConfig = config.Configs["HypergridService"];
+            if (gridConfig != null)
+            {
+                dllName = gridConfig.GetString("StorageProvider", dllName);
+                connString = gridConfig.GetString("ConnectionString", connString);
+                realm = gridConfig.GetString("Realm", realm);
+            }
+            
+            ////
+            //// We tried, but this doesn't exist. We can't proceed.
+            ////
+            //if (dllName.Equals(String.Empty))
+            //    throw new Exception("No StorageProvider configured");
+
+            //m_Database = LoadPlugin<IRegionData>(dllName, new Object[] { connString, realm });
+            //if (m_Database == null)
+            //    throw new Exception("Could not find a storage interface in the given module");
+
+        }
+    }
+}