17 files changed, 619 insertions, 52 deletions

diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index 97035e3..7841f47 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -54,7 +54,6 @@ namespace OpenSim.Framework.Servers.HttpServer
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         private HttpServerLogWriter httpserverlog = new HttpServerLogWriter();
 
-
         /// <summary>
         /// This is a pending websocket request before it got an sucessful upgrade response.
         /// The consumer must call handler.HandshakeAndUpgrade() to signal to the handler to 
@@ -81,6 +80,11 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// </remarks>
         public int RequestNumber { get; private set; }
 
+        /// <summary>
+        /// Statistic for holding number of requests processed.
+        /// </summary>
+        private Stat m_requestsProcessedStat;
+
         private volatile int NotSocketErrors = 0;
         public volatile bool HTTPDRunning = false;
 
@@ -383,6 +387,8 @@ namespace OpenSim.Framework.Servers.HttpServer
 
                 if (TryGetPollServiceHTTPHandler(request.UriPath.ToString(), out psEvArgs))
                 {
+                    psEvArgs.RequestsReceived++;
+
                     PollServiceHttpRequest psreq = new PollServiceHttpRequest(psEvArgs, context, request);
 
                     if (psEvArgs.Request != null)
@@ -437,9 +443,8 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
         }
 
-        public void OnHandleRequestIOThread(IHttpClientContext context, IHttpRequest request)
+        private void OnHandleRequestIOThread(IHttpClientContext context, IHttpRequest request)
         {
-
             OSHttpRequest req = new OSHttpRequest(context, request);
             WebSocketRequestDelegate dWebSocketRequestDelegate = null;
             lock (m_WebSocketHandlers)
@@ -454,9 +459,8 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
             
             OSHttpResponse resp = new OSHttpResponse(new HttpResponse(context, request),context);
-            
-            HandleRequest(req, resp);
-           
+            resp.ReuseContext = true;
+            HandleRequest(req, resp);           
 
             // !!!HACK ALERT!!!
             // There seems to be a bug in the underlying http code that makes subsequent requests
@@ -687,7 +691,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
                 if (buffer != null)
                 {
-                    if (!response.SendChunked)
+                    if (!response.SendChunked && response.ContentLength64 <= 0)
                         response.ContentLength64 = buffer.LongLength;
 
                     response.OutputStream.Write(buffer, 0, buffer.Length);
@@ -782,7 +786,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                 "[BASE HTTP SERVER]: HTTP IN {0} :{1} {2} content type handler {3} {4} from {5}",
                 RequestNumber,
                 Port,
-                (request.ContentType == null || request.ContentType == "") ? "not set" : request.ContentType,
+                string.IsNullOrEmpty(request.ContentType) ? "not set" : request.ContentType,
                 request.HttpMethod,
                 request.Url.PathAndQuery,
                 request.RemoteIPEndPoint);
@@ -1053,7 +1057,21 @@ namespace OpenSim.Framework.Servers.HttpServer
                     }
 
                     response.ContentType = "text/xml";
-                    responseString = XmlRpcResponseSerializer.Singleton.Serialize(xmlRpcResponse);
+                    using (MemoryStream outs = new MemoryStream())
+                    {
+                        using (XmlTextWriter writer = new XmlTextWriter(outs, Encoding.UTF8))
+                        {
+                            writer.Formatting = Formatting.None;
+                            XmlRpcResponseSerializer.Singleton.Serialize(writer, xmlRpcResponse);
+                            writer.Flush();
+                            outs.Flush();
+                            outs.Position = 0;
+                            using (StreamReader sr = new StreamReader(outs))
+                            {
+                                responseString = sr.ReadToEnd();
+                            }
+                        }
+                    }
                 }
                 else
                 {
@@ -1850,8 +1868,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                 m_httpListener2.Start(64);
 
                 // Long Poll Service Manager with 3 worker threads a 25 second timeout for no events
-//                m_PollServiceManager = new PollServiceRequestManager(this, 3, 25000);
                 m_PollServiceManager = new PollServiceRequestManager(this, 4, 25000);
+                m_PollServiceManager.Start();
                 HTTPDRunning = true;
 
                 //HttpListenerContext context;
@@ -1870,6 +1888,21 @@ namespace OpenSim.Framework.Servers.HttpServer
                 // useful without inbound HTTP.
                 throw e;
             }
+
+            m_requestsProcessedStat 
+                = new Stat(
+                    "HTTPRequestsServed",
+                    "Number of inbound HTTP requests processed",
+                    "",
+                    "requests",
+                    "httpserver",
+                    Port.ToString(),
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = RequestNumber,
+                    StatVerbosity.Debug);
+          
+            StatsManager.RegisterStat(m_requestsProcessedStat);
         }
 
         public void httpServerDisconnectMonitor(IHttpClientContext source, SocketError err)
