28 files changed, 488 insertions, 176 deletions

diff --git a/OpenSim/Services/AvatarService/AvatarService.cs b/OpenSim/Services/AvatarService/AvatarService.cs
index c59a9e0..423c781 100644
--- a/OpenSim/Services/AvatarService/AvatarService.cs
+++ b/OpenSim/Services/AvatarService/AvatarService.cs
@@ -93,7 +93,7 @@ namespace OpenSim.Services.AvatarService
                 if (kvp.Key.StartsWith("_"))
                     count++;
 
-            m_log.DebugFormat("[AVATAR SERVICE]: SetAvatar for {0}, attachs={1}", principalID, count);
+//            m_log.DebugFormat("[AVATAR SERVICE]: SetAvatar for {0}, attachs={1}", principalID, count);
             m_Database.Delete("PrincipalID", principalID.ToString());
 
             AvatarBaseData av = new AvatarBaseData();
diff --git a/OpenSim/Services/Connectors/Asset/AssetServiceConnector.cs b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
index 2882906..2882906 100644
--- a/OpenSim/Services/Connectors/Asset/AssetServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Authentication/AuthenticationServiceConnector.cs b/OpenSim/Services/Connectors/Authentication/AuthenticationServicesConnector.cs
index 2b77154..2b77154 100644
--- a/OpenSim/Services/Connectors/Authentication/AuthenticationServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Authentication/AuthenticationServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Authorization/AuthorizationServiceConnector.cs b/OpenSim/Services/Connectors/Authorization/AuthorizationServicesConnector.cs
index 35b7109..35b7109 100644
--- a/OpenSim/Services/Connectors/Authorization/AuthorizationServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Authorization/AuthorizationServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Avatar/AvatarServiceConnector.cs b/OpenSim/Services/Connectors/Avatar/AvatarServicesConnector.cs
index ddfca57..ddfca57 100644
--- a/OpenSim/Services/Connectors/Avatar/AvatarServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Avatar/AvatarServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Friends/FriendsServiceConnector.cs b/OpenSim/Services/Connectors/Friends/FriendsServicesConnector.cs
index b1dd84e..b1dd84e 100644
--- a/OpenSim/Services/Connectors/Friends/FriendsServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Friends/FriendsServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Grid/GridServiceConnector.cs b/OpenSim/Services/Connectors/Grid/GridServicesConnector.cs
index 7deaf95..f982cc1 100644
--- a/OpenSim/Services/Connectors/Grid/GridServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Grid/GridServicesConnector.cs
@@ -116,29 +116,36 @@ namespace OpenSim.Services.Connectors
                     }
                     else if (replyData.ContainsKey("Result")&& (replyData["Result"].ToString().ToLower() == "failure"))
                     {
-                        m_log.DebugFormat("[GRID CONNECTOR]: Registration failed: {0}", replyData["Message"].ToString());
+                        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.DebugFormat("[GRID CONNECTOR]: reply data does not contain result field");
+                        m_log.ErrorFormat(
+                            "[GRID CONNECTOR]: reply data does not contain result field when contacting {0}", uri);
                     }
                     else
                     {
-                        m_log.DebugFormat("[GRID CONNECTOR]: unexpected result {0}", replyData["Result"].ToString());
-                        return "Unexpected result "+replyData["Result"].ToString();
+                        m_log.ErrorFormat(
+                            "[GRID CONNECTOR]: unexpected result {0} when contacting {1}", replyData["Result"], uri);
+
+                        return "Unexpected result " + replyData["Result"].ToString();
                     }
-                    
                 }
                 else
-                    m_log.DebugFormat("[GRID CONNECTOR]: RegisterRegion received null reply");
+                {
+                    m_log.ErrorFormat(
+                        "[GRID CONNECTOR]: RegisterRegion received null reply when contacting grid server at {0}", uri);
+                }
             }
             catch (Exception e)
             {
-                m_log.DebugFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
+                m_log.ErrorFormat("[GRID CONNECTOR]: Exception when contacting grid server at {0}: {1}", uri, e.Message);
             }
 
-            return "Error communicating with grid service";
+            return string.Format("Error communicating with the grid service at {0}", uri);
         }
 
         public bool DeregisterRegion(UUID regionID)
diff --git a/OpenSim/Services/Connectors/GridUser/GridUserServiceConnector.cs b/OpenSim/Services/Connectors/GridUser/GridUserServicesConnector.cs
index 20d7eaf..20d7eaf 100644
--- a/OpenSim/Services/Connectors/GridUser/GridUserServiceConnector.cs
+++ b/OpenSim/Services/Connectors/GridUser/GridUserServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs
index bc0bc54..4cd933c 100644
--- a/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Hypergrid/GatekeeperServiceConnector.cs
@@ -154,17 +154,32 @@ namespace OpenSim.Services.Connectors.Hypergrid
 
             UUID mapTile = m_HGMapImage;
             string filename = string.Empty;
