Merge branch 'master' of opensimulator.org:/var/git/opensim

11 files changed, 449 insertions, 308 deletions

diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index f761813..f832f81 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -33,6 +33,9 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Timers;
+using System.Net;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
 using log4net;
 using log4net.Appender;
 using log4net.Core;
@@ -86,6 +89,26 @@ namespace OpenSim.Framework.Servers
             m_osSecret = UUID.Random().ToString();
         }
 
+        private static bool m_NoVerifyCertChain = false;
+        private static bool m_NoVerifyCertHostname = false;
+
+        public static bool ValidateServerCertificate(
+            object sender,
+            X509Certificate certificate,
+            X509Chain chain,
+            SslPolicyErrors sslPolicyErrors)
+        {
+            if (m_NoVerifyCertChain)
+                sslPolicyErrors &= ~SslPolicyErrors.RemoteCertificateChainErrors;
+ 
+            if (m_NoVerifyCertHostname)
+                sslPolicyErrors &= ~SslPolicyErrors.RemoteCertificateNameMismatch;
+
+            if (sslPolicyErrors == SslPolicyErrors.None)
+                return true;
+
+            return false;
+        }             
         /// <summary>
         /// Must be overriden by child classes for their own server specific startup behaviour.
         /// </summary>
@@ -96,6 +119,11 @@ namespace OpenSim.Framework.Servers
             RegisterCommonComponents(Config);
 
             IConfig startupConfig = Config.Configs["Startup"];
+
+            m_NoVerifyCertChain = startupConfig.GetBoolean("NoVerifyCertChain", m_NoVerifyCertChain);
+            m_NoVerifyCertHostname = startupConfig.GetBoolean("NoVerifyCertHostname", m_NoVerifyCertHostname);
+            ServicePointManager.ServerCertificateValidationCallback = ValidateServerCertificate;
+
             int logShowStatsSeconds = startupConfig.GetInt("LogShowStatsSeconds", m_periodDiagnosticTimerMS / 1000);
             m_periodDiagnosticTimerMS = logShowStatsSeconds * 1000;
             m_periodicDiagnosticsTimer.Elapsed += new ElapsedEventHandler(LogDiagnostics);
@@ -108,13 +136,21 @@ namespace OpenSim.Framework.Servers
 
         protected override void ShutdownSpecific()
         {
-            m_log.Info("[SHUTDOWN]: Shutdown processing on main thread complete.  Exiting...");
+            Watchdog.Enabled = false;
+            base.ShutdownSpecific();
+            
+            MainServer.Stop();
+
+            Thread.Sleep(5000);
+            Util.StopThreadPool();
+            WorkManager.Stop();
 
+            Thread.Sleep(1000);
             RemovePIDFile();
 
-            base.ShutdownSpecific();
+            m_log.Info("[SHUTDOWN]: Shutdown processing on main thread complete.  Exiting...");
 
-            if (!SuppressExit)
+           if (!SuppressExit)
                 Environment.Exit(0);
         }
 
@@ -163,8 +199,7 @@ namespace OpenSim.Framework.Servers
             }
             catch(Exception e)
             {
-                m_log.FatalFormat("Fatal error: {0}",
-                    (e.Message == null || e.Message == String.Empty) ? "Unknown reason":e.Message );
+                m_log.Fatal("Fatal error: " + e.ToString());
                 Environment.Exit(1);
             }
 
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index fb92b92..2819bc9 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -32,6 +32,7 @@ using System.Collections.Specialized;
 using System.IO;
 using System.Net;
 using System.Net.Sockets;
+using System.Net.Security;
 using System.Security.Cryptography.X509Certificates;
 using System.Reflection;
 using System.Globalization;
@@ -43,10 +44,11 @@ using log4net;
 using Nwc.XmlRpc;
 using OpenMetaverse.StructuredData;
 using CoolHTTPListener = HttpServer.HttpListener;
-using HttpListener=System.Net.HttpListener;
-using LogPrio=HttpServer.LogPrio;
+using HttpListener = System.Net.HttpListener;
+using LogPrio = HttpServer.LogPrio;
 using OpenSim.Framework.Monitoring;
 using System.IO.Compression;
+using System.Security.Cryptography;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {
@@ -107,19 +109,26 @@ namespace OpenSim.Framework.Servers.HttpServer
             new Dictionary<string, WebSocketRequestDelegate>();
 
         protected uint m_port;
-        protected uint m_sslport;
         protected bool m_ssl;
         private X509Certificate2 m_cert;
-        protected bool m_firstcaps = true;
         protected string m_SSLCommonName = "";
+        protected List<string> m_certNames = new List<string>();
+        protected List<string> m_certIPs = new List<string>();
+        protected string m_certCN= "";
+        protected RemoteCertificateValidationCallback m_certificateValidationCallback = null;
 
         protected IPAddress m_listenIPAddress = IPAddress.Any;
 
         public PollServiceRequestManager PollServiceRequestManager { get; private set; }
 
+        public string Protocol
+        {
+            get { return m_ssl ? "https://" : "http://"; }
+        }
+
         public uint SSLPort
         {
-            get { return m_sslport; }
+            get { return m_port; }
         }
 
         public string SSLCommonName
@@ -148,27 +157,166 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_port = port;
         }
 
-        public BaseHttpServer(uint port, bool ssl) : this (port)
+        private void load_cert(string CPath, string CPass)
         {
-            m_ssl = ssl;
+            try
+            {
+                 m_cert = new X509Certificate2(CPath, CPass);
+                X509Extension ext = m_cert.Extensions["2.5.29.17"];
+                if(ext != null)
+                {
+                    AsnEncodedData asndata = new AsnEncodedData(ext.Oid, ext.RawData);
+                    string datastr = asndata.Format(true);
+                    string[] lines = datastr.Split(new char[] {'\n','\r'});
+                    foreach(string s in lines)
+                    {
+                        if(String.IsNullOrEmpty(s))
+                            continue;
+                        string[] parts = s.Split(new char[] {'='});
+                        if(String.IsNullOrEmpty(parts[0]))
+                            continue;
+                        string entryName = parts[0].Replace(" ","");
+                        if(entryName == "DNSName")
+                            m_certNames.Add(parts[1]);
+                        else if(entryName == "IPAddress")
+                            m_certIPs.Add(parts[1]);
+                        else if(entryName == "Unknown(135)") // stupid mono
+                        {
+                            try
+                            {
+                                if(parts[1].Length == 8)
+                                {
+                                    long tmp = long.Parse(parts[1], NumberStyles.AllowHexSpecifier);
+                                    tmp = IPAddress.HostToNetworkOrder(tmp);
+                                    tmp = (long)((ulong) tmp >> 32);
+                                    IPAddress ia = new IPAddress(tmp);     
+                                    m_certIPs.Add(ia.ToString());
+                                }
+                            }
+                            catch {}
+                        }
+                    }
+                }
+                m_certCN = m_cert.GetNameInfo(X509NameType.SimpleName, false);
+            }
+            catch
+            {
+                throw new Exception("SSL cert load error");
+            }
         }
 
