8 files changed, 269 insertions, 293 deletions

diff --git a/OpenSim/Framework/ConfigSettings.cs b/OpenSim/Framework/ConfigSettings.cs
index 32415e0..93efffa 100644
--- a/OpenSim/Framework/ConfigSettings.cs
+++ b/OpenSim/Framework/ConfigSettings.cs
@@ -168,7 +168,7 @@ namespace OpenSim.Framework
         public const bool DefaultUserServerHttpSSL = false;
         public const uint DefaultMessageServerHttpPort = 8006;
         public const bool DefaultMessageServerHttpSSL = false;
-        public const uint DefaultGridServerHttpPort = 8003;
-        public const uint DefaultInventoryServerHttpPort = 8003;
+        public const uint DefaultGridServerHttpPort = 8001;
+        public const uint DefaultInventoryServerHttpPort = 8004;
     }
 }
diff --git a/OpenSim/Framework/InventoryConfig.cs b/OpenSim/Framework/InventoryConfig.cs
index dd207ad..f539d55 100644
--- a/OpenSim/Framework/InventoryConfig.cs
+++ b/OpenSim/Framework/InventoryConfig.cs
@@ -56,15 +56,15 @@ namespace OpenSim.Framework
             m_configMember.addConfigurationOption("default_inventory_server",
                                                 ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY,
                                                 "Default Inventory Server URI (this server's external name)",
-                                                "http://127.0.0.1:" + ConfigSettings.DefaultInventoryServerHttpPort, false);
+                                                "http://127.0.0.1:8004", false);
             m_configMember.addConfigurationOption("default_user_server",
                                                 ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY,
                                                 "Default User Server URI",
-                                                "http://127.0.0.1:" + ConfigSettings.DefaultUserServerHttpPort, false);
+                                                "http://127.0.0.1:8002", false);
             m_configMember.addConfigurationOption("default_asset_server",
                                                 ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY,
                                                 "Default Asset Server URI",
-                                                "http://127.0.0.1:" + ConfigSettings.DefaultAssetServerHttpPort, false);
+                                                "http://127.0.0.1:8003", false);
             m_configMember.addConfigurationOption("database_provider", ConfigurationOption.ConfigurationTypes.TYPE_STRING,
                                                 "DLL for database provider", "OpenSim.Data.MySQL.dll", false);
             m_configMember.addConfigurationOption("database_connect", ConfigurationOption.ConfigurationTypes.TYPE_STRING,
diff --git a/OpenSim/Framework/Parallel.cs b/OpenSim/Framework/Parallel.cs
new file mode 100644
index 0000000..74537ba
--- /dev/null
+++ b/OpenSim/Framework/Parallel.cs
@@ -0,0 +1,207 @@
+/*
+ * 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.Threading;
+
+namespace OpenSim.Framework
+{
+    /// <summary>
+    /// Provides helper methods for parallelizing loops
+    /// </summary>
+    public static class Parallel
+    {
+        private static readonly int processorCount = System.Environment.ProcessorCount;
+
+        /// <summary>
+        /// Executes a for loop in which iterations may run in parallel
+        /// </summary>
+        /// <param name="fromInclusive">The loop will be started at this index</param>
+        /// <param name="toExclusive">The loop will be terminated before this index is reached</param>
+        /// <param name="body">Method body to run for each iteration of the loop</param>
+        public static void For(int fromInclusive, int toExclusive, Action<int> body)
+        {
+            For(processorCount, fromInclusive, toExclusive, body);
+        }
+
+        /// <summary>
+        /// Executes a for loop in which iterations may run in parallel
+        /// </summary>
+        /// <param name="threadCount">The number of concurrent execution threads to run</param>
+        /// <param name="fromInclusive">The loop will be started at this index</param>
+        /// <param name="toExclusive">The loop will be terminated before this index is reached</param>
+        /// <param name="body">Method body to run for each iteration of the loop</param>
+        public static void For(int threadCount, int fromInclusive, int toExclusive, Action<int> body)
+        {
+            int counter = threadCount;
+            AutoResetEvent threadFinishEvent = new AutoResetEvent(false);
+            Exception exception = null;
+
+            --fromInclusive;
+
+            for (int i = 0; i < threadCount; i++)
+            {
+                ThreadPool.QueueUserWorkItem(
+                    delegate(object o)
+                    {
+                        int threadIndex = (int)o;
+
+                        while (exception == null)
+                        {
+                            int currentIndex = Interlocked.Increment(ref fromInclusive);
+
+                            if (currentIndex >= toExclusive)
+                                break;
+
+                            try { body(currentIndex); }
+                            catch (Exception ex) { exception = ex; break; }
+                        }
+
+                        if (Interlocked.Decrement(ref counter) == 0)
+                            threadFinishEvent.Set();
+                    }, i
+                );
+            }
+
+            threadFinishEvent.WaitOne();
+
+            if (exception != null)
+                throw new Exception(exception.Message, exception);
+        }
+
+        /// <summary>
+        /// Executes a foreach loop in which iterations may run in parallel
+        /// </summary>
+        /// <typeparam name="T">Object type that the collection wraps</typeparam>
+        /// <param name="enumerable">An enumerable collection to iterate over</param>
+        /// <param name="body">Method body to run for each object in the collection</param>
+        public static void ForEach<T>(IEnumerable<T> enumerable, Action<T> body)
+        {
+            ForEach<T>(processorCount, enumerable, body);
+        }
+
+        /// <summary>
+        /// Executes a foreach loop in which iterations may run in parallel
+        /// </summary>
+        /// <typeparam name="T">Object type that the collection wraps</typeparam>
+        /// <param name="threadCount">The number of concurrent execution threads to run</param>
+        /// <param name="enumerable">An enumerable collection to iterate over</param>
+        /// <param name="body">Method body to run for each object in the collection</param>
+        public static void ForEach<T>(int threadCount, IEnumerable<T> enumerable, Action<T> body)
+        {
+            int counter = threadCount;
+            AutoResetEvent threadFinishEvent = new AutoResetEvent(false);
+            IEnumerator<T> enumerator = enumerable.GetEnumerator();
+            Exception exception = null;
+
+            for (int i = 0; i < threadCount; i++)
+            {
+                ThreadPool.QueueUserWorkItem(
+                    delegate(object o)
+                    {
+                        int threadIndex = (int)o;
+
+                        while (exception == null)
+                        {
+                            T entry;
+
+                            lock (enumerator)
+                            {
+                                if (!enumerator.MoveNext())
+                                    break;
+                                entry = (T)enumerator.Current; // Explicit typecast for Mono's sake
+                            }
+
+                            try { body(entry); }
+                            catch (Exception ex) { exception = ex; break; }
+                        }
+
+                        if (Interlocked.Decrement(ref counter) == 0)
+                            threadFinishEvent.Set();
+                    }, i
+                );
+            }
+
+            threadFinishEvent.WaitOne();
+
+            if (exception != null)
+                throw new Exception(exception.Message, exception);
+        }
+
+        /// <summary>
+        /// Executes a series of tasks in parallel
+        /// </summary>
+        /// <param name="actions">A series of method bodies to execute</param>
+        public static void Invoke(params Action[] actions)
+        {
+            Invoke(processorCount, actions);
+        }
+
+        /// <summary>
+        /// Executes a series of tasks in parallel
+        /// </summary>
+        /// <param name="threadCount">The number of concurrent execution threads to run</param>
+        /// <param name="actions">A series of method bodies to execute</param>
+        public static void Invoke(int threadCount, params Action[] actions)
+        {
+            int counter = threadCount;
+            AutoResetEvent threadFinishEvent = new AutoResetEvent(false);
+            int index = -1;
+            Exception exception = null;
+
+            for (int i = 0; i < threadCount; i++)
+            {
+                ThreadPool.QueueUserWorkItem(
+                    delegate(object o)
+                    {
+                        int threadIndex = (int)o;
+
+                        while (exception == null)
+                        {
+                            int currentIndex = Interlocked.Increment(ref index);
+
+                            if (currentIndex >= actions.Length)
+                                break;
+
+                            try { actions[currentIndex](); }
+                            catch (Exception ex) { exception = ex; break; }
+                        }
+
+                        if (Interlocked.Decrement(ref counter) == 0)
+                            threadFinishEvent.Set();
+                    }, i
+                );
+            }
+
+            threadFinishEvent.WaitOne();
+
+            if (exception != null)
+                throw new Exception(exception.Message, exception);
+        }
+    }
+}
diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index 56155dd..845a9fe 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 using System.Text;
@@ -109,9 +110,8 @@ namespace OpenSim.Framework.Servers
             m_periodicDiagnosticsTimer.Elapsed += new ElapsedEventHandler(LogDiagnostics);
             m_periodicDiagnosticsTimer.Enabled = true;
 
-            // Add ourselves to thread monitoring.  This thread will go on to become the console listening thread
+            // This thread will go on to become the console listening thread
             Thread.CurrentThread.Name = "ConsoleThread";
-            ThreadTracker.Add(Thread.CurrentThread);
 
             ILoggerRepository repository = LogManager.GetRepository();
             IAppender[] appenders = repository.GetAppenders();
@@ -235,7 +235,7 @@ namespace OpenSim.Framework.Servers
         {
             StringBuilder sb = new StringBuilder();
 
-            List<Thread> threads = ThreadTracker.GetThreads();
+            ProcessThreadCollection threads = ThreadTracker.GetThreads();
             if (threads == null)
             {
                 sb.Append("OpenSim thread tracking is only enabled in DEBUG mode.");
@@ -243,25 +243,15 @@ namespace OpenSim.Framework.Servers
             else
             {
                 sb.Append(threads.Count + " threads are being tracked:" + Environment.NewLine);
-                foreach (Thread t in threads)
+                foreach (ProcessThread t in threads)
                 {
-                    if (t.IsAlive)
-                    {
-                        sb.Append(
-                            "ID: " + t.ManagedThreadId + ", Name: " + t.Name + ", Alive: " + t.IsAlive
-                            + ", Pri: " + t.Priority + ", State: " + t.ThreadState + Environment.NewLine);
-                    }
+                    sb.Append("ID: " + t.Id + ", TotalProcessorTime: " + t.TotalProcessorTime + ", TimeRunning: " +
+                        (DateTime.Now - t.StartTime) + ", Pri: " + t.CurrentPriority + ", State: " + t.ThreadState );
+                    if (t.ThreadState == System.Diagnostics.ThreadState.Wait)
+                        sb.Append(", Reason: " + t.WaitReason + Environment.NewLine);
                     else
-                    {
-                        try
-                        {
-                            sb.Append("ID: " + t.ManagedThreadId + ", Name: " + t.Name + ", DEAD" + Environment.NewLine);
-                        }
-                        catch
-                        {
-                            sb.Append("THREAD ERROR" + Environment.NewLine);
-                        }
-                    }
+                        sb.Append(Environment.NewLine);
+
                 }
             }
             int workers = 0, ports = 0, maxWorkers = 0, maxPorts = 0;
diff --git a/OpenSim/Framework/Tests/ThreadTrackerTests.cs b/OpenSim/Framework/Tests/ThreadTrackerTests.cs
index 15d5b73..7eb83e6 100644
--- a/OpenSim/Framework/Tests/ThreadTrackerTests.cs
+++ b/OpenSim/Framework/Tests/ThreadTrackerTests.cs
@@ -41,7 +41,7 @@ namespace OpenSim.Framework.Tests
         [Test]
         public void DefaultThreadTrackerTest()
         {
-            List<Thread> lThread = ThreadTracker.GetThreads();
+            System.Diagnostics.ProcessThreadCollection lThread = ThreadTracker.GetThreads();
             
             /*
             foreach (Thread t in lThread)
@@ -50,143 +50,7 @@ namespace OpenSim.Framework.Tests
             }
             */
 
-            Assert.That(lThread.Count == 1);
-            Assert.That(lThread[0].Name == "ThreadTrackerThread");
+            Assert.That(lThread.Count > 0);
         }
