Merge branch 'master' of /home/git/repo/OpenSim

53 files changed, 2448 insertions, 1371 deletions

diff --git a/OpenSim/Region/Application/Application.cs b/OpenSim/Region/Application/Application.cs
index d120f03..7e320e6 100644
--- a/OpenSim/Region/Application/Application.cs
+++ b/OpenSim/Region/Application/Application.cs
@@ -250,9 +250,7 @@ namespace OpenSim
             m_saveCrashDumps = configSource.Configs["Startup"].GetBoolean("save_crashes", false);
 
             // load Crash directory config
-            m_crashDir = configSource.Configs["Startup"].GetString("crash_dir", m_crashDir);
-
-           
+            m_crashDir = configSource.Configs["Startup"].GetString("crash_dir", m_crashDir);           
 
             if (background)
             {
@@ -260,15 +258,9 @@ namespace OpenSim
                 m_sim.Startup();
             }
             else
-            {
-
-
-                       
-
+            {                       
                 m_sim = new OpenSim(configSource);
-
-                    
-      
+                          
                 m_sim.Startup();
 
                 while (true)
diff --git a/OpenSim/Region/Application/OpenSim.cs b/OpenSim/Region/Application/OpenSim.cs
index 4081888..39004d4 100644
--- a/OpenSim/Region/Application/OpenSim.cs
+++ b/OpenSim/Region/Application/OpenSim.cs
@@ -123,7 +123,7 @@ namespace OpenSim
             m_log.Info("====================================================================");
             m_log.Info("========================= STARTING OPENSIM =========================");
             m_log.Info("====================================================================");
-            m_log.InfoFormat("[OPENSIM MAIN]: Running ");
+            
             //m_log.InfoFormat("[OPENSIM MAIN]: GC Is Server GC: {0}", GCSettings.IsServerGC.ToString());
             // http://msdn.microsoft.com/en-us/library/bb384202.aspx
             //GCSettings.LatencyMode = GCLatencyMode.Batch;
@@ -341,10 +341,15 @@ namespace OpenSim
 
             m_console.Commands.AddCommand("region", false, "config get",
                                           "config get [<section>] [<key>]",
-                                          "Show a config option", 
+                                          "Synonym for config show",
+                                          HandleConfig);
+            
+            m_console.Commands.AddCommand("region", false, "config show",
+                                          "config show [<section>] [<key>]",
+                                          "Show config information", 
                                           "If neither section nor field are specified, then the whole current configuration is printed." + Environment.NewLine
                                           + "If a section is given but not a field, then all fields in that section are printed.",
-                                          HandleConfig);
+                                          HandleConfig);            
 
             m_console.Commands.AddCommand("region", false, "config save",
                                           "config save <path>",
@@ -593,7 +598,9 @@ namespace OpenSim
 
             if (cmdparams.Length > 0)
             {
-                switch (cmdparams[0].ToLower())
+                string firstParam = cmdparams[0].ToLower();
+                
+                switch (firstParam)
                 {
                     case "set":
                         if (cmdparams.Length < 4)
@@ -618,6 +625,7 @@ namespace OpenSim
                         break;
 
                     case "get":
+                    case "show":
                         if (cmdparams.Length == 1)
                         {
                             foreach (IConfig config in m_config.Source.Configs)
@@ -654,8 +662,8 @@ namespace OpenSim
                         }
                         else
                         {
-                            Notice("Syntax: config get [<section>] [<key>]");
-                            Notice("Example: config get ScriptEngine.DotNetEngine NumberOfScriptThreads");
+                            Notice("Syntax: config {0} [<section>] [<key>]", firstParam);
+                            Notice("Example: config {0} ScriptEngine.DotNetEngine NumberOfScriptThreads", firstParam);
                         }
 
                         break;
diff --git a/OpenSim/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index e950613..ea9edf6 100644
--- a/OpenSim/Region/Application/OpenSimBase.cs
+++ b/OpenSim/Region/Application/OpenSimBase.cs
@@ -793,66 +793,112 @@ namespace OpenSim
         }
         
         /// <summary>
-        /// Load the estate information for the provided RegionInfo object.
+        /// Create an estate with an initial region.
         /// </summary>
+        /// <remarks>
+        /// This method doesn't allow an estate to be created with the same name as existing estates.
+        /// </remarks>
         /// <param name="regInfo"></param>
-        public void PopulateRegionEstateInfo(RegionInfo regInfo)
+        /// <param name="existingName">A list of estate names that already exist.</param>
+        /// <returns>true if the estate was created, false otherwise</returns>
+        public bool CreateEstate(RegionInfo regInfo, List<string> existingNames)
         {
-            IEstateDataService estateDataService = EstateDataService;
+            // Create a new estate
+            regInfo.EstateSettings = EstateDataService.LoadEstateSettings(regInfo.RegionID, true);
+            string newName = MainConsole.Instance.CmdPrompt("New estate name", regInfo.EstateSettings.EstateName);
 
-            if (estateDataService != null)
+            if (existingNames.Contains(newName))
             {
-                regInfo.EstateSettings = estateDataService.LoadEstateSettings(regInfo.RegionID, false);
+                MainConsole.Instance.OutputFormat("An estate named {0} already exists.  Please try again.", newName);
+                return false;
             }
+            
+            regInfo.EstateSettings.EstateName = newName;
+            
+            // FIXME: Later on, the scene constructor will reload the estate settings no matter what.
+            // Therefore, we need to do an initial save here otherwise the new estate name will be reset
+            // back to the default.  The reloading of estate settings by scene could be eliminated if it
+            // knows that the passed in settings in RegionInfo are already valid.  Also, it might be 
+            // possible to eliminate some additional later saves made by callers of this method.
+            regInfo.EstateSettings.Save();   
+            
+            return true;
+        }
+        
+        /// <summary>
+        /// Load the estate information for the provided RegionInfo object.
+        /// </summary>
+        /// <param name="regInfo"></param>
+        public void PopulateRegionEstateInfo(RegionInfo regInfo)
+        {
+            if (EstateDataService != null)
+                regInfo.EstateSettings = EstateDataService.LoadEstateSettings(regInfo.RegionID, false);
 
             if (regInfo.EstateSettings.EstateID == 0) // No record at all
             {
-                MainConsole.Instance.Output("Your region is not part of an estate.");
+                MainConsole.Instance.OutputFormat("Region {0} is not part of an estate.", regInfo.RegionName);
+                
+                List<EstateSettings> estates = EstateDataService.LoadEstateSettingsAll();                
+                List<string> estateNames = new List<string>();
+                foreach (EstateSettings estate in estates)
+                    estateNames.Add(estate.EstateName);                
+                
                 while (true)
                 {
-                    string response = MainConsole.Instance.CmdPrompt("Do you wish to join an existing estate?", "no", new List<string>() { "yes", "no" });
-                    if (response == "no")
-                    {
-                        // Create a new estate
-                        regInfo.EstateSettings = estateDataService.LoadEstateSettings(regInfo.RegionID, true);
-
-                        regInfo.EstateSettings.EstateName = MainConsole.Instance.CmdPrompt("New estate name", regInfo.EstateSettings.EstateName);
+                    if (estates.Count == 0)
+                    {                        
+                        MainConsole.Instance.Output("No existing estates found.  You must create a new one.");
                         
-                        // FIXME: Later on, the scene constructor will reload the estate settings no matter what.
-                        // Therefore, we need to do an initial save here otherwise the new estate name will be reset
-                        // back to the default.  The reloading of estate settings by scene could be eliminated if it
-                        // knows that the passed in settings in RegionInfo are already valid.  Also, it might be 
-                        // possible to eliminate some additional later saves made by callers of this method.
-                        regInfo.EstateSettings.Save();
-                        break;
+                        if (CreateEstate(regInfo, estateNames))
+                            break;                        
+                        else
+                            continue;
                     }
                     else
                     {
-                        response = MainConsole.Instance.CmdPrompt("Estate name to join", "None");
-                        if (response == "None")
-                            continue;
-
-                        List<int> estateIDs = estateDataService.GetEstates(response);
-                        if (estateIDs.Count < 1)
+                        string response 
+                            = MainConsole.Instance.CmdPrompt(
+                                string.Format(
+                                    "Do you wish to join region {0} to an existing estate (yes/no)?", regInfo.RegionName), 
+                                    "yes", 
+                                    new List<string>() { "yes", "no" });
+                        
+                        if (response == "no")
                         {
-                            MainConsole.Instance.Output("The name you have entered matches no known estate. Please try again");
-                            continue;
+                            if (CreateEstate(regInfo, estateNames))                            
+                                break;
+                            else
+                                continue;
+                        }
+                        else
+                        {                           
+                            response 
+                                = MainConsole.Instance.CmdPrompt(
+                                    string.Format(
+                                        "Name of estate to join.  Existing estate names are ({0})", string.Join(", ", estateNames.ToArray())), 
+                                    estateNames[0]);
+    
+                            List<int> estateIDs = EstateDataService.GetEstates(response);
+                            if (estateIDs.Count < 1)
+                            {
+                                MainConsole.Instance.Output("The name you have entered matches no known estate.  Please try again.");
+                                continue;
+                            }
+    
+                            int estateID = estateIDs[0];
+    
+                            regInfo.EstateSettings = EstateDataService.LoadEstateSettings(estateID);
+    
+                            if (EstateDataService.LinkRegion(regInfo.RegionID, estateID))
+                                break;
+    
+                            MainConsole.Instance.Output("Joining the estate failed. Please try again.");
                         }
-
-                        int estateID = estateIDs[0];
-
-                        regInfo.EstateSettings = estateDataService.LoadEstateSettings(estateID);
-
-                        if (estateDataService.LinkRegion(regInfo.RegionID, estateID))
-                            break;
-
-                        MainConsole.Instance.Output("Joining the estate failed. Please try again.");
                     }
                 }
             }
         }
     }
-
     
     public class OpenSimConfigSource
     {
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 2c6795f..8de31d7 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -49,6 +49,8 @@ using Timer = System.Timers.Timer;
 using AssetLandmark = OpenSim.Framework.AssetLandmark;
 using Nini.Config;
 
+using System.IO;
+
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
     public delegate bool PacketMethod(IClientAPI simClient, Packet packet);
@@ -298,6 +300,77 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Used to adjust Sun Orbit values so Linden based viewers properly position sun</summary>
         private const float m_sunPainDaHalfOrbitalCutoff = 4.712388980384689858f;
 
+                        // First log file or time has expired, start writing to a new log file
+//<MIC>
+// -----------------------------------------------------------------
+// -----------------------------------------------------------------
+// THIS IS DEBUGGING CODE & SHOULD BE REMOVED
+// -----------------------------------------------------------------
+// -----------------------------------------------------------------
+        public class QueueLogger
+        {
+            public Int32 start = 0;
+            public StreamWriter Log = null;
+            private Dictionary<UUID,int> m_idMap = new Dictionary<UUID,int>();
+
+            public QueueLogger()
+            {
+                DateTime now = DateTime.Now;
+                String fname = String.Format("queue-{0}.log", now.ToString("yyyyMMddHHmmss"));
+                Log = new StreamWriter(fname);
+
+                start = Util.EnvironmentTickCount();
+            }
+
+            public int LookupID(UUID uuid)
+            {
+                int localid;
+                if (! m_idMap.TryGetValue(uuid,out localid))
+                {
+                    localid = m_idMap.Count + 1;
+                    m_idMap[uuid] = localid;
+                }
+                
+                return localid;                
+            }
+        }
+
+        public static QueueLogger QueueLog = null;
+
+        // -----------------------------------------------------------------
+        public void LogAvatarUpdateEvent(UUID client, UUID avatar, Int32 timeinqueue)
+        {
+            if (QueueLog == null)
+                QueueLog = new QueueLogger();
+
+            Int32 ticks = Util.EnvironmentTickCountSubtract(QueueLog.start);
+            lock(QueueLog)
+            {
+                int cid = QueueLog.LookupID(client);
+                int aid = QueueLog.LookupID(avatar);
+                QueueLog.Log.WriteLine("{0},AU,AV{1:D4},AV{2:D4},{3}",ticks,cid,aid,timeinqueue);
+            }
+        }
+
+        // -----------------------------------------------------------------
+        public void LogQueueProcessEvent(UUID client, PriorityQueue queue, uint maxup)
+        {
+            if (QueueLog == null)
+                QueueLog = new QueueLogger();
+
+            Int32 ticks = Util.EnvironmentTickCountSubtract(QueueLog.start);
+            lock(QueueLog)
+            {
+                int cid = QueueLog.LookupID(client);
+                QueueLog.Log.WriteLine("{0},PQ,AV{1:D4},{2},{3}",ticks,cid,maxup,queue.ToString());
+            }
+        }
+// -----------------------------------------------------------------
+// -----------------------------------------------------------------
+// -----------------------------------------------------------------
+// -----------------------------------------------------------------
+//</MIC>
+
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         protected static Dictionary<PacketType, PacketMethod> PacketHandlers = new Dictionary<PacketType, PacketMethod>(); //Global/static handlers for all clients
 
@@ -3547,18 +3620,23 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         #region Primitive Packet/Data Sending Methods
 
+        
         /// <summary>
         /// Generate one of the object update packets based on PrimUpdateFlags
         /// and broadcast the packet to clients
         /// </summary>
         public void SendPrimUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags)
         {
-            double priority = m_prioritizer.GetUpdatePriority(this, entity);
+            //double priority = m_prioritizer.GetUpdatePriority(this, entity);
+            uint priority = m_prioritizer.GetUpdatePriority(this, entity);
 
             lock (m_entityUpdates.SyncRoot)
-                m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags, m_scene.TimeDilation), entity.LocalId);
+                m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags, m_scene.TimeDilation));
         }
 
+        private Int32 m_LastQueueFill = 0;
+        private uint m_maxUpdates = 0;
+
         private void ProcessEntityUpdates(int maxUpdates)
         {
             OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>();
@@ -3566,19 +3644,45 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
             OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseAgentUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
 
-            if (maxUpdates <= 0) maxUpdates = Int32.MaxValue;
+            if (maxUpdates <= 0)
+            {
+                m_maxUpdates = Int32.MaxValue;
+            }
+            else
+            {
+                if (m_maxUpdates == 0 || m_LastQueueFill == 0)
+                {
+                    m_maxUpdates = (uint)maxUpdates;
+                }
+                else
+                {
+                    if (Util.EnvironmentTickCountSubtract(m_LastQueueFill) < 200)
+                        m_maxUpdates += 5;
+                    else
+                        m_maxUpdates = m_maxUpdates >> 1;
+                }
+                m_maxUpdates = Util.Clamp<uint>(m_maxUpdates,10,500);
+            }
+            m_LastQueueFill = Util.EnvironmentTickCount();
+            
             int updatesThisCall = 0;
 
+//<MIC>
+// DEBUGGING CODE... REMOVE
+//            LogQueueProcessEvent(this.m_agentId,m_entityUpdates,m_maxUpdates);
+//</MIC>            
             // We must lock for both manipulating the kill record and sending the packet, in order to avoid a race
             // condition where a kill can be processed before an out-of-date update for the same object.                        
             lock (m_killRecord)
             {
                 float avgTimeDilation = 1.0f;
                 EntityUpdate update;
-                while (updatesThisCall < maxUpdates)
+                Int32 timeinqueue; // this is just debugging code & can be dropped later
+                
+                while (updatesThisCall < m_maxUpdates)
                 {
                     lock (m_entityUpdates.SyncRoot)
-                        if (!m_entityUpdates.TryDequeue(out update))
+                        if (!m_entityUpdates.TryDequeue(out update, out timeinqueue))
                             break;
                     avgTimeDilation += update.TimeDilation;
                     avgTimeDilation *= 0.5f;
@@ -3679,36 +3783,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                         else
                         {
-    //                            if (update.Entity is SceneObjectPart && ((SceneObjectPart)update.Entity).IsAttachment)
-    //                            {
-    //                                SceneObjectPart sop = (SceneObjectPart)update.Entity;
-    //                                string text = sop.Text;
-    //                                if (text.IndexOf("\n") >= 0)
-    //                                    text = text.Remove(text.IndexOf("\n"));
-    //
-    //                                if (m_attachmentsSent.Contains(sop.ParentID))
-    //                                {
-    ////                                    m_log.DebugFormat(
-    ////                                        "[CLIENT]: Sending full info about attached prim {0} text {1}",
-    ////                                        sop.LocalId, text);
-    //
-    //                                    objectUpdateBlocks.Value.Add(CreatePrimUpdateBlock(sop, this.m_agentId));
-    //
-    //                                    m_attachmentsSent.Add(sop.LocalId);
-    //                                }
-    //                                else
-    //                                {
-    //                                    m_log.DebugFormat(
-    //                                        "[CLIENT]: Requeueing full update of prim {0} text {1} since we haven't sent its parent {2} yet",
-    //                                        sop.LocalId, text, sop.ParentID);
-    //
-    //                                    m_entityUpdates.Enqueue(double.MaxValue, update, sop.LocalId);
-    //                                }
-    //                            }
-    //                            else
-    //                            {
-                                objectUpdateBlocks.Value.Add(CreatePrimUpdateBlock((SceneObjectPart)update.Entity, this.m_agentId));
-    //                            }
+                            objectUpdateBlocks.Value.Add(CreatePrimUpdateBlock((SceneObjectPart)update.Entity, this.m_agentId));
                         }
                     }
                     else if (!canUseImproved)
@@ -3802,26 +3877,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void ReprioritizeUpdates()
         {
-            //m_log.Debug("[CLIENT]: Reprioritizing prim updates for " + m_firstName + " " + m_lastName);
-
             lock (m_entityUpdates.SyncRoot)
                 m_entityUpdates.Reprioritize(UpdatePriorityHandler);
         }
 
-        private bool UpdatePriorityHandler(ref double priority, uint localID)
+        private bool UpdatePriorityHandler(ref uint priority, ISceneEntity entity)
         {
-            EntityBase entity;
-            if (m_scene.Entities.TryGetValue(localID, out entity))
+            if (entity != null)
             {
                 priority = m_prioritizer.GetUpdatePriority(this, entity);
+                return true;
             }
 
-            return priority != double.NaN;
+            return false;
         }
 
         public void FlushPrimUpdates()
         {
-            m_log.Debug("[CLIENT]: Flushing prim updates to " + m_firstName + " " + m_lastName);
+            m_log.WarnFormat("[CLIENT]: Flushing prim updates to " + m_firstName + " " + m_lastName);
 
             while (m_entityUpdates.Count > 0)
                 ProcessEntityUpdates(-1);
@@ -4272,8 +4345,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(packet, ThrottleOutPacketType.Task);
         }
 
-        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, LandData landData, float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
+        public void SendLandProperties(
+             int sequence_id, bool snap_selection, int request_result, ILandObject lo, 
+             float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
         {
+//            m_log.DebugFormat("[LLCLIENTVIEW]: Sending land properties for {0} to {1}", lo.LandData.GlobalID, Name);
+            
+            LandData landData = lo.LandData;
+            
             ParcelPropertiesMessage updateMessage = new ParcelPropertiesMessage();
 
             updateMessage.AABBMax = landData.AABBMax;
@@ -4281,15 +4360,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             updateMessage.Area = landData.Area;
             updateMessage.AuctionID = landData.AuctionID;
             updateMessage.AuthBuyerID = landData.AuthBuyerID;
-
             updateMessage.Bitmap = landData.Bitmap;
-
             updateMessage.Desc = landData.Description;
             updateMessage.Category = landData.Category;
             updateMessage.ClaimDate = Util.ToDateTime(landData.ClaimDate);
             updateMessage.ClaimPrice = landData.ClaimPrice;
-            updateMessage.GroupID = landData.GroupID;
-            updateMessage.GroupPrims = landData.GroupPrims;
+            updateMessage.GroupID = landData.GroupID;            
             updateMessage.IsGroupOwned = landData.IsGroupOwned;
             updateMessage.LandingType = (LandingType) landData.LandingType;
             updateMessage.LocalID = landData.LocalID;
@@ -4310,9 +4386,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             updateMessage.Name = landData.Name;
             updateMessage.OtherCleanTime = landData.OtherCleanTime;
             updateMessage.OtherCount = 0; //TODO: Unimplemented
-            updateMessage.OtherPrims = landData.OtherPrims;
-            updateMessage.OwnerID = landData.OwnerID;
-            updateMessage.OwnerPrims = landData.OwnerPrims;
+            updateMessage.OwnerID = landData.OwnerID;            
             updateMessage.ParcelFlags = (ParcelFlags) landData.Flags;
             updateMessage.ParcelPrimBonus = simObjectBonusFactor;
             updateMessage.PassHours = landData.PassHours;
@@ -4327,10 +4401,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             updateMessage.RentPrice = 0;
             updateMessage.RequestResult = (ParcelResult) request_result;
-            updateMessage.SalePrice = landData.SalePrice;
-            updateMessage.SelectedPrims = landData.SelectedPrims;
+            updateMessage.SalePrice = landData.SalePrice;            
             updateMessage.SelfCount = 0; //TODO: Unimplemented
             updateMessage.SequenceID = sequence_id;
+            
             if (landData.SimwideArea > 0)
             {
                 int simulatorCapacity = (int)(((float)landData.SimwideArea / 65536.0f) * (float)m_scene.RegionInfo.ObjectCapacity * (float)m_scene.RegionInfo.RegionSettings.ObjectBonus);
@@ -4340,22 +4414,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 updateMessage.SimWideMaxPrims = 0;
             }
-            updateMessage.SimWideTotalPrims = landData.SimwidePrims;
+            
             updateMessage.SnapSelection = snap_selection;
-            updateMessage.SnapshotID = landData.SnapshotID;
-            updateMessage.Status = (ParcelStatus) landData.Status;
-            updateMessage.TotalPrims = landData.OwnerPrims + landData.GroupPrims + landData.OtherPrims +
-                                                 landData.SelectedPrims;
-            updateMessage.UserLocation = landData.UserLocation;
-            updateMessage.UserLookAt = landData.UserLookAt;
-
-            updateMessage.MediaType = landData.MediaType;
-            updateMessage.MediaDesc = landData.MediaDescription;
-            updateMessage.MediaWidth = landData.MediaWidth;
-            updateMessage.MediaHeight = landData.MediaHeight;
-            updateMessage.MediaLoop = landData.MediaLoop;
-            updateMessage.ObscureMusic = landData.ObscureMusic;
-            updateMessage.ObscureMedia = landData.ObscureMedia;
+            updateMessage.SnapshotID    = landData.SnapshotID;
+            updateMessage.Status        = (ParcelStatus) landData.Status;
+            updateMessage.UserLocation  = landData.UserLocation;
+            updateMessage.UserLookAt    = landData.UserLookAt;
+
+            updateMessage.MediaType     = landData.MediaType;
+            updateMessage.MediaDesc     = landData.MediaDescription;
+            updateMessage.MediaWidth    = landData.MediaWidth;
+            updateMessage.MediaHeight   = landData.MediaHeight;
+            updateMessage.MediaLoop     = landData.MediaLoop;
+            updateMessage.ObscureMusic  = landData.ObscureMusic;
+            updateMessage.ObscureMedia  = landData.ObscureMedia;
+            
+            IPrimCounts pc = lo.PrimCounts;
+            updateMessage.OwnerPrims        = pc.Owner;            
+            updateMessage.GroupPrims        = pc.Group;
+            updateMessage.OtherPrims        = pc.Others;            
+            updateMessage.SelectedPrims     = pc.Selected;
+            updateMessage.TotalPrims        = pc.Total;
+            updateMessage.SimWideTotalPrims = pc.Simulator;
 
             try
             {
@@ -4363,13 +4443,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (eq != null)
                 {
                     eq.ParcelProperties(updateMessage, this.AgentId);
-                } else {
-                    m_log.Warn("No EQ Interface when sending parcel data.");
+                } 
+                else 
+                {
+                    m_log.Warn("[LLCLIENTVIEW]: No EQ Interface when sending parcel data.");
                 }
             }
             catch (Exception ex)
             {
-                m_log.Error("Unable to send parcel data via eventqueue - exception: " + ex.ToString());
+                m_log.Error("[LLCLIENTVIEW]: Unable to send parcel data via eventqueue - exception: " + ex.ToString());
             }
         }
 
@@ -4929,7 +5011,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.TeleportLocationRequest, HandleTeleportLocationRequest);
             AddLocalPacketHandler(PacketType.UUIDNameRequest, HandleUUIDNameRequest, false);
             AddLocalPacketHandler(PacketType.RegionHandleRequest, HandleRegionHandleRequest);
-            AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest, false);
+            AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest);
             AddLocalPacketHandler(PacketType.ParcelAccessListRequest, HandleParcelAccessListRequest, false);
             AddLocalPacketHandler(PacketType.ParcelAccessListUpdate, HandleParcelAccessListUpdate, false);
             AddLocalPacketHandler(PacketType.ParcelPropertiesRequest, HandleParcelPropertiesRequest, false);