-            Bitmap bitmap = null;
+
             try
             {
                 WebClient c = new WebClient();
                 //m_log.Debug("JPEG: " + imageURL);
                 string name = regionID.ToString();
                 filename = Path.Combine(storagePath, name + ".jpg");
-                c.DownloadFile(imageURL, filename);
-                bitmap = new Bitmap(filename);
-                //m_log.Debug("Size: " + m.PhysicalDimension.Height + "-" + m.PhysicalDimension.Width);
-                byte[] imageData = OpenJPEG.EncodeFromImage(bitmap, true);
+                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
diff --git a/OpenSim/Services/Connectors/Hypergrid/HGFriendsServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/HGFriendsServicesConnector.cs
index e984a54..e984a54 100644
--- a/OpenSim/Services/Connectors/Hypergrid/HGFriendsServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Hypergrid/HGFriendsServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Hypergrid/HeloServiceConnector.cs b/OpenSim/Services/Connectors/Hypergrid/HeloServicesConnector.cs
index 5c50936..5c50936 100644
--- a/OpenSim/Services/Connectors/Hypergrid/HeloServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Hypergrid/HeloServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Inventory/XInventoryConnector.cs b/OpenSim/Services/Connectors/Inventory/XInventoryServicesConnector.cs
index 9d96703..9d96703 100644
--- a/OpenSim/Services/Connectors/Inventory/XInventoryConnector.cs
+++ b/OpenSim/Services/Connectors/Inventory/XInventoryServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Land/LandServiceConnector.cs b/OpenSim/Services/Connectors/Land/LandServicesConnector.cs
index 833e22a..833e22a 100644
--- a/OpenSim/Services/Connectors/Land/LandServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Land/LandServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/MapImage/MapImageServiceConnector.cs b/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs
index 30bfb70..30bfb70 100644
--- a/OpenSim/Services/Connectors/MapImage/MapImageServiceConnector.cs
+++ b/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Neighbour/NeighbourServiceConnector.cs b/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs
index 888b072..888b072 100644
--- a/OpenSim/Services/Connectors/Neighbour/NeighbourServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/Presence/PresenceServiceConnector.cs b/OpenSim/Services/Connectors/Presence/PresenceServicesConnector.cs
index 378aab6..378aab6 100644
--- a/OpenSim/Services/Connectors/Presence/PresenceServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Presence/PresenceServicesConnector.cs
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianActivityDetector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianActivityDetector.cs
index 2267325..95e4bab 100644
--- a/OpenSim/Services/Connectors/SimianGrid/SimianActivityDetector.cs
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianActivityDetector.cs
@@ -79,27 +79,13 @@ namespace OpenSim.Services.Connectors.SimianGrid
 
         public void OnConnectionClose(IClientAPI client)
         {
-            if (client.IsLoggingOut)
-            {
-                object sp = null;
-                Vector3 position = new Vector3(128, 128, 0);
-                Vector3 lookat = new Vector3(0, 1, 0);
-
-                if (client.Scene.TryGetScenePresence(client.AgentId, out sp))
-                {
-                    if (sp is ScenePresence)
-                    {
-                        if (((ScenePresence)sp).IsChildAgent)
-                            return;
-
-                        position = ((ScenePresence)sp).AbsolutePosition;
-                        lookat = ((ScenePresence)sp).Lookat;
-                    }
-                }
+            if (client.SceneAgent.IsChildAgent)
+                return;
 
-//                m_log.DebugFormat("[SIMIAN 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, position, lookat);
-            }
+//            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)
@@ -111,4 +97,4 @@ namespace OpenSim.Services.Connectors.SimianGrid
             });
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Services/Connectors/Simulation/SimulationDataService.cs b/OpenSim/Services/Connectors/Simulation/SimulationDataService.cs
index 620bb10..6db830b 100644
--- a/OpenSim/Services/Connectors/Simulation/SimulationDataService.cs
+++ b/OpenSim/Services/Connectors/Simulation/SimulationDataService.cs
@@ -149,6 +149,21 @@ namespace OpenSim.Services.Connectors
             m_database.RemoveRegionWindlightSettings(regionID);
         }
 
+        public string LoadRegionEnvironmentSettings(UUID regionUUID)
+        {
+            return m_database.LoadRegionEnvironmentSettings(regionUUID);
+        }
+
+        public void StoreRegionEnvironmentSettings(UUID regionUUID, string settings)
+        {
+            m_database.StoreRegionEnvironmentSettings(regionUUID, settings);
+        }
+
+        public void RemoveRegionEnvironmentSettings(UUID regionUUID)
+        {
+            m_database.RemoveRegionEnvironmentSettings(regionUUID);
+        }
+
         public UUID[] GetObjectIDs(UUID regionID)
         {
             return m_database.GetObjectIDs(regionID);
diff --git a/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs b/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
index 5037543..cd93386 100644
--- a/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
@@ -62,7 +62,7 @@ namespace OpenSim.Services.Connectors.Simulation
             //m_Region = region;
         }
 
-        public IScene GetScene(ulong regionHandle)
+        public IScene GetScene(UUID regionId)
         {
             return null;
         }
@@ -320,29 +320,40 @@ namespace OpenSim.Services.Connectors.Simulation
                 {
                     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} version {2} ({3})", uri, success, 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 (result.ContainsKey("Message"))
+                    // 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"))
                     {
-                        string message = result["Message"].AsString();
-                        if (message == "Service request failed: [MethodNotAllowed] MethodNotAllowed") // Old style region
+                        if (result.ContainsKey("Message"))
                         {
-                            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;
+                            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";
                         }
-
-                        reason = result["Message"];
-                    }
-                    else
-                    {
-                        reason = "Communications failure";
                     }
 
                     return false;
@@ -356,7 +367,7 @@ namespace OpenSim.Services.Connectors.Simulation
             }
             catch (Exception e)
             {
-                m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR] QueryAcess failed with exception; {0}",e.ToString());
+                m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR] QueryAcesss failed with exception; {0}",e.ToString());
             }
             
             return false;