-
-        /// <summary>
-        /// Validate that adding a thread to the thread tracker works
-        /// Validate that removing a thread from the thread tracker also works.
-        /// </summary>
-        [Test]
-        public void AddThreadToThreadTrackerTestAndRemoveTest()
-        {
-            Thread t = new Thread(run);
-            t.Name = "TestThread";
-            t.Priority = ThreadPriority.BelowNormal;
-            t.IsBackground = true;
-            t.SetApartmentState(ApartmentState.MTA);
-            t.Start();
-            ThreadTracker.Add(t);
-
-            List<Thread> lThread = ThreadTracker.GetThreads();
-
-            Assert.That(lThread.Count == 2);
-
-            foreach (Thread tr in lThread)
-            {
-                Assert.That((tr.Name == "ThreadTrackerThread" || tr.Name == "TestThread"));
-            }
-            running = false;
-            ThreadTracker.Remove(t);
-
-            lThread = ThreadTracker.GetThreads();
-
-            Assert.That(lThread.Count == 1);
-
-            foreach (Thread tr in lThread)
-            {
-                Assert.That((tr.Name == "ThreadTrackerThread"));
-            }
-
-
-        }
-
-        /// <summary>
-        /// Test a dead thread removal by aborting it and setting it's last seen active date to 50 seconds
-        /// </summary>
-        [Test]
-        public void DeadThreadTest()
-        {
-            Thread t = new Thread(run2);
-            t.Name = "TestThread";
-            t.Priority = ThreadPriority.BelowNormal;
-            t.IsBackground = true;
-            t.SetApartmentState(ApartmentState.MTA);
-            t.Start();
-            ThreadTracker.Add(t);
-            t.Abort();
-            Thread.Sleep(5000);
-            ThreadTracker.m_Threads[1].LastSeenActive = DateTime.Now.Ticks - (50*10000000);
-            ThreadTracker.CleanUp();
-            List<Thread> lThread = ThreadTracker.GetThreads();
-
-            Assert.That(lThread.Count == 1);
-
-            foreach (Thread tr in lThread)
-            {
-                Assert.That((tr.Name == "ThreadTrackerThread"));
-            }
-        }
-
-        [Test]
-        public void UnstartedThreadTest()
-        {
-            Thread t = new Thread(run2);
-            t.Name = "TestThread";
-            t.Priority = ThreadPriority.BelowNormal;
-            t.IsBackground = true;
-            t.SetApartmentState(ApartmentState.MTA);
-            ThreadTracker.Add(t);
-            ThreadTracker.m_Threads[1].LastSeenActive = DateTime.Now.Ticks - (50 * 10000000);
-            ThreadTracker.CleanUp();
-            List<Thread> lThread = ThreadTracker.GetThreads();
-
-            Assert.That(lThread.Count == 1);
-
-            foreach (Thread tr in lThread)
-            {
-                Assert.That((tr.Name == "ThreadTrackerThread"));
-            }
-        }
-
-        [Test]
-        public void NullThreadTest()
-        {
-            Thread t = null;
-            ThreadTracker.Add(t);
-            
-            List<Thread> lThread = ThreadTracker.GetThreads();
-
-            Assert.That(lThread.Count == 1);
-
-            foreach (Thread tr in lThread)
-            {
-                Assert.That((tr.Name == "ThreadTrackerThread"));
-            }
-        }
-
-
-        /// <summary>
-        /// Worker thread 0
-        /// </summary>
-        /// <param name="o"></param>
-        public void run(object o)
-        {
-            while (running)
-            {
-                Thread.Sleep(5000);
-            }
-        }
-
-        /// <summary>
-        /// Worker thread 1
-        /// </summary>
-        /// <param name="o"></param>
-        public void run2(object o)
-        {
-            try
-            {
-                while (running2)
-                {
-                    Thread.Sleep(5000);
-                }
-
-            } 
-            catch (ThreadAbortException)
-            {
-            }
-        }
-
     }
 }