-        public BaseHttpServer(uint port, bool ssl, uint sslport, string CN) : this (port, ssl)
+        public BaseHttpServer(uint port, bool ssl, string CN, string CPath, string CPass)
         {
-            if (m_ssl)
+            m_port = port;
+            if (ssl)
             {
-                m_sslport = sslport;
+                if(string.IsNullOrEmpty(CPath))
+                    throw new Exception("invalid main http server cert path");
+
+                if(Uri.CheckHostName(CN) == UriHostNameType.Unknown)
+                    throw new Exception("invalid main http server CN (ExternalHostName)");
+
+                m_certNames.Clear();
+                m_certIPs.Clear();
+                m_certCN= "";
+
+                m_ssl = true;
+                load_cert(CPath, CPass);
+                
+                if(!CheckSSLCertHost(CN))
+                    throw new Exception("invalid main http server CN (ExternalHostName)");
+
+                m_SSLCommonName = CN;
+
+                if(m_cert.Issuer == m_cert.Subject )
+                    m_log.Warn("Self signed certificate. Clients need to allow this (some viewers debug option NoVerifySSLcert must be set to true");
             }
+            else
+                m_ssl = false;
         }
 
-        public BaseHttpServer(uint port, bool ssl, string CPath, string CPass) : this (port, ssl)
+        public BaseHttpServer(uint port, bool ssl, string CPath, string CPass)
         {
-            if (m_ssl)
+            m_port = port;
+            if (ssl)
             {
-                m_cert = new X509Certificate2(CPath, CPass);
+                load_cert(CPath, CPass);
+                if(m_cert.Issuer == m_cert.Subject )
+                    m_log.Warn("Self signed certificate. Http clients need to allow this");
+                m_ssl = true;
+            }
+            else
+                m_ssl = false;
+        }
+
+                static bool MatchDNS (string hostname, string dns) 
+                { 
+                        int indx = dns.IndexOf ('*'); 
+                        if (indx == -1)
+                                return (String.Compare(hostname, dns, true, CultureInfo.InvariantCulture) == 0); 
+ 
+            int dnslen = dns.Length;
+            dnslen--;
+            if(indx == dnslen)
+                return true; // just * ?
+
+            if(indx > dnslen - 2)
+                return false; // 2 short ?
+
+                if (dns[indx + 1] != '.') 
+                        return false; 
+  
+                        int indx2 = dns.IndexOf ('*', indx + 1); 
+                        if (indx2 != -1) 
+                                return false; // there can only be one;
+ 
+                        string end = dns.Substring(indx + 1); 
+            int hostlen = hostname.Length;
+            int endlen = end.Length;
+                        int length = hostlen - endlen; 
+                        if (length <= 0) 
+                                return false; 
+
+                        if (String.Compare(hostname, length, end, 0, endlen, true, CultureInfo.InvariantCulture) != 0) 
+                                return false; 
+ 
+                        if (indx == 0)
+            { 
+                                indx2 = hostname.IndexOf ('.'); 
+                                return ((indx2 == -1) || (indx2 >= length)); 
+                        } 
+  
+                        string start = dns.Substring (0, indx); 
+                        return (String.Compare (hostname, 0, start, 0, start.Length, true, CultureInfo.InvariantCulture) == 0); 
+                } 
+
+        public bool CheckSSLCertHost(string hostname)
+        {
+            UriHostNameType htype = Uri.CheckHostName(hostname);
+
+            if(htype == UriHostNameType.Unknown || htype == UriHostNameType.Basic)
+                return false;
+            if(htype == UriHostNameType.Dns)
+            {
+                foreach(string name in m_certNames)
+                {
+                    if(MatchDNS(hostname, name))
+                        return true;
+                }
+                if(MatchDNS(hostname, m_certCN))
+                    return true;
+            }
+            else
+            {
+                foreach(string ip in m_certIPs)
+                {
+                    if (String.Compare(hostname, ip, true, CultureInfo.InvariantCulture) == 0)
+                        return true;
+                }               
             }
-        }
 
+            return false;
+        }
         /// <summary>
         /// Add a stream handler to the http server.  If the handler already exists, then nothing happens.
         /// </summary>