@@ -1902,9 +1935,12 @@ namespace OpenSim.Framework.Servers.HttpServer
         public void Stop()
         {
             HTTPDRunning = false;
+
+            StatsManager.DeregisterStat(m_requestsProcessedStat);
+
             try
             {
-//                m_PollServiceManager.Stop();
+                m_PollServiceManager.Stop();
 
                 m_httpListener2.ExceptionThrown -= httpServerException;
                 //m_httpListener2.DisconnectHandler = null;
@@ -1931,6 +1967,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void RemoveHTTPHandler(string httpMethod, string path)
         {
+            if (path == null) return; // Caps module isn't loaded, tries to remove handler where path = null
             lock (m_HTTPHandlers)
             {
                 if (httpMethod != null && httpMethod.Length == 0)
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseOutputStreamHandler.cs b/OpenSim/Framework/Servers/HttpServer/BaseOutputStreamHandler.cs
new file mode 100644
index 0000000..72b3065
--- /dev/null
+++ b/OpenSim/Framework/Servers/HttpServer/BaseOutputStreamHandler.cs
@@ -0,0 +1,60 @@
+/*
+ * 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.IO;
+
+namespace OpenSim.Framework.Servers.HttpServer
+{
+    /// <summary>
+    /// Base handler for writing to an output stream
+    /// </summary>
+    /// <remarks>
+    /// Inheriting classes should override ProcessRequest() rather than Handle()
+    /// </remarks>
+    public abstract class BaseOutputStreamHandler : BaseRequestHandler, IRequestHandler
+    {
+        protected BaseOutputStreamHandler(string httpMethod, string path) : this(httpMethod, path, null, null) {}
+
+        protected BaseOutputStreamHandler(string httpMethod, string path, string name, string description)
+            : base(httpMethod, path, name, description) {}
+
+        public virtual void Handle(
+            string path, Stream request, Stream response, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            RequestsReceived++;
+
+            ProcessRequest(path, request, response, httpRequest, httpResponse);
+
+            RequestsHandled++;
+        }
+
+        protected virtual void ProcessRequest(
+            string path, Stream request, Stream response, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseRequestHandler.cs b/OpenSim/Framework/Servers/HttpServer/BaseRequestHandler.cs
index ae7aaf2..bbac699 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseRequestHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseRequestHandler.cs
@@ -31,6 +31,10 @@ namespace OpenSim.Framework.Servers.HttpServer
 {
     public abstract class BaseRequestHandler
     {
+        public int RequestsReceived { get; protected set; }
+
+        public int RequestsHandled { get; protected set; }
+
         public virtual string ContentType
         {
             get { return "application/xml"; }
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseStreamHandler.cs b/OpenSim/Framework/Servers/HttpServer/BaseStreamHandler.cs
index 6342983..252cc2a 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseStreamHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseStreamHandler.cs
@@ -29,14 +29,35 @@ using System.IO;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {
+    /// <summary>
+    /// Base streamed request handler.
+    /// </summary>
+    /// <remarks>
+    /// Inheriting classes should override ProcessRequest() rather than Handle()
+    /// </remarks>
     public abstract class BaseStreamHandler : BaseRequestHandler, IStreamedRequestHandler
     {
-        public abstract byte[] Handle(string path, Stream request,
-                                      IOSHttpRequest httpRequest, IOSHttpResponse httpResponse);
-
         protected BaseStreamHandler(string httpMethod, string path) : this(httpMethod, path, null, null) {}
 
         protected BaseStreamHandler(string httpMethod, string path, string name, string description)
             : base(httpMethod, path, name, description) {}
+
+        public virtual byte[] Handle(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            RequestsReceived++;
+
+            byte[] result = ProcessRequest(path, request, httpRequest, httpResponse);
+
+            RequestsHandled++;
+
+            return result;
+        }
+
+        protected virtual byte[] ProcessRequest(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            return null;
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseStreamHandlerBasicDOSProtector.cs b/OpenSim/Framework/Servers/HttpServer/BaseStreamHandlerBasicDOSProtector.cs
new file mode 100644
index 0000000..1b88545
--- /dev/null
+++ b/OpenSim/Framework/Servers/HttpServer/BaseStreamHandlerBasicDOSProtector.cs
@@ -0,0 +1,107 @@
+/*
+ * 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 OpenSim.Framework;
+using System.IO;
+
+namespace OpenSim.Framework.Servers.HttpServer
+{
+    /// <summary>
+    /// BaseStreamHandlerBasicDOSProtector Base streamed request handler.
+    /// </summary>
+    /// <remarks>
+    /// Inheriting classes should override ProcessRequest() rather than Handle()
+    /// </remarks>
+    public abstract class BaseStreamHandlerBasicDOSProtector : BaseRequestHandler, IStreamedRequestHandler
+    {
+       
+        private readonly BasicDosProtectorOptions _options;
+        private readonly BasicDOSProtector _dosProtector;
+
+        protected BaseStreamHandlerBasicDOSProtector(string httpMethod, string path, BasicDosProtectorOptions options) : this(httpMethod, path, null, null, options) {}
+
+        protected BaseStreamHandlerBasicDOSProtector(string httpMethod, string path, string name, string description, BasicDosProtectorOptions options)
+            : base(httpMethod, path, name, description)
+        {
+            _options = options;
+            _dosProtector = new BasicDOSProtector(_options);
+        }
+
+        public virtual byte[] Handle(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            byte[] result;
+            RequestsReceived++;
+            string clientstring = GetClientString(httpRequest);
+            string endpoint = GetRemoteAddr(httpRequest);
+            if (_dosProtector.Process(clientstring, endpoint))
+                result = ProcessRequest(path, request, httpRequest, httpResponse);
+            else
+                result = ThrottledRequest(path, request, httpRequest, httpResponse);
+            if (_options.MaxConcurrentSessions > 0)
+                _dosProtector.ProcessEnd(clientstring, endpoint);
+            
+            RequestsHandled++;
+
+            return result;
+        }
+
+        protected virtual byte[] ProcessRequest(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            return null;
+        }
+
+        protected virtual byte[] ThrottledRequest(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            return new byte[0];
+        }
+
+        
+        private string GetRemoteAddr(IOSHttpRequest httpRequest)
+        {
+            string remoteaddr = string.Empty;
+            if (httpRequest.Headers["remote_addr"] != null)
+                remoteaddr = httpRequest.Headers["remote_addr"];
+
+            return remoteaddr;
+        }
+
+        private string GetClientString(IOSHttpRequest httpRequest)
+        {
+            string clientstring = string.Empty;
+
+            if (_options.AllowXForwardedFor && httpRequest.Headers["x-forwarded-for"] != null)
+                clientstring = httpRequest.Headers["x-forwarded-for"];
+            else
+                clientstring = GetRemoteAddr(httpRequest);
+
+            return clientstring;
+           
+        }
+    }
+}
diff --git a/OpenSim/Framework/Servers/HttpServer/BinaryStreamHandler.cs b/OpenSim/Framework/Servers/HttpServer/BinaryStreamHandler.cs
index b94bfb4..1b03f54 100644
--- a/OpenSim/Framework/Servers/HttpServer/BinaryStreamHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BinaryStreamHandler.cs
@@ -45,7 +45,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_method = binaryMethod;
         }
 
-        public override byte[] Handle(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
             byte[] data = ReadFully(request);
             string param = GetParam(path);
diff --git a/OpenSim/Framework/Servers/HttpServer/GenericHTTPBasicDOSProtector.cs b/OpenSim/Framework/Servers/HttpServer/GenericHTTPBasicDOSProtector.cs
new file mode 100644
index 0000000..cd4b8ff
--- /dev/null
+++ b/OpenSim/Framework/Servers/HttpServer/GenericHTTPBasicDOSProtector.cs
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections;
+
+namespace OpenSim.Framework.Servers.HttpServer
+{
+    public class GenericHTTPDOSProtector
+    {
+        private readonly GenericHTTPMethod _normalMethod;
+        private readonly GenericHTTPMethod _throttledMethod;
+      
+        private readonly BasicDosProtectorOptions _options;
+        private readonly BasicDOSProtector _dosProtector;
+
+        public GenericHTTPDOSProtector(GenericHTTPMethod normalMethod, GenericHTTPMethod throttledMethod, BasicDosProtectorOptions options)
+        {
+            _normalMethod = normalMethod;
+            _throttledMethod = throttledMethod;
+            
+            _options = options;
+            _dosProtector = new BasicDOSProtector(_options);
+        }
+        public Hashtable Process(Hashtable request)
+        {
+            Hashtable process = null;
+            string clientstring= GetClientString(request);
+            string endpoint = GetRemoteAddr(request);
+            if (_dosProtector.Process(clientstring, endpoint))
+                process =  _normalMethod(request);
+            else
+                process = _throttledMethod(request);
+
+            if (_options.MaxConcurrentSessions>0)
+                _dosProtector.ProcessEnd(clientstring, endpoint);
+
+            return process;
+        }
+        
+        private string GetRemoteAddr(Hashtable request)
+        {
+            string remoteaddr = "";
+            if (!request.ContainsKey("headers"))
+                return remoteaddr;
+            Hashtable requestinfo = (Hashtable)request["headers"];
+            if (!requestinfo.ContainsKey("remote_addr"))
+                return remoteaddr;
+            object remote_addrobj = requestinfo["remote_addr"];
+            if (remote_addrobj != null)
+            {
+                if (!string.IsNullOrEmpty(remote_addrobj.ToString()))
+                {
+                    remoteaddr = remote_addrobj.ToString();
+                }
+
+            }
+            return remoteaddr;
+        }
+
+        private string GetClientString(Hashtable request)
+        {
+            string clientstring = "";
+            if (!request.ContainsKey("headers"))
+                return clientstring;
+
+            Hashtable requestinfo = (Hashtable)request["headers"];
+            if (_options.AllowXForwardedFor && requestinfo.ContainsKey("x-forwarded-for"))
+            {
+                object str = requestinfo["x-forwarded-for"];
+                if (str != null)
+                {
+                    if (!string.IsNullOrEmpty(str.ToString()))
+                    {
+                        return str.ToString();
+                    }
+                }
+            }
+            if (!requestinfo.ContainsKey("remote_addr"))
+                return clientstring;
+
+            object remote_addrobj = requestinfo["remote_addr"];
+            if (remote_addrobj != null)
+            {
+                if (!string.IsNullOrEmpty(remote_addrobj.ToString()))
+                {
+                    clientstring = remote_addrobj.ToString();
+                }
+            }
+
+            return clientstring;
+
+        }
+
+    }
+}
diff --git a/OpenSim/Framework/Servers/HttpServer/Interfaces/IStreamHandler.cs b/OpenSim/Framework/Servers/HttpServer/Interfaces/IStreamHandler.cs
index cb5cce5..b8541cb 100644
--- a/OpenSim/Framework/Servers/HttpServer/Interfaces/IStreamHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/Interfaces/IStreamHandler.cs
@@ -32,7 +32,6 @@ namespace OpenSim.Framework.Servers.HttpServer
 {
     public interface IRequestHandler
     {
-
         /// <summary>
         /// Name for this handler.
         /// </summary>
@@ -59,6 +58,19 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         // Return path
         string Path { get; }
+
+        /// <summary>
+        /// Number of requests received by this handler
+        /// </summary>
+        int RequestsReceived { get; }
+
+        /// <summary>
+        /// Number of requests handled.
+        /// </summary>
+        /// <remarks>
+        /// Should be equal to RequestsReceived unless requested are being handled slowly or there is deadlock.
+        /// </remarks>
+        int RequestsHandled { get; }
     }
 
     public interface IStreamedRequestHandler : IRequestHandler
@@ -69,7 +81,6 @@ namespace OpenSim.Framework.Servers.HttpServer
 
     public interface IStreamHandler : IRequestHandler
     {
-        // Handle request stream, return byte array
         void Handle(string path, Stream request, Stream response, IOSHttpRequest httpReqbuest, IOSHttpResponse httpResponse);
     }
     
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
index c19ac32..3fd3bf7 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
@@ -50,25 +50,39 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public enum EventType : int
         {
-            Normal = 0,
+            LongPoll = 0,
             LslHttp = 1,
             Inventory = 2,
             Texture = 3, 
             Mesh = 4
         }
 
+        public string Url { get; set; }
+
+        /// <summary>
+        /// Number of requests received for this poll service.
+        /// </summary>
+        public int RequestsReceived { get; set; }
+
+        /// <summary>
+        /// Number of requests handled by this poll service.
+        /// </summary>
+        public int RequestsHandled { get; set; }
+
         public PollServiceEventArgs(
             RequestMethod pRequest,
+            string pUrl,
             HasEventsMethod pHasEvents, GetEventsMethod pGetEvents, NoEventsMethod pNoEvents,
             UUID pId, int pTimeOutms)
         {
             Request = pRequest;
+            Url = pUrl;
             HasEvents = pHasEvents;
             GetEvents = pGetEvents;
             NoEvents = pNoEvents;
             Id = pId;
             TimeOutms = pTimeOutms;
-            Type = EventType.Normal;
+            Type = EventType.LongPoll;
         }
     }
 }
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
index 723530a..6aa9479 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
@@ -26,13 +26,19 @@
  */
 
 using System;
+using System.Collections;
+using System.Reflection;
+using System.Text;
 using HttpServer;
+using log4net;
 using OpenMetaverse;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {
     public class PollServiceHttpRequest
     {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         public readonly PollServiceEventArgs PollServiceArgs;
         public readonly IHttpClientContext HttpContext;
         public readonly IHttpRequest Request;
@@ -48,5 +54,44 @@ namespace OpenSim.Framework.Servers.HttpServer
             RequestTime = System.Environment.TickCount;
             RequestID = UUID.Random();
         }
+
+        internal void DoHTTPGruntWork(BaseHttpServer server, Hashtable responsedata)
+        {
+            OSHttpResponse response
+                = new OSHttpResponse(new HttpResponse(HttpContext, Request), HttpContext);
+
+            byte[] buffer = server.DoHTTPGruntWork(responsedata, response);
+
+            response.SendChunked = false;
+            response.ContentLength64 = buffer.Length;
+            response.ContentEncoding = Encoding.UTF8;
+
+            try
+            {
+                response.OutputStream.Write(buffer, 0, buffer.Length);
+            }
+            catch (Exception ex)
+            {
+                m_log.Warn(string.Format("[POLL SERVICE WORKER THREAD]: Error ", ex));
+            }
+            finally
+            {
+                //response.OutputStream.Close();
+                try
+                {
+                    response.OutputStream.Flush();
+                    response.Send();
+
+                    //if (!response.KeepAlive && response.ReuseContext)
+                    //    response.FreeContext();
+                }
+                catch (Exception e)
+                {
+                    m_log.Warn(String.Format("[POLL SERVICE WORKER THREAD]: Error ", e));
+                }
+
+                PollServiceArgs.RequestsHandled++;
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index 5406f00..44f7045 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -64,14 +64,17 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_server = pSrv;
             m_WorkerThreadCount = pWorkerThreadCount;
             m_workerThreads = new Thread[m_WorkerThreadCount];
+        }
 
+        public void Start()
+        {
             //startup worker threads
             for (uint i = 0; i < m_WorkerThreadCount; i++)
             {
                 m_workerThreads[i]
                     = Watchdog.StartThread(
                         PoolWorkerJob,
-                        String.Format("PollServiceWorkerThread{0}", i),
+                        string.Format("PollServiceWorkerThread{0}:{1}", i, m_server.Port),
                         ThreadPriority.Normal,
                         false,
                         false,
@@ -81,7 +84,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
             m_retrysThread = Watchdog.StartThread(
                 this.CheckRetries,
-                "PollServiceWatcherThread",
+                string.Format("PollServiceWatcherThread:{0}", m_server.Port),
                 ThreadPriority.Normal,
                 false,
                 true,
@@ -89,7 +92,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                 1000 * 60 * 10);
         }
 
-
         private void ReQueueEvent(PollServiceHttpRequest req)
         {
             if (m_running)
@@ -103,7 +105,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             if (m_running)
             {
-                if (req.PollServiceArgs.Type != PollServiceEventArgs.EventType.Normal)
+                if (req.PollServiceArgs.Type != PollServiceEventArgs.EventType.LongPoll)
                 {
                     m_requests.Enqueue(req);
                 }
@@ -140,13 +142,13 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
         }
 
-        ~PollServiceRequestManager()
+        public void Stop()
         {
             m_running = false;
             Thread.Sleep(1000); // let the world move
 
             foreach (Thread t in m_workerThreads)
-                    Watchdog.AbortThread(t.ManagedThreadId);
+                Watchdog.AbortThread(t.ManagedThreadId);
 
             try
             {
@@ -205,7 +207,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                             if (responsedata == null)
                                 continue;
 
-                            if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.Normal) // This is the event queue
+                            if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LongPoll) // This is the event queue
                             {
                                 try
                                 {
diff --git a/OpenSim/Framework/Servers/HttpServer/Properties/AssemblyInfo.cs b/OpenSim/Framework/Servers/HttpServer/Properties/AssemblyInfo.cs
index 8e592c1..f409667 100644
--- a/OpenSim/Framework/Servers/HttpServer/Properties/AssemblyInfo.cs
+++ b/OpenSim/Framework/Servers/HttpServer/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyVersion("0.8.0.*")]
 
diff --git a/OpenSim/Framework/Servers/HttpServer/RestDeserialiseHandler.cs b/OpenSim/Framework/Servers/HttpServer/RestDeserialiseHandler.cs
index 07082a8..bd55657 100644
--- a/OpenSim/Framework/Servers/HttpServer/RestDeserialiseHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/RestDeserialiseHandler.cs
@@ -33,7 +33,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 {
     public delegate TResponse RestDeserialiseMethod<TRequest, TResponse>(TRequest request);
 
-    public class RestDeserialiseHandler<TRequest, TResponse> : BaseRequestHandler, IStreamHandler
+    public class RestDeserialiseHandler<TRequest, TResponse> : BaseOutputStreamHandler, IStreamHandler
         where TRequest : new()
     {
         private RestDeserialiseMethod<TRequest, TResponse> m_method;
@@ -48,7 +48,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_method = method;
         }
 
-        public void Handle(string path, Stream request, Stream responseStream,
+        protected override void ProcessRequest(string path, Stream request, Stream responseStream,
                            IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
             TRequest deserial;
diff --git a/OpenSim/Framework/Servers/HttpServer/RestSessionService.cs b/OpenSim/Framework/Servers/HttpServer/RestSessionService.cs
index edcd134..83c9848 100644
--- a/OpenSim/Framework/Servers/HttpServer/RestSessionService.cs
+++ b/OpenSim/Framework/Servers/HttpServer/RestSessionService.cs
@@ -183,7 +183,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
     public delegate bool CheckIdentityMethod(string sid, string aid);
 
-    public class RestDeserialiseSecureHandler<TRequest, TResponse> : BaseRequestHandler, IStreamHandler
+    public class RestDeserialiseSecureHandler<TRequest, TResponse> : BaseOutputStreamHandler, IStreamHandler
         where TRequest : new()
     {
         private static readonly ILog m_log
@@ -201,7 +201,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_method = method;
         }
 
-        public void Handle(string path, Stream request, Stream responseStream,
+        protected override void ProcessRequest(string path, Stream request, Stream responseStream,
                            IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
             RestSessionObject<TRequest> deserial = default(RestSessionObject<TRequest>);
@@ -237,7 +237,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
     public delegate bool CheckTrustedSourceMethod(IPEndPoint peer);
 
-    public class RestDeserialiseTrustedHandler<TRequest, TResponse> : BaseRequestHandler, IStreamHandler
+    public class RestDeserialiseTrustedHandler<TRequest, TResponse> : BaseOutputStreamHandler, IStreamHandler
         where TRequest : new()
     {
         private static readonly ILog m_log
@@ -260,7 +260,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_method = method;
         }
 
-        public void Handle(string path, Stream request, Stream responseStream,
+        protected override void ProcessRequest(string path, Stream request, Stream responseStream,
                            IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
             TRequest deserial = default(TRequest);
@@ -292,6 +292,5 @@ namespace OpenSim.Framework.Servers.HttpServer
                 serializer.Serialize(xmlWriter, response);
             }
         }
-    }
-
-}
+    }   
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs b/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs
index 1f17fee..0305dee 100644
--- a/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/RestStreamHandler.cs
@@ -48,7 +48,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_restMethod = restMethod;
         }
 
-        public override byte[] Handle(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
             Encoding encoding = Encoding.UTF8;
             StreamReader streamReader = new StreamReader(request, encoding);
diff --git a/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs b/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs
index ee96b47..c2925e3 100644
--- a/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs
+++ b/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs
@@ -28,8 +28,10 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Net;
 using System.Security.Cryptography;
 using System.Text;
+using System.Threading;
 using HttpServer;
 
 namespace OpenSim.Framework.Servers.HttpServer
@@ -75,7 +77,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// <summary>
         /// This is a regular HTTP Request...    This may be removed in the future.   
         /// </summary>
-        public event RegularHttpRequestDelegate OnRegularHttpRequest;
+//        public event RegularHttpRequestDelegate OnRegularHttpRequest;
 
         /// <summary>
         /// When the upgrade from a HTTP request to a Websocket is completed, this will be fired
@@ -98,6 +100,8 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// </summary>
         public ValidateHandshake HandshakeValidateMethodOverride = null;
 
+        private ManualResetEvent _receiveDone = new ManualResetEvent(false);
+
         private OSHttpRequest _request;
         private HTTPNetworkContext _networkContext;
         private IHttpClientContext _clientContext;
@@ -109,6 +113,8 @@ namespace OpenSim.Framework.Servers.HttpServer
         private bool _closing;
         private bool _upgraded;
         private int _maxPayloadBytes = 41943040;
+        private int _initialMsgTimeout = 0;
+        private int _defaultReadTimeout = 10000;
 
         private const string HandshakeAcceptText =
             "HTTP/1.1 101 Switching Protocols\r\n" +
@@ -131,6 +137,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             _request = preq;
             _networkContext = pContext.GiveMeTheNetworkStreamIKnowWhatImDoing();
+            _networkContext.Stream.ReadTimeout = _defaultReadTimeout;
             _clientContext = pContext;
             _bufferLength = bufferlen;
             _buffer = new byte[_bufferLength];
@@ -206,6 +213,16 @@ namespace OpenSim.Framework.Servers.HttpServer
         }
 
         /// <summary>
+        /// Set this to the maximum amount of milliseconds to wait for the first complete message to be sent or received on the websocket after upgrading
+        /// Default, it waits forever.  Use this when your Websocket consuming code opens a connection and waits for a message from the other side to avoid a Denial of Service vector.
+        /// </summary>
+        public int InitialMsgTimeout
+        {
+            get { return _initialMsgTimeout; }
+            set { _initialMsgTimeout = value; }
+        }
+
+        /// <summary>
         /// This triggers the websocket start the upgrade process
         /// </summary>
         public void HandshakeAndUpgrade()
@@ -245,6 +262,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                     string rawaccept = string.Format(HandshakeAcceptText, acceptKey);
                     SendUpgradeSuccess(rawaccept);
                     
+
                 }
                 else
                 {
@@ -258,6 +276,10 @@ namespace OpenSim.Framework.Servers.HttpServer
                 SendUpgradeSuccess(rawaccept);
             }
         }
+        public IPEndPoint GetRemoteIPEndpoint()
+        {
+            return _request.RemoteIPEndPoint;
+        }
 
         /// <summary>
         /// Generates a handshake response key string based on the client's 
@@ -290,9 +312,16 @@ namespace OpenSim.Framework.Servers.HttpServer
             WebSocketState socketState = new WebSocketState() { ReceivedBytes = new List<byte>(), Header = WebsocketFrameHeader.HeaderDefault(), FrameComplete = true};
             
             byte[] bhandshakeResponse = Encoding.UTF8.GetBytes(pHandshakeResponse);
+
+            
+           
+
             try
             {
-                
+                if (_initialMsgTimeout > 0)
+                {
+                    _receiveDone.Reset();
+                }
                 // Begin reading the TCP stream before writing the Upgrade success message to the other side of the stream.
                 _networkContext.Stream.BeginRead(_buffer, 0, _bufferLength, OnReceive, socketState);
                 
@@ -303,16 +332,20 @@ namespace OpenSim.Framework.Servers.HttpServer
                 UpgradeCompletedDelegate d = OnUpgradeCompleted;
                 if (d != null)
                     d(this, new UpgradeCompletedEventArgs());
+                if (_initialMsgTimeout > 0)
+                {
+                    if (!_receiveDone.WaitOne(TimeSpan.FromMilliseconds(_initialMsgTimeout)))
+                        Close(string.Empty);
+                }
             }
-            catch (IOException fail)
+            catch (IOException)
             {
                 Close(string.Empty);
             }
-            catch (ObjectDisposedException fail)
+            catch (ObjectDisposedException)
             {
                 Close(string.Empty);
-            }
-            
+            }           
         }
 
         /// <summary>
@@ -414,8 +447,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                                 _socketState.Header = pheader;
                             }
 
-
-
                             if (_socketState.FrameComplete)
                             {
                                 ProcessFrame(_socketState);
@@ -424,7 +455,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                                 _socketState.ExpectedBytes = 0;
 
                             }
-
                         }
                     }
                     else
@@ -457,8 +487,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                             _socketState.ReceivedBytes.Clear();
                             _socketState.ExpectedBytes = 0;
                             // do some processing
-                        }
-
+                        }                       
                     }
                 }
                 if (offset > 0)
