1 files changed, 159 insertions, 144 deletions

diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 1afc5a4..187ed4f 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -30,6 +30,8 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Data;
 using System.Diagnostics;
+using System.Drawing;
+using System.Drawing.Imaging;
 using System.Globalization;
 using System.IO;
 using System.IO.Compression;
@@ -92,6 +94,7 @@ namespace OpenSim.Framework
         // explicitly given
         All = 0x8e000,
         AllAndExport = 0x9e000,
+        AllAndExportNoMod = 0x9a000,
         AllEffective = 0x9e000,
         UnfoldedMask = 0x1e000
     }
@@ -108,9 +111,7 @@ namespace OpenSim.Framework
     {
         None,
         RegressionTest,
-        UnsafeQueueUserWorkItem,
         QueueUserWorkItem,
-        BeginInvoke,
         SmartThreadPool,
         Thread,
     }
@@ -261,10 +262,7 @@ namespace OpenSim.Framework
         /// <returns>The distance between the two vectors</returns>
         public static double GetDistanceTo(Vector3 a, Vector3 b)
         {
-            float dx = a.X - b.X;
-            float dy = a.Y - b.Y;
-            float dz = a.Z - b.Z;
-            return Math.Sqrt(dx * dx + dy * dy + dz * dz);
+            return Vector3.Distance(a,b);
         }
 
         /// <summary>
@@ -276,10 +274,7 @@ namespace OpenSim.Framework
         /// <returns></returns>
         public static bool DistanceLessThan(Vector3 a, Vector3 b, double amount)
         {
-            float dx = a.X - b.X;
-            float dy = a.Y - b.Y;
-            float dz = a.Z - b.Z;
-            return (dx*dx + dy*dy + dz*dz) < (amount*amount);
+            return Vector3.DistanceSquared(a,b) < (amount * amount);
         }
 
         /// <summary>
@@ -380,15 +375,17 @@ namespace OpenSim.Framework
             get { return randomClass; }
         }
 
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static ulong UIntsToLong(uint X, uint Y)
         {
-            return Utils.UIntsToLong(X, Y);
+            return ((ulong)X << 32) | (ulong)Y;
         }
 
         // Regions are identified with a 'handle' made up of its world coordinates packed into a ulong.
         // Region handles are based on the coordinate of the region corner with lower X and Y
         // var regions need more work than this to get that right corner from a generic world position
         // this corner must be on a grid point
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static ulong RegionWorldLocToHandle(uint X, uint Y)
         {
            ulong handle = X & 0xffffff00; // make sure it matchs grid coord points.
@@ -397,6 +394,7 @@ namespace OpenSim.Framework
            return handle;
         }
 
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static ulong RegionGridLocToHandle(uint X, uint Y)
         {
             ulong handle = X;
@@ -405,12 +403,14 @@ namespace OpenSim.Framework
             return handle;
         }
 
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static void RegionHandleToWorldLoc(ulong handle, out uint X, out uint Y)
         {
             X = (uint)(handle >> 32);
             Y = (uint)(handle & 0xfffffffful);
         }
 
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static void RegionHandleToRegionLoc(ulong handle, out uint X, out uint Y)
         {
             X = (uint)(handle >> 40) & 0x00ffffffu; //  bring from higher half, divide by 256 and clean
@@ -420,21 +420,25 @@ namespace OpenSim.Framework
 
         // A region location can be 'world coordinates' (meters) or 'region grid coordinates'
         // grid coordinates have a fixed step of 256m as defined by viewers
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static uint WorldToRegionLoc(uint worldCoord)
         {
             return worldCoord >> 8;
         }
 
         // Convert a region's 'region grid coordinate' to its 'world coordinate'.
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static uint RegionToWorldLoc(uint regionCoord)
         {
             return regionCoord << 8;
         }
 
 
-        public static bool checkServiceURI(string uristr, out string serviceURI)
+        public static bool checkServiceURI(string uristr, out string serviceURI, out string serviceHost, out string serviceIPstr)
         {
             serviceURI = string.Empty;
+            serviceHost = string.Empty;
+            serviceIPstr = string.Empty;
             try
             {
                 Uri  uri = new Uri(uristr);
@@ -443,6 +447,13 @@ namespace OpenSim.Framework
                     serviceURI = serviceURI.Trim(new char[] { '/', ' ' }) +":80/";
                 else if(uri.Port == 443)
                     serviceURI = serviceURI.Trim(new char[] { '/', ' ' }) +":443/";
+                serviceHost = uri.Host;
+
+                IPEndPoint ep = Util.getEndPoint(serviceHost,uri.Port);
+                if(ep == null)
+                    return false;
+
+                serviceIPstr = ep.Address.ToString();
                 return true;
             }
             catch
@@ -452,9 +463,10 @@ namespace OpenSim.Framework
             return false;
         }
 
-        public static bool buildHGRegionURI(string inputName, out string serverURI, out string regionName)
+        public static bool buildHGRegionURI(string inputName, out string serverURI, out string serverHost, out string regionName)
         {
             serverURI = string.Empty;
+            serverHost = string.Empty;
             regionName = string.Empty;
 
             inputName = inputName.Trim();
@@ -563,6 +575,7 @@ namespace OpenSim.Framework
                 serverURI = serverURI.Trim(new char[] { '/', ' ' }) +":80/";
             else if(uri.Port == 443)
                 serverURI = serverURI.Trim(new char[] { '/', ' ' }) +":443/";
+            serverHost = uri.Host;
             return true;
         }
 
@@ -575,14 +588,15 @@ namespace OpenSim.Framework
         }
 
         // Clamp the maximum magnitude of a vector
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static Vector3 ClampV(Vector3 x, float max)
         {
             float lenSq = x.LengthSquared();
             if (lenSq > (max * max))
             {
-                x = x / x.Length() * max;
+                lenSq = max / (float)Math.Sqrt(lenSq);
+                x = x * lenSq;
             }
-
             return x;
         }
 