@@ -396,14 +544,10 @@ namespace OpenSim.Framework.Servers.HttpServer
                     if (psEvArgs.Request != null)
                     {
                         OSHttpRequest req = new OSHttpRequest(context, request);
-
-                        Stream requestStream = req.InputStream;
-
+                        string requestBody;
                         Encoding encoding = Encoding.UTF8;
-                        StreamReader reader = new StreamReader(requestStream, encoding);
-
-                        string requestBody = reader.ReadToEnd();
-                        reader.Close();
+                        using(StreamReader reader = new StreamReader(req.InputStream, encoding))
+                            requestBody = reader.ReadToEnd();
 
                         Hashtable keysvals = new Hashtable();
                         Hashtable headervals = new Hashtable();
@@ -461,8 +605,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
 
             OSHttpResponse resp = new OSHttpResponse(new HttpResponse(context, request),context);
-            resp.ReuseContext = true;
-//            resp.ReuseContext = false;
+
             HandleRequest(req, resp);
 
             // !!!HACK ALERT!!!
@@ -494,6 +637,8 @@ namespace OpenSim.Framework.Servers.HttpServer
             {
                 try
                 {
+                    if(request.InputStream != null && request.InputStream.CanRead) 
+                        request.InputStream.Close();
                     byte[] buffer500 = SendHTML500(response);
                     response.OutputStream.Write(buffer500, 0, buffer500.Length);
                     response.Send();
@@ -541,7 +686,6 @@ namespace OpenSim.Framework.Servers.HttpServer
 //                    }
 //                }
 
-                //response.KeepAlive = true;
                 response.SendChunked = false;
 
                 string path = request.RawUrl;
@@ -565,15 +709,11 @@ namespace OpenSim.Framework.Servers.HttpServer
                     {
                         //m_log.Debug("[BASE HTTP SERVER]: Found Caps based HTTP Handler");
                         IGenericHTTPHandler HTTPRequestHandler = requestHandler as IGenericHTTPHandler;
-                        Stream requestStream = request.InputStream;
 
+                        string requestBody;
                         Encoding encoding = Encoding.UTF8;
-                        StreamReader reader = new StreamReader(requestStream, encoding);
-
-                        string requestBody = reader.ReadToEnd();
-
-                        reader.Close();
-                        //requestStream.Close();
+                        using(StreamReader reader = new StreamReader(request.InputStream, encoding))
+                            requestBody = reader.ReadToEnd();
 
                         Hashtable keysvals = new Hashtable();
                         Hashtable headervals = new Hashtable();
@@ -613,7 +753,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                     else
                     {
                         IStreamHandler streamHandler = (IStreamHandler)requestHandler;
-
                         using (MemoryStream memoryStream = new MemoryStream())
                         {
                             streamHandler.Handle(path, request.InputStream, memoryStream, request, response);
@@ -690,7 +829,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                     }
                 }
 
-                request.InputStream.Close();
+                if(request.InputStream != null && request.InputStream.CanRead)
+                    request.InputStream.Dispose();
 
                 if (buffer != null)
                 {
@@ -723,10 +863,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                 requestEndTick = Environment.TickCount;
 
                 response.Send();
-
-                //response.OutputStream.Close();
-
-                //response.FreeContext();
             }
             catch (SocketException e)
             {
@@ -758,6 +894,9 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
             finally
             {
+                if(request.InputStream != null && request.InputStream.CanRead)
+                    request.InputStream.Close();
+
                 // Every month or so this will wrap and give bad numbers, not really a problem
                 // since its just for reporting
                 int tickdiff = requestEndTick - requestStartTick;
@@ -998,7 +1137,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             String requestBody;
 
-            Stream requestStream = request.InputStream;
+            Stream requestStream = Util.Copy(request.InputStream);
             Stream innerStream = null;
             try
             {
@@ -1009,15 +1148,15 @@ namespace OpenSim.Framework.Servers.HttpServer
                 }
 
                 using (StreamReader reader = new StreamReader(requestStream, Encoding.UTF8))
-                {
                     requestBody = reader.ReadToEnd();
+
                 }
-            }
             finally
             {
-                if (innerStream != null)
+                if (innerStream != null && innerStream.CanRead)
                     innerStream.Dispose();
-                requestStream.Dispose();
+                if (requestStream.CanRead)
+                    requestStream.Dispose();
             }
 
             //m_log.Debug(requestBody);
@@ -1098,6 +1237,17 @@ namespace OpenSim.Framework.Servers.HttpServer
 
                         if (gridproxy)
                             xmlRprcRequest.Params.Add("gridproxy");  // Param[4]
+
+                        // reserve this for
+                        // ... by Fumi.Iseki for DTLNSLMoneyServer
+                        // BUT make its presence possible to detect/parse
+                        string rcn = request.IHttpClientContext.SSLCommonName;
+                        if(!string.IsNullOrWhiteSpace(rcn))
+                        {
+                            rcn = "SSLCN:" + rcn;
+                            xmlRprcRequest.Params.Add(rcn); // Param[4] or Param[5]
+                        }
+                
                         try
                         {
                             xmlRpcResponse = method(xmlRprcRequest, request.RemoteIPEndPoint);
@@ -1263,15 +1413,12 @@ namespace OpenSim.Framework.Servers.HttpServer
             //m_log.Warn("[BASE HTTP SERVER]: We've figured out it's a LLSD Request");
             Stream requestStream = request.InputStream;
 
+            string requestBody;
             Encoding encoding = Encoding.UTF8;
-            StreamReader reader = new StreamReader(requestStream, encoding);
-
-            string requestBody = reader.ReadToEnd();
-            reader.Close();
-            requestStream.Close();
+            using(StreamReader reader = new StreamReader(requestStream, encoding))
+                requestBody= reader.ReadToEnd();
 
             //m_log.DebugFormat("[OGP]: {0}:{1}", request.RawUrl, requestBody);
-            response.KeepAlive = true;
 
             OSD llsdRequest = null;
             OSD llsdResponse = null;
@@ -1592,15 +1739,10 @@ namespace OpenSim.Framework.Servers.HttpServer
             byte[] buffer;
 
             Stream requestStream = request.InputStream;
-
+            string requestBody;
             Encoding encoding = Encoding.UTF8;
-            StreamReader reader = new StreamReader(requestStream, encoding);
-
-            string requestBody = reader.ReadToEnd();
-            // avoid warning for now
-            reader.ReadToEnd();
-            reader.Close();
-            requestStream.Close();
+            using(StreamReader reader = new StreamReader(requestStream, encoding))
+                requestBody = reader.ReadToEnd();
 
             Hashtable keysvals = new Hashtable();
             Hashtable headervals = new Hashtable();
@@ -1792,20 +1934,13 @@ namespace OpenSim.Framework.Servers.HttpServer
             {
                 response.ProtocolVersion = (string)responsedata["http_protocol_version"];
             }
-/*
+
             if (responsedata.ContainsKey("keepalive"))
             {
                 bool keepalive = (bool)responsedata["keepalive"];
                 response.KeepAlive = keepalive;
             }
 
-            if (responsedata.ContainsKey("reusecontext"))
-                response.ReuseContext = (bool) responsedata["reusecontext"];
-*/
-            // disable this things
-            response.KeepAlive = false;
-            response.ReuseContext = false;
-
             // Cross-Origin Resource Sharing with simple requests
             if (responsedata.ContainsKey("access_control_allow_origin"))
                 response.AddHeader("Access-Control-Allow-Origin", (string)responsedata["access_control_allow_origin"]);
@@ -1818,11 +1953,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                 contentType = "text/html";
             }
 
-
-
             // The client ignores anything but 200 here for web login, so ensure that this is 200 for that
 
-
             response.StatusCode = responsecode;
 
             if (responsecode == (int)OSHttpStatusCode.RedirectMovedPermanently)
@@ -1832,13 +1964,12 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
 
             response.AddHeader("Content-Type", contentType);
-
             if (responsedata.ContainsKey("headers"))
             {
                 Hashtable headerdata = (Hashtable)responsedata["headers"];
 
                 foreach (string header in headerdata.Keys)
-                    response.AddHeader(header, (string)headerdata[header]);
+                    response.AddHeader(header, headerdata[header].ToString());
             }
 
             byte[] buffer;
@@ -1906,7 +2037,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void Start()
         {
-            Start(true);
+            Start(true,true);
         }
 
         /// <summary>
@@ -1916,7 +2047,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// If true then poll responses are performed asynchronsly.
         /// Option exists to allow regression tests to perform processing synchronously.
         /// </param>
-        public void Start(bool performPollResponsesAsync)
+        public void Start(bool performPollResponsesAsync, bool runPool)
         {
             m_log.InfoFormat(
                 "[BASE HTTP SERVER]: Starting {0} server on port {1}", UseSSL ? "HTTPS" : "HTTP", Port);
@@ -1945,6 +2076,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                     //m_httpListener.Prefixes.Add("https://+:" + (m_sslport) + "/");
                     //m_httpListener.Prefixes.Add("http://+:" + m_port + "/");
                     m_httpListener2 = CoolHTTPListener.Create(IPAddress.Any, (int)m_port, m_cert);
+                    if(m_certificateValidationCallback != null)
+                        m_httpListener2.CertificateValidationCallback = m_certificateValidationCallback;
                     m_httpListener2.ExceptionThrown += httpServerException;
                     m_httpListener2.LogWriter = httpserverlog;
                 }
@@ -1954,9 +2087,11 @@ namespace OpenSim.Framework.Servers.HttpServer
                 m_httpListener2.Start(64);
 
                 // Long Poll Service Manager with 3 worker threads a 25 second timeout for no events
-
-                PollServiceRequestManager = new PollServiceRequestManager(this, performPollResponsesAsync, 2, 25000);
-                PollServiceRequestManager.Start();
+                if(runPool)
+                {
+                    PollServiceRequestManager = new PollServiceRequestManager(this, performPollResponsesAsync, 2, 25000);
+                    PollServiceRequestManager.Start();
+                }
 
                 HTTPDRunning = true;
 
@@ -1970,7 +2105,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             catch (Exception e)
             {
                 m_log.Error("[BASE HTTP SERVER]: Error - " + e.Message);
-                m_log.Error("[BASE HTTP SERVER]: Tip: Do you have permission to listen on port " + m_port + ", " + m_sslport + "?");
+                m_log.Error("[BASE HTTP SERVER]: Tip: Do you have permission to listen on port " + m_port + "?");
 
                 // We want this exception to halt the entire server since in current configurations we aren't too
                 // useful without inbound HTTP.
@@ -2028,7 +2163,8 @@ namespace OpenSim.Framework.Servers.HttpServer
 
             try
             {
-                PollServiceRequestManager.Stop();
+                if(PollServiceRequestManager != null)
+                    PollServiceRequestManager.Stop();
 
                 m_httpListener2.ExceptionThrown -= httpServerException;
                 //m_httpListener2.DisconnectHandler = null;
@@ -2135,10 +2271,9 @@ namespace OpenSim.Framework.Servers.HttpServer
             string file = Path.Combine(".", "http_500.html");
             if (!File.Exists(file))
                 return getDefaultHTTP500();
-
-            StreamReader sr = File.OpenText(file);
-            string result = sr.ReadToEnd();
-            sr.Close();
+            string result;
+            using(StreamReader sr = File.OpenText(file))
+                result = sr.ReadToEnd();
             return result;
         }
 
diff --git a/OpenSim/Framework/Servers/HttpServer/Interfaces/IOSHttpResponse.cs b/OpenSim/Framework/Servers/HttpServer/Interfaces/IOSHttpResponse.cs
index f61b090..d26b68a 100644
--- a/OpenSim/Framework/Servers/HttpServer/Interfaces/IOSHttpResponse.cs
+++ b/OpenSim/Framework/Servers/HttpServer/Interfaces/IOSHttpResponse.cs
@@ -118,7 +118,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// </summary>
         string StatusDescription { get; set; }
 
-        bool ReuseContext { get; set; }
+//        bool ReuseContext { get; set; }
 
         /// <summary>
         /// Add a header field and content to the response.
diff --git a/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs b/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs
index d7744fc..a107ced 100644
--- a/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs
+++ b/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs
@@ -257,25 +257,6 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
         }
 
-        public bool ReuseContext
-        {
-            get
-            {
-                if (_httpClientContext != null)
-                {
-                    return !_httpClientContext.EndWhenDone;
-                }
-                return true;
-            }
-            set
-            {
-                if (_httpClientContext != null)
-                {
-                    _httpClientContext.EndWhenDone = !value;
-                }
-            }
-        }
-
         protected IHttpResponse _httpResponse;
         private IHttpClientContext _httpClientContext;
 
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
index 8ace7a9..7c7d08d 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
@@ -37,6 +37,7 @@ namespace OpenSim.Framework.Servers.HttpServer
     public delegate Hashtable GetEventsMethod(UUID requestID, UUID pId);
 
     public delegate Hashtable NoEventsMethod(UUID requestID, UUID pId);
+    public delegate void DropMethod(UUID requestID, UUID pId);
 
     public class PollServiceEventArgs : EventArgs
     {
@@ -44,13 +45,14 @@ namespace OpenSim.Framework.Servers.HttpServer
         public GetEventsMethod GetEvents;
         public NoEventsMethod NoEvents;
         public RequestMethod Request;
+        public DropMethod Drop;
         public UUID Id;
         public int TimeOutms;
         public EventType Type;
 
         public enum EventType : int
         {
-            LongPoll = 0,
+            Poll = 0,
             LslHttp = 1,
             Inventory = 2,
             Texture = 3,
@@ -73,16 +75,17 @@ namespace OpenSim.Framework.Servers.HttpServer
             RequestMethod pRequest,
             string pUrl,
             HasEventsMethod pHasEvents, GetEventsMethod pGetEvents, NoEventsMethod pNoEvents,
-            UUID pId, int pTimeOutms)
+            DropMethod pDrop, UUID pId, int pTimeOutms)
         {
             Request = pRequest;
             Url = pUrl;
             HasEvents = pHasEvents;
             GetEvents = pGetEvents;
             NoEvents = pNoEvents;
+            Drop = pDrop;
             Id = pId;
             TimeOutms = pTimeOutms;
-            Type = EventType.LongPoll;
+            Type = EventType.Poll;
         }
     }
 }
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
index 3eb330a..4fd69f3 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
@@ -47,8 +47,10 @@ namespace OpenSim.Framework.Servers.HttpServer
         public readonly UUID RequestID;
         public int  contextHash;
 
+/*
         private void GenContextHash()
         {
+
             Random rnd = new Random();
             contextHash = 0;
             if (Request.Headers["remote_addr"] != null)
@@ -62,8 +64,9 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
             else
                 contextHash += rnd.Next() & 0xffff;
-        }
 
+        }
+*/
         public PollServiceHttpRequest(
             PollServiceEventArgs pPollServiceArgs, IHttpClientContext pHttpContext, IHttpRequest pRequest)
         {
@@ -72,7 +75,8 @@ namespace OpenSim.Framework.Servers.HttpServer
             Request = pRequest;
             RequestTime = System.Environment.TickCount;
             RequestID = UUID.Random();
-            GenContextHash();
+//            GenContextHash();
+            contextHash = HttpContext.contextID;
         }
 
         internal void DoHTTPGruntWork(BaseHttpServer server, Hashtable responsedata)
@@ -82,10 +86,12 @@ namespace OpenSim.Framework.Servers.HttpServer
 
             byte[] buffer = server.DoHTTPGruntWork(responsedata, response);
 
+            if(Request.Body.CanRead)
+                Request.Body.Dispose();
+
             response.SendChunked = false;
             response.ContentLength64 = buffer.Length;
             response.ContentEncoding = Encoding.UTF8;
-            response.ReuseContext = false;
 
             try
             {
@@ -114,10 +120,12 @@ namespace OpenSim.Framework.Servers.HttpServer
             OSHttpResponse response
                 = new OSHttpResponse(new HttpResponse(HttpContext, Request), HttpContext);
 
+            if(Request.Body.CanRead)
+                Request.Body.Dispose();
+
             response.SendChunked = false;
             response.ContentLength64 = 0;
             response.ContentEncoding = Encoding.UTF8;
-            response.ReuseContext = false;
             response.KeepAlive = false;
             response.SendChunked = false;
             response.StatusCode = 503;
@@ -127,7 +135,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                 response.OutputStream.Flush();
                 response.Send();
             }
-            catch (Exception e)
+            catch
             {
             }
         }
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index 936146d..a2f6a11 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -30,13 +30,10 @@ using System.Collections;
 using System.Threading;
 using System.Reflection;
 using log4net;
-using HttpServer;
-using OpenSim.Framework;
 using OpenSim.Framework.Monitoring;
 using Amib.Threading;
-using System.IO;
-using System.Text;
 using System.Collections.Generic;
+using System.Collections.Concurrent;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {
@@ -46,21 +43,18 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         private readonly BaseHttpServer m_server;
 
-        private Dictionary<PollServiceHttpRequest, Queue<PollServiceHttpRequest>> m_bycontext;
-        private BlockingQueue<PollServiceHttpRequest> m_requests = new BlockingQueue<PollServiceHttpRequest>();
-        private static Queue<PollServiceHttpRequest> m_slowRequests = new Queue<PollServiceHttpRequest>();
-        private static Queue<PollServiceHttpRequest> m_retryRequests = new Queue<PollServiceHttpRequest>();
+        private Dictionary<int, Queue<PollServiceHttpRequest>> m_bycontext;
+        private BlockingCollection<PollServiceHttpRequest> m_requests = new BlockingCollection<PollServiceHttpRequest>();
+        private static ConcurrentQueue<PollServiceHttpRequest> m_retryRequests = new ConcurrentQueue<PollServiceHttpRequest>();
 
         private uint m_WorkerThreadCount = 0;
         private Thread[] m_workerThreads;
         private Thread m_retrysThread;
 
         private bool m_running = false;
-        private int slowCount = 0;
 
         private SmartThreadPool m_threadPool;
 
-
         public PollServiceRequestManager(
             BaseHttpServer pSrv, bool performResponsesAsync, uint pWorkerThreadCount, int pTimeout)
         {
@@ -68,8 +62,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_WorkerThreadCount = pWorkerThreadCount;
             m_workerThreads = new Thread[m_WorkerThreadCount];
 
-            PollServiceHttpRequestComparer preqCp = new PollServiceHttpRequestComparer();
-            m_bycontext = new Dictionary<PollServiceHttpRequest, Queue<PollServiceHttpRequest>>(preqCp);
+            m_bycontext = new Dictionary<int, Queue<PollServiceHttpRequest>>(256);
 
             STPStartInfo startInfo = new STPStartInfo();
             startInfo.IdleTimeout = 30000;
@@ -80,7 +73,6 @@ namespace OpenSim.Framework.Servers.HttpServer
             startInfo.ThreadPoolName = "PoolService";
 
             m_threadPool = new SmartThreadPool(startInfo);
-
         }
 
         public void Start()
@@ -95,7 +87,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                         PoolWorkerJob,
                         string.Format("PollServiceWorkerThread {0}:{1}", i, m_server.Port),
                         ThreadPriority.Normal,
-                        false,
+                        true,
                         false,
                         null,
                         int.MaxValue);
@@ -105,36 +97,32 @@ namespace OpenSim.Framework.Servers.HttpServer
                 this.CheckRetries,
                 string.Format("PollServiceWatcherThread:{0}", m_server.Port),
                 ThreadPriority.Normal,
-                false,
+                true,
                 true,
                 null,
                 1000 * 60 * 10);
-
-
         }
 
         private void ReQueueEvent(PollServiceHttpRequest req)
         {
             if (m_running)
-            {
-                lock (m_retryRequests)
-                    m_retryRequests.Enqueue(req);
-            }
+                m_retryRequests.Enqueue(req);
         }
 
         public void Enqueue(PollServiceHttpRequest req)
         {
+            Queue<PollServiceHttpRequest> ctxQeueue;
+            int rhash = req.contextHash;
             lock (m_bycontext)
             {
-                Queue<PollServiceHttpRequest> ctxQeueue;
-                if (m_bycontext.TryGetValue(req, out ctxQeueue))
+                if (m_bycontext.TryGetValue(rhash, out ctxQeueue))
                 {
                     ctxQeueue.Enqueue(req);
                 }
                 else
                 {
                     ctxQeueue = new Queue<PollServiceHttpRequest>();
-                    m_bycontext[req] = ctxQeueue;
+                    m_bycontext[rhash] = ctxQeueue;
                     EnqueueInt(req);
                 }
             }
@@ -143,9 +131,10 @@ namespace OpenSim.Framework.Servers.HttpServer
         public void byContextDequeue(PollServiceHttpRequest req)
         {
             Queue<PollServiceHttpRequest> ctxQeueue;
+            int rhash = req.contextHash;
             lock (m_bycontext)
             {
-                if (m_bycontext.TryGetValue(req, out ctxQeueue))
+                if (m_bycontext.TryGetValue(rhash, out ctxQeueue))
                 {
                     if (ctxQeueue.Count > 0)
                     {
@@ -154,51 +143,41 @@ namespace OpenSim.Framework.Servers.HttpServer
                     }
                     else
                     {
-                        m_bycontext.Remove(req);
+                        m_bycontext.Remove(rhash);
                     }
                 }
             }
         }
 
-        public void EnqueueInt(PollServiceHttpRequest req)
+        public void DropByContext(PollServiceHttpRequest req)
         {
-            if (m_running)
+            Queue<PollServiceHttpRequest> ctxQeueue;
+            int rhash = req.contextHash;
+            lock (m_bycontext)
             {
-                if (req.PollServiceArgs.Type != PollServiceEventArgs.EventType.LongPoll)
+                if (m_bycontext.TryGetValue(rhash, out ctxQeueue))
                 {
-                    m_requests.Enqueue(req);
-                }
-                else
-                {
-                    lock (m_slowRequests)
-                        m_slowRequests.Enqueue(req);
+                    ctxQeueue.Clear();
+                    m_bycontext.Remove(rhash);
                 }
             }
         }
 
+        public void EnqueueInt(PollServiceHttpRequest req)
+        {
+            if (m_running)
+                m_requests.Add(req);
+        }
+
         private void CheckRetries()
         {
+            PollServiceHttpRequest preq;
             while (m_running)
-
             {
-                Thread.Sleep(100); // let the world move  .. back to faster rate
+                Thread.Sleep(100);
                 Watchdog.UpdateThread();
-                lock (m_retryRequests)
-                {
-                    while (m_retryRequests.Count > 0 && m_running)
-                        m_requests.Enqueue(m_retryRequests.Dequeue());
-                }
-                slowCount++;
-                if (slowCount >= 10)
-                {
-                    slowCount = 0;
-
-                    lock (m_slowRequests)
-                    {
-                        while (m_slowRequests.Count > 0 && m_running)
-                            m_requests.Enqueue(m_slowRequests.Dequeue());
-                    }
-                }
+                while (m_running && m_retryRequests.TryDequeue(out preq))
+                    m_requests.Add(preq);
             }
         }
 
@@ -206,117 +185,130 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             m_running = false;
 
-            Thread.Sleep(1000); // let the world move
+            Thread.Sleep(100); // let the world move
 
             foreach (Thread t in m_workerThreads)
                 Watchdog.AbortThread(t.ManagedThreadId);
 
+            m_threadPool.Shutdown();
+
             // any entry in m_bycontext should have a active request on the other queues
             // so just delete contents to easy GC
             foreach (Queue<PollServiceHttpRequest> qu in m_bycontext.Values)
                 qu.Clear();
             m_bycontext.Clear();
 
+            PollServiceHttpRequest req;
             try
             {
-                foreach (PollServiceHttpRequest req in m_retryRequests)
-                {
+                while(m_retryRequests.TryDequeue(out req))
                     req.DoHTTPstop(m_server);
-                }
             }
             catch
             {
             }
 
-            PollServiceHttpRequest wreq;
-            m_retryRequests.Clear();
-
-            lock (m_slowRequests)
+            try
             {
-                while (m_slowRequests.Count > 0)
-                    m_requests.Enqueue(m_slowRequests.Dequeue());
-
+                while(m_requests.TryTake(out req, 0))
+                    req.DoHTTPstop(m_server);
             }
-
-            while (m_requests.Count() > 0)
+            catch
             {
-                try
-                {
-                    wreq = m_requests.Dequeue(0);
-                    wreq.DoHTTPstop(m_server);
-
-                }
-                catch
-                {
-                }
             }
 
-            m_requests.Clear();
+            m_requests.Dispose();
+
         }
 
         // work threads
 
         private void PoolWorkerJob()
         {
+            PollServiceHttpRequest req;
             while (m_running)
             {
-                PollServiceHttpRequest req = m_requests.Dequeue(5000);
+                req = null;
+                if(!m_requests.TryTake(out req, 4500) || req == null)
+                {
+                    Watchdog.UpdateThread();
+                    continue;
+                }
 
-                Watchdog.UpdateThread();
-                if (req != null)
+                Watchdog.UpdateThread();               
+
+                try
                 {
-                    try
+                    if(!req.HttpContext.CanSend())
+                    {
+                        req.PollServiceArgs.Drop(req.RequestID, req.PollServiceArgs.Id);
+                        byContextDequeue(req);
+                        continue;
+                    }
+
+                    if(req.HttpContext.IsSending())
                     {
-                        if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
+                        if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
                         {
-                            Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id);
+                            req.PollServiceArgs.Drop(req.RequestID, req.PollServiceArgs.Id);
+                            byContextDequeue(req);
+                        }
+                        else
+                          ReQueueEvent(req);
+                        continue;
+                    }
 
+                    if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
+                    {
+                        PollServiceHttpRequest nreq = req;
+                        m_threadPool.QueueWorkItem(x =>
+                        {
+                            try
+                            {
+                                Hashtable responsedata = nreq.PollServiceArgs.GetEvents(nreq.RequestID, nreq.PollServiceArgs.Id);
+                                nreq.DoHTTPGruntWork(m_server, responsedata);
+                            }
+                            catch (ObjectDisposedException) { }
+                            finally
+                            {
+                                byContextDequeue(nreq);
+                                nreq = null;
+                            }
+                            return null;
+                        }, null);
+                    }
+                    else
+                    {
+                        if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
+                        {
+                            PollServiceHttpRequest nreq = req;
                             m_threadPool.QueueWorkItem(x =>
                             {
                                 try
                                 {
-                                    req.DoHTTPGruntWork(m_server, responsedata);
-                                    byContextDequeue(req);
+                                    nreq.DoHTTPGruntWork(m_server,
+                                            nreq.PollServiceArgs.NoEvents(nreq.RequestID, nreq.PollServiceArgs.Id));
                                 }
-                                catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
+                                catch (ObjectDisposedException) {}
+                                finally
                                 {
-                                    // Ignore it, no need to reply
+                                    byContextDequeue(nreq);
+                                    nreq = null;
                                 }
                                 return null;
                             }, null);
                         }
                         else
                         {
-                            if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
-                            {
-                                m_threadPool.QueueWorkItem(x =>
-                                {
-                                    try
-                                    {
-                                        req.DoHTTPGruntWork(m_server,
-                                            req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
-                                        byContextDequeue(req);
-                                    }
-                                    catch (ObjectDisposedException)
-                                    {
-                                    // Ignore it, no need to reply
-                                    }
-                                    return null;
-                                }, null);
-                            }
-                            else
-                            {
-                                ReQueueEvent(req);
-                            }
+                            ReQueueEvent(req);
                         }
                     }
-                    catch (Exception e)
-                    {
-                        m_log.ErrorFormat("Exception in poll service thread: " + e.ToString());
-                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("Exception in poll service thread: " + e.ToString());
                 }
             }
         }
-
     }
 }
