8 files changed, 815 insertions, 100 deletions

diff --git a/OpenSim/Grid/UserServer.Modules/GridInfoServiceModule.cs b/OpenSim/Data/Null/NullAuthenticationData.cs
index 0c84348..3fb3105 100644
--- a/OpenSim/Grid/UserServer.Modules/GridInfoServiceModule.cs
+++ b/OpenSim/Data/Null/NullAuthenticationData.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -26,54 +26,56 @@
  */
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.IO;
-using System.Reflection;
-using log4net;
-using log4net.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
-using OpenSim.Framework.Communications.Services;
-using OpenSim.Framework.Communications.Cache;
-using OpenSim.Framework.Servers;
-using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Grid.Communications.OGS1;
-using OpenSim.Grid.Framework;
+using OpenSim.Data;
 
-namespace OpenSim.Grid.UserServer.Modules
+namespace OpenSim.Data.Null
 {
-    public class GridInfoServiceModule
+    public class NullAuthenticationData : IAuthenticationData
     {
-        protected IGridServiceCore m_core;
-        protected GridInfoService m_gridInfoService;
-        protected BaseHttpServer m_httpServer;
+        private static Dictionary<UUID, AuthenticationData> m_DataByUUID = new Dictionary<UUID, AuthenticationData>();
+        private static Dictionary<UUID, string> m_Tokens = new Dictionary<UUID, string>();
 
-        public GridInfoServiceModule()
+        public NullAuthenticationData(string connectionString, string realm)
         {
         }
 
-        public void Initialise(IGridServiceCore core)
+        public AuthenticationData Get(UUID principalID)
         {
-            m_core = core;
-            m_gridInfoService = new GridInfoService();
+            if (m_DataByUUID.ContainsKey(principalID))
+                return m_DataByUUID[principalID];
+
+            return null;
         }
 
-        public void PostInitialise()
+        public bool Store(AuthenticationData data)
         {
+            m_DataByUUID[data.PrincipalID] = data;
+            return true;
+        }
 
+        public bool SetDataItem(UUID principalID, string item, string value)
+        {
+            // Not implemented
+            return false;
         }
 
-        public void RegisterHandlers(BaseHttpServer httpServer)
+        public bool SetToken(UUID principalID, string token, int lifetime)
         {
-            m_httpServer = httpServer;
-            m_httpServer.AddStreamHandler(new RestStreamHandler("GET", "/get_grid_info",
-                                                               m_gridInfoService.RestGetGridInfoMethod));
-            m_httpServer.AddXmlRPCHandler("get_grid_info", m_gridInfoService.XmlRpcGridInfoMethod);
+            m_Tokens[principalID] = token;
+            return true;
         }
 
-        public void Close()
+        public bool CheckToken(UUID principalID, string token, int lifetime)
         {
+            if (m_Tokens.ContainsKey(principalID))
+                return m_Tokens[principalID] == token;
+
+            return false;
         }
+
     }
 }
diff --git a/OpenSim/Grid/MessagingServer.Modules/PresenceBackreferenceEntry.cs b/OpenSim/Data/Null/NullAvatarData.cs
index 67dde6d..c81ba43 100644
--- a/OpenSim/Grid/MessagingServer.Modules/PresenceBackreferenceEntry.cs
+++ b/OpenSim/Data/Null/NullAvatarData.cs
@@ -25,72 +25,69 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
+using System.Collections;
 using System.Collections.Generic;
 using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Data;
 