@@ -8800,13 +8882,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 case "instantmessage":
                     if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
                     {
-                        if (messagePacket.ParamList.Length < 5)
+                        if (messagePacket.ParamList.Length < 2)
                             return true;
+
                         UUID invoice = messagePacket.MethodData.Invoice;
-                        UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
-                        string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
-                        string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
                         UUID sessionID = messagePacket.AgentData.SessionID;
+
+                        UUID SenderID;
+                        string SenderName;
+                        string Message;
+
+                        if (messagePacket.ParamList.Length < 5)
+                        {
+                            SenderID = AgentId;
+                            SenderName = Utils.BytesToString(messagePacket.ParamList[0].Parameter);
+                            Message = Utils.BytesToString(messagePacket.ParamList[1].Parameter);
+                        }
+                        else
+                        { 
+                            SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+                            SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
+                            Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
+                        }
+
                         OnEstateBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);
                     }
                     return true;
@@ -11701,171 +11799,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(pack, ThrottleOutPacketType.Task);
         }
 
-        #region PriorityQueue
-        public class PriorityQueue
-        {
-            internal delegate bool UpdatePriorityHandler(ref double priority, uint local_id);
-
-            private MinHeap<MinHeapItem>[] m_heaps = new MinHeap<MinHeapItem>[1];
-            private Dictionary<uint, LookupItem> m_lookupTable;
-            private Comparison<double> m_comparison;
-            private object m_syncRoot = new object();
-
-            internal PriorityQueue() :
-                this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY, Comparer<double>.Default) { }
-            internal PriorityQueue(int capacity) :
-                this(capacity, Comparer<double>.Default) { }
-            internal PriorityQueue(IComparer<double> comparer) :
-                this(new Comparison<double>(comparer.Compare)) { }
-            internal PriorityQueue(Comparison<double> comparison) :
-                this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY, comparison) { }
-            internal PriorityQueue(int capacity, IComparer<double> comparer) :
-                this(capacity, new Comparison<double>(comparer.Compare)) { }
-            internal PriorityQueue(int capacity, Comparison<double> comparison)
-            {
-                m_lookupTable = new Dictionary<uint, LookupItem>(capacity);
-
-                for (int i = 0; i < m_heaps.Length; ++i)
-                    m_heaps[i] = new MinHeap<MinHeapItem>(capacity);
-                this.m_comparison = comparison;
-            }
-
-            public object SyncRoot { get { return this.m_syncRoot; } }
-            internal int Count
-            {
-                get
-                {
-                    int count = 0;
-                    for (int i = 0; i < m_heaps.Length; ++i)
-                        count = m_heaps[i].Count;
-                    return count;
-                }
-            }
-
-            public bool Enqueue(double priority, EntityUpdate value, uint local_id)
-            {
-                LookupItem item;
-
-                if (m_lookupTable.TryGetValue(local_id, out item))
-                {
-                    // Combine flags
-                    value.Flags |= item.Heap[item.Handle].Value.Flags;
-
-                    item.Heap[item.Handle] = new MinHeapItem(priority, value, local_id, this.m_comparison);
-                    return false;
-                }
-                else
-                {
-                    item.Heap = m_heaps[0];
-                    item.Heap.Add(new MinHeapItem(priority, value, local_id, this.m_comparison), ref item.Handle);
-                    m_lookupTable.Add(local_id, item);
-                    return true;
-                }
-            }
-
-            internal EntityUpdate Peek()
-            {
-                for (int i = 0; i < m_heaps.Length; ++i)
-                    if (m_heaps[i].Count > 0)
-                        return m_heaps[i].Min().Value;
-                throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString()));
-            }
-
-            internal bool TryDequeue(out EntityUpdate value)
-            {
-                for (int i = 0; i < m_heaps.Length; ++i)
-                {
-                    if (m_heaps[i].Count > 0)
-                    {
-                        MinHeapItem item = m_heaps[i].RemoveMin();
-                        m_lookupTable.Remove(item.LocalID);
-                        value = item.Value;
-                        return true;
-                    }
-                }
-
-                value = default(EntityUpdate);
-                return false;
-            }
-
-            internal void Reprioritize(UpdatePriorityHandler handler)
-            {
-                MinHeapItem item;
-                double priority;
-
-                foreach (LookupItem lookup in new List<LookupItem>(this.m_lookupTable.Values))
-                {
-                    if (lookup.Heap.TryGetValue(lookup.Handle, out item))
-                    {
-                        priority = item.Priority;
-                        if (handler(ref priority, item.LocalID))
-                        {
-                            if (lookup.Heap.ContainsHandle(lookup.Handle))
-                                lookup.Heap[lookup.Handle] =
-                                    new MinHeapItem(priority, item.Value, item.LocalID, this.m_comparison);
-                        }
-                        else
-                        {
-                            m_log.Warn("[LLCLIENTVIEW]: UpdatePriorityHandler returned false, dropping update");
-                            lookup.Heap.Remove(lookup.Handle);
-                            this.m_lookupTable.Remove(item.LocalID);
-                        }
-                    }
-                }
-            }
-
-            #region MinHeapItem
-            private struct MinHeapItem : IComparable<MinHeapItem>
-            {
-                private double priority;
-                private EntityUpdate value;
-                private uint local_id;
-                private Comparison<double> comparison;
-
-                internal MinHeapItem(double priority, EntityUpdate value, uint local_id) :
-                    this(priority, value, local_id, Comparer<double>.Default) { }
-                internal MinHeapItem(double priority, EntityUpdate value, uint local_id, IComparer<double> comparer) :
-                    this(priority, value, local_id, new Comparison<double>(comparer.Compare)) { }
-                internal MinHeapItem(double priority, EntityUpdate value, uint local_id, Comparison<double> comparison)
-                {
-                    this.priority = priority;
-                    this.value = value;
-                    this.local_id = local_id;
-                    this.comparison = comparison;
-                }
-
-                internal double Priority { get { return this.priority; } }
-                internal EntityUpdate Value { get { return this.value; } }
-                internal uint LocalID { get { return this.local_id; } }
-
-                public override string ToString()
-                {
-                    StringBuilder sb = new StringBuilder();
-                    sb.Append("[");
-                    sb.Append(this.priority.ToString());
-                    sb.Append(",");
-                    if (this.value != null)
-                        sb.Append(this.value.ToString());
-                    sb.Append("]");
-                    return sb.ToString();
-                }
-
-                public int CompareTo(MinHeapItem other)
-                {
-                    return this.comparison(this.priority, other.priority);
-                }
-            }
-            #endregion
-
-            #region LookupItem
-            private struct LookupItem
-            {
-                internal MinHeap<MinHeapItem> Heap;
-                internal IHandle Handle;
-            }
-            #endregion
-        }
-
         public struct PacketProcessor
         {
             public PacketMethod method;
@@ -11886,8 +11819,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
-        #endregion
-
         public static OSD BuildEvent(string eventName, OSD eventBody)
         {
             OSDMap osdEvent = new OSDMap(2);
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
index 65a8fe3..9a8bfd3 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
@@ -149,7 +149,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Caches packed throttle information</summary>
         private byte[] m_packedThrottles;
 
-        private int m_defaultRTO = 3000;
+        private int m_defaultRTO = 1000; // 1sec is the recommendation in the RFC
         private int m_maxRTO = 60000;
 
         /// <summary>
@@ -557,7 +557,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             int rto = (int)(SRTT + Math.Max(m_udpServer.TickCountResolution, K * RTTVAR));
 
             // Clamp the retransmission timeout to manageable values
-            rto = Utils.Clamp(RTO, m_defaultRTO, m_maxRTO);
+            rto = Utils.Clamp(rto, m_defaultRTO, m_maxRTO);
 
             RTO = rto;
 
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
index d2779ba..6eebd9d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
@@ -100,6 +100,10 @@ namespace OpenMetaverse
                 const int SIO_UDP_CONNRESET = -1744830452;
 
                 IPEndPoint ipep = new IPEndPoint(m_localBindAddress, m_udpPort);
+                
+                m_log.DebugFormat(
+                    "[UDPBASE]: Binding UDP listener using internal IP address config {0}:{1}", 
+                    ipep.Address, ipep.Port);                
 
                 m_udpSocket = new Socket(
                     AddressFamily.InterNetwork,
diff --git a/OpenSim/Region/ClientStack/LindenUDP/PriorityQueue.cs b/OpenSim/Region/ClientStack/LindenUDP/PriorityQueue.cs
new file mode 100644
index 0000000..364ce4b
--- /dev/null
+++ b/OpenSim/Region/ClientStack/LindenUDP/PriorityQueue.cs
@@ -0,0 +1,245 @@
+/*
+ * 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 OpenSim.Framework;
+using OpenSim.Framework.Client;
+using log4net;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    public class PriorityQueue
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        internal delegate bool UpdatePriorityHandler(ref uint priority, ISceneEntity entity);
+
+        // Heap[0] for self updates
+        // Heap[1..12] for entity updates
+
+        internal const uint m_numberOfQueues = 12;
+
+        private MinHeap<MinHeapItem>[] m_heaps = new MinHeap<MinHeapItem>[m_numberOfQueues];
+        private Dictionary<uint, LookupItem> m_lookupTable;
+        private uint m_nextQueue = 0;
+        private UInt64 m_nextRequest = 0;
+
+        private object m_syncRoot = new object();
+        public object SyncRoot {
+            get { return this.m_syncRoot; }
+        }
+
+        internal PriorityQueue() : this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY) { }
+
+        internal PriorityQueue(int capacity)
+        {
+            m_lookupTable = new Dictionary<uint, LookupItem>(capacity);
+
+            for (int i = 0; i < m_heaps.Length; ++i)
+                m_heaps[i] = new MinHeap<MinHeapItem>(capacity);
+        }
+
+        internal int Count
+        {
+            get
+            {
+                int count = 0;
+                for (int i = 0; i < m_heaps.Length; ++i)
+                    count += m_heaps[i].Count;
+                return count;
+            }
+        }
+
+        public bool Enqueue(uint pqueue, EntityUpdate value)
+        {
+            LookupItem lookup;
+
+            uint localid = value.Entity.LocalId;
+            UInt64 entry = m_nextRequest++;
+            if (m_lookupTable.TryGetValue(localid, out lookup))
+            {
+                entry = lookup.Heap[lookup.Handle].EntryOrder;
+                value.Flags |=  lookup.Heap[lookup.Handle].Value.Flags;
+                lookup.Heap.Remove(lookup.Handle);
+            }
+
+            pqueue = Util.Clamp<uint>(pqueue, 0, m_numberOfQueues - 1);
+            lookup.Heap = m_heaps[pqueue];
+            lookup.Heap.Add(new MinHeapItem(pqueue, entry, value), ref lookup.Handle);
+            m_lookupTable[localid] = lookup;
+
+            return true;
+        }
+
+        internal bool TryDequeue(out EntityUpdate value, out Int32 timeinqueue)
+        {
+            for (int i = 0; i < m_numberOfQueues; ++i)
+            {
+                // To get the fair queing, we cycle through each of the
+                // queues when finding an element to dequeue, this code
+                // assumes that the distribution of updates in the queues
+                // is polynomial, probably quadractic (eg distance of PI * R^2)
+                uint h = (uint)((m_nextQueue + i) % m_numberOfQueues);
+                if (m_heaps[h].Count > 0)
+                {
+                    m_nextQueue = (uint)((h + 1) % m_numberOfQueues);
+
+                    MinHeapItem item = m_heaps[h].RemoveMin();
+                    m_lookupTable.Remove(item.Value.Entity.LocalId);
+                    timeinqueue = Util.EnvironmentTickCountSubtract(item.EntryTime);
+                    value = item.Value;
+
+                    return true;
+                }
+            }
+
+            timeinqueue = 0;
+            value = default(EntityUpdate);
+            return false;
+        }
+
+        internal void Reprioritize(UpdatePriorityHandler handler)
+        {
+            MinHeapItem item;
+            foreach (LookupItem lookup in new List<LookupItem>(this.m_lookupTable.Values))
+            {
+                if (lookup.Heap.TryGetValue(lookup.Handle, out item))
+                {
+                    uint pqueue = item.PriorityQueue;
+                    uint localid = item.Value.Entity.LocalId;
+
+                    if (handler(ref pqueue, item.Value.Entity))
+                    {
+                        // unless the priority queue has changed, there is no need to modify
+                        // the entry
+                        pqueue = Util.Clamp<uint>(pqueue, 0, m_numberOfQueues - 1);
+                        if (pqueue != item.PriorityQueue)
+                        {
+                            lookup.Heap.Remove(lookup.Handle);
+
+                            LookupItem litem = lookup;
+                            litem.Heap = m_heaps[pqueue];
+                            litem.Heap.Add(new MinHeapItem(pqueue, item), ref litem.Handle);
+                            m_lookupTable[localid] = litem;
+                        }
+                    }
+                    else
+                    {
+                        // m_log.WarnFormat("[PQUEUE]: UpdatePriorityHandler returned false for {0}",item.Value.Entity.UUID);
+                        lookup.Heap.Remove(lookup.Handle);
+                        this.m_lookupTable.Remove(localid);
+                    }
+                }
+            }
+        }
+
+        public override string ToString()
+        {
+            string s = "";
+            for (int i = 0; i < m_numberOfQueues; i++)
+            {
+                if (s != "") s += ",";
+                s += m_heaps[i].Count.ToString();
+            }
+            return s;
+        }
+
+#region MinHeapItem
+        private struct MinHeapItem : IComparable<MinHeapItem>
+        {
+            private EntityUpdate value;
+            internal EntityUpdate Value {
+                get {
+                    return this.value;
+                }
+            }
+
+            private uint pqueue;
+            internal uint PriorityQueue {
+                get {
+                    return this.pqueue;
+                }
+            }
+
+            private Int32 entrytime;
+            internal Int32 EntryTime {
+                get {
+                    return this.entrytime;
+                }
+            }
+
+            private UInt64 entryorder;
+            internal UInt64 EntryOrder
+            {
+                get {
+                    return this.entryorder;
+                }
+            }
+
+            internal MinHeapItem(uint pqueue, MinHeapItem other)
+            {
+                this.entrytime = other.entrytime;
+                this.entryorder = other.entryorder;
+                this.value = other.value;
+                this.pqueue = pqueue;
+            }
+
+            internal MinHeapItem(uint pqueue, UInt64 entryorder, EntityUpdate value)
+            {
+                this.entrytime = Util.EnvironmentTickCount();
+                this.entryorder = entryorder;
+                this.value = value;
+                this.pqueue = pqueue;
+            }
+
+            public override string ToString()
+            {
+                return String.Format("[{0},{1},{2}]",pqueue,entryorder,value.Entity.LocalId);
+            }
+
+            public int CompareTo(MinHeapItem other)
+            {
+                // I'm assuming that the root part of an SOG is added to the update queue
+                // before the component parts
+                return Comparer<UInt64>.Default.Compare(this.EntryOrder, other.EntryOrder);
+            }
+        }
+#endregion
+
+#region LookupItem
+        private struct LookupItem
+        {
+            internal MinHeap<MinHeapItem> Heap;
+            internal IHandle Handle;
+        }
+#endregion
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
index a5fcb49..0babeb5 100644
--- a/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using Nini.Config;
+using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenMetaverse;
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
index 9b98de3..01170aa 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
@@ -77,7 +77,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// </value>
         private Stream m_loadStream;
         
-        protected bool m_controlFileLoaded;
+        /// <summary>
+        /// FIXME: Do not perform this check since older versions of OpenSim do save the control file after other things
+        /// (I thought they weren't).  We will need to bump the version number and perform this check on all 
+        /// subsequent IAR versions only
+        /// </summary>
+        protected bool m_controlFileLoaded = true;
         protected bool m_assetsLoaded;
         protected bool m_inventoryNodesLoaded;
         
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
index 798547a..73b0a35 100644
--- a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using System.Net;
+using System.Xml;
 using System.Reflection;
 using System.Threading;
 
@@ -205,11 +206,11 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
         public virtual UUID DeleteToInventory(DeRezAction action, UUID folderID,
                 List<SceneObjectGroup> objectGroups, IClientAPI remoteClient)
         {
-            // HACK: This is only working for lists containing a single item!
-            // It's just a hack to make this WIP compile and run. Nothing
-            // currently calls this with multiple items.
             UUID ret = UUID.Zero; 
 
+            // The following code groups the SOG's by owner. No objects
+            // belonging to different people can be coalesced, for obvious
+            // reasons.
             Dictionary<UUID, List<SceneObjectGroup>> deletes =
                     new Dictionary<UUID, List<SceneObjectGroup>>();
 
@@ -221,262 +222,329 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                 deletes[g.OwnerID].Add(g);
             }
 
+            // This is pethod scoped and will be returned. It will be the
+            // last created asset id
+            UUID assetID = UUID.Zero;
+
+            // Each iteration is really a separate asset being created,
+            // with distinct destinations as well.
             foreach (List<SceneObjectGroup> objlist in deletes.Values)
             {
-                foreach (SceneObjectGroup g in objlist)
-                    ret = DeleteToInventory(action, folderID, g, remoteClient);
-            }
+                Dictionary<UUID, string> xmlStrings =
+                        new Dictionary<UUID, string>();
 
-            return ret;
-        }
+                foreach (SceneObjectGroup objectGroup in objlist)
+                {
+                    Vector3 inventoryStoredPosition = new Vector3
+                                (((objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
+                                      ? 250
+                                      : objectGroup.AbsolutePosition.X)
+                                 ,
+                                 (objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
+                                     ? 250
+                                     : objectGroup.AbsolutePosition.X,
+                                 objectGroup.AbsolutePosition.Z);
 
-        private UUID DeleteToInventory(DeRezAction action, UUID folderID,
-                SceneObjectGroup objectGroup, IClientAPI remoteClient)
-        {
-            UUID assetID = UUID.Zero;
+                    Vector3 originalPosition = objectGroup.AbsolutePosition;
 
-            Vector3 inventoryStoredPosition = new Vector3
-                        (((objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
-                              ? 250
-                              : objectGroup.AbsolutePosition.X)
-                         ,
-                         (objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
-                             ? 250
-                             : objectGroup.AbsolutePosition.X,
-                         objectGroup.AbsolutePosition.Z);
+                    objectGroup.AbsolutePosition = inventoryStoredPosition;
 
-            Vector3 originalPosition = objectGroup.AbsolutePosition;
+                    // Make sure all bits but the ones we want are clear
+                    // on take.
+                    // This will be applied to the current perms, so
+                    // it will do what we want.
+                    objectGroup.RootPart.NextOwnerMask &=
+                            ((uint)PermissionMask.Copy |
+                             (uint)PermissionMask.Transfer |
+                             (uint)PermissionMask.Modify);
+                    objectGroup.RootPart.NextOwnerMask |=
+                            (uint)PermissionMask.Move;
 
-            objectGroup.AbsolutePosition = inventoryStoredPosition;
+                    string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(objectGroup);
 
-            string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(objectGroup);
+                    objectGroup.AbsolutePosition = originalPosition;
 
-            objectGroup.AbsolutePosition = originalPosition;
+                    xmlStrings[objectGroup.UUID] = sceneObjectXml;
+                }
 
-            // Get the user info of the item destination
-            //
-            UUID userID = UUID.Zero;
+                string itemXml;
 
-            if (action == DeRezAction.Take || action == DeRezAction.TakeCopy ||
-                action == DeRezAction.SaveToExistingUserInventoryItem)
-            {
-                // Take or take copy require a taker
-                // Saving changes requires a local user
-                //
-                if (remoteClient == null)
-                    return UUID.Zero;
+                if (objlist.Count > 1)
+                {
+                    float minX, minY, minZ;
+                    float maxX, maxY, maxZ;
 
-                userID = remoteClient.AgentId;
-            }
-            else
-            {
-                // All returns / deletes go to the object owner
-                //
+                    Vector3[] offsets = m_Scene.GetCombinedBoundingBox(objlist,
+                            out minX, out maxX, out minY, out maxY,
+                            out minZ, out maxZ);
 
-                userID = objectGroup.RootPart.OwnerID;
-            }
+                    // CreateWrapper
+                    XmlDocument itemDoc = new XmlDocument();
+                    XmlElement root = itemDoc.CreateElement("", "CoalescedObject", "");
+                    itemDoc.AppendChild(root);
 
-            if (userID == UUID.Zero) // Can't proceed
-            {
-                return UUID.Zero;
-            }
+                    // Embed the offsets into the group XML
+                    for ( int i = 0 ; i < objlist.Count ; i++ )
+                    {
+                        XmlDocument doc = new XmlDocument();
+                        SceneObjectGroup g = objlist[i];
+                        doc.LoadXml(xmlStrings[g.UUID]);
+                        XmlElement e = (XmlElement)doc.SelectSingleNode("/SceneObjectGroup");
+                        e.SetAttribute("offsetx", offsets[i].X.ToString());
+                        e.SetAttribute("offsety", offsets[i].Y.ToString());
+                        e.SetAttribute("offsetz", offsets[i].Z.ToString());
+
+                        XmlNode objectNode = itemDoc.ImportNode(e, true);
+                        root.AppendChild(objectNode);
+                    }
 
-            // If we're returning someone's item, it goes back to the
-            // owner's Lost And Found folder.
-            // Delete is treated like return in this case
-            // Deleting your own items makes them go to trash
-            //
+                    float sizeX = maxX - minX;
+                    float sizeY = maxY - minY;
+                    float sizeZ = maxZ - minZ;
 
-            InventoryFolderBase folder = null;
-            InventoryItemBase item = null;
+                    root.SetAttribute("x", sizeX.ToString());
+                    root.SetAttribute("y", sizeY.ToString());
+                    root.SetAttribute("z", sizeZ.ToString());
 
-            if (DeRezAction.SaveToExistingUserInventoryItem == action)
-            {
-                item = new InventoryItemBase(objectGroup.RootPart.FromUserInventoryItemID, userID);
-                item = m_Scene.InventoryService.GetItem(item);
+                    itemXml = itemDoc.InnerXml;
+                }
+                else
+                {
+                    itemXml = xmlStrings[objlist[0].UUID];
+                }
+
+                // Get the user info of the item destination
+                //
+                UUID userID = UUID.Zero;
+
+                if (action == DeRezAction.Take || action == DeRezAction.TakeCopy ||
+                    action == DeRezAction.SaveToExistingUserInventoryItem)
+                {
+                    // Take or take copy require a taker
+                    // Saving changes requires a local user
+                    //
+                    if (remoteClient == null)
+                        return UUID.Zero;
+
+                    userID = remoteClient.AgentId;
+                }
+                else
+                {
+                    // All returns / deletes go to the object owner
+                    //
 
-                //item = userInfo.RootFolder.FindItem(
-                //        objectGroup.RootPart.FromUserInventoryItemID);
+                    userID = objlist[0].RootPart.OwnerID;
+                }
 
-                if (null == item)
+                if (userID == UUID.Zero) // Can't proceed
                 {
-                    m_log.DebugFormat(
-                        "[AGENT INVENTORY]: Object {0} {1} scheduled for save to inventory has already been deleted.",
-                        objectGroup.Name, objectGroup.UUID);
                     return UUID.Zero;
                 }
-            }
-            else
-            {
-                // Folder magic
+
+                // If we're returning someone's item, it goes back to the
+                // owner's Lost And Found folder.
+                // Delete is treated like return in this case
+                // Deleting your own items makes them go to trash
                 //
-                if (action == DeRezAction.Delete)
+
+                InventoryFolderBase folder = null;
+                InventoryItemBase item = null;
+
+                if (DeRezAction.SaveToExistingUserInventoryItem == action)
                 {
-                    // Deleting someone else's item
-                    //
-                    if (remoteClient == null ||
-                        objectGroup.OwnerID != remoteClient.AgentId)
-                    {
+                    item = new InventoryItemBase(objlist[0].RootPart.FromUserInventoryItemID, userID);
+                    item = m_Scene.InventoryService.GetItem(item);
 
-                        folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
-                    }
-                    else
+                    //item = userInfo.RootFolder.FindItem(
+                    //        objectGroup.RootPart.FromUserInventoryItemID);
+
+                    if (null == item)
                     {
-                         folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
+                        m_log.DebugFormat(
+                            "[AGENT INVENTORY]: Object {0} {1} scheduled for save to inventory has already been deleted.",
+                            objlist[0].Name, objlist[0].UUID);
+                        return UUID.Zero;
                     }
                 }
-                else if (action == DeRezAction.Return)
+                else
                 {
-
-                    // Dump to lost + found unconditionally
+                    // Folder magic
                     //
-                    folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
-                }
-
-                if (folderID == UUID.Zero && folder == null)
-                {
                     if (action == DeRezAction.Delete)
                     {
-                        // Deletes go to trash by default
+                        // Deleting someone else's item
                         //
-                        folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
-                    }
-                    else
-                    {
                         if (remoteClient == null ||
-                            objectGroup.OwnerID != remoteClient.AgentId)
+                            objlist[0].OwnerID != remoteClient.AgentId)
                         {
-                            // Taking copy of another person's item. Take to
-                            // Objects folder.
-                            folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.Object);
+
+                            folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
                         }
                         else
                         {
-                            // Catch all. Use lost & found
+                             folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
+                        }
+                    }
+                    else if (action == DeRezAction.Return)
+                    {
+
+                        // Dump to lost + found unconditionally
+                        //
+                        folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                    }
+
+                    if (folderID == UUID.Zero && folder == null)
+                    {
+                        if (action == DeRezAction.Delete)
+                        {
+                            // Deletes go to trash by default
                             //
+                            folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
+                        }
+                        else
+                        {
+                            if (remoteClient == null ||
+                                objlist[0].OwnerID != remoteClient.AgentId)
+                            {
+                                // Taking copy of another person's item. Take to
+                                // Objects folder.
+                                folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.Object);
+                            }
+                            else
+                            {
+                                // Catch all. Use lost & found
+                                //
 
-                            folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                                folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                            }
                         }
                     }
-                }
 
-                // Override and put into where it came from, if it came
-                // from anywhere in inventory
-                //
-                if (action == DeRezAction.Take || action == DeRezAction.TakeCopy)
-                {
-                    if (objectGroup.RootPart.FromFolderID != UUID.Zero)
+                    // Override and put into where it came from, if it came
+                    // from anywhere in inventory
+                    //
+                    if (action == DeRezAction.Take || action == DeRezAction.TakeCopy)
                     {
-                        InventoryFolderBase f = new InventoryFolderBase(objectGroup.RootPart.FromFolderID, userID);
-                        folder = m_Scene.InventoryService.GetFolder(f);
+                        if (objlist[0].RootPart.FromFolderID != UUID.Zero)
+                        {
+                            InventoryFolderBase f = new InventoryFolderBase(objlist[0].RootPart.FromFolderID, userID);
+                            folder = m_Scene.InventoryService.GetFolder(f);
+                        }
                     }
-                }
 
-                if (folder == null) // None of the above
-                {
-                    folder = new InventoryFolderBase(folderID);
+                    if (folder == null) // None of the above
+                    {
+                        folder = new InventoryFolderBase(folderID);
 
-                    if (folder == null) // Nowhere to put it
+                        if (folder == null) // Nowhere to put it
+                        {
+                            return UUID.Zero;
+                        }
+                    }
+
+                    item = new InventoryItemBase();
+                    // Can't know creator is the same, so null it in inventory
+                    if (objlist.Count > 1)
+                        item.CreatorId = UUID.Zero.ToString();
+                    else
+                        item.CreatorId = objlist[0].RootPart.CreatorID.ToString();
+                    item.ID = UUID.Random();
+                    item.InvType = (int)InventoryType.Object;
+                    item.Folder = folder.ID;
+                    item.Owner = userID;
+                    if (objlist.Count > 1)
                     {
-                        return UUID.Zero;
+                        item.Flags = (uint)InventoryItemFlags.ObjectHasMultipleItems;
+                    }
+                    else
+                    {
+                        item.SaleType = objlist[0].RootPart.ObjectSaleType;
+                        item.SalePrice = objlist[0].RootPart.SalePrice;
                     }
                 }
 
-                item = new InventoryItemBase();
-                item.CreatorId = objectGroup.RootPart.CreatorID.ToString();
-                item.CreatorData = objectGroup.RootPart.CreatorData;
-                item.ID = UUID.Random();
-                item.InvType = (int)InventoryType.Object;
-                item.Folder = folder.ID;
-                item.Owner = userID;
-            }
-
-            AssetBase asset = CreateAsset(
-                objectGroup.GetPartName(objectGroup.RootPart.LocalId),
-                objectGroup.GetPartDescription(objectGroup.RootPart.LocalId),
-                (sbyte)AssetType.Object,
-                Utils.StringToBytes(sceneObjectXml),
-                objectGroup.OwnerID.ToString());
-            m_Scene.AssetService.Store(asset);
-            assetID = asset.FullID;
-
-            if (DeRezAction.SaveToExistingUserInventoryItem == action)
-            {
-                item.AssetID = asset.FullID;
-                m_Scene.InventoryService.UpdateItem(item);
-            }
-            else
-            {
-                item.AssetID = asset.FullID;
+                AssetBase asset = CreateAsset(
+                    objlist[0].GetPartName(objlist[0].RootPart.LocalId),
+                    objlist[0].GetPartDescription(objlist[0].RootPart.LocalId),
+                    (sbyte)AssetType.Object,
+                    Utils.StringToBytes(itemXml),
+                    objlist[0].OwnerID.ToString());
+                m_Scene.AssetService.Store(asset);
+                assetID = asset.FullID;
 
-                if (remoteClient != null && (remoteClient.AgentId != objectGroup.RootPart.OwnerID) && m_Scene.Permissions.PropagatePermissions())
+                if (DeRezAction.SaveToExistingUserInventoryItem == action)
                 {
-                    uint perms = objectGroup.GetEffectivePermissions();
-                    uint nextPerms = (perms & 7) << 13;
-                    if ((nextPerms & (uint)PermissionMask.Copy) == 0)
-                        perms &= ~(uint)PermissionMask.Copy;
-                    if ((nextPerms & (uint)PermissionMask.Transfer) == 0)
-                        perms &= ~(uint)PermissionMask.Transfer;
-                    if ((nextPerms & (uint)PermissionMask.Modify) == 0)
-                        perms &= ~(uint)PermissionMask.Modify;
-
-                    // Make sure all bits but the ones we want are clear
-                    // on take.
-                    // This will be applied to the current perms, so
-                    // it will do what we want.
-                    objectGroup.RootPart.NextOwnerMask &=
-                            ((uint)PermissionMask.Copy | 
-                             (uint)PermissionMask.Transfer |
-                             (uint)PermissionMask.Modify);
-                    objectGroup.RootPart.NextOwnerMask |=
-                            (uint)PermissionMask.Move;
-
-                    item.BasePermissions = perms & objectGroup.RootPart.NextOwnerMask;
-                    item.CurrentPermissions = item.BasePermissions;
-                    item.NextPermissions = objectGroup.RootPart.NextOwnerMask;
-                    item.EveryOnePermissions = objectGroup.RootPart.EveryoneMask & objectGroup.RootPart.NextOwnerMask;
-                    item.GroupPermissions = objectGroup.RootPart.GroupMask & objectGroup.RootPart.NextOwnerMask;
-                    
-                    item.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
+                    item.AssetID = asset.FullID;
+                    m_Scene.InventoryService.UpdateItem(item);
                 }
                 else
                 {
-                    item.BasePermissions = objectGroup.GetEffectivePermissions();
-                    item.CurrentPermissions = objectGroup.GetEffectivePermissions();
-                    item.NextPermissions = objectGroup.RootPart.NextOwnerMask;
-                    item.EveryOnePermissions = objectGroup.RootPart.EveryoneMask;
-                    item.GroupPermissions = objectGroup.RootPart.GroupMask;
+                    item.AssetID = asset.FullID;
 
-                    item.CurrentPermissions &=
-                            ((uint)PermissionMask.Copy |
-                             (uint)PermissionMask.Transfer |
-                             (uint)PermissionMask.Modify |
-                             (uint)PermissionMask.Move |
-                             7); // Preserve folded permissions
-                }
+                    uint effectivePerms = (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify | PermissionMask.Move) | 7;
+                    foreach (SceneObjectGroup grp in objlist)
+                        effectivePerms &= grp.GetEffectivePermissions();
+                    effectivePerms |= (uint)PermissionMask.Move;
 
-                // TODO: add the new fields (Flags, Sale info, etc)
-                item.CreationDate = Util.UnixTimeSinceEpoch();
-                item.Description = asset.Description;
-                item.Name = asset.Name;
-                item.AssetType = asset.Type;
+                    if (remoteClient != null && (remoteClient.AgentId != objlist[0].RootPart.OwnerID) && m_Scene.Permissions.PropagatePermissions())
+                    {
+                        uint perms = effectivePerms;
+                        uint nextPerms = (perms & 7) << 13;
+                        if ((nextPerms & (uint)PermissionMask.Copy) == 0)
+                            perms &= ~(uint)PermissionMask.Copy;
+                        if ((nextPerms & (uint)PermissionMask.Transfer) == 0)
+                            perms &= ~(uint)PermissionMask.Transfer;
+                        if ((nextPerms & (uint)PermissionMask.Modify) == 0)
+                            perms &= ~(uint)PermissionMask.Modify;
+
+                        item.BasePermissions = perms & objlist[0].RootPart.NextOwnerMask;
+                        item.CurrentPermissions = item.BasePermissions;
+                        item.NextPermissions = perms & objlist[0].RootPart.NextOwnerMask;
+                        item.EveryOnePermissions = objlist[0].RootPart.EveryoneMask & objlist[0].RootPart.NextOwnerMask;
+                        item.GroupPermissions = objlist[0].RootPart.GroupMask & objlist[0].RootPart.NextOwnerMask;
+                        
+                        // Magic number badness. Maybe this deserves an enum.
+                        // bit 4 (16) is the "Slam" bit, it means treat as passed
+                        // and apply next owner perms on rez
+                        item.CurrentPermissions |= 16; // Slam!
+                    }
+                    else
+                    {
+                        item.BasePermissions = effectivePerms;
+                        item.CurrentPermissions = effectivePerms;
+                        item.NextPermissions = objlist[0].RootPart.NextOwnerMask & effectivePerms;
+                        item.EveryOnePermissions = objlist[0].RootPart.EveryoneMask & effectivePerms;
+                        item.GroupPermissions = objlist[0].RootPart.GroupMask & effectivePerms;
+
+                        item.CurrentPermissions &=
+                                ((uint)PermissionMask.Copy |
+                                 (uint)PermissionMask.Transfer |
+                                 (uint)PermissionMask.Modify |
+                                 (uint)PermissionMask.Move |
+                                 7); // Preserve folded permissions
+                    }
 
-                m_Scene.AddInventoryItem(item);
+                    item.CreationDate = Util.UnixTimeSinceEpoch();
+                    item.Description = asset.Description;
+                    item.Name = asset.Name;
+                    item.AssetType = asset.Type;
 
-                if (remoteClient != null && item.Owner == remoteClient.AgentId)
-                {
-                    remoteClient.SendInventoryItemCreateUpdate(item, 0);
-                }
-                else
-                {
-                    ScenePresence notifyUser = m_Scene.GetScenePresence(item.Owner);
-                    if (notifyUser != null)
+                    m_Scene.AddInventoryItem(item);
+
+                    if (remoteClient != null && item.Owner == remoteClient.AgentId)
                     {
-                        notifyUser.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
+                        remoteClient.SendInventoryItemCreateUpdate(item, 0);
+                    }
+                    else
+                    {
+                        ScenePresence notifyUser = m_Scene.GetScenePresence(item.Owner);
+                        if (notifyUser != null)
+                        {
+                            notifyUser.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
+                        }
                     }
                 }
             }
-
             return assetID;
         }
 
@@ -484,8 +552,10 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
         /// <summary>
         /// Rez an object into the scene from the user's inventory
         /// </summary>
+        /// <remarks>
         /// FIXME: It would be really nice if inventory access modules didn't also actually do the work of rezzing
         /// things to the scene.  The caller should be doing that, I think.
+        /// </remarks>
         /// <param name="remoteClient"></param>
         /// <param name="itemID"></param>
         /// <param name="RayEnd"></param>
@@ -502,21 +572,10 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                                     UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
                                     bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment)
         {
-            // Work out position details
-            byte bRayEndIsIntersection = (byte)0;
-
-            if (RayEndIsIntersection)
-            {
-                bRayEndIsIntersection = (byte)1;
-            }
-            else
-            {
-                bRayEndIsIntersection = (byte)0;
-            }
-
+//            m_log.DebugFormat("[INVENTORY ACCESS MODULE]: RezObject for {0}, item {1}", remoteClient.Name, itemID);
+            
+            byte bRayEndIsIntersection = (byte)(RayEndIsIntersection ? 1 : 0);
             Vector3 scale = new Vector3(0.5f, 0.5f, 0.5f);
-
-
             Vector3 pos = m_Scene.GetNewRezLocation(
                       RayStart, RayEnd, RayTargetID, Quaternion.Identity,
                       BypassRayCast, bRayEndIsIntersection, true, scale, false);
@@ -531,6 +590,8 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
 
                 AssetBase rezAsset = m_Scene.AssetService.Get(item.AssetID.ToString());
 
+                SceneObjectGroup group = null;
+
                 if (rezAsset != null)
                 {
                     UUID itemId = UUID.Zero;
@@ -539,34 +600,78 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                     // item that it came from.  This allows us to enable 'save object to inventory'
                     if (!m_Scene.Permissions.BypassPermissions())
                     {
-                        if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == (uint)PermissionMask.Copy)
+                        if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == (uint)PermissionMask.Copy && (item.Flags & (uint)InventoryItemFlags.ObjectHasMultipleItems) == 0)
                         {
                             itemId = item.ID;
                         }
                     }
                     else
                     {
-                        // Brave new fullperm world
-                        //
-                        itemId = item.ID;
+                        if ((item.Flags & (uint)InventoryItemFlags.ObjectHasMultipleItems) == 0)
+                        {
+                            // Brave new fullperm world
+                            itemId = item.ID;
+                        }
                     }
 
                     string xmlData = Utils.BytesToString(rezAsset.Data);
-                    SceneObjectGroup group
-                        = SceneObjectSerializer.FromOriginalXmlFormat(itemId, xmlData);
+                    List<SceneObjectGroup> objlist =
+                            new List<SceneObjectGroup>();
+                    List<Vector3> veclist = new List<Vector3>();
+
+                    XmlDocument doc = new XmlDocument();
+                    doc.LoadXml(xmlData);
+                    XmlElement e = (XmlElement)doc.SelectSingleNode("/CoalescedObject");
+                    if (e == null || attachment) // Single
+                    {
+                        SceneObjectGroup g =
+                                SceneObjectSerializer.FromOriginalXmlFormat(
+                                itemId, xmlData);
+                        objlist.Add(g);
+                        veclist.Add(new Vector3(0, 0, 0));
 
-                    Util.FireAndForget(delegate { AddUserData(group); });
- 
-                    group.RootPart.FromFolderID = item.Folder;
+                        float offsetHeight = 0;
+                        pos = m_Scene.GetNewRezLocation(
+                            RayStart, RayEnd, RayTargetID, Quaternion.Identity,
+                            BypassRayCast, bRayEndIsIntersection, true, g.GetAxisAlignedBoundingBox(out offsetHeight), false);
+                        pos.Z += offsetHeight;
+                    }
+                    else
+                    {
+                        XmlElement coll = (XmlElement)e;
+                        float bx = Convert.ToSingle(coll.GetAttribute("x"));
+                        float by = Convert.ToSingle(coll.GetAttribute("y"));
+                        float bz = Convert.ToSingle(coll.GetAttribute("z"));
+                        Vector3 bbox = new Vector3(bx, by, bz);
 
-                    // If it's rezzed in world, select it. Much easier to 
-                    // find small items.
-                    //
-                    if (!attachment)
-                        group.RootPart.CreateSelected = true;
+                        pos = m_Scene.GetNewRezLocation(RayStart, RayEnd,
+                                RayTargetID, Quaternion.Identity,
+                                BypassRayCast, bRayEndIsIntersection, true,
+                                bbox, false);
+
+                        pos -= bbox / 2;
+
+                        XmlNodeList groups = e.SelectNodes("SceneObjectGroup");
+                        foreach (XmlNode n in groups)
+                        {
+                            SceneObjectGroup g =
+                                    SceneObjectSerializer.FromOriginalXmlFormat(
+                                    itemId, n.OuterXml);
+                            objlist.Add(g);
+                            XmlElement el = (XmlElement)n;
+                            float x = Convert.ToSingle(el.GetAttribute("offsetx"));
+                            float y = Convert.ToSingle(el.GetAttribute("offsety"));
+                            float z = Convert.ToSingle(el.GetAttribute("offsetz"));
+                            veclist.Add(new Vector3(x, y, z));
+                        }
+                    }
+
+                    int primcount = 0;
+                    foreach (SceneObjectGroup g in objlist)
+                        primcount += g.PrimCount;
 
                     if (!m_Scene.Permissions.CanRezObject(
-                        group.PrimCount, remoteClient.AgentId, pos)
+                        primcount, remoteClient.AgentId, pos)
                         && !attachment)
                     {
                         // The client operates in no fail mode. It will
@@ -579,131 +684,131 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                         return null;
                     }
 
-                    group.ResetIDs();
-
-                    if (attachment)
+                    for (int i = 0 ; i < objlist.Count ; i++ )
                     {
-                        group.RootPart.Flags |= PrimFlags.Phantom;
-                        group.RootPart.IsAttachment = true;
+                        group = objlist[i];
+
+                        Vector3 storedPosition = group.AbsolutePosition;
+                        if (group.UUID == UUID.Zero)
+                        {
+                            m_log.Debug("[InventoryAccessModule]: Inventory object has UUID.Zero! Position 3");
+                        }
+                        group.RootPart.FromFolderID = item.Folder;
+
+                        // If it's rezzed in world, select it. Much easier to 
+                        // find small items.
+                        //
+                        if (!attachment)
+                        {
+                            group.RootPart.CreateSelected = true;
+                            foreach (SceneObjectPart child in group.Parts)
+                                child.CreateSelected = true;
+                        }
+                        group.ResetIDs();
+
+                        if (attachment)
+                        {
+                            group.RootPart.Flags |= PrimFlags.Phantom;
+                            group.RootPart.IsAttachment = true;
+                        }
 
                         // If we're rezzing an attachment then don't ask
                         // AddNewSceneObject() to update the client since
-                        // we'll be doing that later on.  Scheduling more
-                        // than one full update during the attachment
-                        // process causes some clients to fail to display
-                        // the attachment properly.
-                        // Also, don't persist attachments.
-                        m_Scene.AddNewSceneObject(group, false, false);
-                    }
-                    else
-                    {
+                        // we'll be doing that later on.  Scheduling more than
+                        // one full update during the attachment
+                        // process causes some clients to fail to display the
+                        // attachment properly.
                         m_Scene.AddNewSceneObject(group, true, false);
-                    }
 
-                    //  m_log.InfoFormat("ray end point for inventory rezz is {0} {1} {2} ", RayEnd.X, RayEnd.Y, RayEnd.Z);
-                    // if attachment we set it's asset id so object updates can reflect that
-                    // if not, we set it's position in world.
-                    if (!attachment)
-                    {
-                        group.ScheduleGroupForFullUpdate();
-                        
-                        float offsetHeight = 0;
-                        pos = m_Scene.GetNewRezLocation(
-                            RayStart, RayEnd, RayTargetID, Quaternion.Identity,
-                            BypassRayCast, bRayEndIsIntersection, true, group.GetAxisAlignedBoundingBox(out offsetHeight), false);
-                        pos.Z += offsetHeight;
-                        group.AbsolutePosition = pos;
-                        //   m_log.InfoFormat("rezx point for inventory rezz is {0} {1} {2}  and offsetheight was {3}", pos.X, pos.Y, pos.Z, offsetHeight);
-
-                    }
-                    else
-                    {
-                        group.SetFromItemID(itemID);
-                    }
+                        // if attachment we set it's asset id so object updates
+                        // can reflect that, if not, we set it's position in world.
+                        if (!attachment)
+                        {
+                            group.ScheduleGroupForFullUpdate();
+                            
+                            group.AbsolutePosition = pos + veclist[i];
+                        }
+                        else
+                        {
+                            group.SetFromItemID(itemID);
+                        }
 
-                    SceneObjectPart rootPart = null;
-                    try
-                    {
-                        rootPart = group.GetChildPart(group.UUID);
-                    }
-                    catch (NullReferenceException)
-                    {
-                        string isAttachment = "";
+                        SceneObjectPart rootPart = null;
 
-                        if (attachment)
-                            isAttachment = " Object was an attachment";
+                        try
+                        {
+                            rootPart = group.GetChildPart(group.UUID);
+                        }
+                        catch (NullReferenceException)
+                        {
+                            string isAttachment = "";
 
-                        m_log.Error("[AGENT INVENTORY]: Error rezzing ItemID: " + itemID + " object has no rootpart." + isAttachment);
-                    }
+                            if (attachment)
+                                isAttachment = " Object was an attachment";
 
-                    // Since renaming the item in the inventory does not affect the name stored
-                    // in the serialization, transfer the correct name from the inventory to the
-                    // object itself before we rez.
-                    rootPart.Name = item.Name;
-                    rootPart.Description = item.Description;
+                            m_log.Error("[AGENT INVENTORY]: Error rezzing ItemID: " + itemID + " object has no rootpart." + isAttachment);
+                        }
 
-                    if ((item.Flags & (uint)InventoryItemFlags.ObjectSlamSale) != 0)
-                    {
+                        // Since renaming the item in the inventory does not
+                        // affect the name stored in the serialization, transfer
+                        // the correct name from the inventory to the
+                        // object itself before we rez.
+                        rootPart.Name = item.Name;
+                        rootPart.Description = item.Description;
                         rootPart.ObjectSaleType = item.SaleType;
                         rootPart.SalePrice = item.SalePrice;
-                    }
-
-                    group.SetGroup(remoteClient.ActiveGroupId, remoteClient);
-                    if ((rootPart.OwnerID != item.Owner) ||
-                            (item.CurrentPermissions & 16) != 0 || // Magic number
-                            (item.Flags & (uint)InventoryItemFlags.ObjectSlamPerm) != 0)
-                    {
-                        //Need to kill the for sale here
-                        rootPart.ObjectSaleType = 0;
-                        rootPart.SalePrice = 10;
 
-                        if (m_Scene.Permissions.PropagatePermissions())
+                        group.SetGroup(remoteClient.ActiveGroupId, remoteClient);
+                        if ((rootPart.OwnerID != item.Owner) ||
+                            (item.CurrentPermissions & 16) != 0)
                         {
-                            foreach (SceneObjectPart part in group.Parts)
+                            //Need to kill the for sale here
+                            rootPart.ObjectSaleType = 0;
+                            rootPart.SalePrice = 10;
+
+                            if (m_Scene.Permissions.PropagatePermissions())
                             {
-                                if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteEveryone) != 0)
-                                    part.EveryoneMask = item.EveryOnePermissions;
-                                if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteNextOwner) != 0)
-                                    part.NextOwnerMask = item.NextPermissions;
-                                if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteGroup) != 0)
-                                    part.GroupMask = item.GroupPermissions;
+                                foreach (SceneObjectPart part in group.Parts)
+                                {
+                                    if ((item.Flags & (uint)InventoryItemFlags.ObjectHasMultipleItems) == 0)
+                                    {
+                                        part.EveryoneMask = item.EveryOnePermissions;
+                                        part.NextOwnerMask = item.NextPermissions;
+                                    }
+                                    part.GroupMask = 0; // DO NOT propagate here
+                                }
+                                
+                                group.ApplyNextOwnerPermissions();
                             }
-                            
-                            group.ApplyNextOwnerPermissions();
                         }
-                    }
 
-                    foreach (SceneObjectPart part in group.Parts)
-                    {
-                        if ((part.OwnerID != item.Owner) || (item.CurrentPermissions & 16) != 0)
+                        foreach (SceneObjectPart part in group.Parts)
                         {
-                            part.LastOwnerID = part.OwnerID;
-                            part.OwnerID = item.Owner;
-                            part.Inventory.ChangeInventoryOwner(item.Owner);
-                            part.GroupMask = 0; // DO NOT propagate here
-                        }
-                        if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteEveryone) != 0)
+                            if ((part.OwnerID != item.Owner) ||
+                                (item.CurrentPermissions & 16) != 0)
+                            {
+                                part.LastOwnerID = part.OwnerID;
+                                part.OwnerID = item.Owner;
+                                part.Inventory.ChangeInventoryOwner(item.Owner);
+                                part.GroupMask = 0; // DO NOT propagate here
+                            }
                             part.EveryoneMask = item.EveryOnePermissions;
-                        if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteNextOwner) != 0)
                             part.NextOwnerMask = item.NextPermissions;
-                        if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteGroup) != 0)
-                            part.GroupMask = item.GroupPermissions;
-                    }
+                        }
 
-                    rootPart.TrimPermissions();
+                        rootPart.TrimPermissions();
 
-                    if (!attachment)
-                    {
-                        if (group.RootPart.Shape.PCode == (byte)PCode.Prim)
+                        if (!attachment)
                         {
-                            group.ClearPartAttachmentData();
-                        }
-                        
-                        // Fire on_rez
-                        group.CreateScriptInstances(0, true, m_Scene.DefaultScriptEngine, 1);
-                        rootPart.ParentGroup.ResumeScripts();
+                            if (group.RootPart.Shape.PCode == (byte)PCode.Prim)
+                                group.ClearPartAttachmentData();
+                            
+                            // Fire on_rez
+                            group.CreateScriptInstances(0, true, m_Scene.DefaultScriptEngine, 1);
+                            rootPart.ParentGroup.ResumeScripts();
 
-                        rootPart.ScheduleFullUpdate();
+                            rootPart.ScheduleFullUpdate();
+                        }
                     }
 
                     if (!m_Scene.Permissions.BypassPermissions())
@@ -721,9 +826,8 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                             }
                         }
                     }
-
-                    return rootPart.ParentGroup;
                 }
+                return group;
             }
 
             return null;
diff --git a/OpenSim/Region/CoreModules/LightShare/LightShareModule.cs b/OpenSim/Region/CoreModules/LightShare/LightShareModule.cs
index 00b0aa9..2de8d7a 100644
--- a/OpenSim/Region/CoreModules/LightShare/LightShareModule.cs
+++ b/OpenSim/Region/CoreModules/LightShare/LightShareModule.cs
@@ -148,7 +148,7 @@ namespace OpenSim.Region.CoreModules.World.LightShare
         public void SendProfileToClient(ScenePresence presence)
         {
             IClientAPI client = presence.ControllingClient;
-            if (m_enableWindlight)
+            if (m_enableWindlight && m_scene.RegionInfo.WindlightSettings.valid)
             {
                 if (presence.IsChildAgent == false)
                 {
@@ -165,7 +165,7 @@ namespace OpenSim.Region.CoreModules.World.LightShare
         public void SendProfileToClient(ScenePresence presence, RegionLightShareData wl)
         {
             IClientAPI client = presence.ControllingClient;
-            if (m_enableWindlight)
+            if (m_enableWindlight && m_scene.RegionInfo.WindlightSettings.valid)
             {
                 if (presence.IsChildAgent == false)
                 {
diff --git a/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs b/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
index c0975ea..9255791 100644
--- a/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
@@ -111,14 +111,12 @@ namespace OpenSim.Region.CoreModules.Scripting.EmailModules
             {
                 if ((SMTPConfig = m_Config.Configs["SMTP"]) == null)
                 {
-                    m_log.InfoFormat("[SMTP] SMTP server not configured");
                     m_Enabled = false;
                     return;
                 }
 
                 if (!SMTPConfig.GetBoolean("enabled", false))
                 {
-                    m_log.InfoFormat("[SMTP] module disabled in configuration");
                     m_Enabled = false;
                     return;
                 }
diff --git a/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs b/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs
index d78931a..4c8424d 100644
--- a/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs
+++ b/OpenSim/Region/CoreModules/Scripting/HttpRequest/ScriptsHttpRequests.cs
@@ -29,8 +29,10 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Net;
+using System.Net.Security;
 using System.Text;
 using System.Threading;
+using System.Security.Cryptography.X509Certificates;
 using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
@@ -100,8 +102,24 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
 
         public HttpRequestModule()
         {
+            ServicePointManager.ServerCertificateValidationCallback +=ValidateServerCertificate;
         }
 
+        public static bool ValidateServerCertificate(
+            object sender,
+            X509Certificate  certificate,
+            X509Chain  chain,
+            SslPolicyErrors  sslPolicyErrors)
+        {
+            HttpWebRequest Request = (HttpWebRequest)sender;
+
+            if (Request.Headers.Get("NoVerifyCert") != null)
+            {
+                return true;
+            }
+            
+            return chain.Build(new X509Certificate2(certificate));
+        }
         #region IHttpRequestModule Members
 
         public UUID MakeHttpRequest(string url, string parameters, string body)
@@ -141,8 +159,7 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
                             break;
 
                         case (int)HttpRequestConstants.HTTP_VERIFY_CERT:
-
-                            // TODO implement me
+                            htc.HttpVerifyCert = (int.Parse(parms[i + 1]) != 0);
                             break;
                     }
                 }
@@ -189,7 +206,7 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
         * Not sure how important ordering is is here - the next first
         * one completed in the list is returned, based soley on its list
         * position, not the order in which the request was started or
-        * finsihed.  I thought about setting up a queue for this, but
+        * finished.  I thought about setting up a queue for this, but
         * it will need some refactoring and this works 'enough' right now
         */
 
@@ -237,8 +254,8 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
 
             m_scene.RegisterModuleInterface<IHttpRequestModule>(this);
 
-        m_proxyurl = config.Configs["Startup"].GetString("HttpProxy");
-        m_proxyexcepts = config.Configs["Startup"].GetString("HttpProxyExceptions");
+            m_proxyurl = config.Configs["Startup"].GetString("HttpProxy");
+            m_proxyexcepts = config.Configs["Startup"].GetString("HttpProxyExceptions");
 
             m_pendingRequests = new Dictionary<UUID, HttpRequestClass>();
         }
@@ -282,7 +299,7 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
         public string HttpMethod  = "GET";
         public string HttpMIMEType = "text/plain;charset=utf-8";
         public int HttpTimeout;
-        // public bool HttpVerifyCert = true; // not implemented
+        public bool HttpVerifyCert = true;
         private Thread httpThread;
 
         // Request info
@@ -344,6 +361,17 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
                 Request.Method = HttpMethod;
                 Request.ContentType = HttpMIMEType;
 
+                if(!HttpVerifyCert)
+                {
+                    // We could hijack Connection Group Name to identify
+                    // a desired security exception.  But at the moment we'll use a dummy header instead.
+//                    Request.ConnectionGroupName = "NoVerify";
+                    Request.Headers.Add("NoVerifyCert", "true");
+                }
+//                else
+//                {
+//                    Request.ConnectionGroupName="Verify";
+//                }
                 if (proxyurl != null && proxyurl.Length > 0) 
                 {
                     if (proxyexcepts != null && proxyexcepts.Length > 0) 
@@ -436,4 +464,4 @@ namespace OpenSim.Region.CoreModules.Scripting.HttpRequest
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
index 57ab135..b6d64ac 100644
--- a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
@@ -200,12 +200,13 @@ namespace OpenSim.Region.CoreModules.World.Estate
             }
             Scene.RegionInfo.RegionSettings.Save();
             TriggerRegionInfoChange();
+            sendRegionHandshakeToAll();
             sendRegionInfoPacketToAll();
         }
 
         private void handleCommitEstateTerrainTextureRequest(IClientAPI remoteClient)
         {
-            sendRegionHandshakeToAll();
+            // sendRegionHandshakeToAll();
         }
 
         public void setRegionTerrainSettings(float WaterHeight,
@@ -274,8 +275,25 @@ namespace OpenSim.Region.CoreModules.World.Estate
             {
                 if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true) || Scene.Permissions.BypassPermissions())
                 {
+                    if ((estateAccessType & 1) != 0) // All estates
+                    {
+                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                        EstateSettings estateSettings;
+
+                        foreach (int estateID in estateIDs)
+                        {
+                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            {
+                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                estateSettings.AddEstateUser(user);
+                                estateSettings.Save();
+                            }
+                        }
+                    }
+
                     Scene.RegionInfo.EstateSettings.AddEstateUser(user);
                     Scene.RegionInfo.EstateSettings.Save();
+
                     TriggerEstateInfoChange();
                     remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AccessOptions, Scene.RegionInfo.EstateSettings.EstateAccess, Scene.RegionInfo.EstateSettings.EstateID);
                 }