diff --git a/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs b/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs
index 0305dee..dfc2715 100644
--- a/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs
@@ -50,11 +50,10 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
+            string requestBody;
             Encoding encoding = Encoding.UTF8;
-            StreamReader streamReader = new StreamReader(request, encoding);
-
-            string requestBody = streamReader.ReadToEnd();
-            streamReader.Close();
+            using(StreamReader streamReader = new StreamReader(request,encoding))
+                requestBody = streamReader.ReadToEnd();
 
             string param = GetParam(path);
             string responseString = m_restMethod(requestBody, path, param, httpRequest, httpResponse);
diff --git a/OpenSim/Framework/Servers/MainServer.cs b/OpenSim/Framework/Servers/MainServer.cs
index ea7b2b5..523ccba 100644
--- a/OpenSim/Framework/Servers/MainServer.cs
+++ b/OpenSim/Framework/Servers/MainServer.cs
@@ -42,6 +42,7 @@ namespace OpenSim.Framework.Servers
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static BaseHttpServer instance = null;
+        private static BaseHttpServer unsecureinstance = null;
         private static Dictionary<uint, BaseHttpServer> m_Servers = new Dictionary<uint, BaseHttpServer>();
 
         /// <summary>
@@ -93,6 +94,21 @@ namespace OpenSim.Framework.Servers
             }
         }
 