diff --git a/OpenSim/Services/Connectors/UserAccounts/UserAccountServiceConnector.cs b/OpenSim/Services/Connectors/UserAccounts/UserAccountServicesConnector.cs
index 5731e2f..5731e2f 100644
--- a/OpenSim/Services/Connectors/UserAccounts/UserAccountServiceConnector.cs
+++ b/OpenSim/Services/Connectors/UserAccounts/UserAccountServicesConnector.cs
diff --git a/OpenSim/Services/GridService/GridService.cs b/OpenSim/Services/GridService/GridService.cs
index 3dc87bc..aab403a 100644
--- a/OpenSim/Services/GridService/GridService.cs
+++ b/OpenSim/Services/GridService/GridService.cs
@@ -85,13 +85,39 @@ namespace OpenSim.Services.GridService
                 if (MainConsole.Instance != null)
                 {
                     MainConsole.Instance.Commands.AddCommand("Regions", true,
-                            "show region",
-                            "show region <Region name>",
+                            "deregister region id",
+                            "deregister region id <Region UUID>",
+                            "Deregister a region manually.",
+                            String.Empty,
+                            HandleDeregisterRegion);
+
+                    // A messy way of stopping this command being added if we are in standalone (since the simulator
+                    // has an identically named command
+                    //
+                    // XXX: We're relying on the OpenSimulator version being registered first, which is not well defined.
+                    if (MainConsole.Instance.Commands.Resolve(new string[] { "show", "regions" }).Length == 0)
+                        MainConsole.Instance.Commands.AddCommand("Regions", true,
+                                "show regions",
+                                "show regions",
+                                "Show details on all regions",
+                                String.Empty,
+                                HandleShowRegions);
+
+                    MainConsole.Instance.Commands.AddCommand("Regions", true,
+                            "show region name",
+                            "show region name <Region name>",
                             "Show details on a region",
                             String.Empty,
                             HandleShowRegion);
 
                     MainConsole.Instance.Commands.AddCommand("Regions", true,
+                            "show region at",
+                            "show region at <x-coord> <y-coord>",
+                            "Show details on a region at the given co-ordinate.",
+                            "For example, show region at 1000 1000",
+                            HandleShowRegionAt);
+
+                    MainConsole.Instance.Commands.AddCommand("Regions", true,
                             "set region flags",
                             "set region flags <Region name> <flags>",
                             "Set database flags for region",
@@ -495,34 +521,151 @@ namespace OpenSim.Services.GridService
                 return -1;
         }
 
+        private void HandleDeregisterRegion(string module, string[] cmd)
+        {
+            if (cmd.Length != 4)
+            {
+                MainConsole.Instance.Output("Syntax: degregister region id <Region UUID>");
+                return;
+            }
+
+            string rawRegionUuid = cmd[3];
+            UUID regionUuid;
+
+            if (!UUID.TryParse(rawRegionUuid, out regionUuid))
+            {
+                MainConsole.Instance.OutputFormat("{0} is not a valid region uuid", rawRegionUuid);
+                return;
+            }
+
+            GridRegion region = GetRegionByUUID(UUID.Zero, regionUuid);
+
+            if (region == null)
+            {
+                MainConsole.Instance.OutputFormat("No region with UUID {0}", regionUuid);
+                return;
+            }
+
+            if (DeregisterRegion(regionUuid))
+            {
+                MainConsole.Instance.OutputFormat("Deregistered {0} {1}", region.RegionName, regionUuid);
+            }
+            else
+            {
+                // I don't think this can ever occur if we know that the region exists.
+                MainConsole.Instance.OutputFormat("Error deregistering {0} {1}", region.RegionName, regionUuid);
+            }
+
+            return;
+        }
+
+        private void HandleShowRegions(string module, string[] cmd)
+        {
+            if (cmd.Length != 2)
+            {
+                MainConsole.Instance.Output("Syntax: show regions");
+                return;
+            }
+
+            List<RegionData> regions = m_Database.Get(int.MinValue, int.MinValue, int.MaxValue, int.MaxValue, UUID.Zero);
+
+            OutputRegionsToConsoleSummary(regions);
+        }
+
+
         private void HandleShowRegion(string module, string[] cmd)
         {
-            if (cmd.Length != 3)
+            if (cmd.Length != 4)
             {
-                MainConsole.Instance.Output("Syntax: show region <region name>");
+                MainConsole.Instance.Output("Syntax: show region name <region name>");
                 return;
             }
-            List<RegionData> regions = m_Database.Get(cmd[2], UUID.Zero);
+
+            string regionName = cmd[3];
+
+            List<RegionData> regions = m_Database.Get(regionName, UUID.Zero);
             if (regions == null || regions.Count < 1)
             {
-                MainConsole.Instance.Output("Region not found");
+                MainConsole.Instance.Output("No region with name {0} found", regionName);
+                return;
+            }
+
+            OutputRegionsToConsole(regions);
+        }
+
+        private void HandleShowRegionAt(string module, string[] cmd)
+        {
+            if (cmd.Length != 5)
+            {
+                MainConsole.Instance.Output("Syntax: show region at <x-coord> <y-coord>");
+                return;
+            }
+
+            int x, y;
+            if (!int.TryParse(cmd[3], out x))
+            {
+                MainConsole.Instance.Output("x-coord must be an integer");
                 return;
             }
 
-            MainConsole.Instance.Output("Region Name          Region UUID");
-            MainConsole.Instance.Output("Location             URI");
-            MainConsole.Instance.Output("Owner ID                                Flags");
-            MainConsole.Instance.Output("-------------------------------------------------------------------------------");
+            if (!int.TryParse(cmd[4], out y))
+            {
+                MainConsole.Instance.Output("y-coord must be an integer");
+                return;
+            }
+
+            RegionData region = m_Database.Get(x * (int)Constants.RegionSize, y * (int)Constants.RegionSize, UUID.Zero);
+            if (region == null)
+            {
+                MainConsole.Instance.OutputFormat("No region found at {0},{1}", x, y);
+                return;
+            }
+
+            OutputRegionToConsole(region);
+        }
+
+        private void OutputRegionToConsole(RegionData r)
+        {
+            OpenSim.Data.RegionFlags flags = (OpenSim.Data.RegionFlags)Convert.ToInt32(r.Data["flags"]);
+
+            ConsoleDisplayList dispList = new ConsoleDisplayList();
+            dispList.AddRow("Region Name", r.RegionName);
+            dispList.AddRow("Region ID", r.RegionID);
+            dispList.AddRow("Location", string.Format("{0},{1}", r.coordX, r.coordY));
+            dispList.AddRow("URI", r.Data["serverURI"]);
+            dispList.AddRow("Owner ID", r.Data["owner_uuid"]);
+            dispList.AddRow("Flags", flags);
+
+            MainConsole.Instance.Output(dispList.ToString());
+        }
+
+        private void OutputRegionsToConsole(List<RegionData> regions)
+        {
+            foreach (RegionData r in regions)
+                OutputRegionToConsole(r);
+        }
+
+        private void OutputRegionsToConsoleSummary(List<RegionData> regions)
+        {
+            ConsoleDisplayTable dispTable = new ConsoleDisplayTable();
+            dispTable.AddColumn("Name", 16);
+            dispTable.AddColumn("ID", 36);
+            dispTable.AddColumn("Position", 11);
+            dispTable.AddColumn("Owner ID", 36);
+            dispTable.AddColumn("Flags", 60);
+
             foreach (RegionData r in regions)
             {
                 OpenSim.Data.RegionFlags flags = (OpenSim.Data.RegionFlags)Convert.ToInt32(r.Data["flags"]);
-                MainConsole.Instance.Output(String.Format("{0,-20} {1}\n{2,-20} {3}\n{4,-39} {5}\n\n",
-                        r.RegionName, r.RegionID,
-                        String.Format("{0},{1}", r.posX / Constants.RegionSize, r.posY / Constants.RegionSize),
-                        r.Data["serverURI"],
-                        r.Data["owner_uuid"], flags));
+                dispTable.AddRow(
+                    r.RegionName,
+                    r.RegionID.ToString(),
+                    string.Format("{0},{1}", r.coordX, r.coordY),
+                    r.Data["owner_uuid"].ToString(),
+                    flags.ToString());
             }
-            return;
+
+            MainConsole.Instance.Output(dispTable.ToString());
         }
 
         private int ParseFlags(int prev, string flags)
diff --git a/OpenSim/Services/HypergridService/GatekeeperService.cs b/OpenSim/Services/HypergridService/GatekeeperService.cs
index 149a0ab..47d22b9 100644
--- a/OpenSim/Services/HypergridService/GatekeeperService.cs
+++ b/OpenSim/Services/HypergridService/GatekeeperService.cs
@@ -370,8 +370,6 @@ namespace OpenSim.Services.HypergridService
                     return false;
                 }
             }
-
-            return false;
         }
 
         // Check that the service token was generated for *this* grid.
diff --git a/OpenSim/Services/HypergridService/HGFriendsService.cs b/OpenSim/Services/HypergridService/HGFriendsService.cs
index 39524ab..98423d7 100644
--- a/OpenSim/Services/HypergridService/HGFriendsService.cs
+++ b/OpenSim/Services/HypergridService/HGFriendsService.cs
@@ -276,19 +276,19 @@ namespace OpenSim.Services.HypergridService
                 }
             }
 