@@ -289,10 +307,26 @@ namespace OpenSim.Region.CoreModules.World.Estate
             {
                 if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true) || Scene.Permissions.BypassPermissions())
                 {
+                    if ((estateAccessType & 1) != 0) // All estates
+                    {
+                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                        EstateSettings estateSettings;
+
+                        foreach (int estateID in estateIDs)
+                        {
+                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            {
+                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                estateSettings.RemoveEstateUser(user);
+                                estateSettings.Save();
+                            }
+                        }
+                    }
+
                     Scene.RegionInfo.EstateSettings.RemoveEstateUser(user);
                     Scene.RegionInfo.EstateSettings.Save();
-                    TriggerEstateInfoChange();
 
+                    TriggerEstateInfoChange();
                     remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AccessOptions, Scene.RegionInfo.EstateSettings.EstateAccess, Scene.RegionInfo.EstateSettings.EstateID);
                 }
                 else
@@ -304,8 +338,25 @@ namespace OpenSim.Region.CoreModules.World.Estate
             {
                 if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true) || Scene.Permissions.BypassPermissions())
                 {
+                    if ((estateAccessType & 1) != 0) // All estates
+                    {
+                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                        EstateSettings estateSettings;
+
+                        foreach (int estateID in estateIDs)
+                        {
+                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            {
+                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                estateSettings.AddEstateGroup(user);
+                                estateSettings.Save();
+                            }
+                        }
+                    }
+
                     Scene.RegionInfo.EstateSettings.AddEstateGroup(user);
                     Scene.RegionInfo.EstateSettings.Save();
+
                     TriggerEstateInfoChange();
                     remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AllowedGroups, Scene.RegionInfo.EstateSettings.EstateGroups, Scene.RegionInfo.EstateSettings.EstateID);
                 }