@@ -477,13 +506,12 @@ namespace OpenSim.Framework.Servers.HttpServer
                 {
                     // We can't read the stream anymore...  
                 }
-
             }
-            catch (IOException fail)
+            catch (IOException)
             {
                 Close(string.Empty);
             }
-            catch (ObjectDisposedException fail)
+            catch (ObjectDisposedException)
             {
                 Close(string.Empty);
             }
@@ -495,6 +523,11 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// <param name="message">the string message that is to be sent</param>
         public void SendMessage(string message)
         {
+            if (_initialMsgTimeout > 0)
+            {
+                _receiveDone.Set();
+                _initialMsgTimeout = 0;
+            }
             byte[] messagedata = Encoding.UTF8.GetBytes(message);
             WebSocketFrame textMessageFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = messagedata };
             textMessageFrame.Header.Opcode = WebSocketReader.OpCode.Text;
@@ -505,6 +538,11 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void SendData(byte[] data)
         {
+            if (_initialMsgTimeout > 0)
+            {
+                _receiveDone.Set();
+                _initialMsgTimeout = 0;
+            }
             WebSocketFrame dataMessageFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = data};
             dataMessageFrame.Header.IsEnd = true;
             dataMessageFrame.Header.Opcode = WebSocketReader.OpCode.Binary;