@@ -671,7 +685,7 @@ namespace OpenSim.Framework
         public static string GetFormattedXml(string rawXml)
         {
             XmlDocument xd = new XmlDocument();
-            xd.XmlResolver=null;
+
             xd.LoadXml(rawXml);
 
             StringBuilder sb = new StringBuilder();
@@ -825,8 +839,8 @@ namespace OpenSim.Framework
 
         private static byte[] ComputeMD5Hash(string data, Encoding encoding)
         {
-            MD5 md5 = MD5.Create();
-            return md5.ComputeHash(encoding.GetBytes(data));
+            using(MD5 md5 = MD5.Create())
+                return md5.ComputeHash(encoding.GetBytes(data));
         }
 
         /// <summary>
@@ -859,11 +873,24 @@ namespace OpenSim.Framework
         private static byte[] ComputeSHA1Hash(byte[] src)
         {
             byte[] ret;
-            using(SHA1CryptoServiceProvider SHA1 = new SHA1CryptoServiceProvider())
-                 ret = SHA1.ComputeHash(src);
+            using (SHA1CryptoServiceProvider SHA1 = new SHA1CryptoServiceProvider())
+                ret = SHA1.ComputeHash(src);
             return ret;
         }
 
+        public static UUID ComputeSHA1UUID(string src)
+        {
+            return ComputeSHA1UUID(Encoding.Default.GetBytes(src));
+        }
+
+        public static UUID ComputeSHA1UUID(byte[] src)
+        {
+            byte[] ret;
+            using (SHA1CryptoServiceProvider SHA1 = new SHA1CryptoServiceProvider())
+                ret = SHA1.ComputeHash(src);
+            return new UUID(ret, 2);
+        }
+
         public static int fast_distance2d(int x, int y)
         {
             x = Math.Abs(x);
@@ -883,7 +910,7 @@ namespace OpenSim.Framework
         /// <returns></returns>
         public static bool IsInsideBox(Vector3 v, Vector3 min, Vector3 max)
         {
-            return v.X >= min.X & v.Y >= min.Y && v.Z >= min.Z
+            return v.X >= min.X && v.Y >= min.Y && v.Z >= min.Z
                 && v.X <= max.X && v.Y <= max.Y && v.Z <= max.Z;
         }
 
@@ -1279,12 +1306,12 @@ namespace OpenSim.Framework
 
         public static string dbDir()
         {
-            return Path.Combine("..", Path.Combine("..", "db"));
+            return Path.Combine("..", Path.Combine("..", "var/lib/db"));
         }
 
         public static string cacheDir()
         {
-            return Path.Combine("..", Path.Combine("..", "caches"));
+            return Path.Combine("..", Path.Combine("..", "var/cache"));
         }
 
         public static string configDir()
@@ -1300,7 +1327,7 @@ namespace OpenSim.Framework
 
         public static string logsDir()
         {
-            return Path.Combine("..", "logs");
+            return Path.Combine("..", "var/log");
         }
 
         public static string webDir()
@@ -1935,7 +1962,9 @@ namespace OpenSim.Framework
             string ru = String.Empty;
 
             if (Environment.OSVersion.Platform == PlatformID.Unix)
-                ru = "Unix/Mono";
+            {
+               ru = "Unix/Mono";
+            }
             else
                 if (Environment.OSVersion.Platform == PlatformID.MacOSX)
                     ru = "OSX/Mono";
@@ -2385,6 +2414,38 @@ namespace OpenSim.Framework
             return sb.ToString();
         }
 
+        public static bool TryParseHttpRange(string header, out int start, out int end)
+        {
+            start = end = 0;
+
+            if (header.StartsWith("bytes="))
+            {
+                string[] rangeValues = header.Substring(6).Split('-');
+
+                if (rangeValues.Length == 2)
+                {
+                    string rawStart = rangeValues[0].Trim();
+                    if (rawStart != "" && !Int32.TryParse(rawStart, out start))
+                        return false;
+
+                    if (start < 0)
+                        return false;
+
+                    string rawEnd = rangeValues[1].Trim();
+                    if (rawEnd == "")
+                    {
+                        end = -1;
+                        return true;
+                    }
+                    else if (Int32.TryParse(rawEnd, out end))
+                        return end > 0;
+                }
+            }
+
+            start = end = 0;
+            return false;
+        }
+
         /// <summary>
         /// Used to trigger an early library load on Windows systems.
         /// </summary>
@@ -2408,53 +2469,6 @@ namespace OpenSim.Framework
 
         #region FireAndForget Threading Pattern
 
-        /// <summary>
-        /// Created to work around a limitation in Mono with nested delegates
-        /// </summary>
-        private sealed class FireAndForgetWrapper
-        {
-            private static volatile FireAndForgetWrapper instance;
-            private static object syncRoot = new Object();
-
-            public static FireAndForgetWrapper Instance {
-                get {
-
-                    if (instance == null)
-                    {
-                        lock (syncRoot)
-                        {
-                            if (instance == null)
-                            {
-                                instance = new FireAndForgetWrapper();
-                            }
-                        }
-                    }
-
-                    return instance;
-                }
-            }
-
-            public void FireAndForget(System.Threading.WaitCallback callback)
-            {
-                callback.BeginInvoke(null, EndFireAndForget, callback);
-            }
-
-            public void FireAndForget(System.Threading.WaitCallback callback, object obj)
-            {
-                callback.BeginInvoke(obj, EndFireAndForget, callback);
-            }
-
-            private static void EndFireAndForget(IAsyncResult ar)
-            {
-                System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState;
-
-                try { callback.EndInvoke(ar); }
-                catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); }
-
-                ar.AsyncWaitHandle.Close();
-            }
-        }
-
         public static void InitThreadPool(int minThreads, int maxThreads)
         {
             if (maxThreads < 2)
@@ -2485,16 +2499,17 @@ namespace OpenSim.Framework
 
             switch (FireAndForgetMethod)
             {
-                case FireAndForgetMethod.UnsafeQueueUserWorkItem:
                 case FireAndForgetMethod.QueueUserWorkItem:
-                case FireAndForgetMethod.BeginInvoke:
                     int workerThreads, iocpThreads;
                     ThreadPool.GetAvailableThreads(out workerThreads, out iocpThreads);
                     return workerThreads;
                 case FireAndForgetMethod.SmartThreadPool:
                     return m_ThreadPool.MaxThreads - m_ThreadPool.InUseThreads;
                 case FireAndForgetMethod.Thread:
-                    return MAX_SYSTEM_THREADS - System.Diagnostics.Process.GetCurrentProcess().Threads.Count;
+                {
+                    using(Process p = System.Diagnostics.Process.GetCurrentProcess())
+                        return MAX_SYSTEM_THREADS - p.Threads.Count;
+                }
                 default:
                     throw new NotImplementedException();
             }
@@ -2641,20 +2656,6 @@ namespace OpenSim.Framework
         public static void FireAndForget(System.Threading.WaitCallback callback, object obj, string context, bool dotimeout = true)
         {
             Interlocked.Increment(ref numTotalThreadFuncsCalled);
-/*
-            if (context != null)
-            {
-                if (!m_fireAndForgetCallsMade.ContainsKey(context))
-                    m_fireAndForgetCallsMade[context] = 1;
-                else
-                    m_fireAndForgetCallsMade[context]++;
-
-                if (!m_fireAndForgetCallsInProgress.ContainsKey(context))
-                    m_fireAndForgetCallsInProgress[context] = 1;
-                else
-                    m_fireAndForgetCallsInProgress[context]++;
-            }
-*/
             WaitCallback realCallback;
 
             bool loggingEnabled = LogThreadPool > 0;
@@ -2670,9 +2671,6 @@ namespace OpenSim.Framework
                     {
                         Culture.SetCurrentCulture();
                         callback(o);
-
-//                        if (context != null)
-//                            m_fireAndForgetCallsInProgress[context]--;
                     };
             }
             else
@@ -2693,7 +2691,6 @@ namespace OpenSim.Framework
                             m_log.DebugFormat("Run threadfunc {0} (Queued {1}, Running {2})", threadFuncNum, numQueued1, numRunning1);
 
                         Culture.SetCurrentCulture();
-
                         callback(o);
                     }
                     catch (ThreadAbortException)