@@ -318,10 +369,26 @@ namespace OpenSim.Region.CoreModules.World.Estate
             {
                 if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true) || Scene.Permissions.BypassPermissions())
                 {
+                    if ((estateAccessType & 1) != 0) // All estates
+                    {
+                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                        EstateSettings estateSettings;
+
+                        foreach (int estateID in estateIDs)
+                        {
+                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            {
+                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                estateSettings.RemoveEstateGroup(user);
+                                estateSettings.Save();
+                            }
+                        }
+                    }
+
                     Scene.RegionInfo.EstateSettings.RemoveEstateGroup(user);
                     Scene.RegionInfo.EstateSettings.Save();
-                    TriggerEstateInfoChange();
 
+                    TriggerEstateInfoChange();
                     remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AllowedGroups, Scene.RegionInfo.EstateSettings.EstateGroups, Scene.RegionInfo.EstateSettings.EstateID);
                 }
                 else
@@ -349,6 +416,29 @@ namespace OpenSim.Region.CoreModules.World.Estate
                     if (!alreadyInList)
                     {
 
+                        if ((estateAccessType & 1) != 0) // All estates
+                        {
+                            List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                            EstateSettings estateSettings;
+
+                            foreach (int estateID in estateIDs)
+                            {
+                                if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                                {
+                                    EstateBan bitem = new EstateBan();
+
+                                    bitem.BannedUserID = user;
+                                    bitem.EstateID = (uint)estateID;
+                                    bitem.BannedHostAddress = "0.0.0.0";
+                                    bitem.BannedHostIPMask = "0.0.0.0";
+
+                                    estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                    estateSettings.AddBan(bitem);
+                                    estateSettings.Save();
+                                }
+                            }
+                        }
+
                         EstateBan item = new EstateBan();
 
                         item.BannedUserID = user;
@@ -358,6 +448,7 @@ namespace OpenSim.Region.CoreModules.World.Estate
 
                         Scene.RegionInfo.EstateSettings.AddBan(item);
                         Scene.RegionInfo.EstateSettings.Save();
+
                         TriggerEstateInfoChange();
 
                         ScenePresence s = Scene.GetScenePresence(user);
@@ -403,8 +494,25 @@ namespace OpenSim.Region.CoreModules.World.Estate
                     
                     if (alreadyInList && listitem != null)
                     {
+                        if ((estateAccessType & 1) != 0) // All estates
+                        {
+                            List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                            EstateSettings estateSettings;
+
+                            foreach (int estateID in estateIDs)
+                            {
+                                if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                                {
+                                    estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                    estateSettings.RemoveBan(user);
+                                    estateSettings.Save();
+                                }
+                            }
+                        }
+
                         Scene.RegionInfo.EstateSettings.RemoveBan(listitem.BannedUserID);
                         Scene.RegionInfo.EstateSettings.Save();
+
                         TriggerEstateInfoChange();
                     }
                     else
@@ -424,8 +532,25 @@ namespace OpenSim.Region.CoreModules.World.Estate
             {
                 if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true) || Scene.Permissions.BypassPermissions())
                 {
+                    if ((estateAccessType & 1) != 0) // All estates
+                    {
+                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                        EstateSettings estateSettings;
+
+                        foreach (int estateID in estateIDs)
+                        {
+                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            {
+                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                estateSettings.AddEstateManager(user);
+                                estateSettings.Save();
+                            }
+                        }
+                    }
+
                     Scene.RegionInfo.EstateSettings.AddEstateManager(user);
                     Scene.RegionInfo.EstateSettings.Save();
+
                     TriggerEstateInfoChange();
                     remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.EstateManagers, Scene.RegionInfo.EstateSettings.EstateManagers, Scene.RegionInfo.EstateSettings.EstateID);
                 }
@@ -438,10 +563,26 @@ namespace OpenSim.Region.CoreModules.World.Estate
             {
                 if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true) || Scene.Permissions.BypassPermissions())
                 {
+                    if ((estateAccessType & 1) != 0) // All estates
+                    {
+                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                        EstateSettings estateSettings;
+
+                        foreach (int estateID in estateIDs)
+                        {
+                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            {
+                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                estateSettings.RemoveEstateManager(user);
+                                estateSettings.Save();
+                            }
+                        }
+                    }
+
                     Scene.RegionInfo.EstateSettings.RemoveEstateManager(user);
                     Scene.RegionInfo.EstateSettings.Save();
-                    TriggerEstateInfoChange();
 
+                    TriggerEstateInfoChange();
                     remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.EstateManagers, Scene.RegionInfo.EstateSettings.EstateManagers, Scene.RegionInfo.EstateSettings.EstateID);
                 }
                 else
diff --git a/OpenSim/Region/CoreModules/World/Land/LandChannel.cs b/OpenSim/Region/CoreModules/World/Land/LandChannel.cs
index 7d990c2..7fc358d 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandChannel.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandChannel.cs
@@ -133,16 +133,6 @@ namespace OpenSim.Region.CoreModules.World.Land
             return new List<ILandObject>();
         }
 
-        public bool IsLandPrimCountTainted()
-        {
-            if (m_landManagementModule != null)
-            {
-                return m_landManagementModule.IsLandPrimCountTainted();
-            }
-
-            return false;
-        }
-
         public bool IsForcefulBansAllowed()
         {
             if (m_landManagementModule != null)
diff --git a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
index 98ba8c3..bfab7b8 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
@@ -62,8 +62,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
     public class LandManagementModule : INonSharedRegionModule
     {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static readonly string remoteParcelRequestPath = "0009/";
 
@@ -72,6 +71,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         protected Commander m_commander = new Commander("land");
         
         protected IUserManagement m_userManager;
+        protected IPrimCountModule m_primCountModule;
 
         // Minimum for parcels to work is 64m even if we don't actually use them.
         #pragma warning disable 0429
@@ -88,7 +88,6 @@ namespace OpenSim.Region.CoreModules.World.Land
         /// </value>
         private readonly Dictionary<int, ILandObject> m_landList = new Dictionary<int, ILandObject>();
 
-        private bool m_landPrimCountTainted;
         private int m_lastLandLocalID = LandChannel.START_LAND_LOCAL_ID - 1;
 
         private bool m_allowedForcefulBans = true;
@@ -121,18 +120,18 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             m_scene.EventManager.OnParcelPrimCountAdd += EventManagerOnParcelPrimCountAdd;
             m_scene.EventManager.OnParcelPrimCountUpdate += EventManagerOnParcelPrimCountUpdate;
+            m_scene.EventManager.OnObjectBeingRemovedFromScene += EventManagerOnObjectBeingRemovedFromScene;            
+            m_scene.EventManager.OnRequestParcelPrimCountUpdate += EventManagerOnRequestParcelPrimCountUpdate;
+            
             m_scene.EventManager.OnAvatarEnteringNewParcel += EventManagerOnAvatarEnteringNewParcel;
             m_scene.EventManager.OnClientMovement += EventManagerOnClientMovement;
             m_scene.EventManager.OnValidateLandBuy += EventManagerOnValidateLandBuy;
             m_scene.EventManager.OnLandBuy += EventManagerOnLandBuy;
             m_scene.EventManager.OnNewClient += EventManagerOnNewClient;
             m_scene.EventManager.OnSignificantClientMovement += EventManagerOnSignificantClientMovement;
-            m_scene.EventManager.OnObjectBeingRemovedFromScene += EventManagerOnObjectBeingRemovedFromScene;
             m_scene.EventManager.OnNoticeNoLandDataFromStorage += EventManagerOnNoLandDataFromStorage;
             m_scene.EventManager.OnIncomingLandDataFromStorage += EventManagerOnIncomingLandDataFromStorage;
-            m_scene.EventManager.OnSetAllowForcefulBan += EventManagerOnSetAllowedForcefulBan;
-            m_scene.EventManager.OnRequestParcelPrimCountUpdate += EventManagerOnRequestParcelPrimCountUpdate;
-            m_scene.EventManager.OnParcelPrimCountTainted += EventManagerOnParcelPrimCountTainted;
+            m_scene.EventManager.OnSetAllowForcefulBan += EventManagerOnSetAllowedForcefulBan;            
             m_scene.EventManager.OnRegisterCaps += EventManagerOnRegisterCaps;
             m_scene.EventManager.OnPluginConsole += EventManagerOnPluginConsole;
 
@@ -147,6 +146,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         public void RegionLoaded(Scene scene)
         {
              m_userManager = m_scene.RequestModuleInterface<IUserManagement>();         
+             m_primCountModule = m_scene.RequestModuleInterface<IPrimCountModule>();
         }
 
         public void RemoveRegion(Scene scene)
@@ -306,10 +306,14 @@ namespace OpenSim.Region.CoreModules.World.Land
         /// <returns>The parcel created.</returns>
         protected ILandObject CreateDefaultParcel()
         {
-            ILandObject fullSimParcel = new LandObject(UUID.Zero, false, m_scene);
+            m_log.DebugFormat(
+                "[LAND MANAGEMENT MODULE]: Creating default parcel for region {0}", m_scene.RegionInfo.RegionName);
+            
+            ILandObject fullSimParcel = new LandObject(UUID.Zero, false, m_scene);                                                
             fullSimParcel.SetLandBitmap(fullSimParcel.GetSquareLandBitmap(0, 0, (int)Constants.RegionSize, (int)Constants.RegionSize));
             fullSimParcel.LandData.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
             fullSimParcel.LandData.ClaimDate = Util.UnixTimeSinceEpoch();
+            
             return AddLandObject(fullSimParcel);            
         }
 
@@ -579,7 +583,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
             else
             {
-                m_log.WarnFormat("[LAND]: Invalid local land ID {0}", landLocalID);
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Invalid local land ID {0}", landLocalID);
             }
         }
 
@@ -590,6 +594,11 @@ namespace OpenSim.Region.CoreModules.World.Land
         public ILandObject AddLandObject(ILandObject land)
         {
             ILandObject new_land = land.Copy();
+            
+            // Only now can we add the prim counts to the land object - we rely on the global ID which is generated
+            // as a random UUID inside LandData initialization
+            if (m_primCountModule != null)
+                new_land.PrimCounts = m_primCountModule.GetPrimCounts(new_land.LandData.GlobalID);            
 
             lock (m_landList)
             {
@@ -603,6 +612,10 @@ namespace OpenSim.Region.CoreModules.World.Land
                     {
                         if (landBitmap[x, y])
                         {
+//                            m_log.DebugFormat(
+//                                "[LAND MANAGEMENT MODULE]: Registering parcel {0} for land co-ord ({1}, {2}) on {3}", 
+//                                new_land.LandData.Name, x, y, m_scene.RegionInfo.RegionName);
+                            
                             m_landIDList[x, y] = newLandLocalID;
                         }
                     }
@@ -630,7 +643,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                     {
                         if (m_landIDList[x, y] == local_id)
                         {
-                            m_log.WarnFormat("[LAND]: Not removing land object {0}; still being used at {1}, {2}",
+                            m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Not removing land object {0}; still being used at {1}, {2}",
                                              local_id, x, y);
                             return;
                             //throw new Exception("Could not remove land object. Still being used at " + x + ", " + y);
@@ -732,8 +745,16 @@ namespace OpenSim.Region.CoreModules.World.Land
                 // Corner case. If an autoreturn happens during sim startup
                 // we will come here with the list uninitialized
                 //
+                int landId = m_landIDList[x, y];
+                
+//                if (landId == 0)
+//                    m_log.DebugFormat(
+//                        "[LAND MANAGEMENT MODULE]: No land object found at ({0}, {1}) on {2}", 
+//                        x, y, m_scene.RegionInfo.RegionName);
+                
                 if (m_landList.ContainsKey(m_landIDList[x, y]))
                     return m_landList[m_landIDList[x, y]];
+                
                 return null;
             }
         }
@@ -751,13 +772,14 @@ namespace OpenSim.Region.CoreModules.World.Land
             {
                 try
                 {
-                    //if (m_landList.ContainsKey(m_landIDList[x / 4, y / 4]))
-                        return m_landList[m_landIDList[x / 4, y / 4]];
-                    //else
-                    //    return null;
+                    return m_landList[m_landIDList[x / 4, y / 4]];
                 }
                 catch (IndexOutOfRangeException)
                 {
+//                    m_log.WarnFormat(
+//                        "[LAND MANAGEMENT MODULE]: Tried to retrieve land object from out of bounds co-ordinate ({0},{1}) in {2}", 
+//                        x, y, m_scene.RegionInfo.RegionName);
+                    
                     return null;
                 }
             }
@@ -767,34 +789,24 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         #region Parcel Modification
 
-        public void ResetAllLandPrimCounts()
+        public void ResetOverMeRecords()
         {
             lock (m_landList)
             {
                 foreach (LandObject p in m_landList.Values)
                 {
-                    p.ResetLandPrimCounts();
+                    p.ResetOverMeRecord();
                 }
             }
         }
 
-        public void EventManagerOnParcelPrimCountTainted()
-        {
-            m_landPrimCountTainted = true;
-        }
-
-        public bool IsLandPrimCountTainted()
-        {
-            return m_landPrimCountTainted;
-        }
-
         public void EventManagerOnParcelPrimCountAdd(SceneObjectGroup obj)
         {
             Vector3 position = obj.AbsolutePosition;
             ILandObject landUnderPrim = GetLandObject(position.X, position.Y);
             if (landUnderPrim != null)
             {
-                landUnderPrim.AddPrimToCount(obj);
+                ((LandObject)landUnderPrim).AddPrimOverMe(obj);
             }
         }
 
@@ -804,7 +816,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             {
                 foreach (LandObject p in m_landList.Values)
                 {
-                    p.RemovePrimFromCount(obj);
+                    p.RemovePrimFromOverMe(obj);
                 }
             }
         }
@@ -837,8 +849,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 foreach (LandObject p in landOwnersAndParcels[owner])
                 {
                     simArea += p.LandData.Area;
-                    simPrims += p.LandData.OwnerPrims + p.LandData.OtherPrims + p.LandData.GroupPrims +
-                                p.LandData.SelectedPrims;
+                    simPrims += p.PrimCounts.Total;
                 }
 
                 foreach (LandObject p in landOwnersAndParcels[owner])
@@ -851,7 +862,11 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         public void EventManagerOnParcelPrimCountUpdate()
         {
-            ResetAllLandPrimCounts();
+//            m_log.DebugFormat(
+//                "[LAND MANAGEMENT MODULE]: Triggered EventManagerOnParcelPrimCountUpdate() for {0}", 
+//                m_scene.RegionInfo.RegionName);
+            
+            ResetOverMeRecords();
             EntityBase[] entities = m_scene.Entities.GetEntities();
             foreach (EntityBase obj in entities)
             {
@@ -864,15 +879,13 @@ namespace OpenSim.Region.CoreModules.World.Land
                 }
             }
             FinalizeLandPrimCountUpdate();
-            m_landPrimCountTainted = false;
         }
 
         public void EventManagerOnRequestParcelPrimCountUpdate()
         {
-            ResetAllLandPrimCounts();
+            ResetOverMeRecords();
             m_scene.EventManager.TriggerParcelPrimCountUpdate();
             FinalizeLandPrimCountUpdate();
-            m_landPrimCountTainted = false;
         }
 
         /// <summary>
@@ -936,8 +949,6 @@ namespace OpenSim.Region.CoreModules.World.Land
                 m_landList[startLandObjectIndex].ForceUpdateLandInfo();
             }
 
-            EventManagerOnParcelPrimCountTainted();
-
             //Now add the new land object
             ILandObject result = AddLandObject(newLand);
             UpdateLandObject(startLandObject.LandData.LocalID, startLandObject.LandData);
@@ -1004,7 +1015,6 @@ namespace OpenSim.Region.CoreModules.World.Land
                     performFinalLandJoin(masterLandObject, slaveLandObject);
                 }
             }
-            EventManagerOnParcelPrimCountTainted();
 
             masterLandObject.SendLandUpdateToAvatarsOverMe();
         }
@@ -1194,11 +1204,12 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             if (land != null)
             {
+                m_scene.EventManager.TriggerParcelPrimCountUpdate();
                 m_landList[local_id].SendLandObjectOwners(remote_client);
             }
             else
             {
-                m_log.WarnFormat("[PARCEL]: Invalid land object {0} passed for parcel object owner request", local_id);
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Invalid land object {0} passed for parcel object owner request", local_id);
             }
         }
 
@@ -1361,7 +1372,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         {
             ILandObject new_land = new LandObject(data.OwnerID, data.IsGroupOwned, m_scene);
             new_land.LandData = data.Copy();
-            new_land.SetLandBitmapFromByteArray();
+            new_land.SetLandBitmapFromByteArray();            
             AddLandObject(new_land);
         }
 
@@ -1425,8 +1436,9 @@ namespace OpenSim.Region.CoreModules.World.Land
         private string ProcessPropertiesUpdate(string request, string path, string param, UUID agentID, Caps caps)
         {
             IClientAPI client;
-            if (! m_scene.TryGetClient(agentID, out client)) {
-                m_log.WarnFormat("[LAND] unable to retrieve IClientAPI for {0}", agentID.ToString());
+            if (!m_scene.TryGetClient(agentID, out client)) 
+            {
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Unable to retrieve IClientAPI for {0}", agentID);
                 return LLSDHelpers.SerialiseLLSDReply(new LLSDEmpty());
             }
 
@@ -1475,7 +1487,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
             else
             {
-                m_log.WarnFormat("[LAND] unable to find parcelID {0}", parcelID);
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Unable to find parcelID {0}", parcelID);
             }
             return LLSDHelpers.SerialiseLLSDReply(new LLSDEmpty());
         }
@@ -1533,17 +1545,17 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
             catch (LLSD.LLSDParseException e)
             {
-                m_log.ErrorFormat("[LAND] Fetch error: {0}", e.Message);
-                m_log.ErrorFormat("[LAND] ... in request {0}", request);
+                m_log.ErrorFormat("[LAND MANAGEMENT MODULE]: Fetch error: {0}", e.Message);
+                m_log.ErrorFormat("[LAND MANAGEMENT MODULE]: ... in request {0}", request);
             }
-            catch(InvalidCastException)
+            catch (InvalidCastException)
             {
-                m_log.ErrorFormat("[LAND] Wrong type in request {0}", request);
+                m_log.ErrorFormat("[LAND MANAGEMENT MODULE]: Wrong type in request {0}", request);
             }
 
             LLSDRemoteParcelResponse response = new LLSDRemoteParcelResponse();
             response.parcel_id = parcelID;
-            m_log.DebugFormat("[LAND] got parcelID {0}", parcelID);
+            m_log.DebugFormat("[LAND MANAGEMENT MODULE]: Got parcelID {0}", parcelID);
 
             return LLSDHelpers.SerialiseLLSDReply(response);
         }