-namespace OpenSim.Grid.MessagingServer.Modules
+namespace OpenSim.Data.Null
 {
-    // This is a wrapper for a List<UUID> so it can be happily stored in a hashtable.
-    public class PresenceBackreferenceEntry
+    public class NullAvatarData : IAvatarData
     {
-        List<UUID> AgentList = new List<UUID>();
+        private static Dictionary<UUID, AvatarBaseData> m_DataByUUID = new Dictionary<UUID, AvatarBaseData>();
 
-        public PresenceBackreferenceEntry()
+        public NullAvatarData(string connectionString, string realm)
         {
-
         }
 
-        public void Add(UUID item)
+        public AvatarBaseData[] Get(string field, string val)
         {
-            lock (AgentList)
+            if (field == "PrincipalID")
             {
-                AgentList.Add(item);
+                UUID id = UUID.Zero;
+                if (UUID.TryParse(val, out id))
+                    if (m_DataByUUID.ContainsKey(id))
+                        return new AvatarBaseData[] { m_DataByUUID[id] };
             }
-        }
 
-        public UUID getitem(int index)
-        {
-            UUID result = UUID.Zero;
-            lock (AgentList)
-            {
-                if (index > 0 && index < AgentList.Count)
-                {
-                    result = AgentList[index];
-                }
-            }
-            return result;
+            // Fail
+            return new AvatarBaseData[0];
         }
 
-        public int Count
+        public bool Store(AvatarBaseData data)
         {
-            get
-            {
-                int count = 0;
-                lock (AgentList)
-                {
-                    count = AgentList.Count;
-                }
-                return count;
-            }
+            m_DataByUUID[data.PrincipalID] = data;
+            return true;
         }
 
-        public void Remove(UUID item)
+        public bool Delete(UUID principalID, string name)
         {
-            lock (AgentList)
+            if (m_DataByUUID.ContainsKey(principalID) && m_DataByUUID[principalID].Data.ContainsKey(name))
             {
-                if (AgentList.Contains(item))
-                    AgentList.Remove(item);
+                    m_DataByUUID[principalID].Data.Remove(name);
+                    return true;
             }
+
+            return false;
         }
 
-        public bool contains(UUID item)
+        public bool Delete(string field, string val)
         {
-            bool result = false;
-            lock (AgentList)
+            if (field == "PrincipalID")
             {
-                result = AgentList.Contains(item);
+                UUID id = UUID.Zero;
+                if (UUID.TryParse(val, out id))
+                    if (m_DataByUUID.ContainsKey(id))
+                    {
+                        m_DataByUUID.Remove(id);
+                        return true;
+                    }
             }
-            return result;
+
+            return false;
         }
+
     }
 }
diff --git a/OpenSim/Data/Null/NullDataStore.cs b/OpenSim/Data/Null/NullDataStore.cs
index 4b6d0f3..3ba44bb 100644
--- a/OpenSim/Data/Null/NullDataStore.cs
+++ b/OpenSim/Data/Null/NullDataStore.cs
@@ -50,13 +50,13 @@ namespace OpenSim.Data.Null
         public void StoreRegionSettings(RegionSettings rs)
         {
         }
-        public RegionMeta7WindlightData LoadRegionWindlightSettings(UUID regionUUID)
+        public RegionLightShareData LoadRegionWindlightSettings(UUID regionUUID)
         {
             //This connector doesn't support the windlight module yet
             //Return default LL windlight settings
-            return new RegionMeta7WindlightData();
+            return new RegionLightShareData();
         }
-        public void StoreRegionWindlightSettings(RegionMeta7WindlightData wl)
+        public void StoreRegionWindlightSettings(RegionLightShareData wl)
         {
             //This connector doesn't support the windlight module yet
         }
diff --git a/OpenSim/Grid/MessagingServer.Modules/UserDataBaseService.cs b/OpenSim/Data/Null/NullFriendsData.cs
index 76c4899..e7f7fd3 100644
--- a/OpenSim/Grid/MessagingServer.Modules/UserDataBaseService.cs
+++ b/OpenSim/Data/Null/NullFriendsData.cs
@@ -25,51 +25,68 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
+using System.Collections;
+using System.Collections.Generic;
 using OpenMetaverse;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
+using OpenSim.Data;
 