+        
+        public static BaseHttpServer UnSecureInstance
+        {
+            get { return unsecureinstance; }
+
+            set
+            {
+                lock (m_Servers)
+                    if (!m_Servers.ContainsValue(value))
+                        throw new Exception("HTTP server must already have been registered to be set as the main instance");
+
+                unsecureinstance = value;
+            }
+        }
+
         /// <summary>
         /// Get all the registered servers.
         /// </summary>
@@ -353,5 +369,17 @@ namespace OpenSim.Framework.Servers
                 return m_Servers[port];
             }
         }
+
+        public static void Stop()
+        {
+            lock (m_Servers)
+            {
+                foreach (BaseHttpServer httpServer in m_Servers.Values)
+                {
+                    httpServer.Stop();
+                }
+            }
+        }
+
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/ServerBase.cs b/OpenSim/Framework/Servers/ServerBase.cs
index f627ae6..3c2dce8 100644
--- a/OpenSim/Framework/Servers/ServerBase.cs
+++ b/OpenSim/Framework/Servers/ServerBase.cs
@@ -275,18 +275,6 @@ namespace OpenSim.Framework.Servers
                 (string module, string[] args) => Notice(GetThreadsReport()));
 
             m_console.Commands.AddCommand (
-                "Debug", false, "debug comms set",
-                "debug comms set serialosdreq true|false",
-                "Set comms parameters.  For debug purposes.",
-                HandleDebugCommsSet);
-
-            m_console.Commands.AddCommand (
-                "Debug", false, "debug comms status",
-                "debug comms status",
-                "Show current debug comms parameters.",
-                HandleDebugCommsStatus);
-
-            m_console.Commands.AddCommand (
                 "Debug", false, "debug threadpool set",
                 "debug threadpool set worker|iocp min|max <n>",
                 "Set threadpool parameters.  For debug purposes.",
@@ -343,47 +331,13 @@ namespace OpenSim.Framework.Servers
 
         public void RegisterCommonComponents(IConfigSource configSource)
         {
-            IConfig networkConfig = configSource.Configs["Network"];
-
-            if (networkConfig != null)
-            {
-                WebUtil.SerializeOSDRequestsPerEndpoint = networkConfig.GetBoolean("SerializeOSDRequests", false);
-            }
+//            IConfig networkConfig = configSource.Configs["Network"];
 
             m_serverStatsCollector = new ServerStatsCollector();
             m_serverStatsCollector.Initialise(configSource);
             m_serverStatsCollector.Start();
         }
 
-        private void HandleDebugCommsStatus(string module, string[] args)
-        {
-            Notice("serialosdreq is {0}", WebUtil.SerializeOSDRequestsPerEndpoint);
-        }
-
-        private void HandleDebugCommsSet(string module, string[] args)
-        {
-            if (args.Length != 5)
-            {
-                Notice("Usage: debug comms set serialosdreq true|false");
-                return;
-            }
-
-            if (args[3] != "serialosdreq")
-            {
-                Notice("Usage: debug comms set serialosdreq true|false");
-                return;
-            }
-
-            bool setSerializeOsdRequests;
-
-            if (!ConsoleUtil.TryParseConsoleBool(m_console, args[4], out setSerializeOsdRequests))
-                return;
-
-            WebUtil.SerializeOSDRequestsPerEndpoint = setSerializeOsdRequests;
-
-            Notice("serialosdreq is now {0}", setSerializeOsdRequests);
-        }
-
         private void HandleShowThreadpoolCallsActive(string module, string[] args)
         {
             List<KeyValuePair<string, int>> calls = Util.GetFireAndForgetCallsInProgress().ToList();
@@ -928,16 +882,12 @@ namespace OpenSim.Framework.Servers
                 sb.Append("\n");
             }
 
-            sb.Append("\n");
+            sb.Append(GetThreadPoolReport());
 
-            // For some reason mono 2.6.7 returns an empty threads set!  Not going to confuse people by reporting
-            // zero active threads.
+            sb.Append("\n");
             int totalThreads = Process.GetCurrentProcess().Threads.Count;
             if (totalThreads > 0)
-                sb.AppendFormat("Total threads active: {0}\n\n", totalThreads);
-
-            sb.Append("Main threadpool (excluding script engine pools)\n");
-            sb.Append(GetThreadPoolReport());
+                sb.AppendFormat("Total process threads active: {0}\n\n", totalThreads);
 
             return sb.ToString();
         }