@@ -1564,7 +1576,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                         ExtendedLandData extLandData = new ExtendedLandData();
                         Util.ParseFakeParcelID(parcel, out extLandData.RegionHandle,
                                                out extLandData.X, out extLandData.Y);
-                        m_log.DebugFormat("[LAND] got parcelinfo request for regionHandle {0}, x/y {1}/{2}",
+                        m_log.DebugFormat("[LAND MANAGEMENT MODULE]: Got parcelinfo request for regionHandle {0}, x/y {1}/{2}",
                                           extLandData.RegionHandle, extLandData.X, extLandData.Y);
 
                         // for this region or for somewhere else?
@@ -1605,7 +1617,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                     info = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
                 }
                 // we need to transfer the fake parcelID, not the one in landData, so the viewer can match it to the landmark.
-                m_log.DebugFormat("[LAND] got parcelinfo for parcel {0} in region {1}; sending...",
+                m_log.DebugFormat("[LAND MANAGEMENT MODULE]: got parcelinfo for parcel {0} in region {1}; sending...",
                                   data.LandData.Name, data.RegionHandle);
                 // HACK for now
                 RegionInfo r = new RegionInfo();
@@ -1616,7 +1628,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 remoteClient.SendParcelInfo(r, data.LandData, parcelID, data.X, data.Y);
             }
             else
-                m_log.Debug("[LAND] got no parcelinfo; not sending");
+                m_log.Debug("[LAND MANAGEMENT MODULE]: got no parcelinfo; not sending");
         }
 
         public void setParcelOtherCleanTime(IClientAPI remoteClient, int localID, int otherCleanTime)
diff --git a/OpenSim/Region/CoreModules/World/Land/LandObject.cs b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
index 46c15ed..c2f104e 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandObject.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
@@ -51,7 +51,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         private int m_lastSeqId = 0;
 
-        protected LandData m_landData = new LandData();
+        protected LandData m_landData = new LandData();        
         protected Scene m_scene;
         protected List<SceneObjectGroup> primsOverMe = new List<SceneObjectGroup>();
         protected Dictionary<uint, UUID> m_listTransactions = new Dictionary<uint, UUID>();
@@ -64,8 +64,6 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         #endregion
 
-        #region ILandObject Members
-
         public int GetPrimsFree()
         {
             m_scene.EventManager.TriggerParcelPrimCountUpdate();
@@ -79,6 +77,8 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             set { m_landData = value; }
         }
+        
+        public IPrimCounts PrimCounts { get; set; }
 
         public UUID RegionUUID
         {
@@ -211,6 +211,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 return simMax;
             }
         }
+        
         #endregion
 
         #region Packet Request Handling
@@ -241,7 +242,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
 
             remote_client.SendLandProperties(seq_id,
-                    snap_selection, request_result, LandData,
+                    snap_selection, request_result, this,
                     (float)m_scene.RegionInfo.RegionSettings.ObjectBonus,
                     GetParcelMaxPrimCount(this),
                     GetSimulatorMaxPrimCount(this), regionFlags);
@@ -700,23 +701,11 @@ namespace OpenSim.Region.CoreModules.World.Land
             return LandBitmap;
         }
 
-        /// <summary>
-        /// Full sim land object creation
-        /// </summary>
-        /// <returns></returns>
         public bool[,] BasicFullRegionLandBitmap()
         {
             return GetSquareLandBitmap(0, 0, (int) Constants.RegionSize, (int) Constants.RegionSize);
         }
-
-        /// <summary>
-        /// Used to modify the bitmap between the x and y points. Points use 64 scale
-        /// </summary>
-        /// <param name="start_x"></param>
-        /// <param name="start_y"></param>
-        /// <param name="end_x"></param>
-        /// <param name="end_y"></param>
-        /// <returns></returns>
+        
         public bool[,] GetSquareLandBitmap(int start_x, int start_y, int end_x, int end_y)
         {
             bool[,] tempBitmap = new bool[64,64];
@@ -907,9 +896,12 @@ namespace OpenSim.Region.CoreModules.World.Land
 
                 lock (primsOverMe)
                 {
+//                    m_log.DebugFormat(
+//                        "[LAND OBJECT]: Request for SendLandObjectOwners() from {0} with {1} known prims on region", 
+//                        remote_client.Name, primsOverMe.Count);
+                    
                     try
                     {
-
                         foreach (SceneObjectGroup obj in primsOverMe)
                         {
                             try
@@ -921,7 +913,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                             }
                             catch (NullReferenceException)
                             {
-                                m_log.Info("[LAND]: " + "Got Null Reference when searching land owners from the parcel panel");
+                                m_log.Error("[LAND]: " + "Got Null Reference when searching land owners from the parcel panel");
                             }
                             try
                             {
@@ -948,6 +940,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         public Dictionary<UUID, int> GetLandObjectOwners()
         {
             Dictionary<UUID, int> ownersAndCount = new Dictionary<UUID, int>();
+            
             lock (primsOverMe)
             {
                 try
@@ -984,8 +977,10 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         public void ReturnLandObjects(uint type, UUID[] owners, UUID[] tasks, IClientAPI remote_client)
         {
-            Dictionary<UUID,List<SceneObjectGroup>> returns =
-                    new Dictionary<UUID,List<SceneObjectGroup>>();
+//            m_log.DebugFormat(
+//                "[LAND OBJECT]: Request to return objects in {0} from {1}", LandData.Name, remote_client.Name);
+            
+            Dictionary<UUID,List<SceneObjectGroup>> returns = new Dictionary<UUID,List<SceneObjectGroup>>();
 
             lock (primsOverMe)
             {
@@ -1058,83 +1053,29 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         #region Object Adding/Removing from Parcel
 
-        public void ResetLandPrimCounts()
+        public void ResetOverMeRecord()
         {
-            LandData.GroupPrims = 0;
-            LandData.OwnerPrims = 0;
-            LandData.OtherPrims = 0;
-            LandData.SelectedPrims = 0;
-
-
             lock (primsOverMe)
                 primsOverMe.Clear();
         }
 
-        public void AddPrimToCount(SceneObjectGroup obj)
+        public void AddPrimOverMe(SceneObjectGroup obj)
         {
-
-            UUID prim_owner = obj.OwnerID;
-            int prim_count = obj.PrimCount;
-
-            if (obj.IsSelected)
-            {
-                LandData.SelectedPrims += prim_count;
-            }
-            else
-            {
-                if (prim_owner == LandData.OwnerID)
-                {
-                    LandData.OwnerPrims += prim_count;
-                }
-                else if ((obj.GroupID == LandData.GroupID ||
-                          prim_owner  == LandData.GroupID) &&
-                          LandData.GroupID != UUID.Zero)
-                {
-                    LandData.GroupPrims += prim_count;
-                }
-                else
-                {
-                    LandData.OtherPrims += prim_count;
-                }
-            }
-
+//            m_log.DebugFormat("[LAND OBJECT]: Adding scene object {0} {1} over {2}", obj.Name, obj.LocalId, LandData.Name);
+            
             lock (primsOverMe)
                 primsOverMe.Add(obj);
         }
 
-        public void RemovePrimFromCount(SceneObjectGroup obj)
+        public void RemovePrimFromOverMe(SceneObjectGroup obj)
         {
+//            m_log.DebugFormat("[LAND OBJECT]: Removing scene object {0} {1} from over {2}", obj.Name, obj.LocalId, LandData.Name);
+            
             lock (primsOverMe)
-            {
-                if (primsOverMe.Contains(obj))
-                {
-                    UUID prim_owner = obj.OwnerID;
-                    int prim_count = obj.PrimCount;
-
-                    if (prim_owner == LandData.OwnerID)
-                    {
-                        LandData.OwnerPrims -= prim_count;
-                    }
-                    else if (obj.GroupID == LandData.GroupID ||
-                             prim_owner  == LandData.GroupID)
-                    {
-                        LandData.GroupPrims -= prim_count;
-                    }
-                    else
-                    {
-                        LandData.OtherPrims -= prim_count;
-                    }
-
-                    primsOverMe.Remove(obj);
-                }
-            }
+                primsOverMe.Remove(obj);
         }
 
         #endregion
-
-        #endregion
-
-        #endregion
         
         /// <summary>
         /// Set the media url for this land parcel
@@ -1155,5 +1096,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             LandData.MusicURL = url;
             SendLandUpdateToAvatarsOverMe();
         }
+        
+        #endregion
     }
 }
diff --git a/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs b/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs
index 34ef67f..dca842a 100644
--- a/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs
@@ -45,14 +45,13 @@ namespace OpenSim.Region.CoreModules.World.Land
         public int Owner = 0;
         public int Group = 0;
         public int Others = 0;
-        public Dictionary <UUID, int> Users =
-                new Dictionary <UUID, int>();
+        public int Selected = 0;
+        public Dictionary <UUID, int> Users = new Dictionary <UUID, int>();
     }
 
     public class PrimCountModule : IPrimCountModule, INonSharedRegionModule
     {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private Scene m_Scene;
         private Dictionary<UUID, PrimCounts> m_PrimCounts =
@@ -64,10 +63,15 @@ namespace OpenSim.Region.CoreModules.World.Land
         private Dictionary<UUID, ParcelCounts> m_ParcelCounts =
                 new Dictionary<UUID, ParcelCounts>();
 
-        // For now, a simple simwide taint to get this up. Later parcel based
-        // taint to allow recounting a parcel if only ownership has changed
-        // without recounting the whole sim.
+        /// <value>
+        /// For now, a simple simwide taint to get this up. Later parcel based
+        /// taint to allow recounting a parcel if only ownership has changed
+        /// without recounting the whole sim.
+        /// 
+        /// We start out tainted so that the first get call resets the various prim counts.
+        /// <value>
         private bool m_Tainted = true;
+        
         private Object m_TaintLock = new Object();
 
         public Type ReplaceableInterface
@@ -82,13 +86,15 @@ namespace OpenSim.Region.CoreModules.World.Land
         public void AddRegion(Scene scene)
         {
             m_Scene = scene;
+            
+            m_Scene.RegisterModuleInterface<IPrimCountModule>(this);
 
-            m_Scene.EventManager.OnParcelPrimCountAdd +=
-                    OnParcelPrimCountAdd;
+            m_Scene.EventManager.OnObjectAddedToScene += OnParcelPrimCountAdd;            
             m_Scene.EventManager.OnObjectBeingRemovedFromScene +=
                     OnObjectBeingRemovedFromScene;
             m_Scene.EventManager.OnParcelPrimCountTainted +=
                     OnParcelPrimCountTainted;
+            m_Scene.EventManager.OnLandObjectAdded += delegate(ILandObject lo) { OnParcelPrimCountTainted(); };
         }
 
         public void RegionLoaded(Scene scene)
@@ -116,6 +122,11 @@ namespace OpenSim.Region.CoreModules.World.Land
             {
                 if (!m_Tainted)
                     AddObject(obj);
+//                else
+//                    m_log.DebugFormat(
+//                        "[PRIM COUNT MODULE]: Ignoring OnParcelPrimCountAdd() for {0} on {1} since count is tainted", 
+//                        obj.Name, m_Scene.RegionInfo.RegionName);
+                    
             }
         }
 
@@ -126,11 +137,18 @@ namespace OpenSim.Region.CoreModules.World.Land
             {
                 if (!m_Tainted)
                     RemoveObject(obj);
+//                else
+//                    m_log.DebugFormat(
+//                        "[PRIM COUNT MODULE]: Ignoring OnObjectBeingRemovedFromScene() for {0} on {1} since count is tainted", 
+//                        obj.Name, m_Scene.RegionInfo.RegionName);                
             }
         }
 
         private void OnParcelPrimCountTainted()
         {
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: OnParcelPrimCountTainted() called on {0}", m_Scene.RegionInfo.RegionName);            
+            
             lock (m_TaintLock)
                 m_Tainted = true;
         }
@@ -155,15 +173,34 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         // NOTE: Call under Taint Lock
         private void AddObject(SceneObjectGroup obj)
-        {
+        {                       
             if (obj.IsAttachment)
                 return;
             if (((obj.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0))
-                return;
+                return;                       
 
             Vector3 pos = obj.AbsolutePosition;
             ILandObject landObject = m_Scene.LandChannel.GetLandObject(pos.X, pos.Y);
+            
+            // If for some reason there is no land object (perhaps the object is out of bounds) then we can't count it
+            if (landObject == null)
+            {
+//                m_log.WarnFormat(
+//                    "[PRIM COUNT MODULE]: Found no land object for {0} at position ({1}, {2}) on {3}", 
+//                    obj.Name, pos.X, pos.Y, m_Scene.RegionInfo.RegionName);
+                
+                return;
+            }
+            
             LandData landData = landObject.LandData;
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: Adding object {0} with {1} parts to prim count for parcel {2} on {3}", 
+//                obj.Name, obj.Parts.Length, landData.Name, m_Scene.RegionInfo.RegionName);                        
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: Object {0} is owned by {1} over land owned by {2}", 
+//                obj.Name, obj.OwnerID, landData.OwnerID);
 
             ParcelCounts parcelCounts;
             if (m_ParcelCounts.TryGetValue(landData.GlobalID, out parcelCounts))
@@ -177,23 +214,28 @@ namespace OpenSim.Region.CoreModules.World.Land
                 else
                     parcelCounts.Users[obj.OwnerID] = partCount;
 
-                if (landData.IsGroupOwned)
+                if (obj.IsSelected)
                 {
-                    if (obj.OwnerID == landData.GroupID)
-                        parcelCounts.Owner += partCount;
-                    else if (obj.GroupID == landData.GroupID)
-                        parcelCounts.Group += partCount;
-                    else
-                        parcelCounts.Others += partCount;
+                    parcelCounts.Selected += partCount;                
                 }
                 else
                 {
-                    if (obj.OwnerID == landData.OwnerID)
-                        parcelCounts.Owner += partCount;
-                    else if (obj.GroupID == landData.GroupID)
-                        parcelCounts.Group += partCount;
+                    if (landData.IsGroupOwned)
+                    {
+                        if (obj.OwnerID == landData.GroupID)
+                            parcelCounts.Owner += partCount;
+                        else if (landData.GroupID != UUID.Zero && obj.GroupID == landData.GroupID)
+                            parcelCounts.Group += partCount;
+                        else
+                            parcelCounts.Others += partCount;
+                    }
                     else
-                        parcelCounts.Others += partCount;
+                    {
+                        if (obj.OwnerID == landData.OwnerID)
+                            parcelCounts.Owner += partCount;
+                        else
+                            parcelCounts.Others += partCount;
+                    }
                 }
             }
         }
@@ -201,10 +243,16 @@ namespace OpenSim.Region.CoreModules.World.Land
         // NOTE: Call under Taint Lock
         private void RemoveObject(SceneObjectGroup obj)
         {
+//            m_log.DebugFormat("[PRIM COUNT MODULE]: Removing object {0} {1} from prim count", obj.Name, obj.UUID);            
+            
+            // Currently this is being done by tainting the count instead.
         }
 
         public IPrimCounts GetPrimCounts(UUID parcelID)
         {
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetPrimCounts for parcel {0} in {1}", parcelID, m_Scene.RegionInfo.RegionName);
+            
             PrimCounts primCounts;
 
             lock (m_PrimCounts)
@@ -218,8 +266,16 @@ namespace OpenSim.Region.CoreModules.World.Land
             return primCounts;
         }
 
+        
+        /// <summary>
+        /// Get the number of prims on the parcel that are owned by the parcel owner.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>
         public int GetOwnerCount(UUID parcelID)
         {
+            int count = 0;
+            
             lock (m_TaintLock)
             {
                 if (m_Tainted)
@@ -227,13 +283,25 @@ namespace OpenSim.Region.CoreModules.World.Land
 
                 ParcelCounts counts;
                 if (m_ParcelCounts.TryGetValue(parcelID, out counts))
-                    return counts.Owner;
+                    count = counts.Owner;
             }
-            return 0;
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetOwnerCount for parcel {0} in {1} returning {2}", 
+//                parcelID, m_Scene.RegionInfo.RegionName, count);
+            
+            return count;
         }
 
+        /// <summary>
+        /// Get the number of prims on the parcel that have been set to the group that owns the parcel.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>        
         public int GetGroupCount(UUID parcelID)
         {
+            int count = 0;
+            
             lock (m_TaintLock)
             {
                 if (m_Tainted)
@@ -241,13 +309,25 @@ namespace OpenSim.Region.CoreModules.World.Land
 
                 ParcelCounts counts;
                 if (m_ParcelCounts.TryGetValue(parcelID, out counts))
-                    return counts.Group;
+                    count = counts.Group;
             }
-            return 0;
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetGroupCount for parcel {0} in {1} returning {2}", 
+//                parcelID, m_Scene.RegionInfo.RegionName, count);
+            
+            return count;
         }
 
+        /// <summary>
+        /// Get the number of prims on the parcel that are not owned by the parcel owner or set to the parcel group.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>                
         public int GetOthersCount(UUID parcelID)
         {
+            int count = 0;
+            
             lock (m_TaintLock)
             {
                 if (m_Tainted)
@@ -255,13 +335,83 @@ namespace OpenSim.Region.CoreModules.World.Land
 
                 ParcelCounts counts;
                 if (m_ParcelCounts.TryGetValue(parcelID, out counts))
-                    return counts.Others;
+                    count = counts.Others;
             }
-            return 0;
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetOthersCount for parcel {0} in {1} returning {2}", 
+//                parcelID, m_Scene.RegionInfo.RegionName, count);
+            
+            return count;
         }
+        
+        /// <summary>
+        /// Get the number of selected prims.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>           
+        public int GetSelectedCount(UUID parcelID)
+        {
+            int count = 0;
+            
+            lock (m_TaintLock)
+            {
+                if (m_Tainted)
+                    Recount();
 
+                ParcelCounts counts;
+                if (m_ParcelCounts.TryGetValue(parcelID, out counts))
+                    count = counts.Selected;
+            }
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetSelectedCount for parcel {0} in {1} returning {2}", 
+//                parcelID, m_Scene.RegionInfo.RegionName, count);
+            
+            return count;
+        }
+        
+        /// <summary>
+        /// Get the total count of owner, group and others prims on the parcel.
+        /// FIXME: Need to do selected prims once this is reimplemented.   
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>
+        public int GetTotalCount(UUID parcelID)
+        {
+            int count = 0;
+            
+            lock (m_TaintLock)
+            {
+                if (m_Tainted)
+                    Recount();
+
+                ParcelCounts counts;
+                if (m_ParcelCounts.TryGetValue(parcelID, out counts))
+                {
+                    count = counts.Owner;
+                    count += counts.Group;
+                    count += counts.Others;
+                    count += counts.Selected;
+                }
+            }
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetTotalCount for parcel {0} in {1} returning {2}", 
+//                parcelID, m_Scene.RegionInfo.RegionName, count);
+            
+            return count;            
+        }
+
+        /// <summary>
+        /// Get the number of prims that are in the entire simulator for the owner of this parcel.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>              
         public int GetSimulatorCount(UUID parcelID)
         {
+            int count = 0;
+            
             lock (m_TaintLock)
             {
                 if (m_Tainted)
@@ -272,14 +422,27 @@ namespace OpenSim.Region.CoreModules.World.Land
                 {
                     int val;
                     if (m_SimwideCounts.TryGetValue(owner, out val))
-                        return val;
+                        count = val;
                 }
             }
-            return 0;
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetOthersCount for parcel {0} in {1} returning {2}", 
+//                parcelID, m_Scene.RegionInfo.RegionName, count);
+            
+            return count;
         }
 
+        /// <summary>
+        /// Get the number of prims that a particular user owns on this parcel.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <param name="userID"></param>
+        /// <returns></returns>          
         public int GetUserCount(UUID parcelID, UUID userID)
         {
+            int count = 0;
+            
             lock (m_TaintLock)
             {
                 if (m_Tainted)
@@ -290,27 +453,37 @@ namespace OpenSim.Region.CoreModules.World.Land
                 {
                     int val;
                     if (counts.Users.TryGetValue(userID, out val))
-                        return val;
+                        count = val;
                 }
             }
-            return 0;
+
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: GetUserCount for user {0} in parcel {1} in region {2} returning {3}", 
+//                userID, parcelID, m_Scene.RegionInfo.RegionName, count);
+            
+            return count;
         }
 
         // NOTE: This method MUST be called while holding the taint lock!
         private void Recount()
         {
+//            m_log.DebugFormat("[PRIM COUNT MODULE]: Recounting prims on {0}", m_Scene.RegionInfo.RegionName);
+            
             m_OwnerMap.Clear();
             m_SimwideCounts.Clear();
             m_ParcelCounts.Clear();
 
             List<ILandObject> land = m_Scene.LandChannel.AllParcels();
-
+            
             foreach (ILandObject l in land)
             {
                 LandData landData = l.LandData;
 
                 m_OwnerMap[landData.GlobalID] = landData.OwnerID;
                 m_SimwideCounts[landData.OwnerID] = 0;
+//                m_log.DebugFormat(
+//                    "[PRIM COUNT MODULE]: Initializing parcel count for {0} on {1}", 
+//                    landData.Name, m_Scene.RegionInfo.RegionName);
                 m_ParcelCounts[landData.GlobalID] = new ParcelCounts();
             }
 
@@ -322,6 +495,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 if (!m_OwnerMap.ContainsKey(k))
                     m_PrimCounts.Remove(k);
             }
+            
             m_Tainted = false;
         }
     }
@@ -363,6 +537,22 @@ namespace OpenSim.Region.CoreModules.World.Land
                 return m_Parent.GetOthersCount(m_ParcelID);
             }
         }