-namespace OpenSim.Grid.MessagingServer.Modules
+namespace OpenSim.Data.Null
 {
-    public class UserDataBaseService : UserManagerBase
+    public class NullFriendsData : IFriendsData
     {
-        /// <summary>
-        /// Constructor.
-        /// </summary>
-        /// Passing null to parent because we never use any function that requires an interservice inventory call.
-        public UserDataBaseService()
-            : base(null)
+        private static List<FriendsData> m_Data = new List<FriendsData>();
+
+        public NullFriendsData(string connectionString, string realm)
         {
         }
-        
-        public UserAgentData GetUserAgentData(UUID AgentID)
-        {
-            UserProfileData userProfile = GetUserProfile(AgentID);
 
-            if (userProfile != null)
+        /// <summary>
+        /// Tries to implement the Get [] semantics, but it cuts corners.
+        /// Specifically, it gets all friendships even if they weren't accepted yet.
+        /// </summary>
+        /// <param name="fields"></param>
+        /// <param name="values"></param>
+        /// <returns></returns>
+        public FriendsData[] GetFriends(UUID userID)
+        {
+            List<FriendsData> lst = m_Data.FindAll(delegate (FriendsData fdata)
             {
-                return userProfile.CurrentAgent;
-            }
+                return fdata.PrincipalID == userID;
+            });
 
-            return null;
-        }
+            if (lst != null)
+                return lst.ToArray();
 
-        public override UserProfileData SetupMasterUser(string firstName, string lastName)
-        {
-            //throw new Exception("The method or operation is not implemented.");
-            return null;
+            return new FriendsData[0];
         }
 
-        public override UserProfileData SetupMasterUser(string firstName, string lastName, string password)
+        public bool Store(FriendsData data)
         {
-            //throw new Exception("The method or operation is not implemented.");
-            return null;
+            if (data == null)
+                return false;
+
+            m_Data.Add(data);
+
+            return true;
         }
 
-        public override UserProfileData SetupMasterUser(UUID uuid)
+        public bool Delete(UUID userID, string friendID)
         {
-            //throw new Exception("The method or operation is not implemented.");
-            return null;
+            List<FriendsData> lst = m_Data.FindAll(delegate(FriendsData fdata) { return fdata.PrincipalID == userID; });
+            if (lst != null)
+            {
+                FriendsData friend = lst.Find(delegate(FriendsData fdata) { return fdata.Friend == friendID; });
+                if (friendID != null)
+                {
+                    m_Data.Remove(friend);
+                    return true;
+                }
+            }
+
+            return false;
         }
+
     }
 }
