11 files changed, 182 insertions, 57 deletions

diff --git a/OpenSim/Framework/AssetBase.cs b/OpenSim/Framework/AssetBase.cs
index 53d28be..98fa846 100644
--- a/OpenSim/Framework/AssetBase.cs
+++ b/OpenSim/Framework/AssetBase.cs
@@ -60,6 +60,8 @@ namespace OpenSim.Framework
         /// </summary>
         private AssetMetadata m_metadata;
 
+        private int m_uploadAttempts;
+
         // This is needed for .NET serialization!!!
         // Do NOT "Optimize" away!
         public AssetBase()
@@ -197,6 +199,12 @@ namespace OpenSim.Framework
             set { m_metadata.Type = value; }
         }
 
+        public int UploadAttempts
+        {
+            get { return m_uploadAttempts; }
+            set { m_uploadAttempts = value; }
+        }
+
         /// <summary>
         /// Is this a region only asset, or does this exist on the asset server also
         /// </summary>
diff --git a/OpenSim/Framework/IClientAPI.cs b/OpenSim/Framework/IClientAPI.cs
index 556a532..d85b101 100644
--- a/OpenSim/Framework/IClientAPI.cs
+++ b/OpenSim/Framework/IClientAPI.cs
@@ -940,8 +940,10 @@ namespace OpenSim.Framework
         void SetDebugPacketLevel(int newDebug);
 
         void InPacket(object NewPack);
+        void ProcessPendingPackets();
         void ProcessInPacket(Packet NewPack);
         void Close();
+        void Close(bool sendStop);
         void Kick(string message);
         
         /// <summary>
diff --git a/OpenSim/Framework/LandData.cs b/OpenSim/Framework/LandData.cs
index 060e886..ef07438 100644
--- a/OpenSim/Framework/LandData.cs
+++ b/OpenSim/Framework/LandData.cs
@@ -62,7 +62,7 @@ namespace OpenSim.Framework
 
         private uint _flags = (uint) ParcelFlags.AllowFly | (uint) ParcelFlags.AllowLandmark |
                                 (uint) ParcelFlags.AllowAPrimitiveEntry |
-                                (uint) ParcelFlags.AllowDeedToGroup | (uint) ParcelFlags.AllowTerraform |
+                                (uint) ParcelFlags.AllowDeedToGroup |
                                 (uint) ParcelFlags.CreateObjects | (uint) ParcelFlags.AllowOtherScripts |
                                 (uint) ParcelFlags.SoundLocal;
 