+        
+        public int Selected
+        {
+            get
+            {
+                return m_Parent.GetSelectedCount(m_ParcelID);
+            }
+        }
+        
+        public int Total
+        {
+            get
+            {
+                return m_Parent.GetTotalCount(m_ParcelID);
+            }
+        }
 
         public int Simulator
         {
@@ -403,4 +593,4 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/World/Land/Tests/PrimCountModuleTests.cs b/OpenSim/Region/CoreModules/World/Land/Tests/PrimCountModuleTests.cs
new file mode 100644
index 0000000..67b00ac
--- /dev/null
+++ b/OpenSim/Region/CoreModules/World/Land/Tests/PrimCountModuleTests.cs
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Assets;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+using OpenSim.Tests.Common.Setup;
+
+namespace OpenSim.Region.CoreModules.World.Land.Tests
+{
+    [TestFixture]
+    public class PrimCountModuleTests
+    {
+        protected UUID m_userId = new UUID("00000000-0000-0000-0000-100000000000");
+        protected UUID m_groupId = new UUID("00000000-0000-0000-8888-000000000000");        
+        protected UUID m_otherUserId = new UUID("99999999-9999-9999-9999-999999999999");        
+        protected TestScene m_scene;
+        protected PrimCountModule m_pcm;
+        
+        /// <summary>
+        /// A parcel that covers the entire sim except for a 1 unit wide strip on the eastern side.
+        /// </summary>
+        protected ILandObject m_lo;
+        
+        /// <summary>
+        /// A parcel that covers just the eastern strip of the sim.
+        /// </summary>
+        protected ILandObject m_lo2;        
+            
+        [SetUp]
+        public void SetUp()
+        {
+            m_pcm = new PrimCountModule();
+            LandManagementModule lmm = new LandManagementModule();
+            m_scene = SceneSetupHelpers.SetupScene();            
+            SceneSetupHelpers.SetupSceneModules(m_scene, lmm, m_pcm);             
+                        
+            int xParcelDivider = (int)Constants.RegionSize - 1;
+            
+            ILandObject lo = new LandObject(m_userId, false, m_scene);
+            lo.LandData.Name = "m_lo";
+            lo.SetLandBitmap(
+                lo.GetSquareLandBitmap(0, 0, xParcelDivider, (int)Constants.RegionSize));
+            m_lo = lmm.AddLandObject(lo);          
+            
+            ILandObject lo2 = new LandObject(m_userId, false, m_scene);
+            lo2.SetLandBitmap(
+                lo2.GetSquareLandBitmap(xParcelDivider, 0, (int)Constants.RegionSize, (int)Constants.RegionSize));
+            lo2.LandData.Name = "m_lo2";
+            m_lo2 = lmm.AddLandObject(lo2);
+        } 
+        
+        /// <summary>
+        /// Test that counts before we do anything are correct.
+        /// </summary>
+        [Test]
+        public void TestInitialCounts()
+        {
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            Assert.That(pc.Owner, Is.EqualTo(0));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(0));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(0));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(0));              
+        }            
+        
+        /// <summary>
+        /// Test count after a parcel owner owned object is added.
+        /// </summary>
+        [Test]
+        public void TestAddOwnerObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();                                  
+                  
+            IPrimCounts pc = m_lo.PrimCounts;         
+            
+            SceneObjectGroup sog = SceneSetupHelpers.CreateSceneObject(3, m_userId, "a", 0x01);             
+            m_scene.AddNewSceneObject(sog, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(3));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(3));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(3));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(3));            
+            
+            // Add a second object and retest
+            SceneObjectGroup sog2 = SceneSetupHelpers.CreateSceneObject(2, m_userId, "b", 0x10);             
+            m_scene.AddNewSceneObject(sog2, false);   
+            
+            Assert.That(pc.Owner, Is.EqualTo(5));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(5));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(5));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(5));              
+        }
+        
+        /// <summary>
+        /// Test count after a parcel owner owned copied object is added.
+        /// </summary>
+        [Test]
+        public void TestCopyOwnerObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();                                  
+                  
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            SceneObjectGroup sog = SceneSetupHelpers.CreateSceneObject(3, m_userId, "a", 0x01);             
+            m_scene.AddNewSceneObject(sog, false);
+            m_scene.SceneGraph.DuplicateObject(sog.LocalId, Vector3.Zero, 0, m_userId, UUID.Zero, Quaternion.Identity); 
+            
+            Assert.That(pc.Owner, Is.EqualTo(6));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(6));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(6));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(6));              
+        }     
+        
+        /// <summary>
+        /// Test that parcel counts update correctly when an object is moved between parcels, where that movement
+        /// is not done directly by the user/
+        /// </summary>
+        [Test]
+        public void TestMoveOwnerObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();                                  
+                                          
+            SceneObjectGroup sog = SceneSetupHelpers.CreateSceneObject(3, m_userId, "a", 0x01);             
+            m_scene.AddNewSceneObject(sog, false);
+            SceneObjectGroup sog2 = SceneSetupHelpers.CreateSceneObject(2, m_userId, "b", 0x10);             
+            m_scene.AddNewSceneObject(sog2, false);   
+            
+            // Move the first scene object to the eastern strip parcel           
+            sog.AbsolutePosition = new Vector3(254, 2, 2);
+            
+            IPrimCounts pclo1 = m_lo.PrimCounts;         
+            
+            Assert.That(pclo1.Owner, Is.EqualTo(2));
+            Assert.That(pclo1.Group, Is.EqualTo(0));
+            Assert.That(pclo1.Others, Is.EqualTo(0));
+            Assert.That(pclo1.Total, Is.EqualTo(2));
+            Assert.That(pclo1.Selected, Is.EqualTo(0));
+            Assert.That(pclo1.Users[m_userId], Is.EqualTo(2));
+            Assert.That(pclo1.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pclo1.Simulator, Is.EqualTo(5));                
+            
+            IPrimCounts pclo2 = m_lo2.PrimCounts;         
+            
+            Assert.That(pclo2.Owner, Is.EqualTo(3));
+            Assert.That(pclo2.Group, Is.EqualTo(0));
+            Assert.That(pclo2.Others, Is.EqualTo(0));
+            Assert.That(pclo2.Total, Is.EqualTo(3));
+            Assert.That(pclo2.Selected, Is.EqualTo(0));
+            Assert.That(pclo2.Users[m_userId], Is.EqualTo(3));
+            Assert.That(pclo2.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pclo2.Simulator, Is.EqualTo(5)); 
+            
+            // Now move it back again
+            sog.AbsolutePosition = new Vector3(2, 2, 2);   
+            
+            Assert.That(pclo1.Owner, Is.EqualTo(5));
+            Assert.That(pclo1.Group, Is.EqualTo(0));
+            Assert.That(pclo1.Others, Is.EqualTo(0));
+            Assert.That(pclo1.Total, Is.EqualTo(5));
+            Assert.That(pclo1.Selected, Is.EqualTo(0));
+            Assert.That(pclo1.Users[m_userId], Is.EqualTo(5));
+            Assert.That(pclo1.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pclo1.Simulator, Is.EqualTo(5));              
+            
+            Assert.That(pclo2.Owner, Is.EqualTo(0));
+            Assert.That(pclo2.Group, Is.EqualTo(0));
+            Assert.That(pclo2.Others, Is.EqualTo(0));
+            Assert.That(pclo2.Total, Is.EqualTo(0));
+            Assert.That(pclo2.Selected, Is.EqualTo(0));
+            Assert.That(pclo2.Users[m_userId], Is.EqualTo(0));
+            Assert.That(pclo2.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pclo2.Simulator, Is.EqualTo(5));             
+        }
+        
+        /// <summary>
+        /// Test count after a parcel owner owned object is removed.
+        /// </summary>
+        [Test]
+        public void TestRemoveOwnerObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+            
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            m_scene.AddNewSceneObject(SceneSetupHelpers.CreateSceneObject(1, m_userId, "a", 0x1), false);
+            SceneObjectGroup sogToDelete = SceneSetupHelpers.CreateSceneObject(3, m_userId, "b", 0x10);
+            m_scene.AddNewSceneObject(sogToDelete, false);            
+            m_scene.DeleteSceneObject(sogToDelete, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(1));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(1));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(1));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(1));            
+        } 
+        
+        [Test]
+        public void TestAddGroupObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();                                  
+            
+            m_lo.DeedToGroup(m_groupId);
+                  
+            IPrimCounts pc = m_lo.PrimCounts;       
+            
+            SceneObjectGroup sog = SceneSetupHelpers.CreateSceneObject(3, m_otherUserId, "a", 0x01);             
+            sog.GroupID = m_groupId;
+            m_scene.AddNewSceneObject(sog, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(0));
+            Assert.That(pc.Group, Is.EqualTo(3));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(3));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            
+            // Is this desired behaviour?  Not totally sure.
+            Assert.That(pc.Users[m_userId], Is.EqualTo(0));
+            Assert.That(pc.Users[m_groupId], Is.EqualTo(0));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(3));
+            
+            Assert.That(pc.Simulator, Is.EqualTo(3));             
+        }
+        
+        /// <summary>
+        /// Test count after a parcel owner owned object is removed.
+        /// </summary>
+        [Test]
+        public void TestRemoveGroupObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+            
+            m_lo.DeedToGroup(m_groupId);
+            
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            SceneObjectGroup sogToKeep = SceneSetupHelpers.CreateSceneObject(1, m_userId, "a", 0x1);
+            sogToKeep.GroupID = m_groupId;            
+            m_scene.AddNewSceneObject(sogToKeep, false);
+            
+            SceneObjectGroup sogToDelete = SceneSetupHelpers.CreateSceneObject(3, m_userId, "b", 0x10);
+            m_scene.AddNewSceneObject(sogToDelete, false);            
+            m_scene.DeleteSceneObject(sogToDelete, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(0));
+            Assert.That(pc.Group, Is.EqualTo(1));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(1));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(1));
+            Assert.That(pc.Users[m_groupId], Is.EqualTo(0));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(1));            
+        }        
+        
+        [Test]        
+        public void TestAddOthersObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();                                  
+                  
+            IPrimCounts pc = m_lo.PrimCounts;       
+            
+            SceneObjectGroup sog = SceneSetupHelpers.CreateSceneObject(3, m_otherUserId, "a", 0x01);             
+            m_scene.AddNewSceneObject(sog, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(0));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(3));
+            Assert.That(pc.Total, Is.EqualTo(3));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(0));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(3));
+            Assert.That(pc.Simulator, Is.EqualTo(3));                          
+        }
+        
+        [Test]
+        public void TestRemoveOthersObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+            
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            m_scene.AddNewSceneObject(SceneSetupHelpers.CreateSceneObject(1, m_otherUserId, "a", 0x1), false);
+            SceneObjectGroup sogToDelete = SceneSetupHelpers.CreateSceneObject(3, m_otherUserId, "b", 0x10);
+            m_scene.AddNewSceneObject(sogToDelete, false);            
+            m_scene.DeleteSceneObject(sogToDelete, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(0));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(1));
+            Assert.That(pc.Total, Is.EqualTo(1));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(0));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(1));
+            Assert.That(pc.Simulator, Is.EqualTo(1));            
+        }           
+        
+        /// <summary>
+        /// Test the count is correct after is has been tainted.
+        /// </summary>
+        [Test]
+        public void TestTaint()
+        {
+            TestHelper.InMethod();
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            SceneObjectGroup sog = SceneSetupHelpers.CreateSceneObject(3, m_userId, "a", 0x01);             
+            m_scene.AddNewSceneObject(sog, false); 
+            
+            m_pcm.TaintPrimCount();
+            
+            Assert.That(pc.Owner, Is.EqualTo(3));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Total, Is.EqualTo(3));
+            Assert.That(pc.Selected, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(3));
+            Assert.That(pc.Users[m_otherUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(3));              
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/World/Sun/SunModule.cs b/OpenSim/Region/CoreModules/World/Sun/SunModule.cs
index cea7c78..4e14c73 100644
--- a/OpenSim/Region/CoreModules/World/Sun/SunModule.cs
+++ b/OpenSim/Region/CoreModules/World/Sun/SunModule.cs
@@ -469,8 +469,8 @@ namespace OpenSim.Region.CoreModules
                 m_SunFixedHour = FixedSunHour;
                 m_SunFixed = FixedSun;
 
-                m_log.DebugFormat("[SUN]: Sun Settings Update: Fixed Sun? : {0}", m_SunFixed.ToString());
-                m_log.DebugFormat("[SUN]: Sun Settings Update: Sun Hour   : {0}", m_SunFixedHour.ToString());
+                // m_log.DebugFormat("[SUN]: Sun Settings Update: Fixed Sun? : {0}", m_SunFixed.ToString());
+                // m_log.DebugFormat("[SUN]: Sun Settings Update: Sun Hour   : {0}", m_SunFixedHour.ToString());
 
                 receivedEstateToolsSunUpdate = true;
 
@@ -480,7 +480,7 @@ namespace OpenSim.Region.CoreModules
                 // When sun settings are updated, we should update all clients with new settings.
                 SunUpdateToAllClients();
 
-                m_log.DebugFormat("[SUN]: PosTime : {0}", PosTime.ToString());
+                // m_log.DebugFormat("[SUN]: PosTime : {0}", PosTime.ToString());
             }
         }
 
diff --git a/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs b/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs
index 6676ec8..d6fa093 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs
@@ -62,9 +62,20 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
             return LoadBitmap(new Bitmap(filename));
         }
 
-        public ITerrainChannel LoadFile(string filename, int x, int y, int fileWidth, int fileHeight, int w, int h)
+        public virtual ITerrainChannel LoadFile(string filename, int offsetX, int offsetY, int fileWidth, int fileHeight, int w, int h)
         {
-            throw new NotImplementedException();
+            Bitmap bitmap = new Bitmap(filename);
+            ITerrainChannel retval = new TerrainChannel(true);
+
+            for (int x = 0; x < retval.Width; x++)
+            {
+                for (int y = 0; y < retval.Height; y++)
+                {
+                    retval[x, y] = bitmap.GetPixel(offsetX * retval.Width + x, (bitmap.Height - (retval.Height * (offsetY + 1))) + retval.Height - y - 1).GetBrightness() * 128;
+                }
+            }
+
+            return retval;
         }
 
         public virtual ITerrainChannel LoadStream(Stream stream)
diff --git a/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs b/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs
index 7bb7544..f9ef286 100644
--- a/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs
+++ b/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs
@@ -100,8 +100,12 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
                 // service wasn't available; maybe still an old GridServer. Try the old API, though it will return only one region
                 regionInfos = new List<GridRegion>();
                 GridRegion info = m_scene.GridService.GetRegionByName(m_scene.RegionInfo.ScopeID, mapName);
-                if (info != null) regionInfos.Add(info);
+                if (info != null) 
+                    regionInfos.Add(info);
             }
+            else if (regionInfos.Count == 0 && mapName.StartsWith("http://"))
+                remoteClient.SendAlertMessage("Hyperlink could not be established.");
+
             m_log.DebugFormat("[MAPSEARCHMODULE]: search {0} returned {1} regions", mapName, regionInfos.Count);
             List<MapBlockData> blocks = new List<MapBlockData>();
 
diff --git a/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs b/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
index 41d6628..d939329 100644
--- a/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
+++ b/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
@@ -909,7 +909,7 @@ namespace OpenSim.Region.Examples.SimpleModule
         {
         }
 