diff --git a/OpenSim/Data/Null/NullInventoryData.cs b/OpenSim/Data/Null/NullInventoryData.cs
new file mode 100644
index 0000000..8f196e2
--- /dev/null
+++ b/OpenSim/Data/Null/NullInventoryData.cs
@@ -0,0 +1,193 @@
+using System;
+using System.Collections.Generic;
+
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Data.Null
+{
+    /// <summary>
+    /// This class is completely null.
+    /// </summary>
+    public class NullInventoryData : IInventoryDataPlugin
+    {
+        public string Version { get { return "1.0.0.0"; } }
+
+        public void Initialise()
+        {
+        }
+
+        public void Dispose()
+        {
+            // Do nothing.
+        }
+
+        public string Name
+        {
+            get { return "Null Inventory Data Interface"; }
+        }
+
+        public void Initialise(string connect)
+        {
+        }
+
+
+        /// <summary>
+        /// Returns all descendent folders of this folder.  Does not return the parent folder itself.
+        /// </summary>
+        /// <param name="parentID">The folder to get subfolders for</param>
+        /// <returns>A list of inventory folders</returns>
+        public List<InventoryFolderBase> getFolderHierarchy(UUID parentID)
+        {
+            return new List<InventoryFolderBase>();
+        }
+
+        /// <summary>
+        /// Returns a list of inventory items contained within the specified folder
+        /// </summary>
+        /// <param name="folderID">The UUID of the target folder</param>
+        /// <returns>A List of InventoryItemBase items</returns>
+        public List<InventoryItemBase> getInventoryInFolder(UUID folderID)
+        {
+            return new List<InventoryItemBase>();
+        }
+
+        /// <summary>
+        /// Returns a list of the root folders within a users inventory
+        /// </summary>
+        /// <param name="user">The user whos inventory is to be searched</param>
+        /// <returns>A list of folder objects</returns>
+        public List<InventoryFolderBase> getUserRootFolders(UUID user)
+        {
+            return new List<InventoryFolderBase>();
+        }
+
+        /// <summary>
+        /// Returns the users inventory root folder.
+        /// </summary>
+        /// <param name="user">The UUID of the user who is having inventory being returned</param>
+        /// <returns>Root inventory folder, null if no root inventory folder was found</returns>
+        public InventoryFolderBase getUserRootFolder(UUID user)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a list of inventory folders contained in the folder 'parentID'
+        /// </summary>
+        /// <param name="parentID">The folder to get subfolders for</param>
+        /// <returns>A list of inventory folders</returns>
+        public List<InventoryFolderBase> getInventoryFolders(UUID parentID)
+        {
+            return new List<InventoryFolderBase>();
+        }
+
+        /// <summary>
+        /// Returns an inventory item by its UUID
+        /// </summary>
+        /// <param name="item">The UUID of the item to be returned</param>
+        /// <returns>A class containing item information</returns>
+        public InventoryItemBase getInventoryItem(UUID item)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a specified inventory folder by its UUID
+        /// </summary>
+        /// <param name="folder">The UUID of the folder to be returned</param>
+        /// <returns>A class containing folder information</returns>
+        public InventoryFolderBase getInventoryFolder(UUID folder)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Creates a new inventory item based on item
+        /// </summary>
+        /// <param name="item">The item to be created</param>
+        public void addInventoryItem(InventoryItemBase item)
+        {
+        }
+
+        /// <summary>
+        /// Updates an inventory item with item (updates based on ID)
+        /// </summary>
+        /// <param name="item">The updated item</param>
+        public void updateInventoryItem(InventoryItemBase item)
+        {
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="item"></param>
+        public void deleteInventoryItem(UUID item)
+        {
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="item"></param>
+        public InventoryItemBase queryInventoryItem(UUID item)
+        {
+            return null;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="item"></param>
+        public InventoryFolderBase queryInventoryFolder(UUID folder)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Adds a new folder specified by folder
+        /// </summary>
+        /// <param name="folder">The inventory folder</param>
+        public void addInventoryFolder(InventoryFolderBase folder)
+        {
+        }
+
+        /// <summary>
+        /// Updates a folder based on its ID with folder
+        /// </summary>
+        /// <param name="folder">The inventory folder</param>
+        public void updateInventoryFolder(InventoryFolderBase folder)
+        {
+        }
+
+        /// <summary>
+        /// Updates a folder based on its ID with folder
+        /// </summary>
+        /// <param name="folder">The inventory folder</param>
+        public void moveInventoryFolder(InventoryFolderBase folder)
+        {
+        }
+
+        /// <summary>
+        /// Deletes a folder.  Thie will delete both the folder itself and its contents (items and descendent folders)
+        /// </summary>
+        /// <param name="folder">The id of the folder</param>
+        public void deleteInventoryFolder(UUID folder)
+        {
+        }
+
+        /// <summary>
+        /// Returns all activated gesture-items in the inventory of the specified avatar.
+        /// </summary>
+        /// <param name="avatarID">
+        /// The <see cref="UUID"/> of the avatar
+        /// </param>
+        /// <returns>
+        /// The list of gestures (<see cref="InventoryItemBase"/>s)
+        /// </returns>
+        public List<InventoryItemBase> fetchActiveGestures(UUID avatarID)
+        {
+            return new List<InventoryItemBase>();
+        }
+    }
+}
diff --git a/OpenSim/Data/Null/NullPresenceData.cs b/OpenSim/Data/Null/NullPresenceData.cs
new file mode 100644
index 0000000..b98b5c9
--- /dev/null
+++ b/OpenSim/Data/Null/NullPresenceData.cs
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Data;
+
+namespace OpenSim.Data.Null
+{
+    public class NullPresenceData : IPresenceData
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private static NullPresenceData Instance;
+
+        Dictionary<UUID, PresenceData> m_presenceData = new Dictionary<UUID, PresenceData>();
+
+        public NullPresenceData(string connectionString, string realm)
+        {
+            if (Instance == null)
+            {
+                Instance = this;
+
+                //Console.WriteLine("[XXX] NullRegionData constructor");
+            }
+        }
+
+        public bool Store(PresenceData data)
+        {
+            if (Instance != this)
+                return Instance.Store(data);
+
+//            m_log.DebugFormat("[NULL PRESENCE DATA]: Storing presence {0}", data.UserID);
+//            Console.WriteLine("HOME for " + data.UserID + " is " + (data.Data.ContainsKey("HomeRegionID") ? data.Data["HomeRegionID"] : "Not found"));
+
+            m_presenceData[data.SessionID] = data;
+            return true;
+        }
+
+        public PresenceData Get(UUID sessionID)
+        {
+            if (Instance != this)
+                return Instance.Get(sessionID);
+
+            if (m_presenceData.ContainsKey(sessionID))
+            {
+                return m_presenceData[sessionID];
+            }
+
+            return null;
+        }
+
+        public void LogoutRegionAgents(UUID regionID)
+        {
+            if (Instance != this)
+            {
+                Instance.LogoutRegionAgents(regionID);
+                return;
+            }
+
+            List<UUID> toBeDeleted = new List<UUID>();
+            foreach (KeyValuePair<UUID, PresenceData> kvp in m_presenceData)
+                if (kvp.Value.RegionID == regionID)
+                    toBeDeleted.Add(kvp.Key);
+
+            foreach (UUID u in toBeDeleted)
+                m_presenceData.Remove(u);
+        }
+
+        public bool ReportAgent(UUID sessionID, UUID regionID, string position, string lookAt)
+        {
+            if (Instance != this)
+                return Instance.ReportAgent(sessionID, regionID, position, lookAt);
+            
+            if (m_presenceData.ContainsKey(sessionID))
+            {
+                m_presenceData[sessionID].RegionID = regionID;
+                m_presenceData[sessionID].Data["Position"] = position;
+                m_presenceData[sessionID].Data["LookAt"] = lookAt;
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool SetHomeLocation(string userID, UUID regionID, Vector3 position, Vector3 lookAt)
+        {
+            if (Instance != this)
+                return Instance.SetHomeLocation(userID, regionID, position, lookAt);
+
+            bool foundone = false;
+            foreach (PresenceData p in m_presenceData.Values)
+            {
+                if (p.UserID == userID)
+                {
+//                    m_log.DebugFormat(
+//                        "[NULL PRESENCE DATA]: Setting home location {0} {1} {2} for {3}", 
+//                        regionID, position, lookAt, p.UserID);
+
+                    p.Data["HomeRegionID"] = regionID.ToString();
+                    p.Data["HomePosition"] = position.ToString();
+                    p.Data["HomeLookAt"] = lookAt.ToString();
+                    foundone = true;
+                }
+            }
+
+            return foundone;
+        }
+
+        public PresenceData[] Get(string field, string data)
+        {
+            if (Instance != this)
+                return Instance.Get(field, data);
+
+//            m_log.DebugFormat(
+//                "[NULL PRESENCE DATA]: Getting presence data for field {0} with parameter {1}", field, data);
+
+            List<PresenceData> presences = new List<PresenceData>();
+            if (field == "UserID")
+            {
+                foreach (PresenceData p in m_presenceData.Values)
+                {
+                    if (p.UserID == data)
+                    {
+                        presences.Add(p);
+//                        Console.WriteLine("HOME for " + p.UserID + " is " + (p.Data.ContainsKey("HomeRegionID") ? p.Data["HomeRegionID"] : "Not found"));
+                    }
+                }
+                
+                return presences.ToArray();
+            }
+            else if (field == "SessionID")
+            {
+                UUID session = UUID.Zero;
+                if (!UUID.TryParse(data, out session))
+                    return presences.ToArray();
+
+                if (m_presenceData.ContainsKey(session))
+                {
+                    presences.Add(m_presenceData[session]);
+                    return presences.ToArray();
+                }
+            }
+            else if (field == "RegionID")
+            {
+                UUID region = UUID.Zero;
+                if (!UUID.TryParse(data, out region))
+                    return presences.ToArray();
+                foreach (PresenceData p in m_presenceData.Values)
+                    if (p.RegionID == region)
+                        presences.Add(p);
+                return presences.ToArray();
+            }
+            else
+            {
+                foreach (PresenceData p in m_presenceData.Values)
+                {
+                    if (p.Data.ContainsKey(field) && p.Data[field] == data)
+                        presences.Add(p);
+                }
+                return presences.ToArray();
+            }
+
+            return presences.ToArray();
+        }
+
+        public void Prune(string userID)
+        {
+            if (Instance != this)
+            {
+                Instance.Prune(userID);
+                return;
+            }
+
+//            m_log.DebugFormat("[NULL PRESENCE DATA]: Prune called for {0}", userID);
+
+            List<UUID> deleteSessions = new List<UUID>();
+            int online = 0;
+
+            foreach (KeyValuePair<UUID, PresenceData> kvp in m_presenceData)
+            {
+//                m_log.DebugFormat("Online: {0}", kvp.Value.Data["Online"]);
+                
+                bool on = false;
+                if (bool.TryParse(kvp.Value.Data["Online"], out on) && on)
+                    online++;
+                else
+                    deleteSessions.Add(kvp.Key);
+            }
+
+//            m_log.DebugFormat("[NULL PRESENCE DATA]: online [{0}], deleteSession.Count [{1}]", online, deleteSessions.Count);
+
+            // Leave one session behind so that we can pick up details such as home location
+            if (online == 0 && deleteSessions.Count > 0)
+                deleteSessions.RemoveAt(0);
+
+            foreach (UUID s in deleteSessions)
+                m_presenceData.Remove(s);
+        }
+
+        public bool Delete(string field, string data)
+        {
+//            m_log.DebugFormat(
+//                "[NULL PRESENCE DATA]: Deleting presence data for field {0} with parameter {1}", field, data);
+            
+            if (Instance != this)
+                return Instance.Delete(field, data);
+
+            List<UUID> presences = new List<UUID>();
+            if (field == "UserID")
+            {
+                foreach (KeyValuePair<UUID, PresenceData> p in m_presenceData)
+                    if (p.Value.UserID == data)
+                        presences.Add(p.Key);
+            }
+            else if (field == "SessionID")
+            {
+                UUID session = UUID.Zero;
+                if (UUID.TryParse(data, out session))
+                {
+                    if (m_presenceData.ContainsKey(session))
+                    {
+                        presences.Add(session);
+                    }
+                }
+            }
+            else if (field == "RegionID")
+            {
+                UUID region = UUID.Zero;
+                if (UUID.TryParse(data, out region))
+                {
+                    foreach (KeyValuePair<UUID, PresenceData> p in m_presenceData)
+                        if (p.Value.RegionID == region)
+                            presences.Add(p.Key);
+                }
+            }
+            else
+            {
+                foreach (KeyValuePair<UUID, PresenceData> p in m_presenceData)
+                {
+                    if (p.Value.Data.ContainsKey(field) && p.Value.Data[field] == data)
+                        presences.Add(p.Key);
+                }
+            }
+
+            foreach (UUID u in presences)
+                m_presenceData.Remove(u);
+
+            if (presences.Count == 0)
+                return false;
+
+            return true;
+        }
+
+    }
+}
diff --git a/OpenSim/Data/Null/NullRegionData.cs b/OpenSim/Data/Null/NullRegionData.cs
index e8263ea..30ad747 100644
--- a/OpenSim/Data/Null/NullRegionData.cs
+++ b/OpenSim/Data/Null/NullRegionData.cs
@@ -31,20 +31,31 @@ using System.Collections.Generic;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Data;
+using System.Reflection;
+using log4net;
 
 namespace OpenSim.Data.Null
 {
     public class NullRegionData : IRegionData
     {
+        private static NullRegionData Instance = null;
+
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         Dictionary<UUID, RegionData> m_regionData = new Dictionary<UUID, RegionData>();
 
         public NullRegionData(string connectionString, string realm)
         {
+            if (Instance == null)
+                Instance = this;
             //Console.WriteLine("[XXX] NullRegionData constructor");
         }
 
         public List<RegionData> Get(string regionName, UUID scopeID)
         {
+            if (Instance != this)
+                return Instance.Get(regionName, scopeID);
+
             List<RegionData> ret = new List<RegionData>();
 
             foreach (RegionData r in m_regionData.Values)
@@ -69,6 +80,9 @@ namespace OpenSim.Data.Null
 
         public RegionData Get(int posX, int posY, UUID scopeID)
         {
+            if (Instance != this)
+                return Instance.Get(posX, posY, scopeID);
+
             List<RegionData> ret = new List<RegionData>();
 
             foreach (RegionData r in m_regionData.Values)
@@ -85,6 +99,9 @@ namespace OpenSim.Data.Null
 
         public RegionData Get(UUID regionID, UUID scopeID)
         {
+            if (Instance != this)
+                return Instance.Get(regionID, scopeID);
+
             if (m_regionData.ContainsKey(regionID))
                 return m_regionData[regionID];
 
@@ -93,6 +110,9 @@ namespace OpenSim.Data.Null
 
         public List<RegionData> Get(int startX, int startY, int endX, int endY, UUID scopeID)
         {
+            if (Instance != this)
+                return Instance.Get(startX, startY, endX, endY, scopeID);
+
             List<RegionData> ret = new List<RegionData>();
 
             foreach (RegionData r in m_regionData.Values)
@@ -106,6 +126,9 @@ namespace OpenSim.Data.Null
 
         public bool Store(RegionData data)
         {
+            if (Instance != this)
+                return Instance.Store(data);
+
             m_regionData[data.RegionID] = data;
 
             return true;
@@ -113,6 +136,9 @@ namespace OpenSim.Data.Null
 
         public bool SetDataItem(UUID regionID, string item, string value)
         {
+            if (Instance != this)
+                return Instance.SetDataItem(regionID, item, value);
+
             if (!m_regionData.ContainsKey(regionID))
                 return false;
 
@@ -123,6 +149,9 @@ namespace OpenSim.Data.Null
 
         public bool Delete(UUID regionID)
         {
+            if (Instance != this)
+                return Instance.Delete(regionID);
+
             if (!m_regionData.ContainsKey(regionID))
                 return false;
 
@@ -130,5 +159,37 @@ namespace OpenSim.Data.Null
 
             return true;
         }
+
+        public List<RegionData> GetDefaultRegions(UUID scopeID)
+        {
+            if (Instance != this)
+                return Instance.GetDefaultRegions(scopeID);
+
+            List<RegionData> ret = new List<RegionData>();
+
+            foreach (RegionData r in m_regionData.Values)
+            {
+                if ((Convert.ToInt32(r.Data["flags"]) & 1) != 0)
+                    ret.Add(r);
+            }
+
+            return ret;
+        }
+
+        public List<RegionData> GetFallbackRegions(UUID scopeID, int x, int y)
+        {
+            if (Instance != this)
+                return Instance.GetFallbackRegions(scopeID, x, y);
+
+            List<RegionData> ret = new List<RegionData>();
+
+            foreach (RegionData r in m_regionData.Values)
+            {
+                if ((Convert.ToInt32(r.Data["flags"]) & 2) != 0)
+                    ret.Add(r);
+            }
+
+            return ret;
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Data/Null/NullUserAccountData.cs b/OpenSim/Data/Null/NullUserAccountData.cs
new file mode 100644
index 0000000..9eb94e6
--- /dev/null
+++ b/OpenSim/Data/Null/NullUserAccountData.cs
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Data;
+
+namespace OpenSim.Data.Null
+{
+    public class NullUserAccountData : IUserAccountData
+    {
+        private static Dictionary<UUID, UserAccountData> m_DataByUUID = new Dictionary<UUID, UserAccountData>();
+        private static Dictionary<string, UserAccountData> m_DataByName = new Dictionary<string, UserAccountData>();
+        private static Dictionary<string, UserAccountData> m_DataByEmail = new Dictionary<string, UserAccountData>();
+
+        public NullUserAccountData(string connectionString, string realm)
+        {
+        }
+
+        /// <summary>
+        /// Tries to implement the Get [] semantics, but it cuts corners like crazy.
+        /// Specifically, it relies on the knowledge that the only Gets used are
+        /// keyed on PrincipalID, Email, and FirstName+LastName.
+        /// </summary>
+        /// <param name="fields"></param>
+        /// <param name="values"></param>
+        /// <returns></returns>
+        public UserAccountData[] Get(string[] fields, string[] values)
+        {
+            List<string> fieldsLst = new List<string>(fields);
+            if (fieldsLst.Contains("PrincipalID"))
+            {
+                int i = fieldsLst.IndexOf("PrincipalID");
+                UUID id = UUID.Zero;
+                if (UUID.TryParse(values[i], out id))
+                    if (m_DataByUUID.ContainsKey(id))
+                        return new UserAccountData[] { m_DataByUUID[id] };
+            }
+            if (fieldsLst.Contains("FirstName") && fieldsLst.Contains("LastName"))
+            {
+                int findex = fieldsLst.IndexOf("FirstName");
+                int lindex = fieldsLst.IndexOf("LastName");
+                if (m_DataByName.ContainsKey(values[findex] + " " + values[lindex]))
+                    return new UserAccountData[] { m_DataByName[values[findex] + " " + values[lindex]] };
+            }
+            if (fieldsLst.Contains("Email"))
+            {
+                int i = fieldsLst.IndexOf("Email");
+                if (m_DataByEmail.ContainsKey(values[i]))
+                    return new UserAccountData[] { m_DataByEmail[values[i]] };
+            }
+
+            // Fail
+            return new UserAccountData[0];
+        }
+
+        public bool Store(UserAccountData data)
+        {
+            if (data == null)
+                return false;
+
+            m_DataByUUID[data.PrincipalID] = data;
+            m_DataByName[data.FirstName + " " + data.LastName] = data;
+            if (data.Data.ContainsKey("Email") && data.Data["Email"] != string.Empty)
+                m_DataByEmail[data.Data["Email"]] = data;
+
+            return true;
+        }
+
+        public UserAccountData[] GetUsers(UUID scopeID, string query)
+        {
+            string[] words = query.Split(new char[] { ' ' });
+
+            for (int i = 0; i < words.Length; i++)
+            {
+                if (words[i].Length < 3)
+                {
+                    if (i != words.Length - 1)
+                        Array.Copy(words, i + 1, words, i, words.Length - i - 1);
+                    Array.Resize(ref words, words.Length - 1);
+                }
+            }
+
+            if (words.Length == 0)
+                return new UserAccountData[0];
+
+            if (words.Length > 2)
+                return new UserAccountData[0];
+
+            List<string> lst = new List<string>(m_DataByName.Keys);
+            if (words.Length == 1)
+            {
+                lst = lst.FindAll(delegate(string s) { return s.StartsWith(words[0]); });
+            }
+            else
+            {
+                lst = lst.FindAll(delegate(string s) { return s.Contains(words[0]) || s.Contains(words[1]); });
+            }
+
+            if (lst == null || (lst != null && lst.Count == 0))
+                return new UserAccountData[0];
+
+            UserAccountData[] result = new UserAccountData[lst.Count];
+            int n = 0;
+            foreach (string key in lst)
+                result[n++] = m_DataByName[key];
+
+            return result;
+        }
+
+        public bool Delete(string field, string val)
+        {
+            // Only delete by PrincipalID
+            if (field.Equals("PrincipalID"))
+            {
+                UUID uuid = UUID.Zero;
+                if (UUID.TryParse(val, out uuid) && m_DataByUUID.ContainsKey(uuid))
+                {
+                    UserAccountData account = m_DataByUUID[uuid];
+                    m_DataByUUID.Remove(uuid);
+                    if (m_DataByName.ContainsKey(account.FirstName + " " + account.LastName))
+                        m_DataByName.Remove(account.FirstName + " " + account.LastName);
+                    if (account.Data.ContainsKey("Email") && account.Data["Email"] != string.Empty && m_DataByEmail.ContainsKey(account.Data["Email"]))
+                        m_DataByEmail.Remove(account.Data["Email"]);
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}