@@ -2711,9 +2708,6 @@ namespace OpenSim.Framework
                         activeThreads.TryRemove(threadFuncNum, out dummy);
                         if ((loggingEnabled || (threadFuncOverloadMode == 1)) && threadInfo.LogThread)
                             m_log.DebugFormat("Exit threadfunc {0} ({1})", threadFuncNum, FormatDuration(threadInfo.Elapsed()));
-
-//                        if (context != null)
-//                            m_fireAndForgetCallsInProgress[context]--;
                     }
                 };
             }
@@ -2721,45 +2715,7 @@ namespace OpenSim.Framework
             long numQueued = Interlocked.Increment(ref numQueuedThreadFuncs);
             try
             {
-/*
-                long numRunning = numRunningThreadFuncs;
-
-                if (m_ThreadPool != null && LogOverloads)
-                {
-                    if ((threadFuncOverloadMode == 0) && (numRunning >= m_ThreadPool.MaxThreads))
-                    {
-                        if (Interlocked.CompareExchange(ref threadFuncOverloadMode, 1, 0) == 0)
-                            m_log.DebugFormat("Threadfunc: enable overload mode (Queued {0}, Running {1})", numQueued, numRunning);
-                    }
-                    else if ((threadFuncOverloadMode == 1) && (numRunning <= (m_ThreadPool.MaxThreads * 2) / 3))
-                    {
-                        if (Interlocked.CompareExchange(ref threadFuncOverloadMode, 0, 1) == 1)
-                            m_log.DebugFormat("Threadfunc: disable overload mode (Queued {0}, Running {1})", numQueued, numRunning);
-                    }
-                }
-
-                if (loggingEnabled || (threadFuncOverloadMode == 1))
-                {
-                    string full, partial;
-                    GetFireAndForgetStackTrace(out full, out partial);
-                    threadInfo.StackTrace = full;
-                    threadInfo.LogThread = ShouldLogThread(partial);
-
-                    if (threadInfo.LogThread)
-                    {
-                        m_log.DebugFormat("Queue threadfunc {0} (Queued {1}, Running {2}) {3}{4}",
-                            threadFuncNum, numQueued, numRunningThreadFuncs,
-                            (context == null) ? "" : ("(" + context + ") "),
-                            (LogThreadPool >= 2) ? full : partial);
-                    }
-                }
-                else
-*/
-                {
-                    // Since we didn't log "Queue threadfunc", don't log "Run threadfunc" or "End threadfunc" either.
-                    // Those log lines aren't useful when we don't know which function is running in the thread.
-                    threadInfo.LogThread = false;
-                }
+                threadInfo.LogThread = false;
 
                 switch (FireAndForgetMethod)
                 {
@@ -2767,16 +2723,9 @@ namespace OpenSim.Framework
                     case FireAndForgetMethod.None:
                         realCallback.Invoke(obj);
                         break;
-                    case FireAndForgetMethod.UnsafeQueueUserWorkItem:
-                        ThreadPool.UnsafeQueueUserWorkItem(realCallback, obj);
-                        break;
                     case FireAndForgetMethod.QueueUserWorkItem:
                         ThreadPool.QueueUserWorkItem(realCallback, obj);
                         break;
-                    case FireAndForgetMethod.BeginInvoke:
-                        FireAndForgetWrapper wrapper = FireAndForgetWrapper.Instance;
-                        wrapper.FireAndForget(realCallback, obj);
-                        break;
                     case FireAndForgetMethod.SmartThreadPool:
                         if (m_ThreadPool == null)
                             InitThreadPool(2, 15);
@@ -2879,6 +2828,12 @@ namespace OpenSim.Framework
         /// <returns>The stack trace, or null if failed to get it</returns>
         private static StackTrace GetStackTrace(Thread targetThread)
         {
+
+            return null;
+/*
+        not only this does not work on mono but it is not longer recomended on windows.
+        can cause deadlocks etc.
+
             if (IsPlatformMono)
             {
                 // This doesn't work in Mono
@@ -2941,6 +2896,7 @@ namespace OpenSim.Framework
                 // Signal the fallack-thread to stop
                 exitedSafely.Set();
             }
+*/
         }
 #pragma warning restore 0618
 
@@ -3038,16 +2994,37 @@ namespace OpenSim.Framework
             return tcA - tcB;
         }
 
+        public static long GetPhysicalMemUse()
+        {
+            using (Process p = System.Diagnostics.Process.GetCurrentProcess())
+                return p.WorkingSet64;
+        }
+
         // returns a timestamp in ms as double
         // using the time resolution avaiable to StopWatch
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]  
         public static double GetTimeStamp()
         {
-            return (double)Stopwatch.GetTimestamp() * TimeStampClockPeriod;
+            return Stopwatch.GetTimestamp() * TimeStampClockPeriod;
         }
 
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static double GetTimeStampMS()
         {
-            return (double)Stopwatch.GetTimestamp() * TimeStampClockPeriodMS;
+            return Stopwatch.GetTimestamp() * TimeStampClockPeriodMS;
+        }
+
+        // doing math in ticks is usefull to avoid loss of resolution
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static long GetTimeStampTicks()
+        {
+            return Stopwatch.GetTimestamp();
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static double TimeStampTicksToMS(long ticks)
+        {
+            return ticks * TimeStampClockPeriodMS;
         }
 
         /// <summary>
@@ -3428,9 +3405,46 @@ namespace OpenSim.Framework
             if (length > 2000)
                 xml = xml.Substring(0, 2000) + "...";
 
+            for (int i = 0 ; i < xml.Length ; i++)
+            {
+                if (xml[i] < 0x20)
+                {
+                    xml = "Unprintable binary data";
+                    break;
+                }
+            }
+
             m_log.ErrorFormat("{0} Failed XML ({1} bytes) = {2}", message, length, xml);
         }
 
+        /// <summary>
+        /// Performs a high quality image resize
+        /// </summary>
+        /// <param name="image">Image to resize</param>
+        /// <param name="width">New width</param>
+        /// <param name="height">New height</param>
+        /// <returns>Resized image</returns>
+        public static Bitmap ResizeImageSolid(Image image, int width, int height)
+        {
+            Bitmap result = new Bitmap(width, height, PixelFormat.Format24bppRgb);
+
+            using (ImageAttributes atrib = new ImageAttributes())
+            using (Graphics graphics = Graphics.FromImage(result))
+            {
+                atrib.SetWrapMode(System.Drawing.Drawing2D.WrapMode.TileFlipXY);
+                atrib.SetWrapMode(System.Drawing.Drawing2D.WrapMode.TileFlipXY);
+                graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
+                graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
+                graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+                graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.None;
+
+                graphics.DrawImage(image,new Rectangle(0,0, result.Width, result.Height),
+                    0, 0, image.Width, image.Height, GraphicsUnit.Pixel, atrib);
+            }
+
+            return result;
+        }
+
     }
 
 /*  don't like this code
@@ -3595,5 +3609,6 @@ namespace OpenSim.Framework
         {
             rng.GetBytes(buff);
         }
+
     }
 }