-        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, LandData landData, float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
+        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, ILandObject lo, float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
         {
         }
         
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs b/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs
index 95c9659..7066cf2 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs
@@ -34,12 +34,74 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface IEstateDataService
     {
+        /// <summary>
+        /// Load estate settings for a region.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="create">If true, then an estate is created if one is not found.</param>
+        /// <returns></returns>        
         EstateSettings LoadEstateSettings(UUID regionID, bool create);
+        
+        /// <summary>
+        /// Load estate settings for an estate ID.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>        
         EstateSettings LoadEstateSettings(int estateID);
+        
+        /// <summary>
+        /// Load/Get all estate settings.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<EstateSettings> LoadEstateSettingsAll();
+        
+        /// <summary>
+        /// Store estate settings.
+        /// </summary>
+        /// <remarks>
+        /// This is also called by EstateSettings.Save()</remarks>
+        /// <param name="es"></param>        
         void StoreEstateSettings(EstateSettings es);
+        
+        /// <summary>
+        /// Get estate IDs.
+        /// </summary>
+        /// <param name="search">Name of estate to search for.  This is the exact name, no parttern matching is done.</param>
+        /// <returns></returns>        
         List<int> GetEstates(string search);
+        
+        /// <summary>
+        /// Get the IDs of all estates owned by the given user.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<int> GetEstatesByOwner(UUID ownerID);        
+        
+        /// <summary>
+        /// Get the IDs of all estates.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<int> GetEstatesAll();
+            
+        /// <summary>
+        /// Link a region to an estate.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="estateID"></param>
+        /// <returns>true if the link succeeded, false otherwise</returns>        
         bool LinkRegion(UUID regionID, int estateID);
+        
+        /// <summary>
+        /// Get the UUIDs of all the regions in an estate.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>        
         List<UUID> GetRegions(int estateID);
+        
+        /// <summary>
+        /// Delete an estate
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns>true if the delete succeeded, false otherwise</returns>        
         bool DeleteEstate(int estateID);
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs b/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs
index 87c7a05..d790a30 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs
@@ -33,14 +33,80 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface IEstateDataStore
     {
+        /// <summary>
+        /// Initialise the data store.
+        /// </summary>
+        /// <param name="connectstring"></param>
         void Initialise(string connectstring);
 
+        /// <summary>
+        /// Load estate settings for a region.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="create">If true, then an estate is created if one is not found.</param>
+        /// <returns></returns>
         EstateSettings LoadEstateSettings(UUID regionID, bool create);
+        
+        /// <summary>
+        /// Load estate settings for an estate ID.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>
         EstateSettings LoadEstateSettings(int estateID);
+        
+        /// <summary>
+        /// Load/Get all estate settings.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<EstateSettings> LoadEstateSettingsAll();
+        
+        /// <summary>
+        /// Store estate settings.
+        /// </summary>
+        /// <remarks>
+        /// This is also called by EstateSettings.Save()</remarks>
+        /// <param name="es"></param>
         void StoreEstateSettings(EstateSettings es);
+        
+        /// <summary>
+        /// Get estate IDs.
+        /// </summary>
+        /// <param name="search">Name of estate to search for.  This is the exact name, no parttern matching is done.</param>
+        /// <returns></returns>
         List<int> GetEstates(string search);
+
+        /// <summary>
+        /// Get the IDs of all estates owned by the given user.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<int> GetEstatesByOwner(UUID ownerID);
+        
+        /// <summary>
+        /// Get the IDs of all estates.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<int> GetEstatesAll();
+        
+        /// <summary>
+        /// Link a region to an estate.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="estateID"></param>
+        /// <returns>true if the link succeeded, false otherwise</returns>
         bool LinkRegion(UUID regionID, int estateID);
+        
+        /// <summary>
+        /// Get the UUIDs of all the regions in an estate.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>
         List<UUID> GetRegions(int estateID);
+        
+        /// <summary>
+        /// Delete an estate
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns>true if the delete succeeded, false otherwise</returns>
         bool DeleteEstate(int estateID);
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/ILandChannel.cs b/OpenSim/Region/Framework/Interfaces/ILandChannel.cs
deleted file mode 100644
index 30bae16..0000000
--- a/OpenSim/Region/Framework/Interfaces/ILandChannel.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * 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.Collections.Generic;
-using OpenMetaverse;
-using OpenSim.Framework;
-
-namespace OpenSim.Region.Framework.Interfaces
-{
-    public interface ILandChannel
-    {
-        /// <summary>
-        /// Get all parcels
-        /// </summary>
-        /// <returns></returns>
-        List<ILandObject> AllParcels();
-             
-        /// <summary>
-        /// Get the parcel at the specified point
-        /// </summary>
-        /// <param name="x">Value between 0 - 256 on the x axis of the point</param>
-        /// <param name="y">Value between 0 - 256 on the y axis of the point</param>
-        /// <returns>Land object at the point supplied</returns>
-        ILandObject GetLandObject(int x, int y);
-
-        /// <summary>
-        /// Get the parcel at the specified point
-        /// </summary>
-        /// <param name="x">Value between 0 - 256 on the x axis of the point</param>
-        /// <param name="y">Value between 0 - 256 on the y axis of the point</param>
-        /// <returns>Land object at the point supplied</returns>
-        ILandObject GetLandObject(float x, float y);
-
-        /// <summary>
-        /// Get the parcels near the specified point
-        /// </summary>
-        /// <param name="position"></param>
-        /// <returns></returns>
-        List<ILandObject> ParcelsNearPoint(Vector3 position);
-
-        /// <summary>
-        /// Get the parcel given the land's local id.
-        /// </summary>
-        /// <param name="localID"></param>
-        /// <returns></returns>
-        ILandObject GetLandObject(int localID);
-        
-        /// <summary>
-        /// Clear the land channel of all parcels.
-        /// </summary>
-        /// <param name="setupDefaultParcel">
-        /// If true, set up a default parcel covering the whole region owned by the estate owner.
-        /// </param>
-        void Clear(bool setupDefaultParcel);
-        
-        bool IsLandPrimCountTainted();
-        bool IsForcefulBansAllowed();
-        void UpdateLandObject(int localID, LandData data);
-        void ReturnObjectsInParcel(int localID, uint returnType, UUID[] agentIDs, UUID[] taskIDs, IClientAPI remoteClient);
-        void setParcelObjectMaxOverride(overrideParcelMaxPrimCountDelegate overrideDel);
-        void setSimulatorObjectMaxOverride(overrideSimulatorMaxPrimCountDelegate overrideDel);
-        void SetParcelOtherCleanTime(IClientAPI remoteClient, int localID, int otherCleanTime);
-
-        void Join(int start_x, int start_y, int end_x, int end_y, UUID attempting_user_id);
-        void Subdivide(int start_x, int start_y, int end_x, int end_y, UUID attempting_user_id);
-    }
-}
diff --git a/OpenSim/Region/Framework/Interfaces/ILandObject.cs b/OpenSim/Region/Framework/Interfaces/ILandObject.cs
deleted file mode 100644
index eeb9d3a..0000000
--- a/OpenSim/Region/Framework/Interfaces/ILandObject.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * 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.Collections.Generic;
-using OpenMetaverse;
-using OpenSim.Framework;
-using OpenSim.Region.Framework.Scenes;
-
-namespace OpenSim.Region.Framework.Interfaces
-{
-    public delegate int overrideParcelMaxPrimCountDelegate(ILandObject obj);
-    public delegate int overrideSimulatorMaxPrimCountDelegate(ILandObject obj);
-
-    public interface ILandObject
-    {
-        int GetParcelMaxPrimCount(ILandObject thisObject);
-        int GetSimulatorMaxPrimCount(ILandObject thisObject);
-        int GetPrimsFree();
-
-        LandData LandData { get; set; }
-        bool[,] LandBitmap { get; set; }
-        UUID RegionUUID { get; }
-        
-        /// <summary>
-        /// The start point for the land object.  This is the western-most point as one scans land working from 
-        /// north to south.
-        /// </summary>
-        Vector3 StartPoint { get; }
-        
-        /// <summary>
-        /// The end point for the land object.  This is the eastern-most point as one scans land working from 
-        /// south to north.
-        /// </summary>        
-        Vector3 EndPoint { get; }
-        
-        bool ContainsPoint(int x, int y);
-        
-        ILandObject Copy();
-
-        void SendLandUpdateToAvatarsOverMe();
-
-        void SendLandProperties(int sequence_id, bool snap_selection, int request_result, IClientAPI remote_client);
-        void UpdateLandProperties(LandUpdateArgs args, IClientAPI remote_client);
-        bool IsEitherBannedOrRestricted(UUID avatar);
-        bool IsBannedFromLand(UUID avatar);
-        bool IsRestrictedFromLand(UUID avatar);
-        void SendLandUpdateToClient(IClientAPI remote_client);
-        void SendLandUpdateToClient(bool snap_selection, IClientAPI remote_client);
-        List<UUID> CreateAccessListArrayByFlag(AccessList flag);
-        void SendAccessList(UUID agentID, UUID sessionID, uint flags, int sequenceID, IClientAPI remote_client);
-        void UpdateAccessList(uint flags, UUID transactionID, int sequenceID, int sections, List<ParcelManager.ParcelAccessEntry> entries, IClientAPI remote_client);
-        void UpdateLandBitmapByteArray();
-        void SetLandBitmapFromByteArray();
-        bool[,] GetLandBitmap();
-        void ForceUpdateLandInfo();
-        void SetLandBitmap(bool[,] bitmap);
-
-        bool[,] BasicFullRegionLandBitmap();
-        bool[,] GetSquareLandBitmap(int start_x, int start_y, int end_x, int end_y);
-        bool[,] ModifyLandBitmapSquare(bool[,] land_bitmap, int start_x, int start_y, int end_x, int end_y, bool set_value);
-        bool[,] MergeLandBitmaps(bool[,] bitmap_base, bool[,] bitmap_add);
-        void SendForceObjectSelect(int local_id, int request_type, List<UUID> returnIDs, IClientAPI remote_client);
-        void SendLandObjectOwners(IClientAPI remote_client);
-        void ReturnObject(SceneObjectGroup obj);
-        void ReturnLandObjects(uint type, UUID[] owners, UUID[] tasks, IClientAPI remote_client);
-        void ResetLandPrimCounts();
-        void AddPrimToCount(SceneObjectGroup obj);
-        void RemovePrimFromCount(SceneObjectGroup obj);
-        void UpdateLandSold(UUID avatarID, UUID groupID, bool groupOwned, uint AuctionID, int claimprice, int area);
-
-        void DeedToGroup(UUID groupID);
-
-        void SetParcelObjectMaxOverride(overrideParcelMaxPrimCountDelegate overrideDel);
-        void SetSimulatorObjectMaxOverride(overrideSimulatorMaxPrimCountDelegate overrideDel);
-
-        /// <summary>
-        /// Set the media url for this land parcel
-        /// </summary>
-        /// <param name="url"></param>
-        void SetMediaUrl(string url);
-        
-        /// <summary>
-        /// Set the music url for this land parcel
-        /// </summary>
-        /// <param name="url"></param>
-        void SetMusicUrl(string url);
-    }
-}
diff --git a/OpenSim/Region/Framework/Interfaces/IPrimCountModule.cs b/OpenSim/Region/Framework/Interfaces/IPrimCountModule.cs
index 65158e1..d63da2e 100644
--- a/OpenSim/Region/Framework/Interfaces/IPrimCountModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IPrimCountModule.cs
@@ -38,18 +38,4 @@ namespace OpenSim.Region.Framework.Interfaces
 
         IPrimCounts GetPrimCounts(UUID parcelID);
     }
-
-    public interface IPrimCounts
-    {
-        int Owner { get; }
-        int Group { get; }
-        int Others { get; }
-        int Simulator { get; }
-        IUserPrimCounts Users { get; }
-    }
-
-    public interface IUserPrimCounts
-    {
-        int this[UUID agentID] { get; }
-    }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/ModuleLoader.cs b/OpenSim/Region/Framework/ModuleLoader.cs
index 23be9c2..14ecd44 100644
--- a/OpenSim/Region/Framework/ModuleLoader.cs
+++ b/OpenSim/Region/Framework/ModuleLoader.cs
@@ -223,7 +223,8 @@ namespace OpenSim.Region.Framework
                 catch (Exception e)
                 {
                     m_log.ErrorFormat(
-                        "[MODULES]: Could not load types for [{0}].  Exception {1}", pluginAssembly.FullName, e);
+                        "[MODULES]: Could not load types for plugin DLL {0}.  Exception {1} {2}", 
+                        pluginAssembly.FullName, e.Message, e.StackTrace);
                     
                     // justincc: Right now this is fatal to really get the user's attention
                     throw e;
diff --git a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
index 64567db..8feb022 100644
--- a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
+++ b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
@@ -137,7 +137,7 @@ namespace OpenSim.Region.Framework.Scenes
                         x = m_inventoryDeletes.Dequeue();
 
                         m_log.DebugFormat(
-                            "[ASYNC DELETER]: Sending object to user's inventory, {0} item(s) remaining.", left);
+                            "[ASYNC DELETER]: Sending object to user's inventory, action {1}, count {2}, {0} item(s) remaining.", left, x.action, x.objectGroups.Count);
                         
                         try
                         {
@@ -177,4 +177,4 @@ namespace OpenSim.Region.Framework.Scenes
             return false;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index c321a15..fd62535 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -242,7 +242,15 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void GetScriptRunning(IClientAPI controllingClient, UUID objectID, UUID itemID);
 
         public event EstateToolsSunUpdate OnEstateToolsSunUpdate;
+        
+        /// <summary>
+        /// Triggered when an object is added to the scene.
+        /// </summary>
+        public event Action<SceneObjectGroup> OnObjectAddedToScene;
 
+        /// <summary>
+        /// Triggered when an object is removed from the scene.
+        /// </summary>
         public delegate void ObjectBeingRemovedFromScene(SceneObjectGroup obj);
         public event ObjectBeingRemovedFromScene OnObjectBeingRemovedFromScene;
 
@@ -345,6 +353,7 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void Attach(uint localID, UUID itemID, UUID avatarID);
         public event Attach OnAttach;
         
+        
         /// <summary>
         /// Called immediately after an object is loaded from storage.
         /// </summary>
@@ -800,6 +809,27 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public void TriggerObjectAddedToScene(SceneObjectGroup obj)
+        {
+            Action<SceneObjectGroup> handler = OnObjectAddedToScene;
+            if (handler != null)
+            {
+                foreach (Action<SceneObjectGroup> d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(obj);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerObjectAddedToScene failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }        
+        
         public void TriggerObjectBeingRemovedFromScene(SceneObjectGroup obj)
         {
             ObjectBeingRemovedFromScene handlerObjectBeingRemovedFromScene = OnObjectBeingRemovedFromScene;
diff --git a/OpenSim/Region/Framework/Scenes/Prioritizer.cs b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
index f9599f5..4694e2b 100644
--- a/OpenSim/Region/Framework/Scenes/Prioritizer.cs
+++ b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
@@ -58,17 +58,8 @@ namespace OpenSim.Region.Framework.Scenes
 
     public class Prioritizer
     {
-//        private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
         
-        /// <summary>
-        /// This is added to the priority of all child prims, to make sure that the root prim update is sent to the
-        /// viewer before child prim updates.
-        /// The adjustment is added to child prims and subtracted from root prims, so the gap ends up
-        /// being double.  We do it both ways so that there is a still a priority delta even if the priority is already
-        /// double.MinValue or double.MaxValue.
-        /// </summary>
-        private double m_childPrimAdjustmentFactor = 0.05;
-
         private Scene m_scene;
 
         public Prioritizer(Scene scene)
@@ -76,17 +67,35 @@ namespace OpenSim.Region.Framework.Scenes
             m_scene = scene;
         }
 
-        public double GetUpdatePriority(IClientAPI client, ISceneEntity entity)
+        /// <summary>
+        /// Returns the priority queue into which the update should be placed. Updates within a
+        /// queue will be processed in arrival order. There are currently 12 priority queues
+        /// implemented in PriorityQueue class in LLClientView. Queue 0 is generally retained
+        /// for avatar updates. The fair queuing discipline for processing the priority queues
+        /// assumes that the number of entities in each priority queues increases exponentially.
+        /// So for example... if queue 1 contains all updates within 10m of the avatar or camera
+        /// then queue 2 at 20m is about 3X bigger in space & about 3X bigger in total number
+        /// of updates.
+        /// </summary>
+        public uint GetUpdatePriority(IClientAPI client, ISceneEntity entity)
         {
-            double priority = 0;
-
+            // If entity is null we have a serious problem
             if (entity == null)
-                return 100000;
+            {
+                m_log.WarnFormat("[PRIORITIZER] attempt to prioritize null entity");
+                throw new InvalidOperationException("Prioritization entity not defined");
+            }
+
+            // If this is an update for our own avatar give it the highest priority
+            if (client.AgentId == entity.UUID)
+                return 0;
+
+            uint priority;
             
             switch (m_scene.UpdatePrioritizationScheme)
             {
                 case UpdatePrioritizationSchemes.Time:
-                    priority = GetPriorityByTime();
+                    priority = GetPriorityByTime(client, entity);
                     break;
                 case UpdatePrioritizationSchemes.Distance:
                     priority = GetPriorityByDistance(client, entity);
@@ -104,180 +113,111 @@ namespace OpenSim.Region.Framework.Scenes
                     throw new InvalidOperationException("UpdatePrioritizationScheme not defined.");
             }
             
-            // Adjust priority so that root prims are sent to the viewer first.  This is especially important for 
-            // attachments acting as huds, since current viewers fail to display hud child prims if their updates
-            // arrive before the root one.
-            if (entity is SceneObjectPart)
-            {
-                SceneObjectPart sop = ((SceneObjectPart)entity);
-                
-                if (sop.IsRoot)
-                {
-                    if (priority >= double.MinValue + m_childPrimAdjustmentFactor)
-                        priority -= m_childPrimAdjustmentFactor;
-                }
-                else
-                {
-                    if (priority <= double.MaxValue - m_childPrimAdjustmentFactor)
-                        priority += m_childPrimAdjustmentFactor;
-                }
-            }
-            
             return priority;
         }
 
-        private double GetPriorityByTime()
+
+        private uint GetPriorityByTime(IClientAPI client, ISceneEntity entity)
         {
-            return DateTime.UtcNow.ToOADate();
+            return 1;
         }
 
-        private double GetPriorityByDistance(IClientAPI client, ISceneEntity entity)
+        private uint GetPriorityByDistance(IClientAPI client, ISceneEntity entity)
         {
-            ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
-            if (presence != null)
-            {
-                // If this is an update for our own avatar give it the highest priority
-                if (presence == entity)
-                    return 0.0;
-
-                // Use the camera position for local agents and avatar position for remote agents
-                Vector3 presencePos = (presence.IsChildAgent) ?
-                    presence.AbsolutePosition :
-                    presence.CameraPosition;
-
-                // Use group position for child prims
-                Vector3 entityPos;
-                if (entity is SceneObjectPart)
-                {
-                    // Can't use Scene.GetGroupByPrim() here, since the entity may have been delete from the scene
-                    // before its scheduled update was triggered
-                    //entityPos = m_scene.GetGroupByPrim(entity.LocalId).AbsolutePosition;
-                    entityPos = ((SceneObjectPart)entity).ParentGroup.AbsolutePosition;
-                }
-                else
-                {
-                    entityPos = entity.AbsolutePosition;
-                }
-
-                return Vector3.DistanceSquared(presencePos, entityPos);
-            }
-
-            return double.NaN;
+            return ComputeDistancePriority(client,entity,false);
+        }
+        
+        private uint GetPriorityByFrontBack(IClientAPI client, ISceneEntity entity)
+        {
+            return ComputeDistancePriority(client,entity,true);
         }
 
-        private double GetPriorityByFrontBack(IClientAPI client, ISceneEntity entity)
+        private uint GetPriorityByBestAvatarResponsiveness(IClientAPI client, ISceneEntity entity)
         {
+            uint pqueue = ComputeDistancePriority(client,entity,true);
+
             ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
             if (presence != null)
             {
-                // If this is an update for our own avatar give it the highest priority
-                if (presence == entity)
-                    return 0.0;
-
-                // Use group position for child prims
-                Vector3 entityPos = entity.AbsolutePosition;
-                if (entity is SceneObjectPart)
-                {
-                    // Can't use Scene.GetGroupByPrim() here, since the entity may have been delete from the scene
-                    // before its scheduled update was triggered
-                    //entityPos = m_scene.GetGroupByPrim(entity.LocalId).AbsolutePosition;
-                    entityPos = ((SceneObjectPart)entity).ParentGroup.AbsolutePosition;
-                }
-                else
-                {
-                    entityPos = entity.AbsolutePosition;
-                }
-
                 if (!presence.IsChildAgent)
                 {
-                    // Root agent. Use distance from camera and a priority decrease for objects behind us
-                    Vector3 camPosition = presence.CameraPosition;
-                    Vector3 camAtAxis = presence.CameraAtAxis;
-
-                    // Distance
-                    double priority = Vector3.DistanceSquared(camPosition, entityPos);
-
-                    // Plane equation
-                    float d = -Vector3.Dot(camPosition, camAtAxis);
-                    float p = Vector3.Dot(camAtAxis, entityPos) + d;
-                    if (p < 0.0f) priority *= 2.0;
-
-                    return priority;
-                }
-                else
-                {
-                    // Child agent. Use the normal distance method
-                    Vector3 presencePos = presence.AbsolutePosition;
+                    if (entity is SceneObjectPart)
+                    {
+                        // Non physical prims are lower priority than physical prims
+                        PhysicsActor physActor = ((SceneObjectPart)entity).ParentGroup.RootPart.PhysActor;
+                        if (physActor == null || !physActor.IsPhysical)
+                            pqueue++;
 
-                    return Vector3.DistanceSquared(presencePos, entityPos);
+                        // Attachments are high priority, 
+                        // MIC: shouldn't these already be in the highest priority queue already
+                        // since their root position is same as the avatars?
+                        if (((SceneObjectPart)entity).ParentGroup.RootPart.IsAttachment)
+                            pqueue = 1;
+                    }
                 }
             }
 
-            return double.NaN;
+            return pqueue;
         }
 
-        private double GetPriorityByBestAvatarResponsiveness(IClientAPI client, ISceneEntity entity)
+        private uint ComputeDistancePriority(IClientAPI client, ISceneEntity entity, bool useFrontBack)
         {
-            // If this is an update for our own avatar give it the highest priority
-            if (client.AgentId == entity.UUID)
-                return 0.0;
-            if (entity == null)
-                return double.NaN;
-
-            // Use group position for child prims
+            // Get this agent's position
+            ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
+            if (presence == null)
+            {
+                m_log.WarnFormat("[PRIORITIZER] attempt to use agent {0} not in the scene",client.AgentId);
+                // throw new InvalidOperationException("Prioritization agent not defined");
+                return Int32.MaxValue;
+            }
+                
+            // Use group position for child prims, since we are putting child prims in
+            // the same queue with the root of the group, the root prim (which goes into
+            // the queue first) should always be sent first, no need to adjust child prim
+            // priorities
             Vector3 entityPos = entity.AbsolutePosition;
             if (entity is SceneObjectPart)
             {
                 SceneObjectGroup group = (entity as SceneObjectPart).ParentGroup;
                 if (group != null)
                     entityPos = group.AbsolutePosition;
-                else
-                    entityPos = entity.AbsolutePosition;
             }
-            else
-                entityPos = entity.AbsolutePosition;
 
-            ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
-            if (presence != null)
-            {
-                if (!presence.IsChildAgent)
-                {
-                    if (entity is ScenePresence)
-                        return 1.0;
-
-                    // Root agent. Use distance from camera and a priority decrease for objects behind us
-                    Vector3 camPosition = presence.CameraPosition;
-                    Vector3 camAtAxis = presence.CameraAtAxis;
+            // Use the camera position for local agents and avatar position for remote agents
+            Vector3 presencePos = (presence.IsChildAgent) ?
+                presence.AbsolutePosition :
+                presence.CameraPosition;
 
-                    // Distance
-                    double priority = Vector3.DistanceSquared(camPosition, entityPos);
+            // Compute the distance... 
+            double distance = Vector3.Distance(presencePos, entityPos);
 
-                    // Plane equation
-                    float d = -Vector3.Dot(camPosition, camAtAxis);
-                    float p = Vector3.Dot(camAtAxis, entityPos) + d;
-                    if (p < 0.0f) priority *= 2.0;
-
-                    if (entity is SceneObjectPart)
-                    {
-                        PhysicsActor physActor = ((SceneObjectPart)entity).ParentGroup.RootPart.PhysActor;
-                        if (physActor == null || !physActor.IsPhysical)
-                            priority += 100;
-
-                        if (((SceneObjectPart)entity).ParentGroup.RootPart.IsAttachment)
-                            priority = 1.0;
-                    }
-                    return priority;
-                }
-                else
-                {
-                    // Child agent. Use the normal distance method
-                    Vector3 presencePos = presence.AbsolutePosition;
-
-                    return Vector3.DistanceSquared(presencePos, entityPos);
-                }
+            // And convert the distance to a priority queue, this computation gives queues
+            // at 10, 20, 40, 80, 160, 320, 640, and 1280m
+            uint pqueue = 1;
+            for (int i = 0; i < 8; i++)
+            {
+                if (distance < 10 * Math.Pow(2.0,i))
+                    break;
+                pqueue++;
+            }
+            
+            // If this is a root agent, then determine front & back
+            // Bump up the priority queue (drop the priority) for any objects behind the avatar
+            if (useFrontBack && ! presence.IsChildAgent)
+            {
+                // Root agent, decrease priority for objects behind us
+                Vector3 camPosition = presence.CameraPosition;
+                Vector3 camAtAxis = presence.CameraAtAxis;
+
+                // Plane equation
+                float d = -Vector3.Dot(camPosition, camAtAxis);
+                float p = Vector3.Dot(camAtAxis, entityPos) + d;
+                if (p < 0.0f) 
+                    pqueue++;
             }
 
-            return double.NaN;
+            return pqueue;
         }
+
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index fcbcf59..0f85925 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -1955,11 +1955,49 @@ namespace OpenSim.Region.Framework.Scenes
                                     UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
                                     bool RezSelected, bool RemoveItem, UUID fromTaskID)
         {
-            IInventoryAccessModule invAccess = RequestModuleInterface<IInventoryAccessModule>();
-            if (invAccess != null)
-                invAccess.RezObject(
-                    remoteClient, itemID, RayEnd, RayStart, RayTargetID, BypassRayCast, RayEndIsIntersection,
-                    RezSelected, RemoveItem, fromTaskID, false);
+//            m_log.DebugFormat(
+//                "[PRIM INVENTORY]: RezObject from {0} for item {1} from task id {2}", 
+//                remoteClient.Name, itemID, fromTaskID);
+            
+            if (fromTaskID == UUID.Zero)
+            {
+                IInventoryAccessModule invAccess = RequestModuleInterface<IInventoryAccessModule>();
+                if (invAccess != null)
+                    invAccess.RezObject(
+                        remoteClient, itemID, RayEnd, RayStart, RayTargetID, BypassRayCast, RayEndIsIntersection,
+                        RezSelected, RemoveItem, fromTaskID, false);
+            }
+            else
+            {            
+                SceneObjectPart part = GetSceneObjectPart(fromTaskID);
+                if (part == null)
+                {
+                    m_log.ErrorFormat(                                     
+                        "[TASK INVENTORY]: {0} tried to rez item id {1} from object id {2} but there is no such scene object", 
+                        remoteClient.Name, itemID, fromTaskID);
+                    
+                    return;
+                }
+                
+                TaskInventoryItem item = part.Inventory.GetInventoryItem(itemID);
+                if (item == null)
+                {
+                    m_log.ErrorFormat(                                     
+                        "[TASK INVENTORY]: {0} tried to rez item id {1} from object id {2} but there is no such item", 
+                        remoteClient.Name, itemID, fromTaskID);
+                    
+                    return;
+                }                
+                               
+                byte bRayEndIsIntersection = (byte)(RayEndIsIntersection ? 1 : 0);
+                Vector3 scale = new Vector3(0.5f, 0.5f, 0.5f);
+                Vector3 pos 
+                    = GetNewRezLocation(
+                        RayStart, RayEnd, RayTargetID, Quaternion.Identity,
+                        BypassRayCast, bRayEndIsIntersection, true, scale, false);            
+                
+                RezObject(part, item, pos, null, Vector3.Zero, 0);
+            }
         }
         
         /// <summary>
@@ -1967,14 +2005,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="sourcePart"></param>
         /// <param name="item"></param>
-        /// <param name="pos"></param>
-        /// <param name="rot"></param>
-        /// <param name="vel"></param>
+        /// <param name="pos">The position of the rezzed object.</param>
+        /// <param name="rot">The rotation of the rezzed object.  If null, then the rotation stored with the object
+        /// will be used if it exists.</param>
+        /// <param name="vel">The velocity of the rezzed object.</param>
         /// <param name="param"></param>
         /// <returns>The SceneObjectGroup rezzed or null if rez was unsuccessful</returns>
         public virtual SceneObjectGroup RezObject(
-            SceneObjectPart sourcePart, TaskInventoryItem item,
-            Vector3 pos, Quaternion rot, Vector3 vel, int param)
+            SceneObjectPart sourcePart, TaskInventoryItem item, Vector3 pos, Quaternion? rot, Vector3 vel, int param)
         {
             if (null == item)
                 return null;
@@ -1992,8 +2030,14 @@ namespace OpenSim.Region.Framework.Scenes
                 if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
                     sourcePart.Inventory.RemoveInventoryItem(item.ItemID);
             }
-                        
-            AddNewSceneObject(group, true, pos, rot, vel);
+                                    
+            AddNewSceneObject(group, true);
+            
+            group.AbsolutePosition = pos;
+            group.Velocity = vel;            
+            
+            if (rot != null)
+                group.UpdateGroupRotationR((Quaternion)rot);
             
             // We can only call this after adding the scene object, since the scene object references the scene
             // to find out if scripts should be activated at all.
@@ -2069,7 +2113,10 @@ namespace OpenSim.Region.Framework.Scenes
                     SceneObjectPart[] partList = sog.Parts;
                     
                     foreach (SceneObjectPart child in partList)
+                    {
                         child.Inventory.ChangeInventoryOwner(ownerID);
+                        child.TriggerScriptChangedEvent(Changed.OWNER);
+                    }
                 }
                 else
                 {
@@ -2085,6 +2132,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         child.LastOwnerID = child.OwnerID;
                         child.Inventory.ChangeInventoryOwner(groupID);
+                        child.TriggerScriptChangedEvent(Changed.OWNER);
                     }
 
                     sog.SetOwnerId(groupID);
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 1a6a70b..f0acc38 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -563,7 +563,6 @@ namespace OpenSim.Region.Framework.Scenes
             m_regInfo = regInfo;
             m_regionHandle = m_regInfo.RegionHandle;
             m_regionName = m_regInfo.RegionName;
-            m_datastore = m_regInfo.DataStore;
             m_lastUpdate = Util.EnvironmentTickCount();
 
             m_physicalPrim = physicalPrim;
@@ -1109,7 +1108,7 @@ namespace OpenSim.Region.Framework.Scenes
             //
             while (m_regInfo.EstateSettings.EstateOwner == UUID.Zero && MainConsole.Instance != null)
             {
-                MainConsole.Instance.Output("The current estate has no owner set.");
+                MainConsole.Instance.OutputFormat("Estate {0} has no owner set.", m_regInfo.EstateSettings.EstateName);
                 List<char> excluded = new List<char>(new char[1]{' '});
                 string first = MainConsole.Instance.CmdPrompt("Estate owner first name", "Test", excluded);
                 string last = MainConsole.Instance.CmdPrompt("Estate owner last name", "User", excluded);
@@ -1429,20 +1428,6 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Recount SceneObjectPart in parcel aabb
-        /// </summary>
-        private void UpdateLand()
-        {
-            if (LandChannel != null)
-            {
-                if (LandChannel.IsLandPrimCountTainted())
-                {
-                    EventManager.TriggerParcelPrimCountUpdate();
-                }
-            }
-        }
-
-        /// <summary>
         /// Update the terrain if it needs to be updated.
         /// </summary>
         private void UpdateTerrain()
@@ -1536,8 +1521,11 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Return object to avatar Message
+        /// Tell an agent that their object has been returned. 
         /// </summary>
+        /// <remarks>
+        /// The actual return is handled by the caller.
+        /// </remarks>
         /// <param name="agentID">Avatar Unique Id</param>
         /// <param name="objectName">Name of object returned</param>
         /// <param name="location">Location of object returned</param>
@@ -1956,8 +1944,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// If false, it is left to the caller to schedule the update
         /// </param>
         public bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates)
-        {
-            return m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, sendClientUpdates);
+        {           
+            if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, sendClientUpdates))
+            {
+                EventManager.TriggerObjectAddedToScene(sceneObject);
+                return true;       
+            }
+            
+            return false;
         }
         
         /// <summary>
@@ -1974,7 +1968,13 @@ namespace OpenSim.Region.Framework.Scenes
         public bool AddNewSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, Vector3 pos, Quaternion rot, Vector3 vel)
         {
-            return m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, pos, rot, vel);
+            if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, pos, rot, vel))
+            {            
+                EventManager.TriggerObjectAddedToScene(sceneObject);
+                return true;
+            }
+
+            return false;
         }
 
         /// <summary>
@@ -4854,8 +4854,17 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 float ominX, ominY, ominZ, omaxX, omaxY, omaxZ;
 
+                Vector3 vec = g.AbsolutePosition;
+
                 g.GetAxisAlignedBoundingBoxRaw(out ominX, out omaxX, out ominY, out omaxY, out ominZ, out omaxZ);
 
+                ominX += vec.X;
+                omaxX += vec.X;
+                ominY += vec.Y;
+                omaxY += vec.Y;
+                ominZ += vec.Z;
+                omaxZ += vec.Z;
+
                 if (minX > ominX)
                     minX = ominX;
                 if (minY > ominY)
diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index f343bc8..c4547f2 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -136,8 +136,6 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_permissions; }
         }
 
-        protected string m_datastore;
-
          /* Used by the loadbalancer plugin on GForge */
         protected RegionStatus m_regStatus;
         public RegionStatus RegionStatus
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index 734ba22..97af0a0 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -88,9 +88,21 @@ namespace OpenSim.Region.Framework.Scenes
         protected internal object m_syncRoot = new object();
 
         protected internal PhysicsScene _PhyScene;
-
-        protected internal Dictionary<uint, SceneObjectGroup> SceneObjectGroupsByLocalID = new Dictionary<uint, SceneObjectGroup>();
+        
+        /// <summary>
+        /// Index the SceneObjectGroup for each part by the root part's UUID.
+        /// </summary>
         protected internal Dictionary<UUID, SceneObjectGroup> SceneObjectGroupsByFullID = new Dictionary<UUID, SceneObjectGroup>();
+        
+        /// <summary>
+        /// Index the SceneObjectGroup for each part by that part's UUID.
+        /// </summary>
+        protected internal Dictionary<UUID, SceneObjectGroup> SceneObjectGroupsByFullPartID = new Dictionary<UUID, SceneObjectGroup>();
+        
+        /// <summary>
+        /// Index the SceneObjectGroup for each part by that part's local ID.
+        /// </summary>
+        protected internal Dictionary<uint, SceneObjectGroup> SceneObjectGroupsByLocalPartID = new Dictionary<uint, SceneObjectGroup>();        
 
         private Object m_updateLock = new Object();
 
@@ -133,8 +145,10 @@ namespace OpenSim.Region.Framework.Scenes
 
             lock (SceneObjectGroupsByFullID)
                 SceneObjectGroupsByFullID.Clear();
-            lock (SceneObjectGroupsByLocalID)
-                SceneObjectGroupsByLocalID.Clear();
+            lock (SceneObjectGroupsByFullPartID)
+                SceneObjectGroupsByFullPartID.Clear();
+            lock (SceneObjectGroupsByLocalPartID)
+                SceneObjectGroupsByLocalPartID.Clear();
 
             Entities.Clear();
         }
@@ -349,6 +363,10 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (Entities.ContainsKey(sceneObject.UUID))
                 return false;
+            
+//            m_log.DebugFormat(
+//                "[SCENEGRAPH]: Adding scene object {0} {1}, with {2} parts on {3}", 
+//                sceneObject.Name, sceneObject.UUID, sceneObject.Parts.Length, m_parentScene.RegionInfo.RegionName);
 
             SceneObjectPart[] children = sceneObject.Parts;
 
@@ -385,17 +403,20 @@ namespace OpenSim.Region.Framework.Scenes
                 OnObjectCreate(sceneObject);
 
             lock (SceneObjectGroupsByFullID)