-            // Lastly, let's notify the rest who may be online somewhere else
-            foreach (string user in usersToBeNotified)
-            {
-                UUID id = new UUID(user);
-                //m_UserAgentService.LocateUser(id);
-                //etc...
-                //if (m_TravelingAgents.ContainsKey(id) && m_TravelingAgents[id].GridExternalName != m_GridName)
-                //{
-                //    string url = m_TravelingAgents[id].GridExternalName;
-                //    // forward
-                //}
-                //m_log.WarnFormat("[HGFRIENDS SERVICE]: User {0} is visiting another grid. HG Status notifications still not implemented.", user);
-            }
+//            // Lastly, let's notify the rest who may be online somewhere else
+//            foreach (string user in usersToBeNotified)
+//            {
+//                UUID id = new UUID(user);
+//                //m_UserAgentService.LocateUser(id);
+//                //etc...
+//                //if (m_TravelingAgents.ContainsKey(id) && m_TravelingAgents[id].GridExternalName != m_GridName)
+//                //{
+//                //    string url = m_TravelingAgents[id].GridExternalName;
+//                //    // forward
+//                //}
+//                //m_log.WarnFormat("[HGFRIENDS SERVICE]: User {0} is visiting another grid. HG Status notifications still not implemented.", user);
+//            }
 
             // and finally, let's send the online friends
             if (online)
diff --git a/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs b/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs
index b6ec558..6e4b68c 100644
--- a/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs
+++ b/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs
@@ -57,7 +57,7 @@ namespace OpenSim.Services.HypergridService
         private string m_HomeURL;
         private IUserAccountService m_UserAccountService;
 
-        private UserAccountCache m_Cache;
+//        private UserAccountCache m_Cache;
 
         private ExpiringCache<UUID, List<XInventoryFolder>> m_SuitcaseTrees = new ExpiringCache<UUID, List<XInventoryFolder>>();
 
@@ -92,7 +92,7 @@ namespace OpenSim.Services.HypergridService
                 // Preferred
                 m_HomeURL = invConfig.GetString("HomeURI", m_HomeURL);
 
-                m_Cache = UserAccountCache.CreateUserAccountCache(m_UserAccountService);
+//                m_Cache = UserAccountCache.CreateUserAccountCache(m_UserAccountService);
             }
 
             m_log.Debug("[HG SUITCASE INVENTORY SERVICE]: Starting...");
@@ -107,9 +107,8 @@ namespace OpenSim.Services.HypergridService
         public override List<InventoryFolderBase> GetInventorySkeleton(UUID principalID)
         {
             XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
-            XInventoryFolder root = GetRootXFolder(principalID);
 
-            List<XInventoryFolder> tree = GetFolderTree(suitcase.folderID);
+            List<XInventoryFolder> tree = GetFolderTree(principalID, suitcase.folderID);
             if (tree == null || (tree != null && tree.Count == 0))
                 return null;
 
@@ -119,7 +118,7 @@ namespace OpenSim.Services.HypergridService
                 folders.Add(ConvertToOpenSim(x));
             }
 
-            SetAsRootFolder(suitcase, root);
+            SetAsNormalFolder(suitcase);
             folders.Add(ConvertToOpenSim(suitcase));
 
             return folders;
@@ -134,12 +133,11 @@ namespace OpenSim.Services.HypergridService
             userInventory.Items = new List<InventoryItemBase>();
 
             XInventoryFolder suitcase = GetSuitcaseXFolder(userID);
-            XInventoryFolder root = GetRootXFolder(userID);
 
-            List<XInventoryFolder> tree = GetFolderTree(suitcase.folderID);
+            List<XInventoryFolder> tree = GetFolderTree(userID, suitcase.folderID);
             if (tree == null || (tree != null && tree.Count == 0))
             {
-                SetAsRootFolder(suitcase, root);
+                SetAsNormalFolder(suitcase);
                 userInventory.Folders.Add(ConvertToOpenSim(suitcase));
                 return userInventory;
             }
@@ -164,7 +162,7 @@ namespace OpenSim.Services.HypergridService
                 userInventory.Items.AddRange(items);
             }
 
-            SetAsRootFolder(suitcase, root);
+            SetAsNormalFolder(suitcase);
             userInventory.Folders.Add(ConvertToOpenSim(suitcase));
 
             m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: GetUserInventory for user {0} returning {1} folders and {2} items",
@@ -175,14 +173,13 @@ namespace OpenSim.Services.HypergridService
         public override InventoryFolderBase GetRootFolder(UUID principalID)
         {
             m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: GetRootFolder for {0}", principalID);
-            if (m_Database == null)
-                m_log.ErrorFormat("[XXX]: m_Database is NULL!");
 
             // Let's find out the local root folder
             XInventoryFolder root = GetRootXFolder(principalID); ;
             if (root == null)
             {
                 m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: Unable to retrieve local root folder for user {0}", principalID);
+                return null;
             }
 
             // Warp! Root folder for travelers is the suitcase folder
@@ -202,7 +199,7 @@ namespace OpenSim.Services.HypergridService
                 CreateSystemFolders(principalID, suitcase.folderID);
             }
 
-            SetAsRootFolder(suitcase, root);
+            SetAsNormalFolder(suitcase);
 
             return ConvertToOpenSim(suitcase);
         }