diff --git a/OpenSim/Framework/ThreadTracker.cs b/OpenSim/Framework/ThreadTracker.cs
index d3a239d..b68d9b3 100644
--- a/OpenSim/Framework/ThreadTracker.cs
+++ b/OpenSim/Framework/ThreadTracker.cs
@@ -26,138 +26,21 @@
  */
 
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
-using System.Threading;
+using System.Diagnostics;
 using log4net;
 
 namespace OpenSim.Framework
 {
     public static class ThreadTracker
     {
-        private static readonly ILog m_log
-            = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        private static readonly long ThreadTimeout = 30 * 10000000;
-        public static List<ThreadTrackerItem> m_Threads;
-        public static Thread ThreadTrackerThread;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        static ThreadTracker()
+        public static ProcessThreadCollection GetThreads()
         {
-#if DEBUG
-            m_Threads = new List<ThreadTrackerItem>();
-            ThreadTrackerThread = new Thread(ThreadTrackerThreadLoop);
-            ThreadTrackerThread.Name = "ThreadTrackerThread";
-            ThreadTrackerThread.IsBackground = true;
-            ThreadTrackerThread.Priority = ThreadPriority.BelowNormal;
-            ThreadTrackerThread.Start();
-            Add(ThreadTrackerThread);
-#endif
+            Process thisProc = Process.GetCurrentProcess();
+            return thisProc.Threads;
         }
-
-        private static void ThreadTrackerThreadLoop()
-        {
-            try
-            {
-                while (true)
-                {
-                    Thread.Sleep(5000);
-                    CleanUp();
-                }
-            }
-            catch (Exception e)
-            {
-                m_log.ErrorFormat(
-                    "[THREAD TRACKER]: Thread tracker cleanup thread terminating with exception.  Please report this error.  Exception is {0}", 
-                    e);
-            }
-        }
-
-        public static void Add(Thread thread)
-        {
-#if DEBUG
-            if (thread != null)
-            {
-                lock (m_Threads)
-                {
-                    ThreadTrackerItem tti = new ThreadTrackerItem();
-                    tti.Thread = thread;
-                    tti.LastSeenActive = DateTime.Now.Ticks;
-                    m_Threads.Add(tti);
-                }
-            }
-#endif
-        }
-
-        public static void Remove(Thread thread)
-        {
-#if DEBUG
-            lock (m_Threads)
-            {
-                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
-                {
-                    if (tti.Thread == thread)
-                        m_Threads.Remove(tti);
-                }
-            }
-#endif
-        }
-
-        public static void CleanUp()
-        {
-            lock (m_Threads)
-            {
-                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
-                {
-                    try
-                    {
-                        
-                    
-                        if (tti.Thread.IsAlive)
-                        {
-                            // Its active
-                            tti.LastSeenActive = DateTime.Now.Ticks;
-                        }
-                        else
-                        {
-                            // Its not active -- if its expired then remove it
-                            if (tti.LastSeenActive + ThreadTimeout < DateTime.Now.Ticks)
-                                m_Threads.Remove(tti);
-                        }
-                    }
-                    catch (NullReferenceException)
-                    {
-                        m_Threads.Remove(tti);
-                    }
-                }
-            }
-        }
-
-        public static List<Thread> GetThreads()
-        {
-            if (m_Threads == null)
-                return null;
-
-            List<Thread> threads = new List<Thread>();
-            lock (m_Threads)
-            {
-                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
-                {
-                    threads.Add(tti.Thread);
-                }
-            }
-            return threads;
-        }
-
-        #region Nested type: ThreadTrackerItem
-
-        public class ThreadTrackerItem
-        {
-            public long LastSeenActive;
-            public Thread Thread;
-        }
-
-        #endregion
     }
 }