@@ -537,6 +575,11 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// </summary>
         public void SendPingCheck()
         {
+            if (_initialMsgTimeout > 0)
+            {
+                _receiveDone.Set();
+                _initialMsgTimeout = 0;
+            }
             WebSocketFrame pingFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = new byte[0] };
             pingFrame.Header.Opcode = WebSocketReader.OpCode.Ping;
             pingFrame.Header.IsEnd = true;
@@ -550,6 +593,11 @@ namespace OpenSim.Framework.Servers.HttpServer
         /// <param name="message"></param>
         public void Close(string message)
         {
+            if (_initialMsgTimeout > 0)
+            {
+                _receiveDone.Set();
+                _initialMsgTimeout = 0;
+            }
             if (_networkContext == null)
                 return;
             if (_networkContext.Stream != null)
@@ -589,7 +637,11 @@ namespace OpenSim.Framework.Servers.HttpServer
                 WebSocketReader.Mask(psocketState.Header.Mask, unmask);
                 psocketState.ReceivedBytes = new List<byte>(unmask);
             }
-            
+            if (psocketState.Header.Opcode != WebSocketReader.OpCode.Continue  && _initialMsgTimeout > 0)
+            {
+                _receiveDone.Set();
+                _initialMsgTimeout = 0;
+            }
             switch (psocketState.Header.Opcode)
             {
                 case WebSocketReader.OpCode.Ping:
@@ -702,6 +754,11 @@ namespace OpenSim.Framework.Servers.HttpServer
         }
         public void Dispose()
         {
+            if (_initialMsgTimeout > 0)
+            {
+                _receiveDone.Set();
+                _initialMsgTimeout = 0;
+            }
             if (_networkContext != null && _networkContext.Stream != null)
             {
                 if (_networkContext.Stream.CanWrite)
diff --git a/OpenSim/Framework/Servers/HttpServer/XmlRpcBasicDOSProtector.cs b/OpenSim/Framework/Servers/HttpServer/XmlRpcBasicDOSProtector.cs
new file mode 100644
index 0000000..f212208
--- /dev/null
+++ b/OpenSim/Framework/Servers/HttpServer/XmlRpcBasicDOSProtector.cs
@@ -0,0 +1,91 @@
+/*
+ * 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.Net;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+
+
+namespace OpenSim.Framework.Servers.HttpServer
+{
+    public class XmlRpcBasicDOSProtector
+    {
+        private readonly XmlRpcMethod _normalMethod;
+        private readonly XmlRpcMethod _throttledMethod;
+       
+        private readonly BasicDosProtectorOptions _options;
+        private readonly BasicDOSProtector _dosProtector;
+
+        public XmlRpcBasicDOSProtector(XmlRpcMethod normalMethod, XmlRpcMethod throttledMethod,BasicDosProtectorOptions options)
+        {
+            _normalMethod = normalMethod;
+            _throttledMethod = throttledMethod;
+           
+            _options = options;
+            _dosProtector = new BasicDOSProtector(_options);
+
+        }
+        public XmlRpcResponse Process(XmlRpcRequest request, IPEndPoint client)
+        {
+
+            XmlRpcResponse resp = null;
+            string clientstring = GetClientString(request, client);
+            string endpoint = GetEndPoint(request, client);
+            if (_dosProtector.Process(clientstring, endpoint))
+                resp = _normalMethod(request, client);
+            else
+                resp = _throttledMethod(request, client);
+            if (_options.MaxConcurrentSessions > 0)
+                _dosProtector.ProcessEnd(clientstring, endpoint);
+            return resp;
+        }
+
+        private string GetClientString(XmlRpcRequest request, IPEndPoint client)
+        {
+            string clientstring;
+            if (_options.AllowXForwardedFor && request.Params.Count > 3)
+            {
+                object headerstr = request.Params[3];
+                if (headerstr != null && !string.IsNullOrEmpty(headerstr.ToString()))
+                    clientstring = request.Params[3].ToString();
+                else
+                    clientstring = client.Address.ToString();
+            }
+            else
+                clientstring = client.Address.ToString();
+            return clientstring;
+        }
+
+        private string GetEndPoint(XmlRpcRequest request, IPEndPoint client)
+        {
+             return client.Address.ToString();
+        }
+
+    }
+
+    
+}