-            {
                 SceneObjectGroupsByFullID[sceneObject.UUID] = sceneObject;
+            
+            lock (SceneObjectGroupsByFullPartID)
+            {
+                SceneObjectGroupsByFullPartID[sceneObject.UUID] = sceneObject;
                 foreach (SceneObjectPart part in children)
-                    SceneObjectGroupsByFullID[part.UUID] = sceneObject;
+                    SceneObjectGroupsByFullPartID[part.UUID] = sceneObject;
             }
 
-            lock (SceneObjectGroupsByLocalID)
+            lock (SceneObjectGroupsByLocalPartID)
             {
-                SceneObjectGroupsByLocalID[sceneObject.LocalId] = sceneObject;
+                SceneObjectGroupsByLocalPartID[sceneObject.LocalId] = sceneObject;
                 foreach (SceneObjectPart part in children)
-                    SceneObjectGroupsByLocalID[part.LocalId] = sceneObject;
+                    SceneObjectGroupsByLocalPartID[part.LocalId] = sceneObject;
             }
 
             return true;
@@ -426,21 +447,24 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (OnObjectRemove != null)
                 OnObjectRemove(Entities[uuid]);
-
+            
             lock (SceneObjectGroupsByFullID)
+                SceneObjectGroupsByFullID.Remove(grp.UUID);
+
+            lock (SceneObjectGroupsByFullPartID)
             {
                 SceneObjectPart[] parts = grp.Parts;
                 for (int i = 0; i < parts.Length; i++)
-                    SceneObjectGroupsByFullID.Remove(parts[i].UUID);
-                SceneObjectGroupsByFullID.Remove(grp.RootPart.UUID);
+                    SceneObjectGroupsByFullPartID.Remove(parts[i].UUID);
+                SceneObjectGroupsByFullPartID.Remove(grp.RootPart.UUID);
             }
 
-            lock (SceneObjectGroupsByLocalID)
+            lock (SceneObjectGroupsByLocalPartID)
             {
                 SceneObjectPart[] parts = grp.Parts;
                 for (int i = 0; i < parts.Length; i++)
-                    SceneObjectGroupsByLocalID.Remove(parts[i].LocalId);
-                SceneObjectGroupsByLocalID.Remove(grp.RootPart.LocalId);
+                    SceneObjectGroupsByLocalPartID.Remove(parts[i].LocalId);
+                SceneObjectGroupsByLocalPartID.Remove(grp.RootPart.LocalId);
             }
 
             return Entities.Remove(uuid);
@@ -627,7 +651,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (!Entities.Remove(agentID))
             {
                 m_log.WarnFormat(
-                    "[SCENE]: Tried to remove non-existent scene presence with agent ID {0} from scene Entities list",
+                    "[SCENEGRAPH]: Tried to remove non-existent scene presence with agent ID {0} from scene Entities list",
                     agentID);
             }
 
@@ -650,7 +674,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 else
                 {
-                    m_log.WarnFormat("[SCENE]: Tried to remove non-existent scene presence with agent ID {0} from scene ScenePresences list", agentID);
+                    m_log.WarnFormat("[SCENEGRAPH]: Tried to remove non-existent scene presence with agent ID {0} from scene ScenePresences list", agentID);
                 }
             }
         }
@@ -854,14 +878,14 @@ namespace OpenSim.Region.Framework.Scenes
 
             //m_log.DebugFormat("Entered GetGroupByPrim with localID {0}", localID);
             SceneObjectGroup sog;
-            lock (SceneObjectGroupsByLocalID)
-                SceneObjectGroupsByLocalID.TryGetValue(localID, out sog);
+            lock (SceneObjectGroupsByLocalPartID)
+                SceneObjectGroupsByLocalPartID.TryGetValue(localID, out sog);
 
             if (sog != null)
             {
                 if (sog.HasChildPrim(localID))
                     return sog;
-                SceneObjectGroupsByLocalID.Remove(localID);
+                SceneObjectGroupsByLocalPartID.Remove(localID);
             }
 
             EntityBase[] entityList = GetEntities();
@@ -873,8 +897,8 @@ namespace OpenSim.Region.Framework.Scenes
                     sog = (SceneObjectGroup)ent;
                     if (sog.HasChildPrim(localID))
                     {
-                        lock (SceneObjectGroupsByLocalID)
-                            SceneObjectGroupsByLocalID[localID] = sog;
+                        lock (SceneObjectGroupsByLocalPartID)
+                            SceneObjectGroupsByLocalPartID[localID] = sog;
                         return sog;
                     }
                 }
@@ -891,16 +915,16 @@ namespace OpenSim.Region.Framework.Scenes
         private SceneObjectGroup GetGroupByPrim(UUID fullID)
         {
             SceneObjectGroup sog;
-            lock (SceneObjectGroupsByFullID)
-                SceneObjectGroupsByFullID.TryGetValue(fullID, out sog);
+            lock (SceneObjectGroupsByFullPartID)
+                SceneObjectGroupsByFullPartID.TryGetValue(fullID, out sog);
 
             if (sog != null)
             {
                 if (sog.ContainsPart(fullID))
                     return sog;
 
-                lock (SceneObjectGroupsByFullID)
-                    SceneObjectGroupsByFullID.Remove(fullID);
+                lock (SceneObjectGroupsByFullPartID)
+                    SceneObjectGroupsByFullPartID.Remove(fullID);
             }
 
             EntityBase[] entityList = GetEntities();
@@ -911,8 +935,8 @@ namespace OpenSim.Region.Framework.Scenes
                     sog = (SceneObjectGroup)ent;
                     if (sog.HasChildPrim(fullID))
                     {
-                        lock (SceneObjectGroupsByFullID)
-                            SceneObjectGroupsByFullID[fullID] = sog;
+                        lock (SceneObjectGroupsByFullPartID)
+                            SceneObjectGroupsByFullPartID[fullID] = sog;
                         return sog;
                     }
                 }
@@ -1064,11 +1088,12 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Performs action on all scene object groups.
+        /// Performs action once on all scene object groups.
         /// </summary>
         /// <param name="action"></param>
         protected internal void ForEachSOG(Action<SceneObjectGroup> action)
         {
+            // FIXME: Need to lock here, really.
             List<SceneObjectGroup> objlist = new List<SceneObjectGroup>(SceneObjectGroupsByFullID.Values);
             foreach (SceneObjectGroup obj in objlist)
             {
@@ -1079,11 +1104,11 @@ namespace OpenSim.Region.Framework.Scenes
                 catch (Exception e)
                 {
                     // Catch it and move on. This includes situations where splist has inconsistent info
-                    m_log.WarnFormat("[SCENE]: Problem processing action in ForEachSOG: ", e.ToString());
+                    m_log.WarnFormat(
+                        "[SCENEGRAPH]: Problem processing action in ForEachSOG: {0} {1}", e.Message, e.StackTrace);
                 }
             }
         }
-
         
         /// <summary>
         /// Performs action on all scene presences. This can ultimately run the actions in parallel but
@@ -1103,8 +1128,8 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     catch (Exception e)
                     {
-                        m_log.Info("[BUG] in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
-                        m_log.Info("[BUG] Stack Trace: " + e.StackTrace);
+                        m_log.Info("[SCENEGRAPH]: Error in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
+                        m_log.Info("[SCENEGRAPH]: Stack Trace: " + e.StackTrace);
                     }
                 });
             Parallel.ForEach<ScenePresence>(GetScenePresences(), protectedAction);
@@ -1119,7 +1144,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 catch (Exception e)
                 {
-                    m_log.Info("[BUG] in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
+                    m_log.Error("[SCENEGRAPH]: Error in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
                 }
             }
         }
@@ -1777,7 +1802,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="rot"></param>
         public SceneObjectGroup DuplicateObject(uint originalPrimID, Vector3 offset, uint flags, UUID AgentID, UUID GroupID, Quaternion rot)
         {
-            //m_log.DebugFormat("[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}", originalPrim, offset, AgentID);
+//            m_log.DebugFormat(
+//                "[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}", 
+//                originalPrimID, offset, AgentID);
+            
             SceneObjectGroup original = GetGroupByPrim(originalPrimID);
             if (original != null)
             {
@@ -1808,7 +1836,28 @@ namespace OpenSim.Region.Framework.Scenes
                         copy.RootPart.SalePrice = 10;
                     }
 
+                    // FIXME: This section needs to be refactored so that it just calls AddSceneObject()
                     Entities.Add(copy);
+                    
+                    lock (SceneObjectGroupsByFullID)
+                        SceneObjectGroupsByFullID[copy.UUID] = copy;
+                    
+                    SceneObjectPart[] children = copy.Parts;
+                    
+                    lock (SceneObjectGroupsByFullPartID)
+                    {
+                        SceneObjectGroupsByFullPartID[copy.UUID] = copy;
+                        foreach (SceneObjectPart part in children)
+                            SceneObjectGroupsByFullPartID[part.UUID] = copy;
+                    }
+        
+                    lock (SceneObjectGroupsByLocalPartID)
+                    {
+                        SceneObjectGroupsByLocalPartID[copy.LocalId] = copy;
+                        foreach (SceneObjectPart part in children)
+                            SceneObjectGroupsByLocalPartID[part.LocalId] = copy;
+                    }   
+                    // PROBABLE END OF FIXME
 
                     // Since we copy from a source group that is in selected
                     // state, but the copy is shown deselected in the viewer,
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index f17fb28..ca7d9d9 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -325,6 +325,8 @@ namespace OpenSim.Region.Framework.Scenes
                 //m_rootPart.GroupPosition.Z);
                 //m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
                 //}
+                
+                m_scene.EventManager.TriggerParcelPrimCountTainted();
             }
         }
 
@@ -1313,8 +1315,10 @@ namespace OpenSim.Region.Framework.Scenes
                                     parcel.LandData.OtherCleanTime)
                             {
                                 DetachFromBackup();
-                                m_log.InfoFormat("[SCENE]: Returning object {0} due to parcel auto return", RootPart.UUID.ToString());
-                                m_scene.AddReturn(OwnerID, Name, AbsolutePosition, "parcel auto return");
+                                m_log.DebugFormat(
+                                    "[SCENE OBJECT GROUP]: Returning object {0} due to parcel autoreturn", 
+                                     RootPart.UUID);
+                                m_scene.AddReturn(OwnerID, Name, AbsolutePosition, "parcel autoreturn");
                                 m_scene.DeRezObjects(null, new List<uint>() { RootPart.LocalId }, UUID.Zero,
                                         DeRezAction.Return, UUID.Zero);
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index fa404c0..3281eab 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -175,12 +175,12 @@ namespace OpenSim.Region.Framework.Scenes
             foreach (TaskInventoryItem item in items)
             {
                 if (ownerId != item.OwnerID)
-                {
                     item.LastOwnerID = item.OwnerID;
-                    item.OwnerID = ownerId;
-                    item.PermsMask = 0;
-                    item.PermsGranter = UUID.Zero;
-                }
+
+                item.OwnerID = ownerId;
+                item.PermsMask = 0;
+                item.PermsGranter = UUID.Zero;
+                item.OwnerChanged = true;
             }
         }
 
diff --git a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
index 49382f0..821cd4b 100644
--- a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
+++ b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
@@ -1247,7 +1247,7 @@ namespace OpenSim.Region.OptionalModules.Agent.InternetRelayClientView.Server
             
         }
 
-        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, LandData landData, float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
+        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, ILandObject lo, float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
         {
             
         }
diff --git a/OpenSim/Region/OptionalModules/Avatar/Concierge/ConciergeModule.cs b/OpenSim/Region/OptionalModules/Avatar/Concierge/ConciergeModule.cs
index 2fcc477..0d6313a 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Concierge/ConciergeModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Concierge/ConciergeModule.cs
@@ -80,16 +80,11 @@ namespace OpenSim.Region.OptionalModules.Avatar.Concierge
             m_config = config.Configs["Concierge"];
 
             if (null == m_config)
-            {
-                m_log.Info("[Concierge]: no config found, plugin disabled");
                 return;
-            }
 
             if (!m_config.GetBoolean("enabled", false))
-            {
-                m_log.Info("[Concierge]: plugin disabled by configuration");
                 return;
-            }
+
             m_enabled = true;
 
 
@@ -113,9 +108,9 @@ namespace OpenSim.Region.OptionalModules.Avatar.Concierge
             {
                 m_replacingChatModule = false;
             }
+            
             m_log.InfoFormat("[Concierge] {0} ChatModule", m_replacingChatModule ? "replacing" : "not replacing");
 
-
             // take note of concierge channel and of identity
             m_conciergeChannel = config.Configs["Concierge"].GetInt("concierge_channel", m_conciergeChannel);
             m_whoami = m_config.GetString("whoami", "conferencier");
diff --git a/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs b/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
index 05a1c3b..7909d8a 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
@@ -106,16 +106,10 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.FreeSwitchVoice
             m_Config = config.Configs["FreeSwitchVoice"];
 
             if (m_Config == null)
-            {
-                m_log.Info("[FreeSwitchVoice] no config found, plugin disabled");
                 return;
-            }
 
             if (!m_Config.GetBoolean("Enabled", false))
-            {
-                m_log.Info("[FreeSwitchVoice] plugin disabled by configuration");
                 return;
-            }
 
             try
             {
diff --git a/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs b/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
index 34d0e24..534bf92 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
@@ -121,16 +121,10 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.VivoxVoice
             m_config = config.Configs["VivoxVoice"];
 
             if (null == m_config)
-            {
-                m_log.Info("[VivoxVoice] no config found, plugin disabled");
                 return;
-            }
 
             if (!m_config.GetBoolean("enabled", false))
-            {
-                m_log.Info("[VivoxVoice] plugin disabled by configuration");
                 return;
-            }
 
             try
             {
@@ -218,7 +212,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.VivoxVoice
                 m_pluginEnabled = true;
 
                 m_log.Info("[VivoxVoice] plugin enabled");
-
             }
             catch (Exception e)
             {
@@ -228,7 +221,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.VivoxVoice
             }
         }
 
-
         // Called to indicate that the module has been added to the region
         public void AddRegion(Scene scene)
         {
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
index 3d34441..8c01d75 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
@@ -86,13 +86,10 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                     return;
                 }
 
-                m_log.Info("[GROUPS-MESSAGING]: Initializing GroupsMessagingModule");
-
                 m_debugEnabled = groupsConfig.GetBoolean("DebugEnabled", true);
             }
 
             m_log.Info("[GROUPS-MESSAGING]: GroupsMessagingModule starting up");
-
         }
 
         public void AddRegion(Scene scene)
diff --git a/OpenSim/Region/OptionalModules/Example/BareBonesShared/BareBonesSharedModule.cs b/OpenSim/Region/OptionalModules/Example/BareBonesShared/BareBonesSharedModule.cs
index 781fe95..dddea3e 100644
--- a/OpenSim/Region/OptionalModules/Example/BareBonesShared/BareBonesSharedModule.cs
+++ b/OpenSim/Region/OptionalModules/Example/BareBonesShared/BareBonesSharedModule.cs
@@ -33,6 +33,9 @@ using Nini.Config;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
+[assembly: Addin("BareBonesSharedModule", "0.1")]
+[assembly: AddinDependency("OpenSim", "0.5")]
+
 namespace OpenSim.Region.OptionalModules.Example.BareBonesShared
 {
     /// <summary>
diff --git a/OpenSim/Region/OptionalModules/Scripting/Minimodule/LOParcel.cs b/OpenSim/Region/OptionalModules/Scripting/Minimodule/LOParcel.cs
index 8df020f..c898da6 100644
--- a/OpenSim/Region/OptionalModules/Scripting/Minimodule/LOParcel.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/Minimodule/LOParcel.cs
@@ -25,6 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
diff --git a/OpenSim/Region/OptionalModules/Scripting/Minimodule/MRMModule.cs b/OpenSim/Region/OptionalModules/Scripting/Minimodule/MRMModule.cs
index df60709..74f5208 100644
--- a/OpenSim/Region/OptionalModules/Scripting/Minimodule/MRMModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/Minimodule/MRMModule.cs
@@ -75,7 +75,7 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
 
                 if (source.Configs["MRM"].GetBoolean("Enabled", false))
                 {
-                    m_log.Info("[MRM] Enabling MRM Module");
+                    m_log.Info("[MRM]: Enabling MRM Module");
                     m_scene = scene;
 
                     // when hidden, we don't listen for client initiated script events
@@ -90,14 +90,6 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
 
                     scene.RegisterModuleInterface<IMRMModule>(this);
                 }
-                else
-                {
-                    m_log.Info("[MRM] Disabled MRM Module (Disabled in ini)");
-                }
-            }
-            else
-            {
-                m_log.Info("[MRM] Disabled MRM Module (Default disabled)");
             }
         }
 
diff --git a/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs b/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
index 5d44aa1..96760a2 100644
--- a/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
+++ b/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
@@ -925,7 +925,7 @@ namespace OpenSim.Region.OptionalModules.World.NPC
         {
         }
 
-        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, LandData landData, float simObjectBonusFactor,int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
+        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, ILandObject lo, float simObjectBonusFactor,int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
         {
         }
         public void SendLandAccessListData(List<UUID> avatars, uint accessFlag, int localLandID)
diff --git a/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs b/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
index 98e5453..a133e51 100644
--- a/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
+++ b/OpenSim/Region/RegionCombinerModule/RegionCombinerLargeLandChannel.cs
@@ -130,11 +130,6 @@ public class RegionCombinerLargeLandChannel : ILandChannel
             }
         }
 
-        public bool IsLandPrimCountTainted()
-        {
-            return RootRegionLandChannel.IsLandPrimCountTainted();
-        }
-
         public bool IsForcefulBansAllowed()
         {
             return RootRegionLandChannel.IsForcefulBansAllowed();
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 72ee495..aa28fa0 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -81,7 +81,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
     /// </summary>
     public class LSL_Api : MarshalByRefObject, ILSL_Api, IScriptApi
     {
-        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         protected IScriptEngine m_ScriptEngine;
         protected SceneObjectPart m_host;
         protected uint m_localID;
@@ -9835,63 +9835,42 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         public LSL_Integer llGetParcelPrimCount(LSL_Vector pos, int category, int sim_wide)
         {
             m_host.AddScriptLPS(1);
+            
+            ILandObject lo = World.LandChannel.GetLandObject((float)pos.x, (float)pos.y);
 
-            LandData land = World.GetLandData((float)pos.x, (float)pos.y);
-
-            if (land == null)
-            {
+            if (lo == null)
                 return 0;
-            }
+            
+            IPrimCounts pc = lo.PrimCounts;
 
-            else
+            if (sim_wide != ScriptBaseClass.FALSE)
             {
-                if (sim_wide != 0)
+                if (category == ScriptBaseClass.PARCEL_COUNT_TOTAL)
                 {
-                    if (category == 0)
-                    {
-                        return land.SimwidePrims;
-                    }
-
-                    else
-                    {
-                        //public int simwideArea = 0;
-                        return 0;
-                    }
+                    return pc.Simulator;
                 }
-
                 else
                 {
-                    if (category == 0)//Total Prims
-                    {
-                        return 0;//land.
-                    }
-
-                    else if (category == 1)//Owner Prims
-                    {
-                        return land.OwnerPrims;
-                    }
-
-                    else if (category == 2)//Group Prims
-                    {
-                        return land.GroupPrims;
-                    }
-
-                    else if (category == 3)//Other Prims
-                    {
-                        return land.OtherPrims;
-                    }
-
-                    else if (category == 4)//Selected
-                    {
-                        return land.SelectedPrims;
-                    }
-
-                    else if (category == 5)//Temp
-                    {
-                        return 0;//land.
-                    }
+                    // counts not implemented yet
+                    return 0;
                 }
             }
+            else
+            {
+                if (category == ScriptBaseClass.PARCEL_COUNT_TOTAL)
+                    return pc.Total;
+                else if (category == ScriptBaseClass.PARCEL_COUNT_OWNER)
+                    return pc.Owner;
+                else if (category == ScriptBaseClass.PARCEL_COUNT_GROUP)
+                    return pc.Group;
+                else if (category == ScriptBaseClass.PARCEL_COUNT_OTHER)
+                    return pc.Others;
+                else if (category == ScriptBaseClass.PARCEL_COUNT_SELECTED)
+                    return pc.Selected;
+                else if (category == ScriptBaseClass.PARCEL_COUNT_TEMP)
+                    return 0; // counts not implemented yet
+            }
+            
             return 0;
         }
 
@@ -10278,6 +10257,60 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             return GetLinkPrimitiveParams(obj, rules);
         }
+
+        public void print(string str)
+        {
+            // yes, this is a real LSL function. See: http://wiki.secondlife.com/wiki/Print
+            IOSSL_Api ossl = (IOSSL_Api)m_ScriptEngine.GetApi(m_itemID, "OSSL");
+            if (ossl != null)
+            {
+                ossl.CheckThreatLevel(ThreatLevel.High, "print");
+                m_log.Info("LSL print():" + str);
+            }
+        }
+
+        private string Name2Username(string name)
+        {
+            string[] parts = name.Split(new char[] {' '});
+            if (parts.Length < 2)
+                return name.ToLower();
+            if (parts[1] == "Resident")
+                return parts[0].ToLower();
+
+            return name.Replace(" ", ".").ToLower();
+        }
+
+        public LSL_String llGetUsername(string id)
+        {
+            return Name2Username(llKey2Name(id));
+        }
+
+        public LSL_String llRequestUsername(string id)
+        {
+            UUID rq = UUID.Random();
+
+            AsyncCommands.DataserverPlugin.RegisterRequest(m_localID, m_itemID, rq.ToString());
+
+            AsyncCommands.DataserverPlugin.DataserverReply(rq.ToString(), Name2Username(llKey2Name(id)));
+
+            return rq.ToString();
+        }
+
+        public LSL_String llGetDisplayName(string id)
+        {
+            return llKey2Name(id);
+        }
+
+        public LSL_String llRequestDisplayName(string id)
+        {
+            UUID rq = UUID.Random();
+
+            AsyncCommands.DataserverPlugin.RegisterRequest(m_localID, m_itemID, rq.ToString());
+
+            AsyncCommands.DataserverPlugin.DataserverReply(rq.ToString(), llKey2Name(id));
+
+            return rq.ToString();
+        }
     }
 
     public class NotecardCache
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
index fefbb35..47c7915 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
@@ -50,6 +50,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
         private Object SenseLock = new Object();
 
         private const int AGENT = 1;
+        private const int AGENT_BY_USERNAME = 0x10;
         private const int ACTIVE = 2;
         private const int PASSIVE = 4;
         private const int SCRIPTED = 8;
@@ -202,7 +203,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
             List<SensedEntity> sensedEntities = new List<SensedEntity>();
 
             // Is the sensor type is AGENT and not SCRIPTED then include agents
-            if ((ts.type & AGENT) != 0 && (ts.type & SCRIPTED) == 0)
+            if ((ts.type & (AGENT | AGENT_BY_USERNAME)) != 0 && (ts.type & SCRIPTED) == 0)
             {
                sensedEntities.AddRange(doAgentSensor(ts));
             }
@@ -493,9 +494,26 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
             {
                 ScenePresence sp;
                 // Try lookup by name will return if/when found
-                if (!m_CmdManager.m_ScriptEngine.World.TryGetAvatarByName(ts.name, out sp))
-                    return sensedEntities;
-                senseEntity(sp);
+                if (((ts.type & AGENT) != 0) && m_CmdManager.m_ScriptEngine.World.TryGetAvatarByName(ts.name, out sp))
+                    senseEntity(sp);
+                if ((ts.type & AGENT_BY_USERNAME) != 0)
+                {
+                    m_CmdManager.m_ScriptEngine.World.ForEachScenePresence(
+                        delegate (ScenePresence ssp)
+                        {
+                            if (ssp.Lastname == "Resident")
+                            {
+                                if (ssp.Firstname.ToLower() == ts.name)
+                                    senseEntity(ssp);
+                                return;
+                            }
+                            if (ssp.Name.Replace(" ", ".").ToLower() == ts.name)
+                                senseEntity(ssp);
+                        }
+                    );
+                }
+
+                return sensedEntities;
             }
             else
             {
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
index 561e3b3..654ea81 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
@@ -209,6 +209,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
               void llInstantMessage(string user, string message);
         LSL_String llIntegerToBase64(int number);
         LSL_String llKey2Name(string id);
+        LSL_String llGetUsername(string id);
+        LSL_String llRequestUsername(string id);
+        LSL_String llGetDisplayName(string id);
+        LSL_String llRequestDisplayName(string id);
         void llLinkParticleSystem(int linknum, LSL_List rules);
         LSL_String llList2CSV(LSL_List src);
          LSL_Float llList2Float(LSL_List src, int index);
@@ -398,6 +402,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
         LSL_Vector llWind(LSL_Vector offset);
         LSL_String llXorBase64Strings(string str1, string str2);
         LSL_String llXorBase64StringsCorrect(string str1, string str2);
+              void print(string str);
 
         void SetPrimitiveParamsEx(LSL_Key prim, LSL_List rules);
         LSL_List GetLinkPrimitiveParamsEx(LSL_Key prim, LSL_List rules);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
index b3c4d95..9377cda 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
@@ -50,6 +50,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
         public const int STATUS_CAST_SHADOWS = 512;
 
         public const int AGENT = 1;
+        public const int AGENT_BY_LEGACY_NAME = 1;
+        public const int AGENT_BY_USERNAME = 0x10;
         public const int ACTIVE = 2;
         public const int PASSIVE = 4;
         public const int SCRIPTED = 8;
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
index 451163f..303d75e 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
@@ -894,6 +894,26 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
             return m_LSL_Functions.llKey2Name(id);
         }
 
+        public LSL_String llGetUsername(string id)
+        {
+            return m_LSL_Functions.llGetUsername(id);
+        }
+
+        public LSL_String llRequestUsername(string id)
+        {
+            return m_LSL_Functions.llRequestUsername(id);
+        }
+
+        public LSL_String llGetDisplayName(string id)
+        {
+            return m_LSL_Functions.llGetDisplayName(id);
+        }
+
+        public LSL_String llRequestDisplayName(string id)
+        {
+            return m_LSL_Functions.llRequestDisplayName(id);
+        }
+
         public void llLinkParticleSystem(int linknum, LSL_List rules)
         {
             m_LSL_Functions.llLinkParticleSystem(linknum, rules);
@@ -1847,5 +1867,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
         {
             return m_LSL_Functions.llClearPrimMedia(face);
         }
+
+        public void print(string str)
+        {
+            m_LSL_Functions.print(str);
+        }
     }
 }