diff --git a/OpenSim/Framework/ThrottleOutPacketType.cs b/OpenSim/Framework/ThrottleOutPacketType.cs
index 0843757..fd490a5 100644
--- a/OpenSim/Framework/ThrottleOutPacketType.cs
+++ b/OpenSim/Framework/ThrottleOutPacketType.cs
@@ -29,9 +29,9 @@ using System;
 
 namespace OpenSim.Framework
 {
-    [Flags]
     public enum ThrottleOutPacketType : int
     {
+        Unknown = -1, // Also doubles as 'do not throttle'
         Resend = 0,
         Land = 1,
         Wind = 2,
@@ -39,11 +39,5 @@ namespace OpenSim.Framework
         Task = 4,
         Texture = 5,
         Asset = 6,
-        Unknown = 7, // Also doubles as 'do not throttle'
-        Back = 8,
-
-        TypeMask = 15, // The mask to mask off the flags
-
-        LowPriority = 128 // Additional flags
     }
 }
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 0851d26..38729c6 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -1231,6 +1231,42 @@ namespace OpenSim.Framework
             return (ipaddr1 != null) ? "http://" + ipaddr1.ToString() + ":" + port1 : uri;
         }
 
+        public static byte[] StringToBytes256(string str)
+        {
+            if (String.IsNullOrEmpty(str)) { return Utils.EmptyBytes; }
+            if (str.Length > 254) str = str.Remove(254);
+            if (!str.EndsWith("\0")) { str += "\0"; }
+            
+            // Because this is UTF-8 encoding and not ASCII, it's possible we
+            // might have gotten an oversized array even after the string trim
+            byte[] data = UTF8.GetBytes(str);
+            if (data.Length > 256)
+            {
+                Array.Resize<byte>(ref data, 256);
+                data[255] = 0;
+            }
+
+            return data;
+        }
+
+        public static byte[] StringToBytes1024(string str)
+        {
+            if (String.IsNullOrEmpty(str)) { return Utils.EmptyBytes; }
+            if (str.Length > 1023) str = str.Remove(1023);
+            if (!str.EndsWith("\0")) { str += "\0"; }
+
+            // Because this is UTF-8 encoding and not ASCII, it's possible we
+            // might have gotten an oversized array even after the string trim
+            byte[] data = UTF8.GetBytes(str);
+            if (data.Length > 1024)
+            {
+                Array.Resize<byte>(ref data, 1024);
+                data[1023] = 0;
+            }
+
+            return data;
+        }
+
         #region FireAndForget Threading Pattern
 
         public static void FireAndForget(System.Threading.WaitCallback callback)
@@ -1247,7 +1283,9 @@ namespace OpenSim.Framework
         {
             System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState;
 
-            callback.EndInvoke(ar);
+            try { callback.EndInvoke(ar); }
+            catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); }
+
             ar.AsyncWaitHandle.Close();
         }