@@ -271,9 +268,8 @@ namespace OpenSim.Services.HypergridService
         public override InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
         {
             InventoryCollection coll = null;
-            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
 
-            if (!IsWithinSuitcaseTree(folderID, suitcase))
+            if (!IsWithinSuitcaseTree(principalID, folderID))
                 return new InventoryCollection();
 
             coll = base.GetFolderContent(principalID, folderID);
@@ -290,9 +286,7 @@ namespace OpenSim.Services.HypergridService
         {
             // Let's do a bit of sanity checking, more than the base service does
             // make sure the given folder exists under the suitcase tree of this user
-            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
-
-            if (!IsWithinSuitcaseTree(folderID, suitcase))
+            if (!IsWithinSuitcaseTree(principalID, folderID))
                 return new List<InventoryItemBase>();
 
             return base.GetFolderItems(principalID, folderID);
@@ -303,21 +297,27 @@ namespace OpenSim.Services.HypergridService
             m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: AddFolder {0} {1}", folder.Name, folder.ParentID);
             // Let's do a bit of sanity checking, more than the base service does
             // make sure the given folder's parent folder exists under the suitcase tree of this user
-            XInventoryFolder suitcase = GetSuitcaseXFolder(folder.Owner);
 
-            if (!IsWithinSuitcaseTree(folder.ParentID, suitcase))
+            if (!IsWithinSuitcaseTree(folder.Owner, folder.ParentID))
                 return false;
 
             // OK, it's legit
-            return base.AddFolder(folder);
+            if (base.AddFolder(folder))
+            {
+                List<XInventoryFolder> tree;
+                if (m_SuitcaseTrees.TryGetValue(folder.Owner, out tree))
+                    tree.Add(ConvertFromOpenSim(folder));
+
+                return true;
+            }
+
+            return false;
         }
 
         public override bool UpdateFolder(InventoryFolderBase folder)
         {
-            XInventoryFolder suitcase = GetSuitcaseXFolder(folder.Owner);
-
             m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Update folder {0}, version {1}", folder.ID, folder.Version);
-            if (!IsWithinSuitcaseTree(folder.ID, suitcase))
+            if (!IsWithinSuitcaseTree(folder.Owner, folder.ID))
             {
                 m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: folder {0} not within Suitcase tree", folder.Name);
                 return false;
@@ -329,9 +329,8 @@ namespace OpenSim.Services.HypergridService
 
         public override bool MoveFolder(InventoryFolderBase folder)
         {
-            XInventoryFolder suitcase = GetSuitcaseXFolder(folder.Owner);
-
-            if (!IsWithinSuitcaseTree(folder.ID, suitcase) || !IsWithinSuitcaseTree(folder.ParentID, suitcase))
+            if (!IsWithinSuitcaseTree(folder.Owner, folder.ID) || 
+                !IsWithinSuitcaseTree(folder.Owner, folder.ParentID))
                 return false;
 
             return base.MoveFolder(folder);
@@ -353,9 +352,7 @@ namespace OpenSim.Services.HypergridService
         {
             // Let's do a bit of sanity checking, more than the base service does
             // make sure the given folder's parent folder exists under the suitcase tree of this user
-            XInventoryFolder suitcase = GetSuitcaseXFolder(item.Owner);
-
-            if (!IsWithinSuitcaseTree(item.Folder, suitcase))
+            if (!IsWithinSuitcaseTree(item.Owner, item.Folder))
                 return false;
 
             // OK, it's legit
@@ -365,9 +362,7 @@ namespace OpenSim.Services.HypergridService
 
         public override bool UpdateItem(InventoryItemBase item)
         {
-            XInventoryFolder suitcase = GetSuitcaseXFolder(item.Owner);
-
-            if (!IsWithinSuitcaseTree(item.Folder, suitcase))
+            if (!IsWithinSuitcaseTree(item.Owner, item.Folder))
                 return false;
 
             return base.UpdateItem(item);
@@ -377,9 +372,7 @@ namespace OpenSim.Services.HypergridService
         {
             // Principal is b0rked. *sigh*
 
-            XInventoryFolder suitcase = GetSuitcaseXFolder(items[0].Owner);
-
-            if (!IsWithinSuitcaseTree(items[0].Folder, suitcase))
+            if (!IsWithinSuitcaseTree(items[0].Owner, items[0].Folder))
                 return false;
 
             return base.MoveItems(principalID, items);
@@ -400,15 +393,8 @@ namespace OpenSim.Services.HypergridService
                     item.Name, item.ID, item.Folder);
                 return null;
             }
-            XInventoryFolder suitcase = GetSuitcaseXFolder(it.Owner);
-            if (suitcase == null)
-            {
-                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Root or Suitcase are null for user {0}",
-                    it.Owner);
-                return null;
-            }
 
-            if (!IsWithinSuitcaseTree(it.Folder, suitcase))
+            if (!IsWithinSuitcaseTree(it.Owner, it.Folder))
             {
                 m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Item {0} (folder {1}) is not within Suitcase",
                     it.Name, it.Folder);
@@ -431,9 +417,7 @@ namespace OpenSim.Services.HypergridService
 
             if (f != null)
             {
-                XInventoryFolder suitcase = GetSuitcaseXFolder(f.Owner);
-
-                if (!IsWithinSuitcaseTree(f.ID, suitcase))
+                if (!IsWithinSuitcaseTree(f.Owner, f.ID))
                     return null;
             }
 
@@ -481,22 +465,37 @@ namespace OpenSim.Services.HypergridService
 
             if (folders != null && folders.Length > 0)
                 return folders[0];
+            
+            // check to see if we have the old Suitcase folder
+            folders = m_Database.GetFolders(
+                    new string[] { "agentID", "folderName", "parentFolderID" },
+                    new string[] { principalID.ToString(), "My Suitcase", UUID.Zero.ToString() });
+            if (folders != null && folders.Length > 0)
+            {
+                // Move it to under the root folder
+                XInventoryFolder root = GetRootXFolder(principalID);
+                folders[0].parentFolderID = root.folderID;
+                folders[0].type = 100;
+                m_Database.StoreFolder(folders[0]);
+                return folders[0];
+            }
+
             return null;
         }
 
-        private void SetAsRootFolder(XInventoryFolder suitcase, XInventoryFolder root)
+        private void SetAsNormalFolder(XInventoryFolder suitcase)
         {
             suitcase.type = (short)AssetType.Folder;
         }
 
-        private List<XInventoryFolder> GetFolderTree(UUID folder)
+        private List<XInventoryFolder> GetFolderTree(UUID principalID, UUID folder)
         {
             List<XInventoryFolder> t = null;
-            if (m_SuitcaseTrees.TryGetValue(folder, out t))
+            if (m_SuitcaseTrees.TryGetValue(principalID, out t))
                 return t;
 
             t = GetFolderTreeRecursive(folder);
-            m_SuitcaseTrees.AddOrUpdate(folder, t, 120);
+            m_SuitcaseTrees.AddOrUpdate(principalID, t, 5*60); // 5minutes
             return t;
         }
 
@@ -528,11 +527,18 @@ namespace OpenSim.Services.HypergridService
         /// <param name="root"></param>
         /// <param name="suitcase"></param>
         /// <returns></returns>
-        private bool IsWithinSuitcaseTree(UUID folderID, XInventoryFolder suitcase)
+        private bool IsWithinSuitcaseTree(UUID principalID, UUID folderID)
         {
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+            if (suitcase == null)
+            {
+                m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: User {0} does not have a Suitcase folder", principalID);
+                return false;
+            }
+
             List<XInventoryFolder> tree = new List<XInventoryFolder>();
             tree.Add(suitcase); // Warp! the tree is the real root folder plus the children of the suitcase folder
-            tree.AddRange(GetFolderTree(suitcase.folderID));
+            tree.AddRange(GetFolderTree(principalID, suitcase.folderID));
             XInventoryFolder f = tree.Find(delegate(XInventoryFolder fl)
             {
                 if (fl.folderID == folderID) return true;
diff --git a/OpenSim/Services/Interfaces/ISimulationService.cs b/OpenSim/Services/Interfaces/ISimulationService.cs
index 7940256..a963b8e 100644
--- a/OpenSim/Services/Interfaces/ISimulationService.cs
+++ b/OpenSim/Services/Interfaces/ISimulationService.cs
@@ -35,7 +35,17 @@ namespace OpenSim.Services.Interfaces
 {
     public interface ISimulationService
     {
-        IScene GetScene(ulong regionHandle);
+        /// <summary>
+        /// Retrieve the scene with the given region ID.
+        /// </summary>
+        /// <param name='regionId'>
+        /// Region identifier.
+        /// </param>
+        /// <returns>
+        /// The scene.
+        /// </returns>
+        IScene GetScene(UUID regionId);
+
         ISimulationService GetInnerService();
 
         #region Agents
@@ -108,16 +118,6 @@ namespace OpenSim.Services.Interfaces
         /// <returns></returns>
         bool CreateObject(GridRegion destination, Vector3 newPosition, ISceneObject sog, bool isLocalCall);
 
-        /// <summary>
-        /// Create an object from the user's inventory in the destination region. 
-        /// This message is used primarily by clients.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="userID"></param>
-        /// <param name="itemID"></param>
-        /// <returns></returns>
-        bool CreateObject(GridRegion destination, UUID userID, UUID itemID);
-
         #endregion Objects
 
     }
diff --git a/OpenSim/Services/InventoryService/XInventoryService.cs b/OpenSim/Services/InventoryService/XInventoryService.cs
index 0e7a358..7518b86 100644
--- a/OpenSim/Services/InventoryService/XInventoryService.cs
+++ b/OpenSim/Services/InventoryService/XInventoryService.cs
@@ -52,6 +52,7 @@ namespace OpenSim.Services.InventoryService
             : this(config, "InventoryService")
         {
         }
+
         public XInventoryService(IConfigSource config, string configName) : base(config)
         {
             if (configName != string.Empty)
@@ -301,46 +302,62 @@ namespace OpenSim.Services.InventoryService
 
         public virtual bool AddFolder(InventoryFolderBase folder)
         {
-            //m_log.DebugFormat("[XINVENTORY]: Add folder {0} type {1} in parent {2}", folder.Name, folder.Type, folder.ParentID);
+//            m_log.DebugFormat("[XINVENTORY]: Add folder {0} type {1} in parent {2}", folder.Name, folder.Type, folder.ParentID);
+
             InventoryFolderBase check = GetFolder(folder);
             if (check != null)
                 return false;
 
-            if (folder.Type == (short)AssetType.Folder || folder.Type == (short)AssetType.Unknown ||
-                GetFolderForType(folder.Owner, (AssetType)(folder.Type)) == null)
+            if (folder.Type == (short)AssetType.Folder
+                || folder.Type == (short)AssetType.Unknown
+                || folder.Type == (short)AssetType.OutfitFolder
+                || GetFolderForType(folder.Owner, (AssetType)(folder.Type)) == null)
             {
                 XInventoryFolder xFolder = ConvertFromOpenSim(folder);
                 return m_Database.StoreFolder(xFolder);
             }
             else
-                m_log.DebugFormat("[XINVENTORY]: Folder {0} of type {1} already exists", folder.Name, folder.Type);
+            {
+                m_log.WarnFormat(
+                    "[XINVENTORY]: Folder of type {0} already exists when tried to add {1} to {2} for {3}",
+                    folder.Type, folder.Name, folder.ParentID, folder.Owner);
+            }
 
             return false;
         }
 
         public virtual bool UpdateFolder(InventoryFolderBase folder)
         {
-            //m_log.DebugFormat("[XINVENTORY]: Update folder {0} {1} ({2})", folder.Name, folder.Type, folder.ID);
+//            m_log.DebugFormat("[XINVENTORY]: Update folder {0} {1} ({2})", folder.Name, folder.Type, folder.ID);
+
             XInventoryFolder xFolder = ConvertFromOpenSim(folder);
             InventoryFolderBase check = GetFolder(folder);
+
             if (check == null)
                 return AddFolder(folder);
 
-            if (check.Type != -1 || xFolder.type != -1)
+            if ((check.Type != (short)AssetType.Unknown || xFolder.type != (short)AssetType.Unknown)
+                && (check.Type != (short)AssetType.OutfitFolder || xFolder.type != (short)AssetType.OutfitFolder))
             {
                 if (xFolder.version < check.Version)
                 {
-                    //m_log.DebugFormat("[XINVENTORY]: {0} < {1} can't do", xFolder.version, check.Version);
+//                    m_log.DebugFormat("[XINVENTORY]: {0} < {1} can't do", xFolder.version, check.Version);
                     return false;
                 }
+
                 check.Version = (ushort)xFolder.version;
                 xFolder = ConvertFromOpenSim(check);
-                //m_log.DebugFormat("[XINVENTORY]: Storing {0} {1} {2}", xFolder.folderName, xFolder.version, xFolder.type);
+
+//                m_log.DebugFormat(
+//                    "[XINVENTORY]: Storing version only update to system folder {0} {1} {2}",
+//                    xFolder.folderName, xFolder.version, xFolder.type);
+
                 return m_Database.StoreFolder(xFolder);
             }
 
             if (xFolder.version < check.Version)
                 xFolder.version = check.Version;
+
             xFolder.folderID = check.ID;
 
             return m_Database.StoreFolder(xFolder);
@@ -364,6 +381,11 @@ namespace OpenSim.Services.InventoryService
         //
         public virtual bool DeleteFolders(UUID principalID, List<UUID> folderIDs)
         {
+            return DeleteFolders(principalID, folderIDs, true);
+        }
+
+        public virtual bool DeleteFolders(UUID principalID, List<UUID> folderIDs, bool onlyIfTrash)
+        {
             if (!m_AllowDelete)
                 return false;
 
@@ -371,11 +393,12 @@ namespace OpenSim.Services.InventoryService
             //
             foreach (UUID id in folderIDs)
             {
-                if (!ParentIsTrash(id))
+                if (onlyIfTrash && !ParentIsTrash(id))
                     continue;
+                //m_log.InfoFormat("[XINVENTORY SERVICE]: Delete folder {0}", id);
                 InventoryFolderBase f = new InventoryFolderBase();
                 f.ID = id;
-                PurgeFolder(f);
+                PurgeFolder(f, onlyIfTrash);
                 m_Database.DeleteFolders("folderID", id.ToString());
             }
 
@@ -384,10 +407,15 @@ namespace OpenSim.Services.InventoryService
 
         public virtual bool PurgeFolder(InventoryFolderBase folder)
         {
+            return PurgeFolder(folder, true);
+        }
+
+        public virtual bool PurgeFolder(InventoryFolderBase folder, bool onlyIfTrash)
+        {
             if (!m_AllowDelete)
                 return false;
 
-            if (!ParentIsTrash(folder.ID))
+            if (onlyIfTrash && !ParentIsTrash(folder.ID))
                 return false;
 
             XInventoryFolder[] subFolders = m_Database.GetFolders(
@@ -396,7 +424,7 @@ namespace OpenSim.Services.InventoryService
 
             foreach (XInventoryFolder x in subFolders)
             {
-                PurgeFolder(ConvertToOpenSim(x));
+                PurgeFolder(ConvertToOpenSim(x), onlyIfTrash);
                 m_Database.DeleteFolders("folderID", x.folderID.ToString());
             }
 
@@ -408,14 +436,13 @@ namespace OpenSim.Services.InventoryService
         public virtual bool AddItem(InventoryItemBase item)
         {
 //            m_log.DebugFormat(
-//                "[XINVENTORY SERVICE]: Adding item {0} to folder {1} for {2}", item.ID, item.Folder, item.Owner);
+//                "[XINVENTORY SERVICE]: Adding item {0} {1} to folder {2} for {3}", item.Name, item.ID, item.Folder, item.Owner);
             
             return m_Database.StoreItem(ConvertFromOpenSim(item));
         }
 
         public virtual bool UpdateItem(InventoryItemBase item)
         {
-//            throw new Exception("urrgh");
             if (!m_AllowDelete)
                 if (item.AssetType == (sbyte)AssetType.Link || item.AssetType == (sbyte)AssetType.LinkFolder)
                     return false;
diff --git a/OpenSim/Services/LLLoginService/LLLoginResponse.cs b/OpenSim/Services/LLLoginService/LLLoginResponse.cs
index 079bcb1..a4b3cbd 100644
--- a/OpenSim/Services/LLLoginService/LLLoginResponse.cs
+++ b/OpenSim/Services/LLLoginService/LLLoginResponse.cs
@@ -231,7 +231,8 @@ namespace OpenSim.Services.LLLoginService
         public LLLoginResponse(UserAccount account, AgentCircuitData aCircuit, GridUserInfo pinfo,
             GridRegion destination, List<InventoryFolderBase> invSkel, FriendInfo[] friendsList, ILibraryService libService,
             string where, string startlocation, Vector3 position, Vector3 lookAt, List<InventoryItemBase> gestures, string message,
-            GridRegion home, IPEndPoint clientIP, string mapTileURL, string profileURL, string openIDURL, string searchURL, string currency)
+            GridRegion home, IPEndPoint clientIP, string mapTileURL, string profileURL, string openIDURL, string searchURL, string currency,
+            string DSTZone)
             : this()
         {
             FillOutInventoryData(invSkel, libService);
@@ -260,7 +261,45 @@ namespace OpenSim.Services.LLLoginService
             FillOutRegionData(destination);
 
             FillOutSeedCap(aCircuit, destination, clientIP);
-            
+
+            switch (DSTZone)
+            {
+                case "none":
+                    DST = "N";
+                    break;
+                case "local":
+                    DST = TimeZone.CurrentTimeZone.IsDaylightSavingTime(DateTime.Now) ? "Y" : "N";
+                    break;
+                default:
+                    TimeZoneInfo dstTimeZone = null;
+                    string[] tzList = DSTZone.Split(';');
+
+                    foreach (string tzName in tzList)
+                    {
+                        try
+                        {
+                            dstTimeZone = TimeZoneInfo.FindSystemTimeZoneById(tzName);
+                        }
+                        catch
+                        {
+                            continue;
+                        }
+                        break;
+                    }
+
+                    if (dstTimeZone == null)
+                    {
+                        m_log.WarnFormat(
+                            "[LLOGIN RESPONSE]: No valid timezone found for DST in {0}, falling back to system time.", tzList);
+                        DST = TimeZone.CurrentTimeZone.IsDaylightSavingTime(DateTime.Now) ? "Y" : "N";
+                    }
+                    else
+                    {
+                        DST = dstTimeZone.IsDaylightSavingTime(DateTime.Now) ? "Y" : "N";
+                    }
+                
+                    break;
+            }
         }
 
         private void FillOutInventoryData(List<InventoryFolderBase> invSkel, ILibraryService libService)
@@ -355,7 +394,31 @@ namespace OpenSim.Services.LLLoginService
 
         private void SetDefaultValues()
         {
-            DST = TimeZone.CurrentTimeZone.IsDaylightSavingTime(DateTime.Now) ? "Y" : "N";
+            TimeZoneInfo gridTimeZone;
+
+            // Disabled for now pending making timezone a config value, which can at some point have a default of
+            // a ; separated list of possible timezones.
+            // The problem here is that US/Pacific (or even the Olsen America/Los_Angeles) is not universal across
+            // windows, mac and various distributions of linux, introducing another element of consistency.
+            // The server operator needs to be able to control this setting
+//            try
+//            {
+//                // First try to fetch DST from Pacific Standard Time, because this is
+//                // the one expected by the viewer. "US/Pacific" is the string to search 
+//                // on linux and mac, and should work also on Windows (to confirm)
+//                gridTimeZone = TimeZoneInfo.FindSystemTimeZoneById("US/Pacific");
+//            }
+//            catch (Exception e)
+//            {
+//                m_log.WarnFormat(
+//                    "[TIMEZONE]: {0} Falling back to system time. System time should be set to Pacific Standard Time to provide the expected time",
+//                    e.Message);
+
+                gridTimeZone = TimeZoneInfo.Local;
+//            }
+
+            DST = gridTimeZone.IsDaylightSavingTime(DateTime.Now) ? "Y" : "N";
+
             StipendSinceLogin = "N";
             Gendered = "Y";
             EverLoggedIn = "Y";
diff --git a/OpenSim/Services/LLLoginService/LLLoginService.cs b/OpenSim/Services/LLLoginService/LLLoginService.cs
index 891c452..ed887d9 100644
--- a/OpenSim/Services/LLLoginService/LLLoginService.cs
+++ b/OpenSim/Services/LLLoginService/LLLoginService.cs
@@ -82,6 +82,8 @@ namespace OpenSim.Services.LLLoginService
         protected string m_AllowedClients;
         protected string m_DeniedClients;
 
+        protected string m_DSTZone;
+
         IConfig m_LoginServerConfig;
 //        IConfig m_ClientsConfig;
 
@@ -118,6 +120,8 @@ namespace OpenSim.Services.LLLoginService
             m_AllowedClients = m_LoginServerConfig.GetString("AllowedClients", string.Empty);
             m_DeniedClients = m_LoginServerConfig.GetString("DeniedClients", string.Empty);
 
+            m_DSTZone = m_LoginServerConfig.GetString("DSTZone", "America/Los_Angeles;Pacific Standard Time");
+
             // Clean up some of these vars
             if (m_MapTileURL != String.Empty)
             {
@@ -241,6 +245,7 @@ namespace OpenSim.Services.LLLoginService
 
             m_log.InfoFormat("[LLOGIN SERVICE]: Login request for {0} {1} at {2} using viewer {3}, channel {4}, IP {5}, Mac {6}, Id0 {7}",
                 firstName, lastName, startLocation, clientVersion, channel, clientIP.Address.ToString(), mac, id0);
+            
             try
             {
                 //
@@ -253,7 +258,9 @@ namespace OpenSim.Services.LLLoginService
 
                     if (!am.Success)
                     {
-                        m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: client {0} is not allowed", clientVersion);
+                        m_log.InfoFormat(
+                            "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: client {2} is not allowed",
+                            firstName, lastName, clientVersion);
                         return LLFailedLoginResponse.LoginBlockedProblem;
                     }
                 }
@@ -265,7 +272,9 @@ namespace OpenSim.Services.LLLoginService
 
                     if (dm.Success)
                     {
-                        m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: client {0} is denied", clientVersion);
+                        m_log.InfoFormat(
+                            "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: client {2} is denied",
+                            firstName, lastName, clientVersion);
                         return LLFailedLoginResponse.LoginBlockedProblem;
                     }
                 }
@@ -276,7 +285,8 @@ namespace OpenSim.Services.LLLoginService
                 UserAccount account = m_UserAccountService.GetUserAccount(scopeID, firstName, lastName);
                 if (account == null)
                 {
-                    m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: user not found");
+                    m_log.InfoFormat(
+                        "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: user not found", firstName, lastName);
                     return LLFailedLoginResponse.UserProblem;
                 }
 
@@ -288,7 +298,9 @@ namespace OpenSim.Services.LLLoginService
 
                 if (account.UserLevel < m_MinLoginLevel)
                 {
-                    m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: login is blocked for user level {0}", account.UserLevel);
+                    m_log.InfoFormat(
+                        "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: user level is {2} but minimum login level is {3}",
+                        firstName, lastName, m_MinLoginLevel, account.UserLevel);
                     return LLFailedLoginResponse.LoginBlockedProblem;
                 }
 
@@ -299,7 +311,8 @@ namespace OpenSim.Services.LLLoginService
                 {
                     if (account.ScopeID != scopeID && account.ScopeID != UUID.Zero)
                     {
-                        m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: user not found");
+                        m_log.InfoFormat(
+                            "[LLOGIN SERVICE]: Login failed, reason: user {0} {1} not found", firstName, lastName);
                         return LLFailedLoginResponse.UserProblem;
                     }
                 }
@@ -318,7 +331,9 @@ namespace OpenSim.Services.LLLoginService
                 UUID secureSession = UUID.Zero;
                 if ((token == string.Empty) || (token != string.Empty && !UUID.TryParse(token, out secureSession)))
                 {
-                    m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: authentication failed");
+                    m_log.InfoFormat(
+                        "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: authentication failed",
+                        firstName, lastName);
                     return LLFailedLoginResponse.UserProblem;
                 }
 
@@ -327,13 +342,18 @@ namespace OpenSim.Services.LLLoginService
                 //
                 if (m_RequireInventory && m_InventoryService == null)
                 {
-                    m_log.WarnFormat("[LLOGIN SERVICE]: Login failed, reason: inventory service not set up");
+                    m_log.WarnFormat(
+                        "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: inventory service not set up",
+                        firstName, lastName);
                     return LLFailedLoginResponse.InventoryProblem;
                 }
+
                 List<InventoryFolderBase> inventorySkel = m_InventoryService.GetInventorySkeleton(account.PrincipalID);
                 if (m_RequireInventory && ((inventorySkel == null) || (inventorySkel != null && inventorySkel.Count == 0)))
                 {
-                    m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: unable to retrieve user inventory");
+                    m_log.InfoFormat(
+                        "[LLOGIN SERVICE]: Login failed, for {0} {1}, reason: unable to retrieve user inventory",
+                        firstName, lastName);
                     return LLFailedLoginResponse.InventoryProblem;
                 }
 
@@ -347,9 +367,12 @@ namespace OpenSim.Services.LLLoginService
                 if (m_PresenceService != null)
                 {
                     success = m_PresenceService.LoginAgent(account.PrincipalID.ToString(), session, secureSession);
+
                     if (!success)
                     {
-                        m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: could not login presence");
+                        m_log.InfoFormat(
+                            "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: could not login presence",
+                            firstName, lastName);
                         return LLFailedLoginResponse.GridProblem;
                     }
                 }
@@ -382,9 +405,18 @@ namespace OpenSim.Services.LLLoginService
                 if (destination == null)
                 {
                     m_PresenceService.LogoutAgent(session);
-                    m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: destination not found");
+
+                    m_log.InfoFormat(
+                        "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: destination not found",
+                        firstName, lastName);
                     return LLFailedLoginResponse.GridProblem;
                 }
+                else
+                {
+                    m_log.DebugFormat(
+                        "[LLOGIN SERVICE]: Found destination {0}, endpoint {1} for {2} {3}",
+                        destination.RegionName, destination.ExternalEndPoint, firstName, lastName);
+                }
 
                 if (account.UserLevel >= 200)
                     flags |= TeleportFlags.Godlike;
@@ -408,7 +440,7 @@ namespace OpenSim.Services.LLLoginService
                 if (aCircuit == null)
                 {
                     m_PresenceService.LogoutAgent(session);
-                    m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: {0}", reason);
+                    m_log.InfoFormat("[LLOGIN SERVICE]: Login failed for {0} {1}, reason: {2}", firstName, lastName, reason);
                     return new LLFailedLoginResponse("key", reason, "false");
 
                 }
@@ -423,10 +455,14 @@ namespace OpenSim.Services.LLLoginService
                 //
                 // Finally, fill out the response and return it
                 //
-                LLLoginResponse response = new LLLoginResponse(account, aCircuit, guinfo, destination, inventorySkel, friendsList, m_LibraryService,
-                    where, startLocation, position, lookAt, gestures, m_WelcomeMessage, home, clientIP, m_MapTileURL, m_ProfileURL, m_OpenIDURL, m_SearchURL, m_Currency);
+                LLLoginResponse response
+                    = new LLLoginResponse(
+                        account, aCircuit, guinfo, destination, inventorySkel, friendsList, m_LibraryService,
+                        where, startLocation, position, lookAt, gestures, m_WelcomeMessage, home, clientIP,
+                        m_MapTileURL, m_ProfileURL, m_OpenIDURL, m_SearchURL, m_Currency, m_DSTZone);
+
+                m_log.DebugFormat("[LLOGIN SERVICE]: All clear. Sending login response to {0} {1}", firstName, lastName);
 
-                m_log.DebugFormat("[LLOGIN SERVICE]: All clear. Sending login response to client.");
                 return response;
             }
             catch (Exception e)
@@ -438,11 +474,16 @@ namespace OpenSim.Services.LLLoginService
             }
         }
 
-        protected GridRegion FindDestination(UserAccount account, UUID scopeID, GridUserInfo pinfo, UUID sessionID, string startLocation, GridRegion home, out GridRegion gatekeeper, out string where, out Vector3 position, out Vector3 lookAt, out TeleportFlags flags)
+        protected GridRegion FindDestination(
+            UserAccount account, UUID scopeID, GridUserInfo pinfo, UUID sessionID, string startLocation,
+            GridRegion home, out GridRegion gatekeeper,
+            out string where, out Vector3 position, out Vector3 lookAt, out TeleportFlags flags)
         {
             flags = TeleportFlags.ViaLogin;
 
-            m_log.DebugFormat("[LLOGIN SERVICE]: FindDestination for start location {0}", startLocation);
+            m_log.DebugFormat(
+                "[LLOGIN SERVICE]: Finding destination matching start location {0} for {1}",
+                startLocation, account.Name);
 
             gatekeeper = null;
             where = "home";