@@ -948,15 +898,46 @@ namespace OpenSim.Framework.Servers
         /// <returns></returns>
         public static string GetThreadPoolReport()
         {
+
+            StringBuilder sb = new StringBuilder();
+
+            // framework pool is alwasy active
+            int maxWorkers;
+            int minWorkers;
+            int curWorkers;
+            int maxComp;
+            int minComp;
+            int curComp;
+
+            try
+            {
+                ThreadPool.GetMaxThreads(out maxWorkers, out maxComp);
+                ThreadPool.GetMinThreads(out minWorkers, out minComp);
+                ThreadPool.GetAvailableThreads(out curWorkers, out curComp);
+                curWorkers = maxWorkers - curWorkers;
+                curComp = maxComp - curComp;
+
+                sb.Append("\nFramework main threadpool \n");
+                sb.AppendFormat("workers:    {0} ({1} / {2})\n", curWorkers, maxWorkers, minWorkers);
+                sb.AppendFormat("Completion: {0} ({1} / {2})\n", curComp, maxComp, minComp);
+            }
+            catch { }
+
+            if (
+                Util.FireAndForgetMethod == FireAndForgetMethod.QueueUserWorkItem
+                    || Util.FireAndForgetMethod == FireAndForgetMethod.UnsafeQueueUserWorkItem)
+            {
+                sb.AppendFormat("\nThread pool used: Framework main threadpool\n");
+                return sb.ToString();
+            }
+
             string threadPoolUsed = null;
             int maxThreads = 0;
             int minThreads = 0;
             int allocatedThreads = 0;
             int inUseThreads = 0;
             int waitingCallbacks = 0;
-            int completionPortThreads = 0;
 
-            StringBuilder sb = new StringBuilder();
             if (Util.FireAndForgetMethod == FireAndForgetMethod.SmartThreadPool)
             {
                 STPInfo stpi = Util.GetSmartThreadPoolInfo();
@@ -972,22 +953,10 @@ namespace OpenSim.Framework.Servers
                     waitingCallbacks = stpi.WaitingCallbacks;
                 }
             }