diff --git a/OpenSim/Framework/ParcelMediaCommandEnum.cs b/OpenSim/Framework/ParcelMediaCommandEnum.cs
index 93c41ec..e714382 100644
--- a/OpenSim/Framework/ParcelMediaCommandEnum.cs
+++ b/OpenSim/Framework/ParcelMediaCommandEnum.cs
@@ -27,7 +27,7 @@
 
 namespace OpenSim.Framework
 {
-    public enum ParcelMediaCommandEnum
+    public enum ParcelMediaCommandEnum : int
     {
         Stop = 0,
         Pause = 1,
diff --git a/OpenSim/Framework/PrimitiveBaseShape.cs b/OpenSim/Framework/PrimitiveBaseShape.cs
index 4d1de22..990c859 100644
--- a/OpenSim/Framework/PrimitiveBaseShape.cs
+++ b/OpenSim/Framework/PrimitiveBaseShape.cs
@@ -1196,7 +1196,7 @@ namespace OpenSim.Framework
             prim.Textures = this.Textures;
 
             prim.Properties = new Primitive.ObjectProperties();
-            prim.Properties.Name = "Primitive";
+            prim.Properties.Name = "Object";
             prim.Properties.Description = "";
             prim.Properties.CreatorID = UUID.Zero;
             prim.Properties.GroupID = UUID.Zero;
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index afc4060..2a74e79 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -40,6 +40,7 @@ using OpenSim.Framework.Console;
 
 namespace OpenSim.Framework
 {
+    [Serializable]
     public class RegionLightShareData : ICloneable
     {
         public UUID regionID = UUID.Zero;
diff --git a/OpenSim/Framework/Servers/HttpServer/SynchronousRestObjectRequester.cs b/OpenSim/Framework/Servers/HttpServer/SynchronousRestObjectRequester.cs
index eab463c..f07f7ab 100644
--- a/OpenSim/Framework/Servers/HttpServer/SynchronousRestObjectRequester.cs
+++ b/OpenSim/Framework/Servers/HttpServer/SynchronousRestObjectRequester.cs
@@ -57,11 +57,27 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// the request.  You'll want to make sure you deal with this as they're not uncommon</exception>
         public static TResponse MakeRequest<TRequest, TResponse>(string verb, string requestUrl, TRequest obj)
         {
+            return MakeRequest<TRequest, TResponse>(verb, requestUrl, obj, 100);
+        }
+        /// <summary>
+        /// Perform a synchronous REST request.
+        /// </summary>
+        /// <param name="verb"></param>
+        /// <param name="requestUrl"></param>
+        /// <param name="obj"> </param>
+        /// <param name="timeout"> </param>
+        /// <returns></returns>
+        ///
+        /// <exception cref="System.Net.WebException">Thrown if we encounter a network issue while posting
+        /// the request.  You'll want to make sure you deal with this as they're not uncommon</exception>
+        public static TResponse MakeRequest<TRequest, TResponse>(string verb, string requestUrl, TRequest obj, int pTimeout)
+        {
             Type type = typeof (TRequest);
             TResponse deserial = default(TResponse);
 
             WebRequest request = WebRequest.Create(requestUrl);
             request.Method = verb;
+            request.Timeout = pTimeout * 1000;
 
             if ((verb == "POST") || (verb == "PUT"))
             {
@@ -81,7 +97,6 @@ namespace OpenSim.Framework.Servers.HttpServer
 
                 int length = (int) buffer.Length;
                 request.ContentLength = length;
-
                 Stream requestStream = null;
                 try
                 {
diff --git a/OpenSim/Framework/Servers/VersionInfo.cs b/OpenSim/Framework/Servers/VersionInfo.cs
index 100bf1f..f3ac191 100644
--- a/OpenSim/Framework/Servers/VersionInfo.cs
+++ b/OpenSim/Framework/Servers/VersionInfo.cs
@@ -29,11 +29,11 @@ namespace OpenSim
 {
     public class VersionInfo
     {
-        private const string VERSION_NUMBER = "0.7.1";
+        private const string VERSION_NUMBER = "0.7.1CM";
         private const Flavour VERSION_FLAVOUR = Flavour.Dev;
 
         public enum Flavour
-        {
+        { 
             Unknown,
             Dev,
             RC1,
diff --git a/OpenSim/Framework/TaskInventoryDictionary.cs b/OpenSim/Framework/TaskInventoryDictionary.cs
index 25ae6b0..4b9a509 100644
--- a/OpenSim/Framework/TaskInventoryDictionary.cs
+++ b/OpenSim/Framework/TaskInventoryDictionary.cs
@@ -27,9 +27,12 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
+using System.Reflection;
 using System.Xml;
 using System.Xml.Schema;
 using System.Xml.Serialization;
+using log4net;
 using OpenMetaverse;
 
 namespace OpenSim.Framework
@@ -45,6 +48,111 @@ namespace OpenSim.Framework
         // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static XmlSerializer tiiSerializer = new XmlSerializer(typeof (TaskInventoryItem));
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private Thread LockedByThread;
+        /// <value>
+        /// An advanced lock for inventory data
+        /// </value>
+        private System.Threading.ReaderWriterLockSlim m_itemLock = new System.Threading.ReaderWriterLockSlim();
+
+        /// <summary>
+        /// Are we readlocked by the calling thread?
+        /// </summary>
+        public bool IsReadLockedByMe()
+        {
+            if (m_itemLock.RecursiveReadCount > 0)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Lock our inventory list for reading (many can read, one can write)
+        /// </summary>
+        public void LockItemsForRead(bool locked)
+        {
+            if (locked)
+            {
+                if (m_itemLock.IsWriteLockHeld && LockedByThread != null)
+                {
+                    if (!LockedByThread.IsAlive)
+                    {
+                        //Locked by dead thread, reset.
+                        m_itemLock = new System.Threading.ReaderWriterLockSlim(); 
+                    }
+                }
+
+                if (m_itemLock.RecursiveReadCount > 0)
+                {
+                    m_log.Error("[TaskInventoryDictionary] Recursive read lock requested. This should not happen and means something needs to be fixed. For now though, it's safe to continue.");
+                    m_itemLock.ExitReadLock();
+                }
+                if (m_itemLock.RecursiveWriteCount > 0)
+                {
+                    m_log.Error("[TaskInventoryDictionary] Recursive write lock requested. This should not happen and means something needs to be fixed.");
+                    m_itemLock.ExitWriteLock();
+                }
+                
+                while (!m_itemLock.TryEnterReadLock(60000))
+                {
+                    m_log.Error("Thread lock detected while trying to aquire READ lock in TaskInventoryDictionary. Locked by thread " + LockedByThread.Name + ". I'm going to try to solve the thread lock automatically to preserve region stability, but this needs to be fixed.");
+                    if (m_itemLock.IsWriteLockHeld)
+                    {
+                        m_itemLock = new System.Threading.ReaderWriterLockSlim();
+                    }
+                }
+            }
+            else
+            {
+                if (m_itemLock.RecursiveReadCount>0)
+                {
+                    m_itemLock.ExitReadLock();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Lock our inventory list for writing (many can read, one can write)
+        /// </summary>
+        public void LockItemsForWrite(bool locked)
+        {
+            if (locked)
+            {
+                //Enter a write lock, wait indefinately for one to open.
+                if (m_itemLock.RecursiveReadCount > 0)
+                {
+                    m_log.Error("[TaskInventoryDictionary] Recursive read lock requested. This should not happen and means something needs to be fixed. For now though, it's safe to continue.");
+                    m_itemLock.ExitReadLock();
+                }
+                if (m_itemLock.RecursiveWriteCount > 0)
+                {
+                    m_log.Error("[TaskInventoryDictionary] Recursive write lock requested. This should not happen and means something needs to be fixed.");
+                    m_itemLock.ExitWriteLock();
+                }
+                while (!m_itemLock.TryEnterWriteLock(60000))
+                {
+                    m_log.Error("Thread lock detected while trying to aquire WRITE lock in TaskInventoryDictionary. Locked by thread " + LockedByThread.Name + ". I'm going to try to solve the thread lock automatically to preserve region stability, but this needs to be fixed.");
+                    if (m_itemLock.IsWriteLockHeld)
+                    {
+                        m_itemLock = new System.Threading.ReaderWriterLockSlim();
+                    }
+                }
+
+                LockedByThread = Thread.CurrentThread;
+            }
+            else
+            {
+                if (m_itemLock.RecursiveWriteCount > 0)
+                {
+                    m_itemLock.ExitWriteLock();
+                }
+            }
+        }
 
         #region ICloneable Members
 
@@ -52,13 +160,12 @@ namespace OpenSim.Framework
         {
             TaskInventoryDictionary clone = new TaskInventoryDictionary();
 
-            lock (this)
+            m_itemLock.EnterReadLock();
+            foreach (UUID uuid in Keys)
             {
-                foreach (UUID uuid in Keys)
-                {
-                    clone.Add(uuid, (TaskInventoryItem) this[uuid].Clone());
-                }
+                clone.Add(uuid, (TaskInventoryItem) this[uuid].Clone());
             }
+            m_itemLock.ExitReadLock();
 
             return clone;
         }
diff --git a/OpenSim/Framework/UndoStack.cs b/OpenSim/Framework/UndoStack.cs
index 4d800ae..4cd779a 100644
--- a/OpenSim/Framework/UndoStack.cs
+++ b/OpenSim/Framework/UndoStack.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 
 namespace OpenSim.Framework
 {
@@ -36,33 +37,30 @@ namespace OpenSim.Framework
     [Serializable]
     public class UndoStack<T>
     {
-        private int m_new = 1;
-        private int m_old = 0;
-        private T[] m_Undos;
+        private List<T> m_undolist;
+        private int m_max;
 
         public UndoStack(int capacity)
         {
-            m_Undos = new T[capacity + 1];
+            m_undolist = new List<T>();
+            m_max = capacity;
         }
 
         public bool IsFull
         {
-            get { return m_new == m_old; }
+            get { return m_undolist.Count >= m_max; }
         }
 
         public int Capacity
         {
-            get { return m_Undos.Length - 1; }
+            get { return m_max; }
         }
 
         public int Count
         {
             get
             {
-                int count = m_new - m_old - 1;
-                if (count < 0)
-                    count += m_Undos.Length;
-                return count;
+                return m_undolist.Count;
             }
         }
 
@@ -70,45 +68,39 @@ namespace OpenSim.Framework
         {
             if (IsFull)
             {
-                m_old++;
-                if (m_old >= m_Undos.Length)
-                    m_old -= m_Undos.Length;
+                m_undolist.RemoveAt(0);
             }
-            if (++m_new >= m_Undos.Length)
-                m_new -= m_Undos.Length;
-            m_Undos[m_new] = item;
+            m_undolist.Add(item);
         }
 
         public T Pop()
         {
-            if (Count > 0)
+            if (m_undolist.Count > 0)
             {
-                T deleted = m_Undos[m_new];
-                m_Undos[m_new--] = default(T);
-                if (m_new < 0)
-                    m_new += m_Undos.Length;
-                return deleted;
+                int ind = m_undolist.Count - 1;
+                T item = m_undolist[ind];
+                m_undolist.RemoveAt(ind);
+                return item;
             }
             else
-                throw new InvalidOperationException("Cannot pop from emtpy stack");
+                throw new InvalidOperationException("Cannot pop from empty stack");
         }
 
         public T Peek()
         {
-            return m_Undos[m_new];
+            if (m_undolist.Count > 0)
+            {
+                return m_undolist[m_undolist.Count - 1];
+            }
+            else
+            {
+                return default(T);
+            }
         }
 
         public void Clear()
         {
-            if (Count > 0)
-            {
-                for (int i = 0; i < m_Undos.Length; i++)
-                {
-                    m_Undos[i] = default(T);
-                }
-                m_new = 1;
-                m_old = 0;
-            }
+            m_undolist.Clear();
         }
     }
 }
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 802cb37..c39fb6f 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -997,19 +997,19 @@ namespace OpenSim.Framework
         {
             string os = String.Empty;
 
-            if (Environment.OSVersion.Platform != PlatformID.Unix)
-            {
-                os = Environment.OSVersion.ToString();
-            }
-            else
-            {
-                os = ReadEtcIssue();
-            }
-                      
-            if (os.Length > 45)
-            {
-                os = os.Substring(0, 45);
-            }
+//            if (Environment.OSVersion.Platform != PlatformID.Unix)
+//            {
+//                os = Environment.OSVersion.ToString();
+//            }
+//            else
+//            {
+//                os = ReadEtcIssue();
+//            }
+//                      
+//            if (os.Length > 45)
+//            {
+//                os = os.Substring(0, 45);
+//            }
             
             return os;
         }