-            else if (
-                Util.FireAndForgetMethod == FireAndForgetMethod.QueueUserWorkItem
-                    || Util.FireAndForgetMethod == FireAndForgetMethod.UnsafeQueueUserWorkItem)
-            {
-                threadPoolUsed = "BuiltInThreadPool";
-                ThreadPool.GetMaxThreads(out maxThreads, out completionPortThreads);
-                ThreadPool.GetMinThreads(out minThreads, out completionPortThreads);
-                int availableThreads;
-                ThreadPool.GetAvailableThreads(out availableThreads, out completionPortThreads);
-                inUseThreads = maxThreads - availableThreads;
-                allocatedThreads = -1;
-                waitingCallbacks = -1;
-            }
-
+ 
             if (threadPoolUsed != null)
             {
+                sb.Append("\nThreadpool (excluding script engine pools)\n");
                 sb.AppendFormat("Thread pool used           : {0}\n", threadPoolUsed);
                 sb.AppendFormat("Max threads                : {0}\n", maxThreads);
                 sb.AppendFormat("Min threads                : {0}\n", minThreads);
diff --git a/OpenSim/Framework/Servers/Tests/VersionInfoTests.cs b/OpenSim/Framework/Servers/Tests/VersionInfoTests.cs
index 480f2bb..68a1c78 100644
--- a/OpenSim/Framework/Servers/Tests/VersionInfoTests.cs
+++ b/OpenSim/Framework/Servers/Tests/VersionInfoTests.cs
@@ -41,14 +41,5 @@ namespace OpenSim.Framework.Servers.Tests
         {
             Assert.AreEqual(VersionInfo.VERSIONINFO_VERSION_LENGTH, VersionInfo.Version.Length," VersionInfo.Version string not " + VersionInfo.VERSIONINFO_VERSION_LENGTH + " chars.");
         }
-
-        [Test]
-        public void TestGetVersionStringLength()
-        {
-            foreach (VersionInfo.Flavour flavour in Enum.GetValues(typeof(VersionInfo.Flavour)))
-            {
-                Assert.AreEqual(VersionInfo.VERSIONINFO_VERSION_LENGTH, VersionInfo.GetVersionString("0.0.0", flavour).Length, "0.0.0/" + flavour + " failed");
-            }
-        }
     }
 }